ZILF 0.7 released, and Adventure ported to ZIL

The new version of ZILF is here! Most of the improvements are in the parser library: features like disambiguation, ordering, and multiple actions make the parser usable by modern standards. A 350-point port of Adventure is included as an example.

Release notes
Download ZILF 0.7
Download Advent.z3

If use the hell out of this just to say I’m using the ZIL, if only it had a Linux implementation… Are there plans for one? What would the difficulty in compiling for Linux be of I took it upon myself to do so?

EDIT: Nevermind! I RTFMed and found the answer, lol.

I haven’t tested it much on Linux, but it should work out of the box. You can run the binaries with mono, or compile it from source with xbuild. Let me know if you run into any trouble.

One quick question, if you don’t mind… In the Learning ZIL document you pointed to in another post, it mentions breaking the story up into several files ( one for the map, one for items, one for treasures, one for syntax, etc.), but I’ve noticed in your examples, the code is monolithic. Is it possible to break the code into several files in this version of the compiler, of so, how are file linkings recognized by the compiler (I.e. import statements, a makefile system, etc.), and do you have any examples of this?

Yes, see how INSERT-FILE is used in Cloak of Darkness, Adventure, or the parser. You pass the path of your main file to ZILF on the command line, and the INSERT-FILE directives insert code from your other files, searching the current directory and any other location specified with the -ip flag.

Excellent! Final question, I’ve downloaded and read the Learning ZIL PDF, are there any more complete PDF documents available for the language. As great as that file is, it is obviously incomplete, and leaves much to be desired by those with programming experience, lol.

There’s the 1979 manual for The MDL Programming Language, which unfortunately isn’t searchable. ZILF implements a large subset of MDL, because all the code in a ZIL program that runs at compile time (macros and top-level directives) is MDL code.

I think this a higher quality version: dtic.mil/docs/citations/ADA070930

Also, it seems that someone has started transcribing it: github.com/itafroma/mdl-docs
It has only the first 3 chapters and no progress in 7 months so perhaps they’ve given up.

I have an actual printed & bound copy of the book from MIT. I may try to scan & OCR it some day but in a non-destructive way because I want to keep the book.

Oo, thanks for the links.

Same! Downloading the hq version now.

Also, found this one… Throwing up here for interested people…

[EDIT] Sorry, knew there was something I was overlooking, lol.

Tip: cut off that URL at the first ampersand, since the rest is session-specific.


There’s also The MDL Programming Environment, which describes some libraries and utilities. Mostly a historical curiosity, but ZILF implements (a subset of) the package system described there.

Well, since we seem to be sharing files I may as well do these too: aws.bluehome.net/muddle.zip

I’ve been doing a lot of research into Muddle. This is only a small part of it.

It includes the 1975 version of the book, which seems to be in good quality. I expect my scan of the 1979 book to be similar once I get around to scanning it. I’ve also located the original 1972 version but it’s unclear if I’ll be able to scan it or not. Anyway, the zip file has some other documentation: It seems that Muddle eventually got graphics support around 1982. There seems to have been even further changes after the 1979 book as well because that 1982 graphics manual makes references to functions that aren’t in any Muddle book I’ve seen.

Anyway, it also includes “A Dynamic Debugging System For MDL” written by Joel Berez. I started looking for that after watching Dave Lebling’s talk “Classic Game Postmortem: Infocom’s Zork” at youtube.com/watch?v=FXdmo2j_CiQ

He has a slide about 24 minutes in talking of Infocom’s toolchain. It consisted of mostly what I’ve heard of with ZIL, ZILCH, ZAP, etc. but the lower right corner had something I’d never heard of before: ZDDT.

This prompted me to write to him and ask what ZDDT was. His reply:

DDT was a program at the MIT AI Lab and MIT Lab for Computer Science that was an interactive debugger. It stood for "Dynamic Debugging Technique," but I think it probably was named that and then they made up an acronym later. DDT itself was quite powerful; most people on the ITS operating system used it as their shell. ZDDT was an addon to the ZIP runtime (on TOPS-20) that allowed you to do the same sort of debugging as the MIT version of DDT: stepping, examining/changing variables, breakpoints, looking at the stack, etc. I wrote it because it was fun to do and also useful. Dave
This prompted me to go find the DDT information, since ZDDT was likely similar. And in so doing I’ve found a previously-unknown part of Infocom’s toolchain. (At least, unknown to me.)

For some Muddle history, based on a comment in the book “Graphical Programming And Monitoring” (also included in the zip file) it seems that Muddle was eventually ported to run on a VAX from DEC with BSD UNIX 4.2 or 4.3. I’ve not been able to find any further information on the UNIX port (nor source code, which would be awesome.) I did know it had been ported to A/UX based on comments posted online from former Infocom people but I assume the A/UX port stayed within Activision while it seems that the VAX BSD port was done prior to the A/UX port and was used by people outside of Infocom.

This porting may have been made easier due to work on a so-called “machine-independent Muddle.” The zip file contains only very high level information on that as I’ve not been able to find any further information about the virtual machine described in there. Dave Lebling hints that:

[code]The “MIM” (Muddle in Muddle) runtime base was indeed written in C. It
loaded and ran additional runtime code written in Muddle and compiled
by MIMC (“MIM Compiler”). I thought all but the C runtime base layer
was on the (in)famous “Infocom Disk” which can be found in various
places on the web.

What is as far as I know truly lost is the old PDP-10/Tops-20 Muddle
Compiler and MIMC.[/code]

I’ve been running a few of the PDFs through Tesseract, but unfortunately it has great difficulty with the function names. Is there a good workaround for this problem?

OCR is not likely to ever be perfect, especially considering the quality, and will probably need editing regardless. I’m waiting for a book scanner to arrive to begin work on the 1979 version in 1200 dpi. My hope is that it will make OCR easier.

Unfortunately true. The main text is quite good because it follows standard English patterns, but the function names and especially blocks of code are another matter.

I’ve transcribed a few more chapters. The original transcriber isn’t accepting PRs, but you can read them at: github.com/taradinoc/mdl-docs/tree/master/docs