electricwah / combined_compiler.nv

| :: get cause 1 | :stack: A :pattern: . a . b . variable c . d . variable e :index: ( 0 1 2 3 4 ) | :: get cause 2 | :stack: A :pattern: . stride . test :index: ( 0 1 ) | :: get cause 3 | :stack: B :pattern: . other . cause . match . variable c :index: ( 0 1 2 3 ) | :: get effect 1 | :stack: out_A :items: . output . one . variable c :index: ( 0 1 2 ) | :: get effect 2 | :stack: out_B :items: . output . 2 . variable e :index: ( 0 1 2 ) | :: get rule 1 | :causes: ( 1 2 3 ) :effects: ( 1 2 ) | :: get cause 4 | :stack: ohnoes :pattern: . a . second . rule :index: ( 0 1 2 ) | :: get effect 3 | :stack: x :items: . what . shall . we . do :index: ( 0 1 2 3 ) | :: get rule 2 | :causes: ( 4 ) :effects: ( 3 ) || :rules: ( 1 2 ) |------------------------------| |- handle incrementing -| |------------------------------| | :@math: add 0 1 | :@math: 1 | :@math: add 1 1 | :@math: 2 | :@math: add 2 1 | :@math: 3 | :@math: add 3 1 | :@math: 4 | :@math: add 4 1 | :@math: 5 | :@math: add 5 1 | :@math: 6 | :@math: add 6 1 | :@math: 7 | :@math: add 7 1 | :@math: 8 | :@math: add 8 1 | :@math: 9 | :@math: add 9 1 | :@math: 10 | :@math: add 10 1 | :@math: 11 | :@math: add 11 1 | :@math: 12 | :@math: add 12 1 | :@math: 13 | :@math: add 13 1 | :@math: 14 | :@math: add 14 1 | :@math: 15 | :@math: add 1 $x | :@math: add $x 1 |------------------------------| |# run with > nova -d mathpolyfill.nv data.nv emitter.nv < #| | :: process rule :rules: $ruleid | :: get rule $ruleid :current rule id: $ruleid :: process causes :: clear causes temp state :: check stack depths :: process effects :: clear rule temp state | :: clear rule temp state? :stack: $stack | | :: clear rule temp state? :vars: variable $x = index $y of stack $z at depth $q | | :: clear rule temp state | | :: process causes? :causes: $causeid | :: get cause $causeid :length: 0 :: check stack :: process pattern :: check fact lengths :: pop cause | :: process causes | |:: check stack depths| | :: check fact lengths :stack: $stack? :current stride depth: $depth ? :length: $length | :check fact lengths: check stack $stack depth $depth has length $length | :: clear causes temp state :current stride depth: $n | | :: check stack :stack: $stack? | :: add stack $stack | :: pop cause :stack: $stack | :pop causes: pop $stack |------------------------------| | :: add stack $stack? :current stride depth: $n | | :: add stack $stack :@math: $depth | :current stride depth: $depth :strides: check stack $stack has at least depth $depth :: strides temp -> strides | :: add stack $stack? :strides: check stack $stack has at least depth $depth | :@math: add $depth 1 | :: add stack $stack? :strides: check stack $different has at least depth $depth | :strides temp: check stack $different has at least depth $depth | :: add stack $stack | :current stride depth: 1 :strides temp: check stack $stack has at least depth 1 :: strides temp -> strides | :: strides temp -> strides? :strides temp: check stack $stack has at least depth $depth | :strides: check stack $stack has at least depth $depth | :: strides temp -> strides | |------------------------------| | :: increment length :length: $old :@math: $n | :length: $n | :: increment length? :length: $n? | :@math: add $n 1 | :: process pattern? :stack: $stack? :pattern: variable $name :index: $i :current stride depth: $depth? | :: do variable $name at index $i of stack $stack at depth $depth :: increment length |- var is already declared -| | :: do variable $name at index $i of stack $stack at depth $depth :vars: variable $name = index $j of stack $stack2 at depth $depth2? | :check vars: check index $i of top of stack $stack at depth $depth equals value of var $name :: vars temp -> vars |# can also do this to give more information #| :check vars: check index $i of top of stack $stack at depth $depth equals var $name stack $stack2 depth $depth2 index $index2 |- not the right var, check next -| | :: do variable $name at index $i of stack $stack at depth $depth? :vars: variable $different = index $j of stack $stack2 at depth $depth2 | :vars temp: variable $different = index $j of stack $stack2 at depth $depth2 |- variable isn't declared yet, so declare it -| | :: do variable $name at index $i of stack $stack at depth $depth | :set vars: declare variable $name = index $i of stack $stack at depth $depth :vars: variable $name = index $i of stack $stack at depth $depth :: vars temp -> vars | :: vars temp -> vars :vars temp: variable $name = index $i of stack $stack at depth $depth | :vars: variable $name = index $i of stack $stack at depth $depth | :: vars temp -> vars | | :: process pattern? :stack: $stack? :pattern: $symbol :index: $i :current stride depth: $depth? | :check facts: check stack $stack at depth $depth matches symbol $symbol at index $i :: increment length | :: process pattern | |--------------------| | :: process effects? :effects: $effectid | :: get effect $effectid :: push effects start :: process items :: push effects end | :: process effects | | :: push effects start | :push effects: start fact to push | :: push effects end | :push effects: end fact to push | :: process items? :stack: $stack? :items: $symbol :index: $i | :push effects: symbol $symbol | :: process items? :stack: $stack? :items: variable $name :index: $i | :push effects: variable $name | :: process items | | :emit: rule header $ruleid | :out: rule header $ruleid | :emit: check stack heights? :strides: check stack $stack has at least depth $depth | :out: check stack $stack has at least depth $depth | :emit: check stack heights | | :emit: check facts lengths? :check fact lengths: check stack $stack depth $depth has length $length | :out: check stack $stack depth $depth has length $length | :emit: check facts lengths | | :emit: check facts constant symbol matches? :check facts: check stack $stack at depth $depth matches symbol $symbol at index $index | :out: check stack $stack at depth $depth matches symbol $symbol at index $index | :emit: check facts constant symbol matches | | :emit: set variables? :set vars: declare variable $name = index $i of stack $stack at depth $depth | :out: declare variable $name = index $i of stack $stack at depth $depth | :emit: set variables | | :emit: check variables equality? :check vars: check index $i of top of stack $stack at depth $depth equals value of var $name | :out: check index $i of top of stack $stack at depth $depth equals value of var $name | :emit: check variables equality | | :emit: pop causes ? :pop causes: $a $b | :out: $a $b | :emit: pop causes | | :emit: push effects -> push effects reversed? :push effects: $a $b | :push effects reversed: $a $b | :emit: push effects -> push effects reversed? :push effects: $a $b $c $d | :push effects reversed: $a $b $c $d | :emit: push effects -> push effects reversed | | :emit: push effects reversed -> out? :push effects reversed: $a $b $c $d | :out: $a $b $c $d | :emit: push effects reversed -> out? :push effects reversed: $a $b | :out: $a $b | :emit: push effects reversed -> out | | :emit: push effects | :emit: push effects -> push effects reversed :emit: push effects reversed -> out | :emit: rule footer | :out: rule footer | :: emit rule :current rule id: $ruleid | :: emitting rule :emit: . rule header $ruleid . check stack heights . check facts lengths . check facts constant symbol matches . set variables . check variables equality . pop causes . push effects . rule footer | :: emitting rule | |- :vim:sw=3:ts=3:et: -| | :: translate? :out: rule header $ruleid | :@js: f('final out', `function rule${$ruleid} () {`); f('rule functions', `rule${$ruleid}`); | :: translate? :out: check stack $stack has at least depth $depth | :@js: f('final out', `if ( stack["${$stack}"].length < ${$depth} ) return false;`) | :: translate? :out: check stack $stack depth $depth has length $length | :@js: f('final out', `if ( stack["${$stack}"][${$depth}].length != ${$length} ) return false;`) | :: translate? :out: check stack $stack at depth $depth matches symbol $symbol at index $index | :@js: f('final out', `if ( stack["${$stack}"][${$depth}][${$index}] != "${$symbol}" ) return false;`) | :: translate? :out: declare variable $name = index $index of stack $stack at depth $depth | :@js: f('final out', `let ${$name} = stack["${$stack}"][${$depth}][${$index}];`) | :: translate? :out: check index $i of top of stack $stack at depth $depth equals value of var $name | :@js: f('final out', `if ( stack["${$stack}"][${$depth}][${$i}] != ${$name} ) return false;`) | :: translate? :out: start fact to push | :final out: f( | :: translate? :out: symbol $symbol | :@js: f('final out',`"${$symbol}",`) | :: translate? :out: variable $varname | :@js: f('final out',`${$varname},`) | :: translate? :out: pop $stack | :@js: f('final out',`stack["${$stack}"].pop();`) | :: translate? :out: end fact to push | :final out: ); | :: translate? :out: rule footer | :final out: } :final out: [] | :: emit file header | :final out: [/* stub */] :final out: [] | :: translate | |#========#| | :: breakpoint | | :: breakpoint | :@js: me.gas = 0; || :: emit file header :: output :: process, emit, and output rules :: emit step function ::output :: output main loop | :: process, emit, and output rules ? :rules: $n?| :: breakpoint :: process rule :: breakpoint :: emit rule :: breakpoint :: translate :: breakpoint :: output :: breakpoint | :: process, emit, and output rules | |# in reverse order because we are pushing directly to the final out stack #| | :: emit step function | :: emit step function footer :: emit rule function names :: emit step function header | :: emit step function header | :final out: [function step () {] | :: emit rule function names? :rule functions: $fname | :@js: f('final out',`if (${$fname}()) return true;`) | :: emit rule function names | | :: emit step function footer | :final out: } :final out: [] | :: output main loop | :: output :final out: . [function run() {] . [ while (step()) {] . [ // nop] . [ }] . [}] |#===============#| || '@include' lib/platforms/browser_dom.nv || :DOM: ( <query #code-actions <@after #out or textarea id = out value = [] ) | :: output reversed? :first: :reversed: $x | :append: $x | :append: \n :current dom element: $o?| :@js: $o.value += '\n'; | :append: \t :current dom element: $o?| :@js: $o.value += '\t'; | :append: $x :current dom element: $o?| :@js: $o.value += $x; | :: output reversed? :reversed: label :in label: | :append: ( label \n \t \t ) | :: output reversed? :reversed: label | :append: ( \n \t label [ ] ) :in label: | :: output reversed? :reversed: rule | :append: ( \n rule [ ] ) | :: output reversed? :reversed: end | :append: ( \n end ) | :: output reversed? :reversed: $x | :append: ( $x [ ] ) | :: output reversed | :DOM: ( > > ) |#===============#| | :: output :current dom element: $out? | :@js: $out.value += (stacks['final out'].map(x=>x.join('')).toReversed().join('\n')+'\n'); delete stacks['final out'];