mirror of
https://github.com/flynx/Course-JavaScript.git
synced 2025-10-31 03:50:10 +00:00
607 lines
15 KiB
JavaScript
Executable File
607 lines
15 KiB
JavaScript
Executable File
/**********************************************************************
|
|
*
|
|
*
|
|
*
|
|
**********************************************************************/
|
|
|
|
|
|
/*********************************************************************/
|
|
|
|
function run(context){
|
|
|
|
var stack = context.stack
|
|
stack = stack == null ? [] : stack
|
|
context.stack = stack
|
|
|
|
var ns = context.ns
|
|
|
|
while(context.code.length > 0){
|
|
|
|
var cur = context.code.splice(0, 1)[0]
|
|
|
|
// exit...
|
|
if(typeof(cur) == typeof('abc') && cur == '_exit'){
|
|
return context
|
|
|
|
// word
|
|
} else if(typeof(cur) == typeof('abc') && cur in ns){
|
|
var word = ns[cur]
|
|
// low-level word...
|
|
if(typeof(word) == typeof(function(){})){
|
|
var res = ns[cur](context)
|
|
|
|
// hi-level word...
|
|
} else if(typeof(word) == typeof([]) && word.constructor.name == 'Array'){
|
|
// XXX add isolation with a continuation...
|
|
context.code.splice.apply(context.code, [0, 0].concat(word))
|
|
var res = null
|
|
|
|
// variable...
|
|
} else {
|
|
res = word
|
|
}
|
|
|
|
if(res != null){
|
|
context.stack.push(res)
|
|
}
|
|
|
|
// everything else...
|
|
} else {
|
|
context.stack.push(cur)
|
|
}
|
|
}
|
|
|
|
return context
|
|
}
|
|
|
|
var SPLITTER = /\s*\([^\)]*\)\s*|\s*--.*[\n$]|\s*"([^"]*)"\s*|\s*'([^']*)'\s*|\s+/m
|
|
|
|
|
|
// pre-processor namespace...
|
|
var PRE_NAMESPACE = {
|
|
// XXX use the real reader...
|
|
// block...
|
|
// syntax: [ ... ]
|
|
'[': function(context){
|
|
var block = []
|
|
var code = context.code
|
|
var cur = code.splice(0, 1)[0]
|
|
while(cur != ']' && code.length > 0){
|
|
if(cur == '['){
|
|
cur = this['['](context)
|
|
}
|
|
block.push(cur)
|
|
cur = code.splice(0, 1)[0]
|
|
}
|
|
if(code.length == 0 && cur != ']'){
|
|
console.error('Did not find expected "]".')
|
|
}
|
|
return block
|
|
},
|
|
'macro:': function(context){
|
|
var ident = context.code.splice(0, 1)
|
|
var cur = context.code.splice(0, 1)
|
|
|
|
// as we do not have blocks yet we need to manually collect one ;)
|
|
if(cur[0] == '['){
|
|
cur = [ this['['](context) ]
|
|
}
|
|
|
|
this[ident] = cur[0]
|
|
},
|
|
}
|
|
|
|
|
|
// main namespace...
|
|
var NAMESPACE = {
|
|
// constants...
|
|
'true': true,
|
|
'false': false,
|
|
// this is mutable, so we'll need to create a new instance each time
|
|
'[]': function(){ return [] },
|
|
|
|
'nop': function(){},
|
|
|
|
// XXX experimental...
|
|
// flip the code and stack...
|
|
// ... -- ...
|
|
'_flip': function(context){
|
|
var stack = context.stack
|
|
context.stack = context.code.reverse()
|
|
context.code = stack.reverse()
|
|
},
|
|
|
|
// swap heads of stack and code
|
|
// ... ns nc -- ...
|
|
'_swapN': function(context){
|
|
var c = context.stack.pop()
|
|
var s = context.stack.pop()
|
|
var l = context.stack.length
|
|
|
|
// get the stack/code sections to swap...
|
|
var s_c = context.stack.splice(l-s, l)
|
|
var c_c = context.code.splice(0, c)
|
|
var l = context.stack.length
|
|
|
|
// we need to pad e_c and c_c to requested length...
|
|
s_c = s_c.length < s ? s_c.concat(Array( s - s_c.length )) : s_c
|
|
c_c = c_c.length < c ? c_c.concat(Array( c - c_c.length )) : c_c
|
|
|
|
// XXX we also need to shove something more sensible in the
|
|
// padding that undefined...
|
|
|
|
context.code.splice.apply(context.code, [0, 0].concat(s_c))
|
|
context.stack.splice.apply(context.stack, [l, 0].concat(c_c))
|
|
},
|
|
|
|
// encapsulate stack to a block...
|
|
// ... -- [ ... ]
|
|
's2b': function(context){
|
|
context.stack = [ context.stack ]
|
|
},
|
|
// expand block to stack...
|
|
// NOTE: this will append the block contents to stack, w.o. replacing
|
|
// stack contents. this is different to _s2b
|
|
// ... [ ... ] -- ... ...
|
|
'b2s': function(context){
|
|
var c = context.stack.pop()
|
|
context.stack.splice.apply(context.stack, [context.stack.length, 0].concat(c))
|
|
},
|
|
'print': function(context){
|
|
console.log('>>>', context.stack[context.stack.length-1])
|
|
},
|
|
|
|
// turn a sting into a lexical list...
|
|
// c -- b
|
|
// XXX BUG see code...
|
|
'lex': function(context){
|
|
code = context.stack.pop()
|
|
if(typeof(code) == typeof('abc')){
|
|
// XXX BUG: '"aaa" "bbb"' translates to ['"aaa"', '" "', '"bbb"']
|
|
// i.e. quotes w/o whitespace are eaten...
|
|
if(/^\s*(['"]).*\1\s*$/m.test(code)){
|
|
code = code.split(/^\s*(['"])(.*)\1\s*$/m)[2]
|
|
}
|
|
|
|
console.log(code)
|
|
|
|
var res = []
|
|
code = code
|
|
// split by strings whitespace and block comments...
|
|
.split(SPLITTER)
|
|
// parse numbers...
|
|
.map(function(e){
|
|
// numbers...
|
|
if(/^[-+]?[0-9]+\.[0-9]+$/.test(e)){
|
|
e = parseFloat(e)
|
|
} else if(/^[-+]?[0-9]+$/.test(e)){
|
|
e = parseInt(e)
|
|
}
|
|
return e
|
|
})
|
|
// remove undefined groups...
|
|
.filter(function(e){
|
|
// NOTE: in JS 0 == '' is true ;)
|
|
return e !== undefined && e !== ''
|
|
})
|
|
}
|
|
return code
|
|
},
|
|
// pre-process a lexical list...
|
|
// a -- b
|
|
'prep': function(context){
|
|
var code = context.stack.pop()
|
|
|
|
return run({
|
|
stack: [],
|
|
code: code,
|
|
ns: context.pre_ns,
|
|
pre_ns: {},
|
|
}).stack
|
|
},
|
|
|
|
// word definition...
|
|
// syntax: :: <ident> <block>
|
|
// --
|
|
'::': function(context){
|
|
var ident = context.code.splice(0, 1)
|
|
var cur = context.code.splice(0, 1)
|
|
|
|
this[ident] = cur[0]
|
|
},
|
|
|
|
// s c -- s
|
|
'_exec': function(context){
|
|
// block...
|
|
var b = context.stack.pop()
|
|
if(typeof(b) == typeof([]) && b.constructor.name == 'Array'){
|
|
b = b.slice()
|
|
} else {
|
|
b = [ b ]
|
|
}
|
|
// stack...
|
|
var s = context.stack.pop()
|
|
var res = run({
|
|
stack: s,
|
|
code: b,
|
|
// NOTE: this can have side-effects on the context...
|
|
ns: context.ns,
|
|
pre_ns: context.pre_ns
|
|
}).stack
|
|
return res
|
|
},
|
|
// quote - push the next elem as-is to stack...
|
|
// -- x
|
|
'\\': function(context){
|
|
var code = context.code
|
|
return code.splice(0, 1)[0]
|
|
},
|
|
|
|
// comparisons and logic...
|
|
// a b -- c
|
|
'and': function(context){
|
|
var b = context.stack.pop()
|
|
var a = context.stack.pop()
|
|
if(a){
|
|
return b
|
|
} else {
|
|
return a
|
|
}
|
|
},
|
|
// a b -- c
|
|
'or': function(context){
|
|
var b = context.stack.pop()
|
|
var a = context.stack.pop()
|
|
if(a){
|
|
return a
|
|
} else {
|
|
return b
|
|
}
|
|
},
|
|
// x -- b
|
|
'not': function(context){
|
|
return !context.stack.pop()
|
|
},
|
|
// a b -- c
|
|
'gt': function(context){
|
|
return context.stack.pop() < context.stack.pop()
|
|
},
|
|
// a b -- c
|
|
'eq': function(context){
|
|
return context.stack.pop() == context.stack.pop()
|
|
},
|
|
|
|
// stack operations...
|
|
// ... x -- x ...
|
|
'rot': function(context){
|
|
context.stack.splice(0, 0, context.stack.pop())
|
|
},
|
|
// x ... -- ... x
|
|
'tor': function(context){
|
|
context.stack.push(context.stack.shift())
|
|
},
|
|
// a b -- b a
|
|
'swap': function(context){
|
|
return context.stack.splice(context.stack.length-2, 1)[0]
|
|
},
|
|
// x -- x x
|
|
'dup': function(context){
|
|
return context.stack[context.stack.length-1]
|
|
},
|
|
// x --
|
|
'drop': function(context){
|
|
context.stack.pop()
|
|
},
|
|
|
|
// basic number operations...
|
|
// a -- b
|
|
'isNumber': function(context){
|
|
return typeof(context.stack.pop()) == typeof(123)
|
|
},
|
|
// a b -- c
|
|
'add': function(context){
|
|
return context.stack.pop() + context.stack.pop()
|
|
},
|
|
'sub': function(context){
|
|
return - context.stack.pop() + context.stack.pop()
|
|
},
|
|
'mul': function(context){
|
|
return context.stack.pop() * context.stack.pop()
|
|
},
|
|
'div': function(context){
|
|
return context.stack.pop() / context.stack.pop()
|
|
},
|
|
|
|
// block/list operations...
|
|
'isBlock': function(context){
|
|
var e = context.stack.pop()
|
|
return typeof(e) == typeof([]) && e.constructor.name == 'Array'
|
|
},
|
|
// b n -- b e
|
|
'at': function(context){
|
|
var i = context.stack.pop()
|
|
if(i < 0){
|
|
var l = context.stack[context.stack.length-1]
|
|
return l[l.length + i]
|
|
}
|
|
return context.stack[context.stack.length-1][i]
|
|
},
|
|
// b e n -- b
|
|
'to': function(context){
|
|
var i = context.stack.pop()
|
|
var e = context.stack.pop()
|
|
if(i < 0){
|
|
var l = context.stack[context.stack.length-1]
|
|
l[l.length + i] = e
|
|
} else {
|
|
context.stack[context.stack.length-1][i] = e
|
|
}
|
|
},
|
|
// b e n -- b
|
|
'before': function(context){
|
|
var i = context.stack.pop()
|
|
var e = context.stack.pop()
|
|
if(i < 0){
|
|
var l = context.stack[context.stack.length-1]
|
|
l.splice(l.length + i + 1, 0, e)
|
|
} else {
|
|
context.stack[context.stack.length-1].splice(i, 0, e)
|
|
}
|
|
},
|
|
// b -- b e
|
|
'pop': function(context){
|
|
return context.stack[context.stack.length-1].pop()
|
|
},
|
|
// b -- b l
|
|
'len': function(context){
|
|
return context.stack[context.stack.length-1].length
|
|
},
|
|
// b c -- b
|
|
'each': function(context){
|
|
var c = context.stack.pop()
|
|
var b = context.stack[context.stack.length-1]
|
|
for(var i=0; i < b.length; i++){
|
|
// exec block in a separate context...
|
|
var res = run({
|
|
stack: [b[i], c],
|
|
code: ['exec'],
|
|
// NOTE: this can have side-effects on the context...
|
|
ns: context.ns
|
|
}).stack
|
|
var l = res.length
|
|
if(l == 0){
|
|
b.splice(i, 1)
|
|
i--
|
|
} else {
|
|
b.splice.apply(b, [i, 1].concat(res))
|
|
i += l - 1
|
|
}
|
|
}
|
|
},
|
|
}
|
|
|
|
|
|
var BOOTSTRAP = '\n'+
|
|
'-- To expalin stack and code effect some commands have will use a not so\n'+
|
|
'-- traditional notation, the "|" will indicate the split between the stack\n'+
|
|
'-- and code, here is a representation:\n'+
|
|
'--\n'+
|
|
'-- [ .. STACK .. ] <-- runtime -- [ .. CODE .. ]\n'+
|
|
'--\n'+
|
|
'--\n'+
|
|
'-- And here is the new notation representing the states while we run through a\n'+
|
|
'-- word, "add" in this case:\n'+
|
|
'--\n'+
|
|
'-- stack code\n'+
|
|
'-- | 1 2 add\n'+
|
|
'-- 1 | 2 add\n'+
|
|
'-- 1 2 | add\n'+
|
|
'-- 1 2 [add] (a)\n'+
|
|
'-- 3 | (b)\n'+
|
|
'--\n'+
|
|
'-- With stack effect is written like this:\n'+
|
|
'--\n'+
|
|
'-- ( a b -- c )\n'+
|
|
'--\n'+
|
|
'--\n'+
|
|
'-- In traditional stack effect notation we indicate the difference between\n'+
|
|
'-- states (a) ans (b), but when we need to explain something like _swap we\'ll\n'+
|
|
'-- also affect the code, so the process will go like this (expanding "+" word):\n'+
|
|
'--\n'+
|
|
'-- stack code\n'+
|
|
'-- | 1 + 2\n'+
|
|
'-- 1 | + 2\n'+
|
|
'-- 1 [+] 2 (a)\n'+
|
|
'-- 3 | (b)\n'+
|
|
'--\n'+
|
|
'-- So here what "+" actually does is the difference between steps (a) and (b)\n'+
|
|
'-- thus the notation:\n'+
|
|
'--\n'+
|
|
'-- ( a | b -- c | )\n'+
|
|
'--\n'+
|
|
'--\n'+
|
|
'-- Just for illustration, here is how _swap ( a | b -- b | a ) works:\n'+
|
|
'--\n'+
|
|
'-- stack code\n'+
|
|
'-- | a _swap b\n'+
|
|
'-- a | _swap b\n'+
|
|
'-- a [_swap] b (a)\n'+
|
|
'-- b | a (b)\n'+
|
|
'--\n'+
|
|
'--\n'+
|
|
':: _swap ( x | y -- y | x ) [ 1 1 _swapN ]\n'+
|
|
':: _push ( x | -- | x ) [ 0 _swapN ]\n'+
|
|
':: _pull ( | x -- x | ) [ 0 swap _swapN ]\n'+
|
|
'\n'+
|
|
':: exec ( b -- ... ) [ s2b pop _exec b2s ]\n'+
|
|
':: eval ( c -- ... ) [ lex prep exec ]\n'+
|
|
'-- like exec but will run a block in current context...\n'+
|
|
':: b2c [ len rot b2s tor 0 _swapN ]\n'+
|
|
'\n'+
|
|
':: . ( x -- ) [ drop ]\n'+
|
|
':: .. ( x -- ) [ print drop ]\n'+
|
|
'\n'+
|
|
':: swap2 ( a _ b -- b _ a ) [ swap rot swap tor swap ]\n'+
|
|
':: dup2 ( a b -- a b a b ) [ dup swap2 dup rot swap2 tor swap ]\n'+
|
|
'\n'+
|
|
':: ne ( a -- b ) [ eq not ]\n'+
|
|
':: isT ( a -- b ) [ not not true eq ]\n'+
|
|
':: isF ( a -- b ) [ not isT ]\n'+
|
|
'\n'+
|
|
'-- this defines a classic [ cond ] [ A ] [ B ] if word... (a bit too polish IMHO)\n'+
|
|
':: if ( cond a b -- ... ) [ rot rot exec isT tor and tor or exec ]\n'+
|
|
'\n'+
|
|
'-- helpers for the ternary operator...\n'+
|
|
'-- run then block and drop \'else B\' if it exists...\n'+
|
|
':: _run_then ( a x | -- ... | x )\n'+
|
|
' ( a else | b -- ... | )\n'+
|
|
' [ \\ exec swap dup \\ else eq [ (drop else) drop \\ drop _swap 6 ] and\n'+
|
|
' [ (run as-is) 1 _push 4 ] or\n'+
|
|
' b2s 0 _swapN ]\n'+
|
|
'-- if \'else B\' exists, run it, else cleanup...\n'+
|
|
':: _run_else ( a | -- | a )\n'+
|
|
' ( b else | b -- ... | )\n'+
|
|
' [ drop dup \\ else eq [ drop \\ exec _swap 4 ] and\n'+
|
|
' [ 1 _push 2 ] or\n'+
|
|
' b2s 0 _swapN ]\n'+
|
|
'-- NOTE: this may actually have one of three stack effects...\n'+
|
|
':: ? ( c | a -- | )\n'+
|
|
' ( c | a -- ... | )\n'+
|
|
' ( c | a else b -- ... | )\n'+
|
|
' [ exec [ _run_then 1 ] and [ swap _run_else 2 ] or b2s 2 _swapN ]\n'+
|
|
'\n'+
|
|
'\n'+
|
|
'-- list/block 2\'nd gen stuff...\n'+
|
|
':: push ( b e i -- b ) [ -1 before ]\n'+
|
|
'\n'+
|
|
'\n'+
|
|
':: inc ( a -- b ) [ 1 add ]\n'+
|
|
':: dec ( a -- b ) [ 1 sub ]\n'+
|
|
'\n'+
|
|
'-- experimental...\n'+
|
|
'-- NOTE: these are at this point stupid and do not support priorities or grouping...\n'+
|
|
'-- NOTE: these have both stack and code effect, in genera the operations are of \n'+
|
|
'-- the form: A op B\n'+
|
|
':: + ( a | b -- c | ) [ \\ add _swap ]\n'+
|
|
':: - ( a | b -- c | ) [ \\ sub _swap ]\n'+
|
|
':: * ( a | b -- c | ) [ \\ mul _swap ]\n'+
|
|
':: / ( a | b -- c | ) [ \\ div _swap ]\n'+
|
|
'\n'+
|
|
':: == ( a | b -- c | ) [ \\ eq _swap ]\n'+
|
|
':: > ( a | b -- c | ) [ \\ gt _swap ]\n'+
|
|
'\n'+
|
|
'\n'+
|
|
'-- this is here for devel use only\n'+
|
|
':: _clear ( ... -- ) [ s2b drop ] \n'+
|
|
':: _stack_size ( -- l ) [ s2b len swap b2s tor ] \n'+
|
|
'\n'+
|
|
'\n'+
|
|
'-- tests and examples...\n'+
|
|
':: hi ( -- ) [ "Hello World!" print drop ]\n'+
|
|
//'-- NOTE: nop at the end is a stub to fix a bug in ? else ...\n'+
|
|
//':: ! ( a -- b ) [ [ dup 1 ne ] ? [ dup 1 sub ! mul ] nop ]\n'+
|
|
':: ! ( a -- b ) [ [ dup 1 ne ] ? [ dup 1 sub ! mul ] ]\n'+
|
|
':: range ( n -- b ) [\n'+
|
|
' -- initial state...\n'+
|
|
' [ dup isNumber ] ? \n'+
|
|
' [ [] swap ]\n'+
|
|
' -- get first elem...\n'+
|
|
' else\n'+
|
|
' [ 0 at ]\n'+
|
|
' -- we got to the end...\n'+
|
|
' [ dup 0 eq ] ? \n'+
|
|
' [ drop ]\n'+
|
|
' -- dec push new and continue...\n'+
|
|
' else\n'+
|
|
' [ 1 sub 0 before range ] ]\n'+
|
|
':: range2 ( n s -- b )\n'+
|
|
' [ swap range swap [] swap push \\ * 0 before each ]\n'+
|
|
'\n'+
|
|
''
|
|
|
|
|
|
var STARTUP = [[], BOOTSTRAP, 'lex', 'prep', '_exec', 'drop']
|
|
|
|
|
|
// build bootstrap...
|
|
var CONTEXT = {
|
|
stack: [],
|
|
code: STARTUP.slice(),
|
|
ns: NAMESPACE,
|
|
pre_ns: PRE_NAMESPACE,
|
|
}
|
|
|
|
|
|
// run bootstrap...
|
|
run(CONTEXT)
|
|
|
|
|
|
// convenience...
|
|
function _slang(code, context){
|
|
context = context == null ? CONTEXT : context
|
|
|
|
context.code = code
|
|
return run(context).stack
|
|
}
|
|
|
|
|
|
function slang(code, context){
|
|
context = context == null ? CONTEXT : context
|
|
|
|
if(typeof(code) == typeof('abc')){
|
|
code = [ '\\', code, 'lex', 'prep', 'exec' ]
|
|
} else {
|
|
code = [ code, 'prep', 'exec' ]
|
|
}
|
|
|
|
context.code = code
|
|
return run(context).stack
|
|
}
|
|
|
|
|
|
|
|
/********************************************************** RSlang ***/
|
|
|
|
var RS_PRE_NAMESPACE = {
|
|
// XXX using the ";" here just for the experiment, in the real thing
|
|
// if this thing pans out, that is, use indent... (a-la make/Python)
|
|
// XXX this reads ahead at the moment, but it must read back...
|
|
';': function(context){
|
|
var line = []
|
|
var code = context.code
|
|
var cur = code.splice(0, 1)[0]
|
|
while(cur != ';' && code.length > 0){
|
|
line.push(cur)
|
|
cur = code.splice(0, 1)[0]
|
|
}
|
|
|
|
context.code.splice.apply(context.code, [0, 0].concat(line.reverse()))
|
|
},
|
|
|
|
'[': PRE_NAMESPACE['['],
|
|
'macro:': PRE_NAMESPACE['macro:'],
|
|
}
|
|
|
|
RS_CONTEXT = {
|
|
stack: [],
|
|
code: STARTUP.slice(),
|
|
ns: NAMESPACE,
|
|
pre_ns: PRE_NAMESPACE,
|
|
}
|
|
|
|
// NOTE: we use the traditional bootstrap for this...
|
|
run(RS_CONTEXT)
|
|
|
|
RS_CONTEXT.pre_ns = RS_PRE_NAMESPACE
|
|
|
|
function rslang(code, context){
|
|
context = context == null ? RS_CONTEXT : context
|
|
|
|
return slang(code, context)
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
* vim:set ts=4 sw=4 : */
|