bitgloo
/
alee-forth
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: bitgloo:native
Branches Tags
bitgloo:master
bitgloo:native
bitgloo:optimize
bitgloo:llvm
..
compare: bitgloo:master
Branches Tags
bitgloo:master
bitgloo:native
bitgloo:optimize
bitgloo:llvm

1 Commits
native ... master

Author SHA1 Message Date
Clyne 6264c07c3b
add .gitattributes 10 months ago
11 changed files with 222 additions and 288 deletions
Show Stats

1
.gitattributes vendored
Unescape Escape View File

@ -0,0 +1 @@
msp430/msp430fr2476.h linguist-vendored

2
alee-standalone.cpp
Unescape Escape View File

@ -40,8 +40,6 @@ int main(int argc, char *argv[])
SplitMemDict<sizeof(alee_dat)> dict (alee_dat); SplitMemDict<sizeof(alee_dat)> dict (alee_dat);
State state (dict, readchar); State state (dict, readchar);
//dict.initialize();
std::vector args (argv + 1, argv + argc); std::vector args (argv + 1, argv + argc);
for (const auto& a : args) { for (const auto& a : args) {
std::ifstream file (a); std::ifstream file (a);

11
forth/core.fth
Unescape Escape View File

@ -99,6 +99,10 @@
: j postpone 2r> ['] r> , postpone r@ ['] swap , : j postpone 2r> ['] r> , postpone r@ ['] swap ,
['] >r , ['] -rot , postpone 2>r ; imm ['] >r , ['] -rot , postpone 2>r ; imm
: aligned dup [ 1 cells 1- ] literal swap over & if [ 1 cells ] literal
swap - + else drop then ;
: align here dup aligned swap - allot ;
: and & ; : and & ;
: or | ; : or | ;
: xor ^ ; : xor ^ ;
@ -110,9 +114,6 @@
: _msb [ 1 1 cells 8 * 1- << ] literal ; : _msb [ 1 1 cells 8 * 1- << ] literal ;
: 2/ dup 1 >> swap 0< if _msb or then ; : 2/ dup 1 >> swap 0< if _msb or then ;
: aligned [ 1 cells 1- ] literal swap over + swap invert and ;
: align here dup aligned swap - allot ;
: /mod 2dup % -rot / ; : /mod 2dup % -rot / ;
: */ >r m* r> _/ ; : */ >r m* r> _/ ;
: sm/rem >r 2dup r@ _% -rot r> _/ ; : sm/rem >r 2dup r@ _% -rot r> _/ ;
@ -220,8 +221,8 @@
dup _isdigit - _uma dup _isdigit - _uma
r> char+ r> 1- repeat ; r> char+ r> 1- repeat ;
: <# [ 20 cells ] literal here c! ; : <# 40 here c! ;
: #> 2drop here dup c@ + [ 20 cells ] literal here c@ - ; : #> 2drop here dup c@ + 40 here c@ - ;
: hold -1 here +! here dup c@ + c! ; : hold -1 here +! here dup c@ + c! ;
: # base @ : # base @
>r 0 i um/mod r> swap >r um/mod r> >r 0 i um/mod r> swap >r um/mod r>

4
forth/tools.fth
Unescape Escape View File

@ -6,8 +6,8 @@
: words _latest @ begin : words _latest @ begin
dup @ dup 31 & dup @ dup 31 &
2 pick cell+ \ lt l len ws 2 pick cell+ \ lt l len ws
2 pick 7 >> 1023 < if \ lt l len ws 2 pick 6 >> 1023 < if \ lt l len ws
rot 7 >> else \ lt len ws adv rot 6 >> else \ lt len ws adv
>r cell+ rot drop r> @ then >r cell+ rot drop r> @ then
-rot swap type space \ lt adv -rot swap type space \ lt adv
over _begin <> while - repeat 2drop ; over _begin <> while - repeat 2drop ;

306
libalee/corewords.cpp
Unescape Escape View File

@ -27,168 +27,133 @@ static void pushd(State&, DoubleCell);
LIBALEE_SECTION LIBALEE_SECTION
void CoreWords::run(Cell ins, State& state) void CoreWords::run(Cell ins, State& state)
{ {
Cell cell;
DoubleCell dcell;
Addr index = ins; Addr index = ins;
auto& ip = state.ip();
execute:
if (index >= Dictionary::Begin) { if (index >= Dictionary::Begin) {
auto& ip = state.ip(); // must be calling a defined subroutine
state.pushr(ip); state.pushr(ip);
ip = static_cast<Addr>(index - sizeof(Cell)); ip = index;
} else { return;
wordstbl[index](state); } else switch (index) {
} case token("_lit"): // Execution semantics of `literal`.
}
LIBALEE_SECTION
Cell CoreWords::findi(State& state, Word word)
{
return findi(word.begin(&state.dict), word.size());
}
LIBALEE_SECTION
void find(State& state, Word word)
{
Cell tok = 0;
Cell imm = 0;
if (auto j = state.dict.find(word); j > 0) {
tok = state.dict.getexec(j);
imm = (state.dict.read(j) & Dictionary::Immediate) ? 1 : -1;
} else if (tok = CoreWords::findi(state, word); tok >= 0) {
imm = (tok == CoreWords::token(";")) ? 1 : -1;
}
state.push(tok);
state.push(imm);
}
DoubleCell popd(State& s)
{
DoubleCell dcell = s.pop();
dcell <<= sizeof(Cell) * 8;
dcell |= static_cast<Addr>(s.pop());
return dcell;
}
void pushd(State& s, DoubleCell d)
{
s.push(static_cast<Cell>(d));
s.push(static_cast<Cell>(d >> (sizeof(Cell) * 8)));
}
void CoreWords::word_lit(State& state) { // Execution semantics of `literal`.
state.push(state.beyondip()); state.push(state.beyondip());
} break;
void CoreWords::word_drop(State& state) { case token("drop"):
state.pop(); state.pop();
} break;
void CoreWords::word_dup(State& state) { case token("dup"):
state.push(state.top()); state.push(state.top());
} break;
void CoreWords::word_swap(State& state) { case token("swap"):
std::swap(state.top(), state.pick(1)); std::swap(state.top(), state.pick(1));
} break;
void CoreWords::word_pick(State& state) { case token("pick"):
state.push(state.pick(state.pop())); state.push(state.pick(state.pop()));
} break;
void CoreWords::word_sys(State& state) { // Calls user-defined "system" handler. case token("sys"): // Calls user-defined "system" handler.
user_sys(state); user_sys(state);
} break;
void CoreWords::word_add(State& state) { case token("+"):
auto cell = state.pop(); cell = state.pop();
state.top() += cell; state.top() += cell;
} break;
void CoreWords::word_sub(State& state) { case token("-"):
auto cell = state.pop(); cell = state.pop();
state.top() -= cell; state.top() -= cell;
} break;
void CoreWords::word_mul(State& state) { // ( n n -- d ) case token("m*"): // ( n n -- d )
auto cell = state.pop(); cell = state.pop();
auto dcell = (DoubleCell)state.pop() * cell; dcell = state.pop() * cell;
pushd(state, dcell); pushd(state, dcell);
} break;
void CoreWords::word_div(State& state) { // ( d n -- n ) case token("_/"): // ( d n -- n )
auto cell = state.pop(); cell = state.pop();
auto dcell = (DoubleCell)popd(state); dcell = popd(state);
state.push(static_cast<Cell>(dcell / cell)); state.push(static_cast<Cell>(dcell / cell));
} break;
void CoreWords::word_mod(State& state) { // ( d n -- n ) case token("_%"): // ( d n -- n )
auto cell = state.pop(); cell = state.pop();
auto dcell = (DoubleCell)popd(state); dcell = popd(state);
state.push(static_cast<Cell>(dcell % cell)); state.push(static_cast<Cell>(dcell % cell));
} break;
void CoreWords::word_peek(State& state) { // ( addr cell? -- n ) case token("_@"): // ( addr cell? -- n )
if (state.pop()) if (state.pop())
state.push(state.dict.read(state.pop())); state.push(state.dict.read(state.pop()));
else else
state.push(state.dict.readbyte(state.pop())); state.push(state.dict.readbyte(state.pop()));
} break;
void CoreWords::word_poke(State& state) { // ( n addr cell? -- ) case token("_!"): // ( n addr cell? -- )
auto cell = state.pop(); cell = state.pop();
if (auto addr = state.pop(); cell) if (auto addr = state.pop(); cell)
state.dict.write(addr, state.pop()); state.dict.write(addr, state.pop());
else else
state.dict.writebyte(addr, state.pop() & 0xFFu); state.dict.writebyte(addr, state.pop() & 0xFFu);
} break;
void CoreWords::word_rpush(State& state) { case token(">r"):
state.pushr(state.pop()); state.pushr(state.pop());
} break;
void CoreWords::word_rpop(State& state) { case token("r>"):
state.push(state.popr()); state.push(state.popr());
} break;
void CoreWords::word_eq(State& state) { case token("="):
auto cell = state.pop(); cell = state.pop();
state.top() = state.top() == cell ? -1 : 0; state.top() = state.top() == cell ? -1 : 0;
} break;
void CoreWords::word_lt(State& state) { case token("<"):
auto cell = state.pop(); cell = state.pop();
state.top() = state.top() < cell ? -1 : 0; state.top() = state.top() < cell ? -1 : 0;
} break;
void CoreWords::word_and(State& state) { case token("&"):
auto cell = state.pop(); cell = state.pop();
state.top() &= cell; state.top() &= cell;
} break;
void CoreWords::word_or(State& state) { case token("|"):
auto cell = state.pop(); cell = state.pop();
state.top() |= cell; state.top() |= cell;
} break;
void CoreWords::word_xor(State& state) { case token("^"):
auto cell = state.pop(); cell = state.pop();
state.top() ^= cell; state.top() ^= cell;
} break;
void CoreWords::word_shl(State& state) { case token("<<"):
auto cell = state.pop(); cell = state.pop();
reinterpret_cast<Addr&>(state.top()) <<= static_cast<Addr>(cell); reinterpret_cast<Addr&>(state.top()) <<= static_cast<Addr>(cell);
} break;
void CoreWords::word_shr(State& state) { case token(">>"):
auto cell = state.pop(); cell = state.pop();
reinterpret_cast<Addr&>(state.top()) >>= static_cast<Addr>(cell); reinterpret_cast<Addr&>(state.top()) >>= static_cast<Addr>(cell);
} break;
void CoreWords::word_colon(State& state) { // Begins definition/compilation of new word. case token(":"): // Begins definition/compilation of new word.
state.push(state.dict.alignhere()); state.push(state.dict.alignhere());
state.dict.write(Dictionary::CompToken, state.top()); state.dict.write(Dictionary::CompToken, state.top());
while (!state.dict.hasInput()) while (!state.dict.hasInput())
state.input(); state.input();
state.dict.addDefinition(state.dict.input()); state.dict.addDefinition(state.dict.input());
state.compiling(true); state.compiling(true);
} break;
void CoreWords::word_tick(State& state) { // Collects input word and finds execution token. case token("_'"): // Collects input word and finds execution token.
while (!state.dict.hasInput()) while (!state.dict.hasInput())
state.input(); state.input();
find(state, state.dict.input()); find(state, state.dict.input());
} break;
void CoreWords::word_execute(State& state) { case token("execute"):
run(state.pop(), state); index = state.pop();
} goto execute;
void CoreWords::word_exit(State& state) { case token("exit"):
state.ip() = state.popr(); ip = state.popr();
state.verify(state.ip() != 0, Error::exit); state.verify(ip != 0, Error::exit);
} break;
void CoreWords::word_semic(State& state) { // Concludes word definition. case token(";"): // Concludes word definition.
state.dict.add(token("exit")); state.dict.add(token("exit"));
state.compiling(false); state.compiling(false);
auto cell = state.pop(); cell = state.pop();
auto dcell = (DoubleCell)cell - state.dict.latest(); dcell = cell - state.dict.latest();
if (dcell >= Dictionary::MaxDistance) { if (dcell >= Dictionary::MaxDistance) {
// Large distance to previous entry: store in dedicated cell. // Large distance to previous entry: store in dedicated cell.
state.dict.write(static_cast<Addr>(cell) + sizeof(Cell), state.dict.write(static_cast<Addr>(cell) + sizeof(Cell),
@ -196,56 +161,59 @@ void CoreWords::word_semic(State& state) { // Concludes word definition.
dcell = Dictionary::MaxDistance; dcell = Dictionary::MaxDistance;
} }
state.dict.write(cell, state.dict.write(cell,
(state.dict.read(cell) & 0x1F) | static_cast<Cell>(dcell << Dictionary::DistancePos)); (state.dict.read(cell) & 0x1F) | static_cast<Cell>(dcell << 6));
state.dict.latest(cell); state.dict.latest(cell);
} break;
void CoreWords::word_jmp0(State& state) { // Jump if popped value equals zero. case token("_jmp0"): // Jump if popped value equals zero.
if (state.pop()) { if (state.pop()) {
state.beyondip(); state.beyondip();
} else { break;
state.ip() = static_cast<Addr>(state.beyondip() - sizeof(Cell));
}
} }
void CoreWords::word_jmp(State& state) { // Unconditional jump. [[fallthrough]];
state.ip() = static_cast<Addr>(state.beyondip() - sizeof(Cell)); case token("_jmp"): // Unconditional jump.
} ip = state.beyondip();
void CoreWords::word_depth(State& state) { return;
case token("depth"):
state.push(static_cast<Cell>(state.size())); state.push(static_cast<Cell>(state.size()));
} break;
void CoreWords::word_rdepth(State& state) { case token("_rdepth"):
state.push(static_cast<Cell>(state.rsize())); state.push(static_cast<Cell>(state.rsize()));
} break;
void CoreWords::word_in(State& state) { // Fetches more input from the user input source. case token("_in"): // Fetches more input from the user input source.
state.input(); state.input();
} break;
void CoreWords::word_ev(State& state) { // Evaluates words from current input source. case token("_ev"): // Evaluates words from current input source.
{
const auto st = state.save(); const auto st = state.save();
state.ip() = 0; ip = 0;
Parser::parseSource(state); Parser::parseSource(state);
state.load(st); state.load(st);
} }
void CoreWords::word_find(State& state) { break;
auto cell = state.pop(); case token("find"):
cell = state.pop();
find(state, find(state,
Word::fromLength(static_cast<Addr>(cell + 1), Word::fromLength(static_cast<Addr>(cell + 1),
state.dict.readbyte(cell))); state.dict.readbyte(cell)));
} break;
void CoreWords::word_uma(State& state) { // ( d u u -- d ): Unsigned multiply-add. case token("_uma"): // ( d u u -- d ): Unsigned multiply-add.
{
const auto plus = state.pop(); const auto plus = state.pop();
auto cell = state.pop(); cell = state.pop();
auto dcell = popd(state); dcell = popd(state);
dcell *= static_cast<Addr>(cell); dcell *= static_cast<Addr>(cell);
dcell += static_cast<Addr>(plus); dcell += static_cast<Addr>(plus);
pushd(state, dcell); pushd(state, dcell);
} }
void CoreWords::word_ult(State& state) { break;
auto cell = state.pop(); case token("u<"):
cell = state.pop();
state.top() = static_cast<Addr>(state.top()) < state.top() = static_cast<Addr>(state.top()) <
static_cast<Addr>(cell) ? -1 : 0; static_cast<Addr>(cell) ? -1 : 0;
} break;
void CoreWords::word_ummod(State& state) { case token("um/mod"):
auto cell = state.pop(); cell = state.pop();
auto dcell = popd(state); dcell = popd(state);
state.push(static_cast<Cell>( state.push(static_cast<Cell>(
static_cast<DoubleAddr>(dcell) % static_cast<DoubleAddr>(dcell) %
@ -253,5 +221,49 @@ void CoreWords::word_ummod(State& state) {
state.push(static_cast<Cell>( state.push(static_cast<Cell>(
static_cast<DoubleAddr>(dcell) / static_cast<DoubleAddr>(dcell) /
static_cast<Addr>(cell))); static_cast<Addr>(cell)));
break;
default: // Compacted literals (WordCount <= ins < Begin).
state.push(ins - WordCount);
break;
}
ip += sizeof(Cell);
}
LIBALEE_SECTION
Cell CoreWords::findi(State& state, Word word)
{
return findi(word.begin(&state.dict), word.size());
}
LIBALEE_SECTION
void find(State& state, Word word)
{
Cell tok = 0;
Cell imm = 0;
if (auto j = state.dict.find(word); j > 0) {
tok = state.dict.getexec(j);
imm = (state.dict.read(j) & Dictionary::Immediate) ? 1 : -1;
} else if (tok = CoreWords::findi(state, word); tok >= 0) {
imm = (tok == CoreWords::token(";")) ? 1 : -1;
}
state.push(tok);
state.push(imm);
}
DoubleCell popd(State& s)
{
DoubleCell dcell = s.pop();
dcell <<= sizeof(Cell) * 8;
dcell |= static_cast<Addr>(s.pop());
return dcell;
}
void pushd(State& s, DoubleCell d)
{
s.push(static_cast<Cell>(d));
s.push(static_cast<Cell>(d >> (sizeof(Cell) * 8)));
} }

81
libalee/corewords.hpp
Unescape Escape View File

@ -81,7 +81,7 @@ public:
"<<\0>>\0:\0_'\0execute\0" "<<\0>>\0:\0_'\0execute\0"
"exit\0;\0_jmp0\0_jmp\0" "exit\0;\0_jmp0\0_jmp\0"
"depth\0_rdepth\0_in\0_ev\0find\0" "depth\0_rdepth\0_in\0_ev\0find\0"
"_uma\0u<\0um/mod\0_nx\0"; "_uma\0u<\0um/mod\0";
/** /**
* Count of total fundamental words. * Count of total fundamental words.
@ -113,85 +113,6 @@ private:
return -1; return -1;
} }
public:
static void word_lit(State&);
static void word_drop(State&);
static void word_dup(State&);
static void word_swap(State&);
static void word_pick(State&);
static void word_sys(State&);
static void word_add(State&);
static void word_sub(State&);
static void word_mul(State&);
static void word_div(State&);
static void word_mod(State&);
static void word_peek(State&);
static void word_poke(State&);
static void word_rpush(State&);
static void word_rpop(State&);
static void word_eq(State&);
static void word_lt(State&);
static void word_and(State&);
static void word_or(State&);
static void word_xor(State&);
static void word_shl(State&);
static void word_shr(State&);
static void word_colon(State&);
static void word_tick(State&);
static void word_execute(State&);
static void word_exit(State&);
static void word_semic(State&);
static void word_jmp0(State&);
static void word_jmp(State&);
static void word_depth(State&);
static void word_rdepth(State&);
static void word_in(State&);
static void word_ev(State&);
static void word_find(State&);
static void word_uma(State&);
static void word_ult(State&);
static void word_ummod(State&);
constexpr static void (*wordstbl[])(State&) = {
word_lit,
word_drop,
word_dup,
word_swap,
word_pick,
word_sys,
word_add,
word_sub,
word_mul,
word_div,
word_mod,
word_peek,
word_poke,
word_rpush,
word_rpop,
word_eq,
word_lt,
word_and,
word_or,
word_xor,
word_shl,
word_shr,
word_colon,
word_tick,
word_execute,
word_exit,
word_semic,
word_jmp0,
word_jmp,
word_depth,
word_rdepth,
word_in,
word_ev,
word_find,
word_uma,
word_ult,
word_ummod
};
}; };
#endif // ALEEFORTH_COREWORDS_HPP #endif // ALEEFORTH_COREWORDS_HPP

6
libalee/dictionary.cpp
Unescape Escape View File

@ -91,14 +91,14 @@ Addr Dictionary::find(Word word) noexcept
const Addr len = l & 0x1F; const Addr len = l & 0x1F;
Word lw; Word lw;
if ((l >> DistancePos) < MaxDistance) { if ((l >> 6) < MaxDistance) {
lw = Word::fromLength(lt + sizeof(Cell), len); lw = Word::fromLength(lt + sizeof(Cell), len);
if (equal(word, lw)) if (equal(word, lw))
return lt; return lt;
else if (lt == Begin) else if (lt == Begin)
break; break;
else else
lt -= l >> DistancePos; lt -= l >> 6;
} else { } else {
lw = Word::fromLength(lt + 2 * sizeof(Cell), len); lw = Word::fromLength(lt + 2 * sizeof(Cell), len);
if (equal(word, lw)) if (equal(word, lw))
@ -120,7 +120,7 @@ Addr Dictionary::getexec(Addr addr) noexcept
const Addr len = l & 0x1Fu; const Addr len = l & 0x1Fu;
addr += sizeof(Cell); addr += sizeof(Cell);
if ((l >> DistancePos) == MaxDistance) if ((l >> 6) == MaxDistance)
addr += sizeof(Cell); addr += sizeof(Cell);
addr += len; addr += len;

5
libalee/dictionary.hpp
Unescape Escape View File

@ -73,11 +73,8 @@ public:
/** "Immediate" marker bit for a word's definition. */ /** "Immediate" marker bit for a word's definition. */
constexpr static Cell Immediate = (1 << 5); constexpr static Cell Immediate = (1 << 5);
constexpr static Cell DistancePos = 6;
/** Maximum "short" distance between two definitions. */ /** Maximum "short" distance between two definitions. */
constexpr static Cell MaxDistance = (1 << (sizeof(Cell) * 8 - DistancePos)) - 1; constexpr static Cell MaxDistance = (1 << (sizeof(Cell) * 8 - 6)) - 1;
/** Returns the value of the cell at the given address. */ /** Returns the value of the cell at the given address. */
virtual Cell read(Addr) const noexcept = 0; virtual Cell read(Addr) const noexcept = 0;

12
libalee/parser.cpp
Unescape Escape View File

@ -124,7 +124,17 @@ LIBALEE_SECTION
void Parser::processLiteral(State& state, Cell value) void Parser::processLiteral(State& state, Cell value)
{ {
if (state.compiling()) { if (state.compiling()) {
state.dict.add(CoreWords::token("_lit")); constexpr auto ins = CoreWords::token("_lit");
// Literal compression: opcodes between WordCount and Begin are unused,
// so we assign literals to them to save space. Opcode "WordCount"
// pushes zero to the stack, "WordCount + 1" pushes a one, etc.
const Cell maxlit = Dictionary::Begin - CoreWords::WordCount;
if (value >= 0 && value < maxlit)
value += CoreWords::WordCount;
else
state.dict.add(ins);
state.dict.add(value); state.dict.add(value);
} else { } else {
state.push(value); state.push(value);

4
libalee/state.cpp
Unescape Escape View File

@ -54,10 +54,8 @@ Error State::execute(Addr addr)
if (context.ip >= Dictionary::Begin) { if (context.ip >= Dictionary::Begin) {
// longjmp will exit this loop. // longjmp will exit this loop.
for (;;) { for (;;)
context.ip += sizeof(Cell);
CoreWords::run(dict.read(context.ip), *this); CoreWords::run(dict.read(context.ip), *this);
}
} else { } else {
// addr was a CoreWord, all done now. // addr was a CoreWord, all done now.
context.ip = 0; context.ip = 0;

4
libalee/state.hpp
Unescape Escape View File

@ -28,8 +28,6 @@
#include <csetjmp> #include <csetjmp>
#include <cstddef> #include <cstddef>
//#define verify(C, E)
/** /**
* Size of the primary data stack, number of cells. * Size of the primary data stack, number of cells.
*/ */
@ -181,8 +179,6 @@ public:
return dict.read(context.ip); return dict.read(context.ip);
} }
//#undef verify
/** /**
* Asserts the given condition is true, longjmp-ing if false. * Asserts the given condition is true, longjmp-ing if false.
* Used as an exception handler and the method of exiting execution. * Used as an exception handler and the method of exiting execution.

Write Preview
Loading…
Cancel
Save