some experiment on optimization

some experiment on optimization by directly operating on continuation, not very successful.
start coding compiler

start coding compiler, and find a wrong thought in solver implementation.
compiler on solve and lisp pass tests

compiler on solve and lisp pass tests. but find logic is hard. need to find a new way.
simplify compiler
commit frequently is good.
use string as keyword

deprecate using integer as keyword, using string instead.
all vop added by a loop

all vop added as specials by a loop.
lambda and macro

compile lambda and macro
block/break/continue

block/break/continue come back.
redo some bug fix

after roll back from split-local-global-continuation branch, redo some bug fix:
JSfun: optimize
Apply: optimize
Clamda: optimize add @v:@v to env.
il.begin: <+++result =+++> result.concat(exps)
more optimization

optimize JSFun, sideEffect's vop
analyze to get reference dictionary

analyze before optimization to get reference dictionary
optimize Apply

optimize Apply, especially with Lamda as caller.
optimize vop

optimize vop, add is tested.
optimize il.If

optimize il.If, tested.
fix bug in assign optimize

fix bug in assign optimize: don't optimize left side of assign to value.
remove abundant braces.

remove abundant braces for begin when toCode.
sideEffect and applySideEffect

refactor sideEffect and applySideEffect used in optimization.
fix bug in jsfun.optimize

fix bug in jsfun.optimize
io mark for optimization

io mark for optimization