10

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?

Improve this question
8
  • 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.
    – dave
    Commented Sep 6, 2020 at 17:55
  • 4
    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
    Commented Sep 6, 2020 at 18:33
  • 3
    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.
    – dave
    Commented Sep 6, 2020 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
    Commented Sep 7, 2020 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
    Commented Sep 7, 2020 at 7:36

4 Answers 4

Reset to default
5

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
10

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
1
  • 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
    Commented Sep 6, 2020 at 22:24
9

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
8
  • 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
    Commented Sep 6, 2020 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
    Commented Sep 6, 2020 at 22:50
  • If you could recover the source, was it more of a tokeniser than a compiler?
    – gidds
    Commented Sep 7, 2020 at 8:31
  • 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
    Commented Sep 7, 2020 at 16:02
  • 1
    @davidbak I think that the most useful place is the discussion page of en.wikipedia.org/wiki/TREE-META also noting the links at the bottom of the article itself. Scanned listings definitely belong on Bitsavers but in the interim Github would probably be as good a place as any. I'll mention it to somebody with an HP background who will probably be interested to know that they exist.
    – Mark Morgan Lloyd
    Commented Aug 30, 2022 at 7:40
3

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
2
  • 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
    Commented Sep 7, 2020 at 14:12
  • @JeffreyHenning: I think a fundamental difference between GPL and TMS9900 machine code is that the former is designed to directly execute code stored in chips called GROMs. GPL isn't so much "Graphical programming language" as "(Graphical-Read-Only-Memory) Programming Language".
    – supercat
    Commented Oct 18 at 16:46

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .