X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=jonesforth.S;h=4fae872f2e5c3b68c7d2f8b332e093a57e8e9bfd;hb=ff91abdd1c57f5ce560195bcef26bdafc7a7d672;hp=53e27067772628c6f10f4dafa50a06373b5f7a7c;hpb=9dc526d7477809c27b8e153cd2e0dea6bbcf69d5;p=rrq%2Fjonesforth.git diff --git a/jonesforth.S b/jonesforth.S index 53e2706..4fae872 100644 --- a/jonesforth.S +++ b/jonesforth.S @@ -1,5 +1,7 @@ /* A sometimes minimal FORTH compiler and tutorial for Linux / i386 systems. -*- asm -*- By Richard W.M. Jones http://annexia.org/forth + This is PUBLIC DOMAIN (see public domain release statement below). + $Id: jonesforth.S,v 1.16 2007-09-08 17:02:11 rich Exp $ gcc -m32 -nostdlib -static -Wl,-Ttext,0 -o jonesforth jonesforth.S @@ -69,6 +71,13 @@ Also I used this document (http://ftp.funet.fi/pub/doc/IOCCC/1992/buzzard.2.design) which really defies easy explanation. + PUBLIC DOMAIN ---------------------------------------------------------------------- + + I, the copyright holder of this work, hereby release it into the public domain. This applies worldwide. + + In case this is not legally possible, I grant any entity the right to use this work for any purpose, + without any conditions, unless such conditions are required by law. + SETTING UP ---------------------------------------------------------------------- Let's get a few housekeeping things out of the way. Firstly because I need to draw lots of @@ -107,6 +116,14 @@ strings (or rather it used to, but the developers removed it!) so I've abused the syntax slightly to make things readable. Ignore these warnings. + If you want to run your own FORTH programs you can do: + + ./jonesforth < myprog.f + + If you want to load your own FORTH code and then continue reading user commands, you can do: + + cat myfunctions.f - | ./jonesforth + ASSEMBLER ---------------------------------------------------------------------- (You can just skip to the next section -- you don't need to be able to read assembler to @@ -139,7 +156,7 @@ THE DICTIONARY ---------------------------------------------------------------------- - In FORTH as you will know, functions are called "words", as just as in other languages they + In FORTH as you will know, functions are called "words", and just as in other languages they have a name and a definition. Here are two FORTH words: : DOUBLE DUP + ; \ name is "DOUBLE", definition is "DUP +" @@ -185,7 +202,7 @@ You shoud be able to see from this how you might implement functions to find a word in the dictionary (just walk along the dictionary entries starting at LATEST and matching - the names until you either find a match or hit the NULL pointer at the end of the dictionary), + the names until you either find a match or hit the NULL pointer at the end of the dictionary); and add a word to the dictionary (create a new definition, set its LINK to LATEST, and set LATEST to point to the new word). We'll see precisely these functions implemented in assembly code later on. @@ -219,7 +236,7 @@ and so on. How would a function, say 'f' above, be compiled by a standard C compiler? Probably into assembly code like this. On the right hand side I've written the actual - 16 bit machine code. + i386 machine code. f: CALL a E8 08 00 00 00 @@ -253,7 +270,7 @@ %esi -> 1C 00 00 00 2C 00 00 00 - The all-important x86 instruction is called LODSL (or in Intel manuals, LODSW). It does + The all-important i386 instruction is called LODSL (or in Intel manuals, LODSW). It does two things. Firstly it reads the memory at %esi into the accumulator (%eax). Secondly it increments %esi by 4 bytes. So after LODSL, the situation now looks like this: @@ -487,11 +504,11 @@ DOCOL: | addr of DOUBLE ---------------> +------------------+ +------------------+ %eax -> | addr of DOCOL | %esi -> | addr of DOUBLE | +------------------+ - +------------------+ | addr of DUP --------------> + +------------------+ | addr of DUP | | addr of EXIT | +------------------+ +------------------+ | etc. | - First, the call to DOUBLE causes DOCOL (the codeword of DOUBLE). DOCOL does this: It + First, the call to DOUBLE calls DOCOL (the codeword of DOUBLE). DOCOL does this: It pushes the old %esi on the return stack. %eax points to the codeword of DOUBLE, so we just add 4 on to it to get our new %esi: @@ -502,7 +519,7 @@ DOCOL: | addr of DOUBLE ---------------> +------------------+ top of return +------------------+ %eax -> | addr of DOCOL | stack points -> | addr of DOUBLE | + 4 = +------------------+ - +------------------+ %esi -> | addr of DUP --------------> + +------------------+ %esi -> | addr of DUP | | addr of EXIT | +------------------+ +------------------+ | etc. | @@ -645,7 +662,7 @@ name_\label : +--|------+---+---+---+---+------------+ | LINK | 3 | D | U | P | code_DUP ---------------------> points to the assembly +---------+---+---+---+---+------------+ code used to write DUP, - ^ len codeword which is ended with NEXT. + ^ len codeword which ends with NEXT. | LINK in next word @@ -726,11 +743,11 @@ code_\label : // assembler code follows NEXT defcode "4+",2,,INCR4 - addl $4,(%esp) // increment top of stack + addl $4,(%esp) // add 4 to top of stack NEXT defcode "4-",2,,DECR4 - subl $4,(%esp) // decrement top of stack + subl $4,(%esp) // subtract 4 from top of stack NEXT defcode "+",1,,ADD @@ -740,7 +757,7 @@ code_\label : // assembler code follows defcode "-",1,,SUB pop %eax // get top of stack - subl %eax,(%esp) // and subtract if from next word on stack + subl %eax,(%esp) // and subtract it from next word on stack NEXT defcode "*",1,,MUL @@ -970,7 +987,7 @@ var_\name : STATE Is the interpreter executing code (0) or compiling a word (non-zero)? LATEST Points to the latest (most recently defined) word in the dictionary. - HERE When compiling, compiled words go here. + HERE Points to the next free byte of memory. When compiling, compiled words go here. _X These are three scratch variables, used by some standard dictionary words. _Y _Z @@ -994,15 +1011,6 @@ var_\name : the top of the return stack. */ - defcode "DSP@",4,,DSPFETCH - mov %esp,%eax - push %eax - NEXT - - defcode "DSP!",4,,DSPSTORE - pop %esp - NEXT - defcode ">R",2,,TOR pop %eax // pop parameter stack into %eax PUSHRSP %eax // push it on to the return stack @@ -1025,12 +1033,46 @@ var_\name : lea 4(%ebp),%ebp // pop return stack and throw away NEXT +/* + PARAMETER (DATA) STACK ---------------------------------------------------------------------- + + These functions allow you to manipulate the parameter stack. Recall that Linux sets up the parameter + stack for us, and it is accessed through %esp. +*/ + + defcode "DSP@",4,,DSPFETCH + mov %esp,%eax + push %eax + NEXT + + defcode "DSP!",4,,DSPSTORE + pop %esp + NEXT + /* INPUT AND OUTPUT ---------------------------------------------------------------------- + These are our first really meaty/complicated FORTH primitives. I have chosen to write them in + assembler, but surprisingly in "real" FORTH implementations these are often written in terms + of more fundamental FORTH primitives. I chose to avoid that because I think that just obscures + the implementation. After all, you may not understand assembler but you can just think of it + as an opaque block of code that does what it says. + Let's discuss input first. + The FORTH word KEY reads the next byte from stdin (and pushes it on the parameter stack). + So if KEY is called and someone hits the space key, then the number 32 (ASCII code of space) + is pushed on the stack. + In FORTH there is no distinction between reading code and reading input. We might be reading + and compiling code, we might be reading words to execute, we might be asking for the user + to type their name -- ultimately it all comes in through KEY. + + The implementation of KEY uses an input buffer of a certain size (defined at the end of the + program). It calls the Linux read(2) system call to fill this buffer and tracks its position + in the buffer using a couple of variables, and if it runs out of input buffer then it refills + it automatically. The other thing that KEY does is if it detects that stdin has closed, it + exits the program, which is why when you hit ^D the FORTH system cleanly exits. */ #include @@ -1067,6 +1109,12 @@ _KEY: mov $__NR_exit,%eax // syscall: exit int $0x80 +/* + By contrast, output is much simpler. The FORTH word EMIT writes out a single byte to stdout. + This implementation just uses the write system call. No attempt is made to buffer output, but + it would be a good exercise to add it. +*/ + defcode "EMIT",4,,EMIT pop %eax call _EMIT @@ -1087,6 +1135,33 @@ _EMIT: .bss 2: .space 1 // scratch used by EMIT +/* + Back to input, WORD is a FORTH word which reads the next full word of input. + + What it does in detail is that it first skips any blanks (spaces, tabs, newlines and so on). + Then it calls KEY to read characters into an internal buffer until it hits a blank. Then it + calculates the length of the word it read and returns the address and the length as + two words on the stack (with address at the top). + + Notice that WORD has a single internal buffer which it overwrites each time (rather like + a static C string). Also notice that WORD's internal buffer is just 32 bytes long and + there is NO checking for overflow. 31 bytes happens to be the maximum length of a + FORTH word that we support, and that is what WORD is used for: to read FORTH words when + we are compiling and executing code. The returned strings are not NUL-terminated, so + in some crazy-world you could define FORTH words containing ASCII NULs, although why + you'd want to is a bit beyond me. + + WORD is not suitable for just reading strings (eg. user input) because of all the above + peculiarities and limitations. + + Note that when executing, you'll see: + WORD FOO + which puts "FOO" and length 3 on the stack, but when compiling: + : BAR WORD FOO ; + is an error (or at least it doesn't do what you might expect). Later we'll talk about compiling + and immediate mode, and you'll understand why. +*/ + defcode "WORD",4,,WORD call _WORD push %ecx // push length @@ -1128,15 +1203,14 @@ _WORD: // overwrite this buffer. Maximum word length is 32 chars. 5: .space 32 - defcode "EMITSTRING",10,,EMITSTRING - mov $1,%ebx // 1st param: stdout - pop %ecx // 2nd param: address of string - pop %edx // 3rd param: length of string - - mov $__NR_write,%eax // write syscall - int $0x80 +/* + . (also called DOT) prints the top of the stack as an integer. In real FORTH implementations + it should print it in the current base, but this assembler version is simpler and can only + print in base 10. - NEXT + Remember that you can override even built-in FORTH words easily, so if you want to write a + more advanced DOT then you can do so easily at a later point, and probably in FORTH. +*/ defcode ".",1,,DOT pop %eax // Get the number to print into %eax @@ -1161,9 +1235,16 @@ _DOT: call _EMIT ret - // Parse a number from a string on the stack -- almost the opposite of . (DOT) - // Note that there is absolutely no error checking. In particular the length of the - // string must be >= 1 bytes. +/* + Almost the opposite of DOT (but not quite), SNUMBER parses a numeric string such as one returned + by WORD and pushes the number on the parameter stack. + + This function does absolutely no error checking, and in particular the length of the string + must be >= 1 bytes, and should contain only digits 0-9. If it doesn't you'll get random results. + + This function is only used when reading literal numbers in code, and shouldn't really be used + in user code at all. +*/ defcode "SNUMBER",7,,SNUMBER pop %edi pop %ecx @@ -1183,6 +1264,30 @@ _SNUMBER: jnz 1b ret +/* + DICTIONARY LOOK UPS ---------------------------------------------------------------------- + + We're building up to our prelude on how FORTH code is compiled, but first we need yet more infrastructure. + + The FORTH word FIND takes a string (a word as parsed by WORD -- see above) and looks it up in the + dictionary. What it actually returns is the address of the dictionary header, if it finds it, + or 0 if it didn't. + + So if DOUBLE is defined in the dictionary, then WORD DOUBLE FIND returns the following pointer: + + pointer to this + | + | + V + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT | + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + + See also >CFA which takes a dictionary entry pointer and returns a pointer to the codeword. + + FIND doesn't find dictionary entries which are flagged as HIDDEN. See below for why. +*/ + defcode "FIND",4,,FIND pop %edi // %edi = address pop %ecx // %ecx = length @@ -1231,7 +1336,31 @@ _FIND: xor %eax,%eax // Return zero to indicate not found. ret - defcode ">CFA",4,,TCFA // DEA -> Codeword address +/* + FIND returns the dictionary pointer, but when compiling we need the codeword pointer (recall + that FORTH definitions are compiled into lists of codeword pointers). + + In the example below, WORD DOUBLE FIND >CFA + + FIND returns a pointer to this + | >CFA converts it to a pointer to this + | | + V V + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT | + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + + Notes: + + Because names vary in length, this isn't just a simple increment. + + In this FORTH you cannot easily turn a codeword pointer back into a dictionary entry pointer, but + that is not true in most FORTH implementations where they store a back pointer in the definition + (with an obvious memory/complexity cost). The reason they do this is that it is useful to be + able to go backwards (codeword -> dictionary entry) in order to decompile FORTH definitions. +*/ + + defcode ">CFA",4,,TCFA pop %edi call _TCFA push %edi @@ -1247,12 +1376,118 @@ _TCFA: andl $~3,%edi ret - defcode "CHAR",4,,CHAR - call _WORD // Returns %ecx = length, %edi = pointer to word. - xor %eax,%eax - movb (%edi),%al // Get the first character of the word. - push %eax // Push it onto the stack. - NEXT +/* + COMPILING ---------------------------------------------------------------------- + + Now we'll talk about how FORTH compiles words. Recall that a word definition looks like this: + + : DOUBLE DUP + ; + + and we have to turn this into: + + pointer to previous word + ^ + | + +--|------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT | + +---------+---+---+---+---+---+---+---+---+------------+--|---------+------------+------------+ + ^ len pad codeword | + | V + LATEST points here points to codeword of DUP + + There are several problems to solve. Where to put the new word? How do we read words? How + do we define : (COLON) and ; (SEMICOLON)? + + FORTH solves this rather elegantly and as you might expect in a very low-level way which + allows you to change how the compiler works in your own code. + + FORTH has an INTERPRETER function (a true interpreter this time, not DOCOL) which runs in a + loop, reading words (using WORD), looking them up (using FIND), turning them into codeword + points (using >CFA) and deciding what to do with them. What it does depends on the mode + of the interpreter (in variable STATE). When STATE is zero, the interpreter just runs + each word as it looks them up. (Known as immediate mode). + + The interesting stuff happens when STATE is non-zero -- compiling mode. In this mode the + interpreter just appends the codeword pointers to user memory (the HERE variable points to + the next free byte of user memory). + + So you may be able to see how we could define : (COLON). The general plan is: + + (1) Use WORD to read the name of the function being defined. + + (2) Construct the dictionary entry header in user memory: + + pointer to previous word (from LATEST) +-- Afterwards, HERE points here, where + ^ | the interpreter will start appending + | V codewords. + +--|------+---+---+---+---+---+---+---+---+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | + +---------+---+---+---+---+---+---+---+---+------------+ + len pad codeword + + (3) Set LATEST to point to the newly defined word and most importantly leave HERE pointing + just after the new codeword. This is where the interpreter will append codewords. + + (4) Set STATE to 1. Go into compile mode so the interpreter starts appending codewords. + + After : has run, our input is here: + + : DOUBLE DUP + ; + ^ + | + Next byte returned by KEY + + so the interpreter (now it's in compile mode, so I guess it's really the compiler) reads DUP, + gets its codeword pointer, and appends it: + + +-- HERE updated to point here. + | + V + +---------+---+---+---+---+---+---+---+---+------------+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + +---------+---+---+---+---+---+---+---+---+------------+------------+ + len pad codeword + + Next we read +, get the codeword pointer, and append it: + + +-- HERE updated to point here. + | + V + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+ + len pad codeword + + The issue is what happens next. Obviously what we _don't_ want to happen is that we + read ; and compile it and go on compiling everything afterwards. + + At this point, FORTH uses a trick. Remember the length byte in the dictionary definition + isn't just a plain length byte, but can also contain flags. One flag is called the + IMMEDIATE flag (F_IMMED in this code). If a word in the dictionary is flagged as + IMMEDIATE then the interpreter runs it immediately _even if it's in compile mode_. + + I hope I don't need to explain that ; (SEMICOLON) is an IMMEDIATE flagged word. And + all it does is append the codeword for EXIT on to the current definition and switch + back to immediate mode (set STATE back to 0). After executing ; we get this: + + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT | + +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+ + len pad codeword ^ + | + HERE + + And that's it, job done, our new definition is compiled. + + The only last wrinkle in this is that while our word was being compiled, it was in a + half-finished state. We certainly wouldn't want DOUBLE to be called somehow during + this time. There are several ways to stop this from happening, but in FORTH what we + do is flag the word with the HIDDEN flag (F_HIDDEN in this code) just while it is + being compiled. This prevents FIND from finding it, and thus in theory stops any + chance of it being called. + + Compared to the description above, the actual definition of : (COLON) is comparatively simple: +*/ defcode ":",1,,COLON @@ -1287,6 +1522,11 @@ _TCFA: movl $1,var_STATE NEXT +/* + , (COMMA) is a standard FORTH word which appends a 32 bit integer (normally a codeword + pointer) to the user data area pointed to by HERE, and adds 4 to HERE. +*/ + defcode ",",1,,COMMA pop %eax // Code pointer to store. call _COMMA @@ -1297,6 +1537,10 @@ _COMMA: movl %edi,var_HERE // Update HERE (incremented) ret +/* + ; (SEMICOLON) is also elegantly simple. Notice the F_IMMED flag. +*/ + defcode ";",1,F_IMMED,SEMICOLON movl $EXIT,%eax // EXIT is the final codeword in compiled words. call _COMMA // Store it. @@ -1305,6 +1549,27 @@ _COMMA: movl %eax,var_STATE NEXT +/* + IMMEDIATE mode words aren't just for the FORTH compiler to use. You can define your + own IMMEDIATE words too. The IMMEDIATE word toggles the F_IMMED (IMMEDIATE flag) on the + most recently defined word, or on the current word if you call it in the middle of a + definition. + + Typical usage is: + + : MYIMMEDWORD IMMEDIATE + ...definition... + ; + + but some FORTH programmers write this instead: + + : MYIMMEDWORD + ...definition... + ; IMMEDIATE + + The two are basically equivalent. +*/ + defcode "IMMEDIATE",9,F_IMMED,IMMEDIATE call _IMMEDIATE NEXT @@ -1314,6 +1579,11 @@ _IMMEDIATE: xorb $F_IMMED,(%edi) // Toggle the IMMED bit. ret +/* + HIDDEN toggles the other flag, F_HIDDEN, of the latest word. Note that words flagged + as hidden are defined but cannot be called, so this is rarely used. +*/ + defcode "HIDDEN",6,,HIDDEN call _HIDDEN NEXT @@ -1323,12 +1593,78 @@ _HIDDEN: xorb $F_HIDDEN,(%edi) // Toggle the HIDDEN bit. ret -/* This definiton of ' (TICK) is strictly cheating - it also only works in compiled code. */ +/* + ' (TICK) is a standard FORTH word which returns the codeword pointer of the next word. + + The common usage is: + + ' FOO , + + which appends the codeword of FOO to the current word we are defining (this only works in compiled code). + + You tend to use ' in IMMEDIATE words. For example an alternate (and rather useless) way to define + a literal 2 might be: + + : LIT2 IMMEDIATE + ' LIT , \ Appends LIT to the currently-being-defined word + 2 , \ Appends the number 2 to the currently-being-defined word + ; + + So you could do: + + : DOUBLE LIT2 * ; + + (If you don't understand how LIT2 works, then you should review the material about compiling words + and immediate mode). + + This definition of ' uses a cheat which I copied from buzzard92. As a result it only works in + compiled code. +*/ defcode "'",1,,TICK lodsl // Get the address of the next word and skip it. pushl %eax // Push it on the stack. NEXT +/* + BRANCHING ---------------------------------------------------------------------- + + It turns out that all you need in order to define looping constructs, IF-statements, etc. + are two primitives. + + BRANCH is an unconditional branch. 0BRANCH is a conditional branch (it only branches if the + top of stack is zero). + + This is how BRANCH works. When BRANCH executes, %esi starts by pointing to the offset: + + +---------------------+-------+---- - - ---+------------+------------+---- - - - ----+------------+ + | (Dictionary header) | DOCOL | | BRANCH | offset | (skipped) | word | + +---------------------+-------+---- - - ---+------------+-----|------+---- - - - ----+------------+ + ^ | ^ + | | | + | +-----------------------+ + %esi added to offset + + The offset is added to %esi to make the new %esi, and the result is that when NEXT runs, execution + continues at the branch target. Negative offsets work as expected. + + 0BRANCH is the same except the branch happens conditionally. + + Now standard FORTH words such as IF, THEN, ELSE, WHILE, REPEAT, etc. are implemented entirely + in FORTH. They are IMMEDIATE words which append various combinations of BRANCH or 0BRANCH + into the word currently being compiled. + + As an example, code written like this: + + condition-code IF true-part THEN rest-code + + compiles to: + + condition-code 0BRANCH OFFSET true-part rest-code + | ^ + | | + +-------------+ +*/ + defcode "BRANCH",6,,BRANCH add (%esi),%esi // add the offset to the instruction pointer NEXT @@ -1340,6 +1676,13 @@ _HIDDEN: lodsl // otherwise we need to skip the offset NEXT +/* + PRINTING STRINGS ---------------------------------------------------------------------- + + LITSTRING and EMITSTRING are primitives used to implement the ." operator (which is + written in FORTH). See the definition of that operator below. +*/ + defcode "LITSTRING",9,,LITSTRING lodsl // get the length of the string push %eax // push it on the stack @@ -1349,6 +1692,24 @@ _HIDDEN: andl $~3,%esi NEXT + defcode "EMITSTRING",10,,EMITSTRING + mov $1,%ebx // 1st param: stdout + pop %ecx // 2nd param: address of string + pop %edx // 3rd param: length of string + mov $__NR_write,%eax // write syscall + int $0x80 + NEXT + +/* + COLD START AND INTERPRETER ---------------------------------------------------------------------- + + COLD is the first FORTH function called, almost immediately after the FORTH system "boots". + + INTERPRETER is the FORTH interpreter ("toploop", "toplevel" or REPL might be a more accurate + description). +*/ + + // COLD must not return (ie. must not call EXIT). defword "COLD",4,,COLD .int INTERPRETER // call the interpreter loop (never returns) @@ -1420,19 +1781,60 @@ _HIDDEN: interpret_is_lit: .int 0 // Flag used to record if reading a literal +/* + ODDS AND ENDS ---------------------------------------------------------------------- + + CHAR puts the ASCII code of the first character of the following word on the stack. For example + CHAR A puts 65 on the stack. + + SYSEXIT pops the status off the stack and exits the process (using Linux exit syscall). +*/ + + defcode "CHAR",4,,CHAR + call _WORD // Returns %ecx = length, %edi = pointer to word. + xor %eax,%eax + movb (%edi),%al // Get the first character of the word. + push %eax // Push it onto the stack. + NEXT + // NB: SYSEXIT must be the last entry in the built-in dictionary. defcode SYSEXIT,7,,SYSEXIT pop %ebx mov $__NR_exit,%eax int $0x80 -/*---------------------------------------------------------------------- - * Input buffer & initial input. - */ +/* + START OF FORTH CODE ---------------------------------------------------------------------- + + We've now reached the stage where the FORTH system is running and self-hosting. All further + words can be written as FORTH itself, including words like IF, THEN, .", etc which in most + languages would be considered rather fundamental. + + As a kind of trick, I prefill the input buffer with the initial FORTH code. Once this code + has run (when we get to the "OK" prompt), this input buffer is reused for reading user input. + + Some notes about the code: + + \ (backslash) is the FORTH way to start a comment which goes up to the next newline. However + because this is a C-style string, I have to escape the backslash, which is why they appear as + \\ comment. + + Similarly, any backslashes in the code are doubled, and " becomes \" (eg. the definition of ." + is written as : .\" ... ;) + + I use indenting to show structure. The amount of whitespace has no meaning to FORTH however + except that you must use at least one whitespace character between words, and words themselves + cannot contain whitespace. + + FORTH is case-sensitive. Use capslock! + + Enjoy! +*/ + .data .align 4096 buffer: - // XXX gives 'Warning: unterminated string; newline inserted' messages which you can ignore + // Multi-line constant gives 'Warning: unterminated string; newline inserted' messages which you can ignore .ascii "\ \\ Define some character constants : '\\n' 10 ; @@ -1661,3 +2063,5 @@ currkey: .int buffer bufftop: .int _initbufftop + +/* END OF jonesforth.S */