JLS Basic Compiler

Votes / Statistics
Hits: 1,852
Downloads: 0
Votes: 0
Your vote:
My Atarimania
Bookmark and Share
Comments (0)


GenreProgramming - LanguageYear1985
LanguageMachine LanguagePublisher

Jackson, Jeff

Graphic Artist(s)Medium Disk
Cover Artist(s)Serial

Additional Comments

From the Author's site:

"JLS BASIC History

I started developing the BASIC compiler in 1983 or 1984 (I don't recall for sure the exact date). I was in college at the time, studying Computer Science and had taken the compiler course. It was initially written in BASIC/A+ from OSS. It targeted a stack based p-code, similar to FORTH, which I had read a lot about at the time. The first version was very crude, lacked operator precedence and user defined procedures. But, I was eventually able to self compile.

The initial compiler ran on an ATARI 800 with 48K of RAM. The p-code interpreter and run-time library was written with the ATARI Assembler Editor cartridge. I eventually bought an ATARI 800XL with 64K of RAM and MAC/65 from OSS, which greatly enhanced my productivity in Assembly Language programming. I also devised a way of taking advantage of the extra RAM on the XL series. This gave me enough room to be able to add many more neat features to the compiler.

I used DOS2.0S as my File Management System, but replaced the DUP.SYS of ATARI DOS with my own code. My own code consisted of two parts: a memory manager for using all of RAM, and a loader for loading the rest of my compilation system. The memory manager leaves the shadow RAM under the OS ROM visible under normal circumstances. The 2K floating point code was copied to the same addresses in the RAM, then all the OS vectors were replaced with pointers to code in the memory manager. Whenever any OS action was requested, such as an interrupt or OS service request, it got routed to the memory manager, who then made the ROM visible, called the ROM OS, which then returned to the memory manager, who made the RAM visible again, and returned to the user. This gave me nearly 12KB of additional RAM to play with.

The loader read CONFIG.SYS for a list of files to load. It loaded the p-code interpreter and runtime library (RTL.SYS) and the relocating loader (RELOCATE.SYS) into the high 8KB of shadow RAM. The Control Program (CP.SYS) was loaded into the low 4K of shadow RAM.

This gave me extra space to greatly extend the capabilities of the compiler. I added operator precedence, and allowed the user to define subroutines and functions, supporting local variables and recursion. The syntax of these features seems a bit esoteric today. I had never seen C at that time, and did my programming in college in PL/I, so some of the concepts come from that language (which was a cross between FORTRAN and COBOL).

Towards the end of 1984, I had something that could be regarded as a complete product and attempted to market it. In 1985 I started working on the next version, and made considerable progress towards adding a PASCAL compiler. In May I graduated with a Computer Science degree, but the BASIC compiler wasn't selling much. The 8-bit world was coming to an end, and I didn't have the money to get a IBM PC, Atari ST, or Amiga. So finally, I had to get a real job working for what was then Harris Corporation, Computer Systems Division, where I continued being a compiler geek. The PASCAL project was abandoned, although I continued using the 8-bit Atari and the JLS system for another two or three years before I finally bought an Atari ST.

I never did a compiler project for it, but I did do some programming on it. Somewhere around 1990, the Atari 800XL died, and I sold a lot of hardware I didn't use anymore. I kept all my floppies. In 2000, I discovered Gemulator and decided to attempt to resurrect the JLS software for nostalgia's sake. I've not recovered any of the PASCAL compiler yet, and probably will never attempt to finish it. I have fixed a couple of bugs in the version-2-under-development stuff, and added a few more commands for fun. I added some on-line help commands and enhanced the interface to a few others, such as EDIT, FILES, and the Control Program (shell in unix parlance).

I thought it might be fun to let other 8-bit Atari buffs have a look at it, so I'm making the whole thing freely available. Shoot, if there is demand, I might even fix some bugs and incorporate enhancements. I never took advantage of the extra 64K of the XE series, so I'm giving some thought as to how that might be done. A RAMDISK is the obvious way, although I'd really like to come up with a way for a single program to more or less transparently make use of it. I thought about at one time having the p-code interpreter implement a virtual address space, using either the extended memory, or a disk drive for swapping. I'm not sure I can still make changes in the RTL.SYS though. It was written with the MAC/65 cartridge, which isn't available in any simulators yet. I do have a copy of the older disk based MAC/65, but I don't know how compatible it is."



JLS Basic Compiler Atari ad
About Us - Contact - Credits - Powered with Webdev - © Atarimania 2003-2020