I've been continuing to revise and expand the Wikipedia article that I started on BASIC interpreters. One of the criticisms was that it was too focused on the microcomputer era (which interested me the most). I've expanded it but realize that the section on coding focuses on machine- and assembly-language programming (my favorite is the Tiny BASIC Extended team that programmed in octal!). Anyway, I haven't had any luck identifying early BASIC interpreters that were coded in higher-level languages (presumably C). Do you know of any interpreters in the 1970s or 1980s that were coded above assembly?

  • 5
    I vaguely recall starting to write one in Algol 60 on KDF9 under Eldon2, but the system got decommissioned before I got very far. This probably doesn't count. @Ralfzahn: 'why'? because that is why we have high-level languages. – another-dave Sep 6 at 17:55
  • 3
    Just a comment because I have nothing definitive to report, but BASICally, on the earlier machines, there were no great HLL for implementing another language like BASIC. On later machines, BASIC tended to be one of the first to be implemented - and therefore in assembler. It may seem strange now with so many HLLs implemented in C (or C++ or whatever), but in the good 'ol days, every language either compiled assembler (and then assembled) or compiled straight to machine code. – manassehkatz-Moving 2 Codidact Sep 6 at 18:33
  • 2
    Unclear to how the choice of implementation language for a compiler relates to the object language produced by that compiler. "Implemented in HLL, output in machine code" seems commonplace. – another-dave Sep 6 at 19:17
  • 2
    Wikipedia suggests that 7th edition Dartmouth BASIC (1978) was written in itself, though that's a compiler not an interpreter. – Kelvin Sherlock Sep 7 at 4:34
  • 2
    Isn't it more "who do we have who can lead a team for creating the interpreter" and "what tools do we have available for doing it". If all they have is assembler and a Fortran compiler, then it will probably be written in Fortran. – cup Sep 7 at 7:36

https://github.com/pkimpel/retro-b5500/blob/master/source/XBASIC/XBASIC.alg_m is a BASIC interpreter for the B5500, written in ALGOL, and dated 1975.

This also mentions Burroughs's own BASIC, but a cursory search doesn't turn up a manual etc. so I can't ascribe a date to it. However ALL Burroughs system software was either written in ALGOL (this includes compilers etc.) or in ESPOL (an ALGOL derivative with inline machine code etc.), with the exception of the initial boot card and test programs which were strictly for internal use.

(Later) The system software tapes have the source of Burroughs's own BASIC compiler, Mark XII dated 1971.

| improve this answer | |

Gordon Eubanks' BASIC-E for CP/M was written in PL/M around 1977. While PL/M is a fairly low-level systems programming language almost entirely targeting Intel processors, it's still higher level than directly targeting a specific processor in assembly language.

BASIC-E compiles to an intermediate p-code, which is then interpreted by a separate runtime. So it's still an interpreter, if not an interactive one.

| improve this answer | |
  • While there is a continuum from interpreter to compiler, this seems more like a compiler than an interpreter to me. But I just downloaded the PL/M source code to skim. Thanks! – Jeffrey Henning Sep 6 at 22:24

BASIC for the MAI Basic Four minicomputer series was programmed in a version of TREE-META - a language for writing compilers in. I hesitate to call it a "high level language". TREE-META was more of a notation - very similar to BNF - with callouts to action routines. But it was not assembly language in any way. It was in fact an "attributed grammar" notation that happened to be executable.

(BTW, regardless of what the wikipedia article linked above implies, MAI's Basic Four computers were on the market by the mid 70s. I worked for them in '79-'81 and they were already very established in multiple vertical markets - car dealership parts&service, small doctor/dentist offices, to name two.)

Now I think of it: The TREE-META part was the lexer+parser+"byte" code generator. The "byte" code interpreter itself - not many instructions and those were high level as they handled BASIC string operations (e.g., concatenation) as single byte codes - was written in microcode. ("byte" code is in quotes because I'm not actually sure it was a one-byte-per-instruction coding scheme - I don't remember how it was encoded. But it was pretty simple! And you could recover the BASIC language source statements from the instructions.) Also in microcode was all of the memory management for the variables - which of course in BASIC means strings and arrays of numbers or strings as well as integers and floating point - and for the compiled byte code as well. (So whether BASIC Four BASIC answers the OP's question is up to him.)

| improve this answer | |
  • Was it a compiler? Most minicomputer BASICs were compile-and-go. That MAI Basic Four article really needs some love from someone with original source documents. – Jeffrey Henning Sep 6 at 22:31
  • 1
    @JeffreyHenning - it was a line-at-a-time compiler - one source line was compiled into a procedure in a "byte' code. Only the byte code was kept. When you wanted to list lines of the program the source was recovered from the byte code (via a second TREE-META grammar!). I don't have source documents - just my memories of working there! They were very good people! Though, of course, doomed when the microcomputer era took off ... – davidbak Sep 6 at 22:50
  • If you could recover the source, was it more of a tokeniser than a compiler? – gidds Sep 7 at 8:31
  • @davidbak If you can find any further relevant info please add it to the Wp page, either to the article itself or to the "talk" area. There's a number of us interested in Tree-Meta but information is difficult to come by; apart from anything else it was used for at least one project in HP but the (retired?) engineer responsible lost everything in the California fires a couple of years ago. – Mark Morgan Lloyd Sep 7 at 14:39
  • 1
    I might have old sources somewhere ... I will actively look for it but don't hold your breath. Otherwise, all information above comes from an unimpeachable and totally reliable source: Me. I wrote the tree-meta interpreter and basic compiler/interpreter and a "high level scoped language" compiler/interpreter for a brand new computer architecture developed as the next generation of BASIC Four machines - was all working nicely on a simulation (written in BASIC! (by someone else)) until, of course, the project got cancelled ... as was the way of most projects back then ...) – davidbak Sep 7 at 16:02

The BASIC interpreter for the TI 99/4A computer is written in an intermediate language called GPL, which in turn runs natively on the TMS9900 microprocessor.

See: http://www.nouspikel.com/ti99/titechpages.htm

| improve this answer | |
  • Interesting - I think of it as a virtual machine implementation (of which there were a few, especially for Tiny BASIC). From your link, "Texas Instruments thus designed a special, low-level interpreted language they called GPL, for 'Graphic Programming Language'." The TMS9900 has a different assembly language. For instance, GPL doesn't use the status register but a status byte; so it's higher level. – Jeffrey Henning Sep 7 at 14:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.