diff --git a/README.md b/README.md index 1bf772b..4f81e0e 100644 --- a/README.md +++ b/README.md @@ -4,16 +4,23 @@ Alee is a portable and concise Forth implementation in modern C++. Its primary aims are for reduced program size and execution efficiency. Portability includes bare-metal platforms, with intentions to support microcontrollers with kilobytes of memory. -## Compatibility +## Cross-platform compatibility -A base dictionary is being built by working through the "core" and "core extension" [glossaries](https://forth-standard.org/standard/core). These word lists are included in `compat.txt`, with "yes" indicating that the word is implemented either in `core.fth` or within Alee itself. +Alee relies on the C++17 standard. Alee *does not* rely on operating-system-specific functions, making portability easy. See the `msp430` target for an example of a port. -A `sys` word is available to provide access to user-defined C++ functions. +System-specific functionality such as text output is contained to a `sys` word. This word calls a user-supplied `user_sys` C++ function that should implement the necessary (or any additional) system-specific functionality. + +# Forth compatibility + +A base dictionary is being built by working through the "core" and "core extension" [glossaries](https://forth-standard.org/standard/core). These glossaries are listed in `compat.txt`, with "yes" indicating that the word is implemented either in `core.fth` or within Alee itself. `core.fth` may be compiled into a binary for loading on targets without filesystems. + +Alee Forth aims for compliance with common Forth standards like Forth 2012 and ANS Forth. Compliance is tested using a [Forth 2012 test suite](https://github.com/gerryjackson/forth2012-test-suite). Supported test files are in the `test` directory, with non-passing or unimplemented tests commented out. ## Building Alee requires `make` and a C++17-compatible compiler. To compile, simply run the `make` command. This will produce a library, `libalee.a`, as well as a REPL binary named `alee`. -A `small` target exists that optimizes the build for size. +A `small` target exists that optimizes the build for size. +A `fast` target exists that optimizes for maximum performance on the host (not target) system. diff --git a/alee.cpp b/alee.cpp index c5b0a95..d3e4c4c 100644 --- a/alee.cpp +++ b/alee.cpp @@ -19,6 +19,7 @@ #include "alee.hpp" #include "memdict.hpp" +#include #include #include #include @@ -35,11 +36,7 @@ int main(int argc, char *argv[]) State state (dict, readchar); Parser parser; - dict.write(Dictionary::Base, 10); - dict.write(Dictionary::Here, Dictionary::Begin); - dict.write(Dictionary::Latest, Dictionary::Begin); - dict.write(Dictionary::Compiling, 0); - dict.write(Dictionary::Postpone, 0); + dict.initialize(); std::vector args (argv + 1, argv + argc); for (const auto& a : args) { @@ -63,6 +60,8 @@ static void readchar(State& state) state.dict.writebyte(addr, state.dict.readbyte(addr + 1)); auto c = std::cin.get(); + if (isupper(c)) + c += 32; state.dict.writebyte(addr, c ? c : ' '); state.dict.write(Dictionary::Input, len + 1); } @@ -88,19 +87,31 @@ static void load(State& state) void user_sys(State& state) { + char buf[32] = {0}; + switch (state.pop()) { - case 0: - std::cout << state.pop() << ' '; + case 0: // . + std::to_chars(buf, buf + sizeof(buf), state.pop(), + state.dict.read(Dictionary::Base)); + std::cout << buf << ' '; break; - case 1: + case 1: // emit std::cout << static_cast(state.pop()); break; - case 2: + case 2: // save save(state); break; - case 3: + case 3: // load load(state); break; + case 4: // u. + { + Addr ucell = static_cast(state.pop()); + std::to_chars(buf, buf + sizeof(buf), ucell, + state.dict.read(Dictionary::Base)); + std::cout << buf << ' '; + } + break; } } @@ -132,6 +143,12 @@ void parseLine(Parser& parser, State& state, const std::string& line) std::cout << "error: " << r << std::endl; break; } + + while (state.size()) + state.pop(); + while (state.rsize()) + state.popr(); + state.dict.write(Dictionary::Compiling, 0); } } @@ -140,6 +157,7 @@ void parseFile(Parser& parser, State& state, std::istream& file) while (file.good()) { std::string line; std::getline(file, line); + if (line == "bye") exit(0); diff --git a/core.fth b/core.fth index 5832a95..e3ec5d0 100644 --- a/core.fth +++ b/core.fth @@ -1,16 +1,19 @@ : * m* drop ; -: / 0 swap _/ ; -: % 0 swap _% ; +: s>d 1 m* ; +: / >r s>d r> _/ ; +: % >r s>d r> _% ; : cell+ 2 + ; : cells 2 * ; : . 0 sys ; : emit 1 sys ; +: u. 4 sys ; : 1+ 1 + ; : 1- 1 - ; +: ' _' drop ; : ! 1 _! ; : @ 1 _@ ; : +! dup >r swap r> @ + swap ! ; @@ -19,13 +22,27 @@ : here 1 cells @ ; : allot 1 cells +! ; : _latest 2 cells ; -: imm _latest @ dup @ 1 6 << | swap ! ; +: imm _latest @ dup @ 1 5 << | swap ! ; +: immediate imm ; : state 3 cells ; -: postpone 1 4 cells ! ; imm -: _input 5 cells ; +: _input 4 cells ; : , here ! 1 cells allot ; +: [ 0 state ! ; imm +: ] 1 state ! ; + +: literal [ ' _lit dup , , ] , , ; imm +: ['] ' [ ' literal , ] ; imm + +: if ['] _jmp0 , here 0 , ; imm +: then here swap ! ; imm +: else ['] _jmp , here 0 , swap here swap ! ; imm + +: postpone _' dup 0 = if exit then + 1 = swap ['] _lit , , if ['] execute , + else ['] , , then ; imm + : over 1 pick ; : rot >r swap r> swap ; : -rot rot rot ; @@ -46,11 +63,6 @@ : decimal 10 base ! ; : hex 16 base ! ; -: literal 1 , , ; imm -: ['] ' postpone literal ; imm -: [ 0 state ! ; imm -: ] 1 state ! ; - : 2r> ['] r> , ['] r> , ['] swap , ; imm : 2>r ['] swap , ['] >r , ['] >r , ; imm : 2r@ ['] r> , ['] r> , ['] 2dup , ['] >r , ['] >r , ['] swap , ; imm @@ -61,16 +73,12 @@ : 0= 0 = ; : 0< 0 < ; -: <= - 1- 0< ; +: <= 2dup < >r = r> | ; : > swap < ; : <> = 0= ; : 0<> 0= 0= ; : 0> 0 > ; -: if ['] _jmp0 , here 0 , ; imm -: then here swap ! ; imm -: else ['] _jmp , here 0 , here rot ! ; imm - : begin 0 here ; imm : while swap 1+ swap postpone if -rot ; imm : repeat ['] _jmp , , if postpone then then ; imm @@ -81,21 +89,20 @@ : ?do ['] 2dup , ['] _lit , here 0 , ['] >r , ['] = , postpone if ['] 2drop , postpone 2r> ['] drop , ['] >r , ['] exit , postpone then postpone 2>r here ; imm -: unloop postpone 2r> ['] 2drop , ; imm -: leave postpone unloop postpone 2r> +: unloop postpone 2r> ['] 2drop , ['] r> , ['] drop , ; imm +: leave postpone 2r> ['] 2drop , postpone 2r> ['] drop , ['] >r , ['] exit , ; imm : +loop postpone 2r> ['] 2dup , ['] swap , ['] < , ['] >r , ['] rot , ['] + , ['] 2dup , ['] swap , ['] < , ['] r> , ['] ^ , ['] -rot , postpone 2>r ['] _jmp0 , , - postpone unloop - here swap ! ['] r> , ['] drop , ; imm + postpone unloop here swap ! ; imm : loop postpone 2r> ['] 1+ , ['] 2dup , postpone 2>r ['] = , ['] _jmp0 , , - postpone unloop - here swap ! ['] r> , ['] drop , ; imm + postpone unloop here swap ! ; imm : i postpone r@ ; imm -: j postpone 2r> postpone r@ ['] -rot , postpone 2>r ; imm +: j postpone 2r> ['] r> , postpone r@ ['] swap , + ['] >r , ['] -rot , postpone 2>r ; imm : align here 1 cells 1- tuck & if 1 cells swap - allot else drop then ; : aligned dup 1 cells 1- tuck & if 1 cells swap - + else drop then ; @@ -108,10 +115,10 @@ : invert -1 ^ ; : mod % ; : 2* 2 * ; -: 2/ 2 / ; +: _msb 1 1 cells 8 * 1- << ; +: 2/ dup 1 >> swap 0< if _msb or then ; : /mod 2dup % -rot / ; -: s>d 1 m* ; : */ >r m* r> _/ ; : */mod >r m* 2dup r@ _% r> _/ ; : sm/rem >r 2dup r@ _% -rot r> _/ ; @@ -162,10 +169,8 @@ : create align here bl word count nip cell+ allot align ['] _lit , here 3 cells + , ['] exit dup , , - dup @ 31 & over _latest @ - 7 << or over ! _latest ! ; -: _latword _latest @ - dup @ 31 & + cell+ aligned ; -: _does> _latword 2 cells + + dup @ 31 & over _latest @ - 6 << or over ! _latest ! ; +: _does> _latest @ dup @ 31 & + cell+ aligned 2 cells + ['] _jmp over ! cell+ r@ 1 cells - @ swap ! ; : does> ['] _jmp , here 2 cells + dup , 2 cells + , @@ -196,12 +201,14 @@ postpone if ['] type , ['] abort , postpone else ['] 2drop , postpone then ; imm -: recurse _latword , ; imm +: recurse depth 1- pick dup @ 31 & + cell+ aligned , ; imm -: move begin dup 0 > while - rot dup @ >r 1+ - rot r> over ! 1+ - rot 1- repeat drop 2drop ; +: move dup 0 <= if drop 2drop exit then + >r 2dup < r> swap if + 1- 0 swap do over i + c@ over i + c! -1 +loop + else + 0 do over i + c@ over i + c! loop + then 2drop ; : fill -rot begin dup 0 > while >r 2dup c! char+ r> 1- repeat 2drop drop ; diff --git a/corewords.cpp b/corewords.cpp index 49a757a..ff09bcc 100644 --- a/corewords.cpp +++ b/corewords.cpp @@ -30,40 +30,29 @@ Word getword(State& state) } return word; } -void newdef(Dictionary& dict, Word word) +void newdef(State& state, Word word) { + auto& dict = state.dict; + auto addr = dict.alignhere(); dict.addDefinition(word); - dict.write(addr, - (dict.read(addr) & 0x1F) | - ((addr - dict.latest()) << 7)); - dict.latest(addr); + state.push(addr); }; void tick(State& state) { auto word = getword(state); - if (auto j = state.dict.find(word); j > 0) + if (auto j = state.dict.find(word); j > 0) { state.push(state.dict.getexec(j)); - else if (auto i = CoreWords::findi(state, word); i >= 0) - state.push(((i & ~CoreWords::Immediate) << 1) | 1); - else + auto imm = state.dict.read(j) & CoreWords::Immediate; + state.push(imm ? 1 : -1); + } else if (auto i = CoreWords::findi(state, word); i >= 0) { + state.push(i); + state.push(i == CoreWords::Semicolon ? 1 : -1); + } else { + state.push(0); state.push(0); + } } -// auto addr = state.pop(); -// auto count = state.dict.read(addr++); -// Word word (addr, addr + count); -// -// if (auto j = state.dict.find(word); j > 0) { -// state.push(state.dict.getexec(j)); -// auto imm = state.dict.read(ins) & CoreWords::Immediate; -// state.push(imm ? 1 : -1); -// } else if (auto i = CoreWords::findi(state, word); i >= 0) { -// state.push(((i & ~CoreWords::Immediate) << 1) | 1); -// state.push((i & CoreWords::Immediate) ? 1 : -1); -// } else { -// state.push(addr); -// state.push(0); -// } void CoreWords::run(unsigned int index, State& state) { @@ -71,14 +60,14 @@ void CoreWords::run(unsigned int index, State& state) DoubleCell dcell; execute: - if ((index & 1) == 0) { + if (/*(index & 1) == 0 &&*/ index >= WordCount) { // must be calling a defined subroutine state.pushr(state.ip); state.ip = index; return; - } else switch ((index & 0x3E) >> 1) { + } else switch (index & 0x1F) { case 0: // _lit - state.push((index & 0xFF00) ? (index >> 8) - 1 : state.beyondip()); + state.push(/*(index & 0xFF00) ? ((Addr)index >> 8u) - 1 :*/ state.beyondip()); break; case 1: // drop state.pop(); @@ -144,11 +133,11 @@ execute: break; case 15: // equal cell = state.pop(); - state.top() = state.top() == cell; + state.top() = state.top() == cell ? -1 : 0; break; case 16: // lt cell = state.pop(); - state.top() = state.top() < cell; + state.top() = state.top() < cell ? -1 : 0; break; case 17: // and cell = state.pop(); @@ -164,14 +153,14 @@ execute: break; case 20: // shl cell = state.pop(); - state.top() <<= cell; + reinterpret_cast(state.top()) <<= static_cast(cell); break; case 21: // shr cell = state.pop(); - state.top() >>= cell; + reinterpret_cast(state.top()) >>= static_cast(cell); break; case 22: // colon - newdef(state.dict, getword(state)); + newdef(state, getword(state)); state.compiling(true); break; case 23: // tick @@ -188,8 +177,16 @@ execute: } break; case 26: // semic - state.dict.add((findi("exit") << 1) | 1); + { + state.dict.add(findi("exit")); state.compiling(false); + + auto addr = state.pop(); + state.dict.write(addr, + (state.dict.read(addr) & 0x1F) | + ((addr - state.dict.latest()) << 6)); + state.dict.latest(addr); + } break; case 27: // _jmp0 if (state.pop()) { diff --git a/corewords.hpp b/corewords.hpp index 9546ac1..21a0951 100644 --- a/corewords.hpp +++ b/corewords.hpp @@ -29,7 +29,7 @@ class CoreWords public: constexpr static std::size_t WordCount = 32; - constexpr static Cell Immediate = (1 << 6); + constexpr static Cell Immediate = (1 << 5); constexpr static int Semicolon = 26; @@ -43,7 +43,7 @@ private: "+\0-\0m*\0_/\0_%\0" "_@\0_!\0>r\0r>\0=\0" "<\0&\0|\0^\0" - "<<\0>>\0:\0'\0execute\0" + "<<\0>>\0:\0_'\0execute\0" "exit\0;\0_jmp0\0_jmp\0" "depth\0_rdepth\0_in\0"; }; diff --git a/dictionary.cpp b/dictionary.cpp index fe19684..27fcb47 100644 --- a/dictionary.cpp +++ b/dictionary.cpp @@ -21,6 +21,14 @@ #include #include +void Dictionary::initialize() +{ + write(Base, 10); + write(Here, Begin); + write(Latest, Begin); + write(Compiling, 0); +} + Addr Dictionary::allot(Cell amount) noexcept { Addr old = here(); @@ -62,7 +70,7 @@ Addr Dictionary::find(Word word) noexcept Addr lt = latest(), oldlt; do { oldlt = lt; - const Cell l = read(lt); + const auto l = static_cast(read(lt)); const Addr len = l & 0x1F; const Word lw { static_cast(lt + sizeof(Cell)), @@ -72,7 +80,7 @@ Addr Dictionary::find(Word word) noexcept if (equal(word, lw)) return lt; else - lt -= l >> 7; + lt -= l >> 6; } while (lt != oldlt); return 0; @@ -118,8 +126,15 @@ bool Dictionary::equal(Word word, const char *str, unsigned len) const noexcept return false; for (auto w = word.start; w != word.end; ++w) { - if (readbyte(w) != *str) + auto wc = readbyte(w); + if (wc != *str) { + if (isalpha(wc) && isalpha(*str) && (wc | 32) == (*str | 32)) { + ++str; + continue; + } + return false; + } ++str; } @@ -134,8 +149,15 @@ bool Dictionary::equal(Word word, Word other) const noexcept auto w = word.start, o = other.start; while (w != word.end) { - if (readbyte(w) != readbyte(o)) + auto wc = readbyte(w), oc = readbyte(o); + if (wc != oc) { + if (isalpha(wc) && isalpha(oc) && (wc | 32) == (oc | 32)) { + ++w, ++o; + continue; + } + return false; + } ++w, ++o; } diff --git a/dictionary.hpp b/dictionary.hpp index 1321875..48d4e1b 100644 --- a/dictionary.hpp +++ b/dictionary.hpp @@ -31,10 +31,11 @@ public: constexpr static Addr Here = sizeof(Cell); constexpr static Addr Latest = sizeof(Cell) * 2; constexpr static Addr Compiling = sizeof(Cell) * 3; - constexpr static Addr Postpone = sizeof(Cell) * 4; - constexpr static Addr Input = sizeof(Cell) * 5; // len data... + constexpr static Addr Input = sizeof(Cell) * 4; // len data... constexpr static Addr InputCells = 80; // bytes! - constexpr static Addr Begin = sizeof(Cell) * 6 + InputCells; + constexpr static Addr Begin = sizeof(Cell) * 5 + InputCells; + + void initialize(); Addr here() const noexcept { return read(Here); } void here(Addr l) noexcept { write(Here, l); } diff --git a/memdict.hpp b/memdict.hpp index 65063e0..c8ccce0 100644 --- a/memdict.hpp +++ b/memdict.hpp @@ -22,7 +22,7 @@ #include "dictionary.hpp" #ifndef MEMDICTSIZE -#define MEMDICTSIZE (4096) +#define MEMDICTSIZE (65536) #endif constexpr unsigned long int MemDictSize = MEMDICTSIZE; diff --git a/parser.cpp b/parser.cpp index 7335f90..9390a79 100644 --- a/parser.cpp +++ b/parser.cpp @@ -59,27 +59,19 @@ int Parser::parseWord(State& state, Word word) if (ins <= 0) { ins = CoreWords::findi(state, word); - if (ins < 0) { + if (ins < 0) return parseNumber(state, word); - } else { + else imm = ins == CoreWords::Semicolon; - ins &= ~CoreWords::Immediate; - ins = (ins << 1) | 1; - } } else { imm = state.dict.read(ins) & CoreWords::Immediate; ins = state.dict.getexec(ins); } - if (state.dict.read(Dictionary::Postpone)) { - state.dict.add(ins); - state.dict.write(Dictionary::Postpone, 0); - } else if (state.compiling() && !imm) { + if (state.compiling() && !imm) state.dict.add(ins); - } else { - if (auto stat = state.execute(ins); stat != State::Error::none) - return static_cast(stat); - } + else if (auto stat = state.execute(ins); stat != State::Error::none) + return static_cast(stat); return 0; } @@ -93,19 +85,20 @@ int Parser::parseNumber(State& state, Word word) buf[i] = '\0'; auto base = state.dict.read(0); - Cell l; - auto [ptr, ec] = std::from_chars(buf, buf + i, l, base); + DoubleCell dl; + auto [ptr, ec] = std::from_chars(buf, buf + i, dl, base); + Cell l = static_cast(dl); if (ec == std::errc() && ptr == buf + i) { if (state.compiling()) { - auto ins = (CoreWords::findi("_lit") << 1) | 1; + auto ins = CoreWords::findi("_lit"); - if (l >= 0 && l < 0xFF) { - state.dict.add(ins | ((l + 1) << 8)); - } else { + //if (l >= 0 && l < 0xFF) { + // state.dict.add(ins | ((l + 1) << 8)); + //} else { state.dict.add(ins); state.dict.add(l); - } + //} } else { state.push(l); } diff --git a/test/core.fr b/test/core.fr new file mode 100644 index 0000000..229ca29 --- /dev/null +++ b/test/core.fr @@ -0,0 +1,1017 @@ +\ From: John Hayes S1I +\ Subject: core.fr +\ Date: Mon, 27 Nov 95 13:10 + +\ (C) 1995 JOHNS HOPKINS UNIVERSITY / APPLIED PHYSICS LABORATORY +\ MAY BE DISTRIBUTED FREELY AS LONG AS THIS COPYRIGHT NOTICE REMAINS. +\ VERSION 1.2 +\ THIS PROGRAM TESTS THE CORE WORDS OF AN ANS FORTH SYSTEM. +\ THE PROGRAM ASSUMES A TWO'S COMPLEMENT IMPLEMENTATION WHERE +\ THE RANGE OF SIGNED NUMBERS IS -2^(N-1) ... 2^(N-1)-1 AND +\ THE RANGE OF UNSIGNED NUMBERS IS 0 ... 2^(N)-1. +\ I HAVEN'T FIGURED OUT HOW TO TEST KEY, QUIT, ABORT, OR ABORT"... +\ I ALSO HAVEN'T THOUGHT OF A WAY TO TEST ENVIRONMENT?... + +CR +." TESTING CORE WORDS" CR +HEX + +\ ------------------------------------------------------------------------ +." TESTING BASIC ASSUMPTIONS" CR + +T{ -> }T \ START WITH CLEAN SLATE +( TEST IF ANY BITS ARE SET; ANSWER IN BASE 1 ) +T{ : BITSSET? IF 0 0 ELSE 0 THEN ; -> }T +T{ 0 BITSSET? -> 0 }T ( ZERO IS ALL BITS CLEAR ) +T{ 1 BITSSET? -> 0 0 }T ( OTHER NUMBER HAVE AT LEAST ONE BIT ) +T{ -1 BITSSET? -> 0 0 }T + +\ ------------------------------------------------------------------------ +." TESTING BOOLEANS: INVERT AND OR XOR" CR + +T{ 0 0 AND -> 0 }T +T{ 0 1 AND -> 0 }T +T{ 1 0 AND -> 0 }T +T{ 1 1 AND -> 1 }T + +T{ 0 INVERT 1 AND -> 1 }T +T{ 1 INVERT 1 AND -> 0 }T + +0 CONSTANT 0S +0 INVERT CONSTANT 1S + +T{ 0S INVERT -> 1S }T +T{ 1S INVERT -> 0S }T + +T{ 0S 0S AND -> 0S }T +T{ 0S 1S AND -> 0S }T +T{ 1S 0S AND -> 0S }T +T{ 1S 1S AND -> 1S }T + +T{ 0S 0S OR -> 0S }T +T{ 0S 1S OR -> 1S }T +T{ 1S 0S OR -> 1S }T +T{ 1S 1S OR -> 1S }T + +T{ 0S 0S XOR -> 0S }T +T{ 0S 1S XOR -> 1S }T +T{ 1S 0S XOR -> 1S }T +T{ 1S 1S XOR -> 0S }T + +\ ------------------------------------------------------------------------ +." TESTING 2* 2/ LSHIFT RSHIFT" CR + +( WE TRUST 1S, INVERT, AND BITSSET?; WE WILL CONFIRM RSHIFT LATER ) +1S 1 RSHIFT INVERT CONSTANT MSB +T{ MSB BITSSET? -> 0 0 }T + +T{ 0S 2* -> 0S }T +T{ 1 2* -> 2 }T +T{ 4000 2* -> 8000 }T +T{ 1S 2* 1 XOR -> 1S }T +T{ MSB 2* -> 0S }T + +T{ 0S 2/ -> 0S }T +T{ 1 2/ -> 0 }T +T{ 4000 2/ -> 2000 }T +T{ 1S 2/ -> 1S }T \ MSB PROPOGATED +T{ 1S 1 XOR 2/ -> 1S }T +T{ MSB 2/ MSB AND -> MSB }T + +T{ 1 0 LSHIFT -> 1 }T +T{ 1 1 LSHIFT -> 2 }T +T{ 1 2 LSHIFT -> 4 }T +T{ 1 F LSHIFT -> 8000 }T \ BIGGEST GUARANTEED SHIFT +T{ 1S 1 LSHIFT 1 XOR -> 1S }T +T{ MSB 1 LSHIFT -> 0 }T + +T{ 1 0 RSHIFT -> 1 }T +T{ 1 1 RSHIFT -> 0 }T +T{ 2 1 RSHIFT -> 1 }T +T{ 4 2 RSHIFT -> 1 }T +T{ 8000 F RSHIFT -> 1 }T \ BIGGEST +T{ MSB 1 RSHIFT MSB AND -> 0 }T \ RSHIFT ZERO FILLS MSBS +T{ MSB 1 RSHIFT 2* -> MSB }T + +\ ------------------------------------------------------------------------ +." TESTING COMPARISONS: 0= = 0< < > U< MIN MAX" CR +0 INVERT CONSTANT MAX-UINT +0 INVERT 1 RSHIFT CONSTANT MAX-INT +0 INVERT 1 RSHIFT INVERT CONSTANT MIN-INT +0 INVERT 1 RSHIFT CONSTANT MID-UINT +0 INVERT 1 RSHIFT INVERT CONSTANT MID-UINT+1 + +0S CONSTANT +1S CONSTANT + +T{ 0 0= -> }T +T{ 1 0= -> }T +T{ 2 0= -> }T +T{ -1 0= -> }T +T{ MAX-UINT 0= -> }T +T{ MIN-INT 0= -> }T +T{ MAX-INT 0= -> }T + +T{ 0 0 = -> }T +T{ 1 1 = -> }T +T{ -1 -1 = -> }T +T{ 1 0 = -> }T +T{ -1 0 = -> }T +T{ 0 1 = -> }T +T{ 0 -1 = -> }T + +T{ 0 0< -> }T +T{ -1 0< -> }T +T{ MIN-INT 0< -> }T +T{ 1 0< -> }T +T{ MAX-INT 0< -> }T + +T{ 0 1 < -> }T +T{ 1 2 < -> }T +T{ -1 0 < -> }T +T{ -1 1 < -> }T +T{ MIN-INT 0 < -> }T +T{ MIN-INT MAX-INT < -> }T +T{ 0 MAX-INT < -> }T +T{ 0 0 < -> }T +T{ 1 1 < -> }T +T{ 1 0 < -> }T +T{ 2 1 < -> }T +T{ 0 -1 < -> }T +T{ 1 -1 < -> }T +T{ 0 MIN-INT < -> }T +T{ MAX-INT MIN-INT < -> }T +T{ MAX-INT 0 < -> }T + +T{ 0 1 > -> }T +T{ 1 2 > -> }T +T{ -1 0 > -> }T +T{ -1 1 > -> }T +T{ MIN-INT 0 > -> }T +T{ MIN-INT MAX-INT > -> }T +T{ 0 MAX-INT > -> }T +T{ 0 0 > -> }T +T{ 1 1 > -> }T +T{ 1 0 > -> }T +T{ 2 1 > -> }T +T{ 0 -1 > -> }T +T{ 1 -1 > -> }T +T{ 0 MIN-INT > -> }T +T{ MAX-INT MIN-INT > -> }T +T{ MAX-INT 0 > -> }T + +." HEY! U< IS NOT IMPLEMENTED!" CR +\ T{ 0 1 U< -> }T +\ T{ 1 2 U< -> }T +\ T{ 0 MID-UINT U< -> }T +\ T{ 0 MAX-UINT U< -> }T +\ T{ MID-UINT MAX-UINT U< -> }T +\ T{ 0 0 U< -> }T +\ T{ 1 1 U< -> }T +\ T{ 1 0 U< -> }T +\ T{ 2 1 U< -> }T +\ T{ MID-UINT 0 U< -> }T +\ T{ MAX-UINT 0 U< -> }T +\ T{ MAX-UINT MID-UINT U< -> }T + +T{ 0 1 MIN -> 0 }T +T{ 1 2 MIN -> 1 }T +T{ -1 0 MIN -> -1 }T +T{ -1 1 MIN -> -1 }T +T{ MIN-INT 0 MIN -> MIN-INT }T +T{ MIN-INT MAX-INT MIN -> MIN-INT }T +T{ 0 MAX-INT MIN -> 0 }T +T{ 0 0 MIN -> 0 }T +T{ 1 1 MIN -> 1 }T +T{ 1 0 MIN -> 0 }T +T{ 2 1 MIN -> 1 }T +T{ 0 -1 MIN -> -1 }T +T{ 1 -1 MIN -> -1 }T +T{ 0 MIN-INT MIN -> MIN-INT }T +T{ MAX-INT MIN-INT MIN -> MIN-INT }T +T{ MAX-INT 0 MIN -> 0 }T + +T{ 0 1 MAX -> 1 }T +T{ 1 2 MAX -> 2 }T +T{ -1 0 MAX -> 0 }T +T{ -1 1 MAX -> 1 }T +T{ MIN-INT 0 MAX -> 0 }T +T{ MIN-INT MAX-INT MAX -> MAX-INT }T +T{ 0 MAX-INT MAX -> MAX-INT }T +T{ 0 0 MAX -> 0 }T +T{ 1 1 MAX -> 1 }T +T{ 1 0 MAX -> 1 }T +T{ 2 1 MAX -> 2 }T +T{ 0 -1 MAX -> 0 }T +T{ 1 -1 MAX -> 1 }T +T{ 0 MIN-INT MAX -> 0 }T +T{ MAX-INT MIN-INT MAX -> MAX-INT }T +T{ MAX-INT 0 MAX -> MAX-INT }T + +\ ------------------------------------------------------------------------ +." TESTING STACK OPS: 2DROP 2DUP 2OVER 2SWAP ?DUP DEPTH DROP DUP OVER ROT SWAP" +CR + +T{ 1 2 2DROP -> }T +T{ 1 2 2DUP -> 1 2 1 2 }T +T{ 1 2 3 4 2OVER -> 1 2 3 4 1 2 }T +T{ 1 2 3 4 2SWAP -> 3 4 1 2 }T +T{ 0 ?DUP -> 0 }T +T{ 1 ?DUP -> 1 1 }T +T{ -1 ?DUP -> -1 -1 }T +T{ DEPTH -> 0 }T +T{ 0 DEPTH -> 0 1 }T +T{ 0 1 DEPTH -> 0 1 2 }T +T{ 0 DROP -> }T +T{ 1 2 DROP -> 1 }T +T{ 1 DUP -> 1 1 }T +T{ 1 2 OVER -> 1 2 1 }T +T{ 1 2 3 ROT -> 2 3 1 }T +T{ 1 2 SWAP -> 2 1 }T + +\ ------------------------------------------------------------------------ +." TESTING >R R> R@" CR + +T{ : GR1 >R R> ; -> }T +T{ : GR2 >R R@ R> DROP ; -> }T +T{ 123 GR1 -> 123 }T +T{ 123 GR2 -> 123 }T +T{ 1S GR1 -> 1S }T ( RETURN STACK HOLDS CELLS ) + +\ ------------------------------------------------------------------------ +." TESTING ADD/SUBTRACT: + - 1+ 1- ABS NEGATE" CR + +T{ 0 5 + -> 5 }T +T{ 5 0 + -> 5 }T +T{ 0 -5 + -> -5 }T +T{ -5 0 + -> -5 }T +T{ 1 2 + -> 3 }T +T{ 1 -2 + -> -1 }T +T{ -1 2 + -> 1 }T +T{ -1 -2 + -> -3 }T +T{ -1 1 + -> 0 }T +T{ MID-UINT 1 + -> MID-UINT+1 }T + +T{ 0 5 - -> -5 }T +T{ 5 0 - -> 5 }T +T{ 0 -5 - -> 5 }T +T{ -5 0 - -> -5 }T +T{ 1 2 - -> -1 }T +T{ 1 -2 - -> 3 }T +T{ -1 2 - -> -3 }T +T{ -1 -2 - -> 1 }T +T{ 0 1 - -> -1 }T +T{ MID-UINT+1 1 - -> MID-UINT }T + +T{ 0 1+ -> 1 }T +T{ -1 1+ -> 0 }T +T{ 1 1+ -> 2 }T +T{ MID-UINT 1+ -> MID-UINT+1 }T + +T{ 2 1- -> 1 }T +T{ 1 1- -> 0 }T +T{ 0 1- -> -1 }T +T{ MID-UINT+1 1- -> MID-UINT }T + +T{ 0 NEGATE -> 0 }T +T{ 1 NEGATE -> -1 }T +T{ -1 NEGATE -> 1 }T +T{ 2 NEGATE -> -2 }T +T{ -2 NEGATE -> 2 }T + +T{ 0 ABS -> 0 }T +T{ 1 ABS -> 1 }T +T{ -1 ABS -> 1 }T +T{ MIN-INT ABS -> MID-UINT+1 }T + +\ ------------------------------------------------------------------------ +." TESTING MULTIPLY: S>D * M* UM*" CR + +T{ 0 S>D -> 0 0 }T +T{ 1 S>D -> 1 0 }T +T{ 2 S>D -> 2 0 }T +T{ -1 S>D -> -1 -1 }T +T{ -2 S>D -> -2 -1 }T +T{ MIN-INT S>D -> MIN-INT -1 }T +T{ MAX-INT S>D -> MAX-INT 0 }T + +T{ 0 0 M* -> 0 S>D }T +T{ 0 1 M* -> 0 S>D }T +T{ 1 0 M* -> 0 S>D }T +T{ 1 2 M* -> 2 S>D }T +T{ 2 1 M* -> 2 S>D }T +T{ 3 3 M* -> 9 S>D }T +T{ -3 3 M* -> -9 S>D }T +T{ 3 -3 M* -> -9 S>D }T +T{ -3 -3 M* -> 9 S>D }T +T{ 0 MIN-INT M* -> 0 S>D }T +T{ 1 MIN-INT M* -> MIN-INT S>D }T +T{ 2 MIN-INT M* -> 0 1S }T +T{ 0 MAX-INT M* -> 0 S>D }T +T{ 1 MAX-INT M* -> MAX-INT S>D }T +T{ 2 MAX-INT M* -> MAX-INT 1 LSHIFT 0 }T +T{ MIN-INT MIN-INT M* -> 0 MSB 1 RSHIFT }T +T{ MAX-INT MIN-INT M* -> MSB MSB 2/ }T +T{ MAX-INT MAX-INT M* -> 1 MSB 2/ INVERT }T + +T{ 0 0 * -> 0 }T \ TEST IDENTITIES +T{ 0 1 * -> 0 }T +T{ 1 0 * -> 0 }T +T{ 1 2 * -> 2 }T +T{ 2 1 * -> 2 }T +T{ 3 3 * -> 9 }T +T{ -3 3 * -> -9 }T +T{ 3 -3 * -> -9 }T +T{ -3 -3 * -> 9 }T + +T{ MID-UINT+1 1 RSHIFT 2 * -> MID-UINT+1 }T +T{ MID-UINT+1 2 RSHIFT 4 * -> MID-UINT+1 }T +T{ MID-UINT+1 1 RSHIFT MID-UINT+1 OR 2 * -> MID-UINT+1 }T + +." HEY! UM* IS NOT IMPLEMENTED!" CR +\ T{ 0 0 UM* -> 0 0 }T +\ T{ 0 1 UM* -> 0 0 }T +\ T{ 1 0 UM* -> 0 0 }T +\ T{ 1 2 UM* -> 2 0 }T +\ T{ 2 1 UM* -> 2 0 }T +\ T{ 3 3 UM* -> 9 0 }T +\ +\ T{ MID-UINT+1 1 RSHIFT 2 UM* -> MID-UINT+1 0 }T +\ T{ MID-UINT+1 2 UM* -> 0 1 }T +\ T{ MID-UINT+1 4 UM* -> 0 2 }T +\ T{ 1S 2 UM* -> 1S 1 LSHIFT 1 }T +\ T{ MAX-UINT MAX-UINT UM* -> 1 1 INVERT }T + +\ \ ------------------------------------------------------------------------ +\ TESTING DIVIDE: FM/MOD SM/REM UM/MOD */ */MOD / /MOD MOD +\ +\ T{ 0 S>D 1 FM/MOD -> 0 0 }T +\ T{ 1 S>D 1 FM/MOD -> 0 1 }T +\ T{ 2 S>D 1 FM/MOD -> 0 2 }T +\ T{ -1 S>D 1 FM/MOD -> 0 -1 }T +\ T{ -2 S>D 1 FM/MOD -> 0 -2 }T +\ T{ 0 S>D -1 FM/MOD -> 0 0 }T +\ T{ 1 S>D -1 FM/MOD -> 0 -1 }T +\ T{ 2 S>D -1 FM/MOD -> 0 -2 }T +\ T{ -1 S>D -1 FM/MOD -> 0 1 }T +\ T{ -2 S>D -1 FM/MOD -> 0 2 }T +\ T{ 2 S>D 2 FM/MOD -> 0 1 }T +\ T{ -1 S>D -1 FM/MOD -> 0 1 }T +\ T{ -2 S>D -2 FM/MOD -> 0 1 }T +\ T{ 7 S>D 3 FM/MOD -> 1 2 }T +\ T{ 7 S>D -3 FM/MOD -> -2 -3 }T +\ T{ -7 S>D 3 FM/MOD -> 2 -3 }T +\ T{ -7 S>D -3 FM/MOD -> -1 2 }T +\ T{ MAX-INT S>D 1 FM/MOD -> 0 MAX-INT }T +\ T{ MIN-INT S>D 1 FM/MOD -> 0 MIN-INT }T +\ T{ MAX-INT S>D MAX-INT FM/MOD -> 0 1 }T +\ T{ MIN-INT S>D MIN-INT FM/MOD -> 0 1 }T +\ T{ 1S 1 4 FM/MOD -> 3 MAX-INT }T +\ T{ 1 MIN-INT M* 1 FM/MOD -> 0 MIN-INT }T +\ T{ 1 MIN-INT M* MIN-INT FM/MOD -> 0 1 }T +\ T{ 2 MIN-INT M* 2 FM/MOD -> 0 MIN-INT }T +\ T{ 2 MIN-INT M* MIN-INT FM/MOD -> 0 2 }T +\ T{ 1 MAX-INT M* 1 FM/MOD -> 0 MAX-INT }T +\ T{ 1 MAX-INT M* MAX-INT FM/MOD -> 0 1 }T +\ T{ 2 MAX-INT M* 2 FM/MOD -> 0 MAX-INT }T +\ T{ 2 MAX-INT M* MAX-INT FM/MOD -> 0 2 }T +\ T{ MIN-INT MIN-INT M* MIN-INT FM/MOD -> 0 MIN-INT }T +\ T{ MIN-INT MAX-INT M* MIN-INT FM/MOD -> 0 MAX-INT }T +\ T{ MIN-INT MAX-INT M* MAX-INT FM/MOD -> 0 MIN-INT }T +\ T{ MAX-INT MAX-INT M* MAX-INT FM/MOD -> 0 MAX-INT }T +\ +\ T{ 0 S>D 1 SM/REM -> 0 0 }T +\ T{ 1 S>D 1 SM/REM -> 0 1 }T +\ T{ 2 S>D 1 SM/REM -> 0 2 }T +\ T{ -1 S>D 1 SM/REM -> 0 -1 }T +\ T{ -2 S>D 1 SM/REM -> 0 -2 }T +\ T{ 0 S>D -1 SM/REM -> 0 0 }T +\ T{ 1 S>D -1 SM/REM -> 0 -1 }T +\ T{ 2 S>D -1 SM/REM -> 0 -2 }T +\ T{ -1 S>D -1 SM/REM -> 0 1 }T +\ T{ -2 S>D -1 SM/REM -> 0 2 }T +\ T{ 2 S>D 2 SM/REM -> 0 1 }T +\ T{ -1 S>D -1 SM/REM -> 0 1 }T +\ T{ -2 S>D -2 SM/REM -> 0 1 }T +\ T{ 7 S>D 3 SM/REM -> 1 2 }T +\ T{ 7 S>D -3 SM/REM -> 1 -2 }T +\ T{ -7 S>D 3 SM/REM -> -1 -2 }T +\ T{ -7 S>D -3 SM/REM -> -1 2 }T +\ T{ MAX-INT S>D 1 SM/REM -> 0 MAX-INT }T +\ T{ MIN-INT S>D 1 SM/REM -> 0 MIN-INT }T +\ T{ MAX-INT S>D MAX-INT SM/REM -> 0 1 }T +\ T{ MIN-INT S>D MIN-INT SM/REM -> 0 1 }T +\ T{ 1S 1 4 SM/REM -> 3 MAX-INT }T +\ T{ 2 MIN-INT M* 2 SM/REM -> 0 MIN-INT }T +\ T{ 2 MIN-INT M* MIN-INT SM/REM -> 0 2 }T +\ T{ 2 MAX-INT M* 2 SM/REM -> 0 MAX-INT }T +\ T{ 2 MAX-INT M* MAX-INT SM/REM -> 0 2 }T +\ T{ MIN-INT MIN-INT M* MIN-INT SM/REM -> 0 MIN-INT }T +\ T{ MIN-INT MAX-INT M* MIN-INT SM/REM -> 0 MAX-INT }T +\ T{ MIN-INT MAX-INT M* MAX-INT SM/REM -> 0 MIN-INT }T +\ T{ MAX-INT MAX-INT M* MAX-INT SM/REM -> 0 MAX-INT }T +\ +\ T{ 0 0 1 UM/MOD -> 0 0 }T +\ T{ 1 0 1 UM/MOD -> 0 1 }T +\ T{ 1 0 2 UM/MOD -> 1 0 }T +\ T{ 3 0 2 UM/MOD -> 1 1 }T +\ T{ MAX-UINT 2 UM* 2 UM/MOD -> 0 MAX-UINT }T +\ T{ MAX-UINT 2 UM* MAX-UINT UM/MOD -> 0 2 }T +\ T{ MAX-UINT MAX-UINT UM* MAX-UINT UM/MOD -> 0 MAX-UINT }T +\ +\ : IFFLOORED +\ [ -3 2 / -2 = INVERT ] LITERAL IF POSTPONE \ THEN ; +\ +\ : IFSYM +\ [ -3 2 / -1 = INVERT ] LITERAL IF POSTPONE \ THEN ; +\ +\ \ THE SYSTEM MIGHT DO EITHER FLOORED OR SYMMETRIC DIVISION. +\ \ SINCE WE HAVE ALREADY TESTED M*, FM/MOD, AND SM/REM WE CAN USE THEM IN TEST +\ +\ IFFLOORED : T/MOD >R S>D R> FM/MOD ; +\ IFFLOORED : T/ T/MOD SWAP DROP ; +\ IFFLOORED : TMOD T/MOD DROP ; +\ IFFLOORED : T*/MOD >R M* R> FM/MOD ; +\ IFFLOORED : T*/ T*/MOD SWAP DROP ; +\ IFSYM : T/MOD >R S>D R> SM/REM ; +\ IFSYM : T/ T/MOD SWAP DROP ; +\ IFSYM : TMOD T/MOD DROP ; +\ IFSYM : T*/MOD >R M* R> SM/REM ; +\ IFSYM : T*/ T*/MOD SWAP DROP ; +\ +\ T{ 0 1 /MOD -> 0 1 T/MOD }T +\ T{ 1 1 /MOD -> 1 1 T/MOD }T +\ T{ 2 1 /MOD -> 2 1 T/MOD }T +\ T{ -1 1 /MOD -> -1 1 T/MOD }T +\ T{ -2 1 /MOD -> -2 1 T/MOD }T +\ T{ 0 -1 /MOD -> 0 -1 T/MOD }T +\ T{ 1 -1 /MOD -> 1 -1 T/MOD }T +\ T{ 2 -1 /MOD -> 2 -1 T/MOD }T +\ T{ -1 -1 /MOD -> -1 -1 T/MOD }T +\ T{ -2 -1 /MOD -> -2 -1 T/MOD }T +\ T{ 2 2 /MOD -> 2 2 T/MOD }T +\ T{ -1 -1 /MOD -> -1 -1 T/MOD }T +\ T{ -2 -2 /MOD -> -2 -2 T/MOD }T +\ T{ 7 3 /MOD -> 7 3 T/MOD }T +\ T{ 7 -3 /MOD -> 7 -3 T/MOD }T +\ T{ -7 3 /MOD -> -7 3 T/MOD }T +\ T{ -7 -3 /MOD -> -7 -3 T/MOD }T +\ T{ MAX-INT 1 /MOD -> MAX-INT 1 T/MOD }T +\ T{ MIN-INT 1 /MOD -> MIN-INT 1 T/MOD }T +\ T{ MAX-INT MAX-INT /MOD -> MAX-INT MAX-INT T/MOD }T +\ T{ MIN-INT MIN-INT /MOD -> MIN-INT MIN-INT T/MOD }T +\ +\ T{ 0 1 / -> 0 1 T/ }T +\ T{ 1 1 / -> 1 1 T/ }T +\ T{ 2 1 / -> 2 1 T/ }T +\ T{ -1 1 / -> -1 1 T/ }T +\ T{ -2 1 / -> -2 1 T/ }T +\ T{ 0 -1 / -> 0 -1 T/ }T +\ T{ 1 -1 / -> 1 -1 T/ }T +\ T{ 2 -1 / -> 2 -1 T/ }T +\ T{ -1 -1 / -> -1 -1 T/ }T +\ T{ -2 -1 / -> -2 -1 T/ }T +\ T{ 2 2 / -> 2 2 T/ }T +\ T{ -1 -1 / -> -1 -1 T/ }T +\ T{ -2 -2 / -> -2 -2 T/ }T +\ T{ 7 3 / -> 7 3 T/ }T +\ T{ 7 -3 / -> 7 -3 T/ }T +\ T{ -7 3 / -> -7 3 T/ }T +\ T{ -7 -3 / -> -7 -3 T/ }T +\ T{ MAX-INT 1 / -> MAX-INT 1 T/ }T +\ T{ MIN-INT 1 / -> MIN-INT 1 T/ }T +\ T{ MAX-INT MAX-INT / -> MAX-INT MAX-INT T/ }T +\ T{ MIN-INT MIN-INT / -> MIN-INT MIN-INT T/ }T +\ +\ T{ 0 1 MOD -> 0 1 TMOD }T +\ T{ 1 1 MOD -> 1 1 TMOD }T +\ T{ 2 1 MOD -> 2 1 TMOD }T +\ T{ -1 1 MOD -> -1 1 TMOD }T +\ T{ -2 1 MOD -> -2 1 TMOD }T +\ T{ 0 -1 MOD -> 0 -1 TMOD }T +\ T{ 1 -1 MOD -> 1 -1 TMOD }T +\ T{ 2 -1 MOD -> 2 -1 TMOD }T +\ T{ -1 -1 MOD -> -1 -1 TMOD }T +\ T{ -2 -1 MOD -> -2 -1 TMOD }T +\ T{ 2 2 MOD -> 2 2 TMOD }T +\ T{ -1 -1 MOD -> -1 -1 TMOD }T +\ T{ -2 -2 MOD -> -2 -2 TMOD }T +\ T{ 7 3 MOD -> 7 3 TMOD }T +\ T{ 7 -3 MOD -> 7 -3 TMOD }T +\ T{ -7 3 MOD -> -7 3 TMOD }T +\ T{ -7 -3 MOD -> -7 -3 TMOD }T +\ T{ MAX-INT 1 MOD -> MAX-INT 1 TMOD }T +\ T{ MIN-INT 1 MOD -> MIN-INT 1 TMOD }T +\ T{ MAX-INT MAX-INT MOD -> MAX-INT MAX-INT TMOD }T +\ T{ MIN-INT MIN-INT MOD -> MIN-INT MIN-INT TMOD }T +\ +\ T{ 0 2 1 */ -> 0 2 1 T*/ }T +\ T{ 1 2 1 */ -> 1 2 1 T*/ }T +\ T{ 2 2 1 */ -> 2 2 1 T*/ }T +\ T{ -1 2 1 */ -> -1 2 1 T*/ }T +\ T{ -2 2 1 */ -> -2 2 1 T*/ }T +\ T{ 0 2 -1 */ -> 0 2 -1 T*/ }T +\ T{ 1 2 -1 */ -> 1 2 -1 T*/ }T +\ T{ 2 2 -1 */ -> 2 2 -1 T*/ }T +\ T{ -1 2 -1 */ -> -1 2 -1 T*/ }T +\ T{ -2 2 -1 */ -> -2 2 -1 T*/ }T +\ T{ 2 2 2 */ -> 2 2 2 T*/ }T +\ T{ -1 2 -1 */ -> -1 2 -1 T*/ }T +\ T{ -2 2 -2 */ -> -2 2 -2 T*/ }T +\ T{ 7 2 3 */ -> 7 2 3 T*/ }T +\ T{ 7 2 -3 */ -> 7 2 -3 T*/ }T +\ T{ -7 2 3 */ -> -7 2 3 T*/ }T +\ T{ -7 2 -3 */ -> -7 2 -3 T*/ }T +\ T{ MAX-INT 2 MAX-INT */ -> MAX-INT 2 MAX-INT T*/ }T +\ T{ MIN-INT 2 MIN-INT */ -> MIN-INT 2 MIN-INT T*/ }T +\ +\ T{ 0 2 1 */MOD -> 0 2 1 T*/MOD }T +\ T{ 1 2 1 */MOD -> 1 2 1 T*/MOD }T +\ T{ 2 2 1 */MOD -> 2 2 1 T*/MOD }T +\ T{ -1 2 1 */MOD -> -1 2 1 T*/MOD }T +\ T{ -2 2 1 */MOD -> -2 2 1 T*/MOD }T +\ T{ 0 2 -1 */MOD -> 0 2 -1 T*/MOD }T +\ T{ 1 2 -1 */MOD -> 1 2 -1 T*/MOD }T +\ T{ 2 2 -1 */MOD -> 2 2 -1 T*/MOD }T +\ T{ -1 2 -1 */MOD -> -1 2 -1 T*/MOD }T +\ T{ -2 2 -1 */MOD -> -2 2 -1 T*/MOD }T +\ T{ 2 2 2 */MOD -> 2 2 2 T*/MOD }T +\ T{ -1 2 -1 */MOD -> -1 2 -1 T*/MOD }T +\ T{ -2 2 -2 */MOD -> -2 2 -2 T*/MOD }T +\ T{ 7 2 3 */MOD -> 7 2 3 T*/MOD }T +\ T{ 7 2 -3 */MOD -> 7 2 -3 T*/MOD }T +\ T{ -7 2 3 */MOD -> -7 2 3 T*/MOD }T +\ T{ -7 2 -3 */MOD -> -7 2 -3 T*/MOD }T +\ T{ MAX-INT 2 MAX-INT */MOD -> MAX-INT 2 MAX-INT T*/MOD }T +\ T{ MIN-INT 2 MIN-INT */MOD -> MIN-INT 2 MIN-INT T*/MOD }T +\ +\ ------------------------------------------------------------------------ +." TESTING HERE , @ ! CELL+ CELLS C, C@ C! CHARS 2@ 2! ALIGN ALIGNED +! ALLOT" +CR + +HERE 1 ALLOT +HERE +CONSTANT 2NDA +CONSTANT 1STA +T{ 1STA 2NDA U< -> }T \ HERE MUST GROW WITH ALLOT +T{ 1STA 1+ -> 2NDA }T \ ... BY ONE ADDRESS UNIT +( MISSING TEST: NEGATIVE ALLOT ) + +\ Added by GWJ so that ALIGN can be used before , (comma) is tested +1 ALIGNED CONSTANT ALMNT \ -- 1|2|4|8 for 8|16|32|64 bit alignment +ALIGN +T{ HERE 1 ALLOT ALIGN HERE SWAP - ALMNT = -> }T +\ End of extra test + +HERE 1 , +HERE 2 , +CONSTANT 2ND +CONSTANT 1ST +T{ 1ST 2ND U< -> }T \ HERE MUST GROW WITH ALLOT +T{ 1ST CELL+ -> 2ND }T \ ... BY ONE CELL +T{ 1ST 1 CELLS + -> 2ND }T +T{ 1ST @ 2ND @ -> 1 2 }T +T{ 5 1ST ! -> }T +T{ 1ST @ 2ND @ -> 5 2 }T +T{ 6 2ND ! -> }T +T{ 1ST @ 2ND @ -> 5 6 }T +T{ 1ST 2@ -> 6 5 }T +T{ 2 1 1ST 2! -> }T +T{ 1ST 2@ -> 2 1 }T +T{ 1S 1ST ! 1ST @ -> 1S }T \ CAN STORE CELL-WIDE VALUE + +HERE 1 C, +HERE 2 C, +CONSTANT 2NDC +CONSTANT 1STC +T{ 1STC 2NDC U< -> }T \ HERE MUST GROW WITH ALLOT +T{ 1STC CHAR+ -> 2NDC }T \ ... BY ONE CHAR +T{ 1STC 1 CHARS + -> 2NDC }T +T{ 1STC C@ 2NDC C@ -> 1 2 }T +T{ 3 1STC C! -> }T +T{ 1STC C@ 2NDC C@ -> 3 2 }T +T{ 4 2NDC C! -> }T +T{ 1STC C@ 2NDC C@ -> 3 4 }T + +ALIGN 1 ALLOT HERE ALIGN HERE 3 CELLS ALLOT +CONSTANT A-ADDR CONSTANT UA-ADDR +T{ UA-ADDR ALIGNED -> A-ADDR }T +T{ 1 A-ADDR C! A-ADDR C@ -> 1 }T +T{ 1234 A-ADDR ! A-ADDR @ -> 1234 }T +T{ 123 456 A-ADDR 2! A-ADDR 2@ -> 123 456 }T +T{ 2 A-ADDR CHAR+ C! A-ADDR CHAR+ C@ -> 2 }T +T{ 3 A-ADDR CELL+ C! A-ADDR CELL+ C@ -> 3 }T +T{ 1234 A-ADDR CELL+ ! A-ADDR CELL+ @ -> 1234 }T +T{ 123 456 A-ADDR CELL+ 2! A-ADDR CELL+ 2@ -> 123 456 }T + +: BITS ( X -- U ) + 0 SWAP BEGIN DUP WHILE DUP MSB AND IF >R 1+ R> THEN 2* REPEAT DROP ; +( CHARACTERS >= 1 AU, <= SIZE OF CELL, >= 8 BITS ) +T{ 1 CHARS 1 < -> }T +T{ 1 CHARS 1 CELLS > -> }T +( TBD: HOW TO FIND NUMBER OF BITS? ) + +( CELLS >= 1 AU, INTEGRAL MULTIPLE OF CHAR SIZE, >= 16 BITS ) +T{ 1 CELLS 1 < -> }T +T{ 1 CELLS 1 CHARS MOD -> 0 }T +T{ 1S BITS 10 < -> }T + +T{ 0 1ST ! -> }T +T{ 1 1ST +! -> }T +T{ 1ST @ -> 1 }T +T{ -1 1ST +! 1ST @ -> 0 }T + +\ ------------------------------------------------------------------------ +." TESTING CHAR [CHAR] [ ] BL Squote" CR + +T{ BL -> 20 }T +T{ CHAR X -> 58 }T +T{ CHAR HELLO -> 48 }T +T{ : GC1 [CHAR] X ; -> }T +T{ : GC2 [CHAR] HELLO ; -> }T +T{ GC1 -> 58 }T +T{ GC2 -> 48 }T +T{ : GC3 [ GC1 ] LITERAL ; -> }T +T{ GC3 -> 58 }T +T{ : GC4 S" XY" ; -> }T +T{ GC4 SWAP DROP -> 2 }T +T{ GC4 DROP DUP C@ SWAP CHAR+ C@ -> 58 59 }T + +\ ------------------------------------------------------------------------ +." TESTING ' ['] FIND EXECUTE IMMEDIATE COUNT LITERAL POSTPONE STATE" CR + +T{ : GT1 123 ; -> }T +T{ ' GT1 EXECUTE -> 123 }T +T{ : GT2 ['] GT1 ; IMMEDIATE -> }T +T{ GT2 EXECUTE -> 123 }T +HERE 3 C, CHAR G C, CHAR T C, CHAR 1 C, CONSTANT GT1STRING +HERE 3 C, CHAR G C, CHAR T C, CHAR 2 C, CONSTANT GT2STRING +\ T{ GT1STRING FIND -> ' GT1 -1 }T +\ T{ GT2STRING FIND -> ' GT2 1 }T +\ ( HOW TO SEARCH FOR NON-EXISTENT WORD? ) +T{ : GT3 GT2 LITERAL ; -> }T +T{ GT3 -> ' GT1 }T +\ T{ GT1STRING COUNT -> GT1STRING CHAR+ 3 }T + +T{ : GT4 POSTPONE GT1 ; IMMEDIATE -> }T +T{ : GT5 GT4 ; -> }T +T{ GT5 -> 123 }T +T{ : GT6 345 ; IMMEDIATE -> }T +T{ : GT7 POSTPONE GT6 ; -> }T +T{ GT7 -> 345 }T + +T{ : GT8 STATE @ ; IMMEDIATE -> }T +T{ GT8 -> 0 }T +T{ : GT9 GT8 LITERAL ; -> }T +T{ GT9 0= -> }T + +\ ------------------------------------------------------------------------ +." TESTING IF ELSE THEN BEGIN WHILE REPEAT UNTIL RECURSE" CR + +T{ : GI1 IF 123 THEN ; -> }T +T{ : GI2 IF 123 ELSE 234 THEN ; -> }T +T{ 0 GI1 -> }T +T{ 1 GI1 -> 123 }T +T{ -1 GI1 -> 123 }T +T{ 0 GI2 -> 234 }T +T{ 1 GI2 -> 123 }T +T{ -1 GI1 -> 123 }T + +T{ : GI3 BEGIN DUP 5 < WHILE DUP 1+ REPEAT ; -> }T +T{ 0 GI3 -> 0 1 2 3 4 5 }T +T{ 4 GI3 -> 4 5 }T +T{ 5 GI3 -> 5 }T +T{ 6 GI3 -> 6 }T + +T{ : GI4 BEGIN DUP 1+ DUP 5 > UNTIL ; -> }T +T{ 3 GI4 -> 3 4 5 6 }T +T{ 5 GI4 -> 5 6 }T +T{ 6 GI4 -> 6 7 }T + +T{ : GI5 BEGIN DUP 2 > + WHILE DUP 5 < WHILE DUP 1+ REPEAT 123 ELSE 345 THEN ; -> }T +T{ 1 GI5 -> 1 345 }T +T{ 2 GI5 -> 2 345 }T +T{ 3 GI5 -> 3 4 5 123 }T +T{ 4 GI5 -> 4 5 123 }T +T{ 5 GI5 -> 5 123 }T + +T{ : GI6 ( N -- 0,1,..N ) DUP IF DUP >R 1- RECURSE R> THEN ; -> }T +T{ 0 GI6 -> 0 }T +T{ 1 GI6 -> 0 1 }T +T{ 2 GI6 -> 0 1 2 }T +T{ 3 GI6 -> 0 1 2 3 }T +T{ 4 GI6 -> 0 1 2 3 4 }T + +\ ------------------------------------------------------------------------ +." TESTING DO LOOP +LOOP I J UNLOOP LEAVE EXIT" CR + +T{ : GD1 DO I LOOP ; -> }T +T{ 4 1 GD1 -> 1 2 3 }T +T{ 2 -1 GD1 -> -1 0 1 }T +T{ MID-UINT+1 MID-UINT GD1 -> MID-UINT }T + +T{ : GD2 DO I -1 +LOOP ; -> }T +T{ 1 4 GD2 -> 4 3 2 1 }T +T{ -1 2 GD2 -> 2 1 0 -1 }T +\ T{ MID-UINT MID-UINT+1 GD2 -> MID-UINT+1 MID-UINT }T + +T{ : GD3 DO 1 0 DO J LOOP LOOP ; -> }T +T{ 4 1 GD3 -> 1 2 3 }T +T{ 2 -1 GD3 -> -1 0 1 }T +\ T{ MID-UINT+1 MID-UINT GD3 -> MID-UINT }T + +T{ : GD4 DO 1 0 DO J LOOP -1 +LOOP ; -> }T +T{ 1 4 GD4 -> 4 3 2 1 }T +T{ -1 2 GD4 -> 2 1 0 -1 }T +\ T{ MID-UINT MID-UINT+1 GD4 -> MID-UINT+1 MID-UINT }T + +T{ : GD5 123 SWAP 0 DO I 4 > IF DROP 234 LEAVE THEN LOOP ; -> }T +T{ 1 GD5 -> 123 }T +T{ 5 GD5 -> 123 }T +T{ 6 GD5 -> 234 }T + +T{ : GD6 ( PAT: T{0 0},{0 0}{1 0}{1 1},{0 0}{1 0}{1 1}{2 0}{2 1}{2 2} ) + 0 SWAP 0 DO + I 1+ 0 DO I J + 3 = IF I UNLOOP I UNLOOP EXIT THEN 1+ LOOP + LOOP ; -> }T +T{ 1 GD6 -> 1 }T +T{ 2 GD6 -> 3 }T +T{ 3 GD6 -> 4 1 2 }T + +\ ------------------------------------------------------------------------ +." TESTING DEFINING WORDS: : ; CONSTANT VARIABLE CREATE DOES> >BODY" CR + +T{ 123 CONSTANT X123 -> }T +T{ X123 -> 123 }T +T{ : EQU CONSTANT ; -> }T +T{ X123 EQU Y123 -> }T +T{ Y123 -> 123 }T + +T{ VARIABLE V1 -> }T +T{ 123 V1 ! -> }T +T{ V1 @ -> 123 }T + +T{ : NOP : POSTPONE ; ; -> }T +T{ NOP NOP1 NOP NOP2 -> }T +T{ NOP1 -> }T +T{ NOP2 -> }T + +T{ : DOES1 DOES> @ 1 + ; -> }T +T{ : DOES2 DOES> @ 2 + ; -> }T +T{ CREATE CR1 -> }T +T{ CR1 -> HERE }T +T{ ' CR1 >BODY -> HERE }T +T{ 1 , -> }T +T{ CR1 @ -> 1 }T +T{ DOES1 -> }T +T{ CR1 -> 2 }T +T{ DOES2 -> }T +T{ CR1 -> 3 }T + +T{ : WEIRD: CREATE DOES> 1 + DOES> 2 + ; -> }T +T{ WEIRD: W1 -> }T +T{ ' W1 >BODY -> HERE }T +T{ W1 -> HERE 1 + }T +T{ W1 -> HERE 2 + }T + +\ \ ------------------------------------------------------------------------ +\ TESTING EVALUATE +\ +\ : GE1 S" 123" ; IMMEDIATE +\ : GE2 S" 123 1+" ; IMMEDIATE +\ : GE3 S" : GE4 345 ;" ; +\ : GE5 EVALUATE ; IMMEDIATE +\ +\ T{ GE1 EVALUATE -> 123 }T ( TEST EVALUATE IN INTERP. STATE ) +\ T{ GE2 EVALUATE -> 124 }T +\ T{ GE3 EVALUATE -> }T +\ T{ GE4 -> 345 }T +\ +\ T{ : GE6 GE1 GE5 ; -> }T ( TEST EVALUATE IN COMPILE STATE ) +\ T{ GE6 -> 123 }T +\ T{ : GE7 GE2 GE5 ; -> }T +\ T{ GE7 -> 124 }T +\ +\ \ ------------------------------------------------------------------------ +\ TESTING SOURCE >IN WORD +\ +\ : GS1 S" SOURCE" 2DUP EVALUATE +\ >R SWAP >R = R> R> = ; +\ T{ GS1 -> }T +\ +\ VARIABLE SCANS +\ : RESCAN? -1 SCANS +! SCANS @ IF 0 >IN ! THEN ; +\ +\ T{ 2 SCANS ! +\ 345 RESCAN? +\ -> 345 345 }T +\ +\ : GS2 5 SCANS ! S" 123 RESCAN?" EVALUATE ; +\ T{ GS2 -> 123 123 123 123 123 }T +\ +\ : GS3 WORD COUNT SWAP C@ ; +\ T{ BL GS3 HELLO -> 5 CHAR H }T +\ T{ CHAR " GS3 GOODBYE" -> 7 CHAR G }T +\ T{ BL GS3 +\ DROP -> 0 }T \ BLANK LINE RETURN ZERO-LENGTH STRING +\ +\ : GS4 SOURCE >IN ! DROP ; +\ T{ GS4 123 456 +\ -> }T +\ +\ \ ------------------------------------------------------------------------ +\ TESTING <# # #S #> HOLD SIGN BASE >NUMBER HEX DECIMAL +\ +\ : S= \ ( ADDR1 C1 ADDR2 C2 -- T/F ) COMPARE TWO STRINGS. +\ >R SWAP R@ = IF \ MAKE SURE STRINGS HAVE SAME LENGTH +\ R> ?DUP IF \ IF NON-EMPTY STRINGS +\ 0 DO +\ OVER C@ OVER C@ - IF 2DROP UNLOOP EXIT THEN +\ SWAP CHAR+ SWAP CHAR+ +\ LOOP +\ THEN +\ 2DROP \ IF WE GET HERE, STRINGS MATCH +\ ELSE +\ R> DROP 2DROP \ LENGTHS MISMATCH +\ THEN ; +\ +\ : GP1 <# 41 HOLD 42 HOLD 0 0 #> S" BA" S= ; +\ T{ GP1 -> }T +\ +\ : GP2 <# -1 SIGN 0 SIGN -1 SIGN 0 0 #> S" --" S= ; +\ T{ GP2 -> }T +\ +\ : GP3 <# 1 0 # # #> S" 01" S= ; +\ T{ GP3 -> }T +\ +\ : GP4 <# 1 0 #S #> S" 1" S= ; +\ T{ GP4 -> }T +\ +\ 24 CONSTANT MAX-BASE \ BASE 2 .. 36 +\ : COUNT-BITS +\ 0 0 INVERT BEGIN DUP WHILE >R 1+ R> 2* REPEAT DROP ; +\ COUNT-BITS 2* CONSTANT #BITS-UD \ NUMBER OF BITS IN UD +\ +\ : GP5 +\ BASE @ +\ MAX-BASE 1+ 2 DO \ FOR EACH POSSIBLE BASE +\ I BASE ! \ TBD: ASSUMES BASE WORKS +\ I 0 <# #S #> S" 10" S= AND +\ LOOP +\ SWAP BASE ! ; +\ T{ GP5 -> }T +\ +\ : GP6 +\ BASE @ >R 2 BASE ! +\ MAX-UINT MAX-UINT <# #S #> \ MAXIMUM UD TO BINARY +\ R> BASE ! \ S: C-ADDR U +\ DUP #BITS-UD = SWAP +\ 0 DO \ S: C-ADDR FLAG +\ OVER C@ [CHAR] 1 = AND \ ALL ONES +\ >R CHAR+ R> +\ LOOP SWAP DROP ; +\ T{ GP6 -> }T +\ +\ : GP7 +\ BASE @ >R MAX-BASE BASE ! +\ +\ A 0 DO +\ I 0 <# #S #> +\ 1 = SWAP C@ I 30 + = AND AND +\ LOOP +\ MAX-BASE A DO +\ I 0 <# #S #> +\ 1 = SWAP C@ 41 I A - + = AND AND +\ LOOP +\ R> BASE ! ; +\ +\ T{ GP7 -> }T +\ +\ \ >NUMBER TESTS +\ CREATE GN-BUF 0 C, +\ : GN-STRING GN-BUF 1 ; +\ : GN-CONSUMED GN-BUF CHAR+ 0 ; +\ : GN' [CHAR] ' WORD CHAR+ C@ GN-BUF C! GN-STRING ; +\ +\ T{ 0 0 GN' 0' >NUMBER -> 0 0 GN-CONSUMED }T +\ T{ 0 0 GN' 1' >NUMBER -> 1 0 GN-CONSUMED }T +\ T{ 1 0 GN' 1' >NUMBER -> BASE @ 1+ 0 GN-CONSUMED }T +\ T{ 0 0 GN' -' >NUMBER -> 0 0 GN-STRING }T \ SHOULD FAIL TO CONVERT THESE +\ T{ 0 0 GN' +' >NUMBER -> 0 0 GN-STRING }T +\ T{ 0 0 GN' .' >NUMBER -> 0 0 GN-STRING }T +\ +\ : >NUMBER-BASED +\ BASE @ >R BASE ! >NUMBER R> BASE ! ; +\ +\ T{ 0 0 GN' 2' 10 >NUMBER-BASED -> 2 0 GN-CONSUMED }T +\ T{ 0 0 GN' 2' 2 >NUMBER-BASED -> 0 0 GN-STRING }T +\ T{ 0 0 GN' F' 10 >NUMBER-BASED -> F 0 GN-CONSUMED }T +\ T{ 0 0 GN' G' 10 >NUMBER-BASED -> 0 0 GN-STRING }T +\ T{ 0 0 GN' G' MAX-BASE >NUMBER-BASED -> 10 0 GN-CONSUMED }T +\ T{ 0 0 GN' Z' MAX-BASE >NUMBER-BASED -> 23 0 GN-CONSUMED }T +\ +\ : GN1 \ ( UD BASE -- UD' LEN ) UD SHOULD EQUAL UD' AND LEN SHOULD BE ZERO. +\ BASE @ >R BASE ! +\ <# #S #> +\ 0 0 2SWAP >NUMBER SWAP DROP \ RETURN LENGTH ONLY +\ R> BASE ! ; +\ T{ 0 0 2 GN1 -> 0 0 0 }T +\ T{ MAX-UINT 0 2 GN1 -> MAX-UINT 0 0 }T +\ T{ MAX-UINT DUP 2 GN1 -> MAX-UINT DUP 0 }T +\ T{ 0 0 MAX-BASE GN1 -> 0 0 0 }T +\ T{ MAX-UINT 0 MAX-BASE GN1 -> MAX-UINT 0 0 }T +\ T{ MAX-UINT DUP MAX-BASE GN1 -> MAX-UINT DUP 0 }T +\ +\ : GN2 \ ( -- 16 10 ) +\ BASE @ >R HEX BASE @ DECIMAL BASE @ R> BASE ! ; +\ T{ GN2 -> 10 A }T +\ +\ ------------------------------------------------------------------------ +." TESTING FILL MOVE" CR + +CREATE FBUF 00 C, 00 C, 00 C, +CREATE SBUF 12 C, 34 C, 56 C, +: SEEBUF FBUF C@ FBUF CHAR+ C@ FBUF CHAR+ CHAR+ C@ ; + +T{ FBUF 0 20 FILL -> }T +T{ SEEBUF -> 00 00 00 }T + +T{ FBUF 1 20 FILL -> }T +T{ SEEBUF -> 20 00 00 }T + +T{ FBUF 3 20 FILL -> }T +T{ SEEBUF -> 20 20 20 }T + +T{ FBUF FBUF 3 CHARS MOVE -> }T \ BIZARRE SPECIAL CASE +T{ SEEBUF -> 20 20 20 }T + +T{ SBUF FBUF 0 CHARS MOVE -> }T +T{ SEEBUF -> 20 20 20 }T + +T{ SBUF FBUF 1 CHARS MOVE -> }T +T{ SEEBUF -> 12 20 20 }T + +T{ SBUF FBUF 3 CHARS MOVE -> }T +T{ SEEBUF -> 12 34 56 }T + +T{ FBUF FBUF CHAR+ 2 CHARS MOVE -> }T +T{ SEEBUF -> 12 12 34 }T + +T{ FBUF CHAR+ FBUF 2 CHARS MOVE -> }T +T{ SEEBUF -> 12 34 34 }T + +\ ------------------------------------------------------------------------ +." TESTING OUTPUT: . .quote CR EMIT SPACE SPACES TYPE U." CR + +: OUTPUT-TEST + ." YOU SHOULD SEE THE STANDARD GRAPHIC CHARACTERS:" CR + 41 BL DO I EMIT LOOP CR + 61 41 DO I EMIT LOOP CR + 7F 61 DO I EMIT LOOP CR + ." YOU SHOULD SEE 0-9 SEPARATED BY A SPACE:" CR + 9 1+ 0 DO I . LOOP CR + ." YOU SHOULD SEE 0-9 (WITH NO SPACES):" CR + [CHAR] 9 1+ [CHAR] 0 DO I 0 SPACES EMIT LOOP CR + ." YOU SHOULD SEE A-G SEPARATED BY A SPACE:" CR + [CHAR] G 1+ [CHAR] A DO I EMIT SPACE LOOP CR + ." YOU SHOULD SEE 0-5 SEPARATED BY TWO SPACES:" CR + 5 1+ 0 DO I [CHAR] 0 + EMIT 2 SPACES LOOP CR + ." YOU SHOULD SEE TWO SEPARATE LINES:" CR + S" LINE 1" TYPE CR S" LINE 2" TYPE CR + ." YOU SHOULD SEE THE NUMBER RANGES OF SIGNED AND UNSIGNED NUMBERS:" CR +; + +: OUTPUT-TEST-LIMITS + ." SIGNED: " MIN-INT . MAX-INT . CR + ." UNSIGNED: " 0 U. MAX-UINT U. CR +; + +T{ OUTPUT-TEST -> }T +T{ OUTPUT-TEST-LIMITS -> }T + + +\ ------------------------------------------------------------------------ +." TESTING INPUT: ACCEPT" CR + +CREATE ABUF 50 CHARS ALLOT + +: ACCEPT-TEST + CR ." PLEASE TYPE UP TO 80 CHARACTERS:" CR + ABUF 50 ACCEPT + CR ." RECEIVED: " [CHAR] " EMIT + ABUF SWAP TYPE [CHAR] " EMIT CR +; + +T{ ACCEPT-TEST -> }T + +\ ------------------------------------------------------------------------ +." TESTING DICTIONARY SEARCH RULES" CR + +T{ : GDX 123 ; : GDX GDX 234 ; -> }T + +T{ GDX -> 123 234 }T + +CR .( End of Core word set tests) CR + + diff --git a/test/tester.fr b/test/tester.fr new file mode 100644 index 0000000..2cf108d --- /dev/null +++ b/test/tester.fr @@ -0,0 +1,66 @@ +\ From: John Hayes S1I +\ Subject: tester.fr +\ Date: Mon, 27 Nov 95 13:10:09 PST + +\ (C) 1995 JOHNS HOPKINS UNIVERSITY / APPLIED PHYSICS LABORATORY +\ MAY BE DISTRIBUTED FREELY AS LONG AS THIS COPYRIGHT NOTICE REMAINS. +\ VERSION 1.2 + +\ 24/11/2015 Replaced Core Ext word <> with = 0= +\ 31/3/2015 Variable #ERRORS added and incremented for each error reported. +\ 22/1/09 The words { and } have been changed to T{ and }T respectively to +\ agree with the Forth 200X file ttester.fs. This avoids clashes with +\ locals using { ... } and the FSL use of } + +HEX + +\ SET THE FOLLOWING FLAG TO TRUE FOR MORE VERBOSE OUTPUT; THIS MAY +\ ALLOW YOU TO TELL WHICH TEST CAUSED YOUR SYSTEM TO HANG. +VARIABLE VERBOSE + FALSE VERBOSE ! +\ TRUE VERBOSE ! + +: EMPTY-STACK \ ( ... -- ) EMPTY STACK: HANDLES UNDERFLOWED STACK TOO. + DEPTH ?DUP IF DUP 0< IF NEGATE 0 DO 0 LOOP ELSE 0 DO DROP LOOP THEN THEN ; + +VARIABLE #ERRORS 0 #ERRORS ! + +: ERROR \ ( C-ADDR U -- ) DISPLAY AN ERROR MESSAGE FOLLOWED BY + \ THE LINE THAT HAD THE ERROR. + CR TYPE SOURCE TYPE \ DISPLAY LINE CORRESPONDING TO ERROR + EMPTY-STACK \ THROW AWAY EVERY THING ELSE + #ERRORS @ 1 + #ERRORS ! +\ QUIT \ *** Uncomment this line to QUIT on an error +; + +VARIABLE ACTUAL-DEPTH \ STACK RECORD +CREATE ACTUAL-RESULTS 20 CELLS ALLOT + +: T{ \ ( -- ) SYNTACTIC SUGAR. + ; + +: -> \ ( ... -- ) RECORD DEPTH AND CONTENT OF STACK. + DEPTH DUP ACTUAL-DEPTH ! \ RECORD DEPTH + ?DUP IF \ IF THERE IS SOMETHING ON STACK + 0 DO ACTUAL-RESULTS I CELLS + ! LOOP \ SAVE THEM + THEN ; + +: }T \ ( ... -- ) COMPARE STACK (EXPECTED) CONTENTS WITH SAVED + \ (ACTUAL) CONTENTS. + DEPTH ACTUAL-DEPTH @ = IF \ IF DEPTHS MATCH + DEPTH ?DUP IF \ IF THERE IS SOMETHING ON THE STACK + 0 DO \ FOR EACH STACK ITEM + ACTUAL-RESULTS I CELLS + @ \ COMPARE ACTUAL WITH EXPECTED + = 0= IF S" INCORRECT RESULT: " ERROR LEAVE THEN + LOOP + THEN + ELSE \ DEPTH MISMATCH + S" WRONG NUMBER OF RESULTS: " ERROR + THEN ; + +: TESTING \ ( -- ) TALKING COMMENT. + SOURCE VERBOSE @ + IF DUP >R TYPE CR R> >IN ! + ELSE >IN ! DROP [CHAR] * EMIT + THEN ; +