[gforth] / gforth / kernel / recognizer.fs  

gforth: gforth/kernel/recognizer.fs

Diff for /gforth/kernel/recognizer.fs between version 1.1 and 1.13

version 1.1, Wed Oct 5 20:48:16 2011 UTC version 1.13, Thu Oct 6 21:18:46 2011 UTC
Line 15 
Line 15 
 \ interpret it, compile interpretation semantics  \ interpret it, compile interpretation semantics
 \ compile it, compile it as literal.  \ compile it, compile it as literal.
   
 : recognizer: ( xt1 xt2 xt3 xt4 -- ) Create 2swap swap 2, swap 2, ;  : recognizer: ( xt1 xt2 xt3 -- ) Create rot , swap , , ;
   
 : r>int     ( r-addr -- )  @ ;  (field) r>int      ( r-addr -- addr )  0 cells ,
 : r>compint ( r-addr -- )  cell+ @ ;  (field) r>comp     ( r-addr -- addr )  1 cells ,
 : r>comp    ( r-addr -- )  cell+ cell+ @ ;  (field) r>lit      ( r-addr -- addr )  2 cells ,
 : r>lit     ( r-addr -- )  cell+ cell+ cell+ @ ;  
   
 :noname ( ... nt -- ) name>int execute ;  :noname ( ... nt -- ) name>int execute ;
 :noname ( ... nt -- ) name>int compile, ;  
 :noname ( ... nt -- ) name>comp execute ;  :noname ( ... nt -- ) name>comp execute ;
 :noname ( ... nt -- ) postpone Literal ;  :noname ( ... nt -- ) postpone Literal ;
 recognizer: r:int-table  Create r:word rot A, swap A, A,
   
 :noname ( addr u -- nt int-table true | addr u false )  : word-recognizer ( addr u -- nt int-table true | addr u false )
     2dup find-name [ [IFDEF] prelude-mask ] run-prelude [ [THEN] ] dup      2dup find-name [ [IFDEF] prelude-mask ] run-prelude [ [THEN] ] dup
     IF      IF
         nip nip r:int-table true  EXIT          nip nip r:word true  EXIT
     THEN ; Constant int-recognizer      THEN ;
   
 ' noop  ' noop
 :noname  postpone Literal ;  :noname  postpone Literal ;
 dup  dup
 dup  Create r:num rot A, swap A, A,
 recognizer: r:number  
   
 ' noop  ' noop
 :noname  postpone 2Literal ;  :noname  postpone 2Literal ;
 dup  dup
 dup  Create r:2num rot A, swap A, A,
 recognizer: r:2number  
   \ snumber? should be implemented as recognizer stack
   
 :noname ( addr u -- nt int-table true | addr u false )  : num-recognizer ( addr u -- n/d int-table true | addr u false )
     2dup 2>r snumber?  dup      2dup 2>r snumber?  dup
     IF      IF
         2rdrop 0> IF  r:2number   ELSE  r:number  THEN  true  EXIT          2rdrop 0> IF  r:2num   ELSE  r:num  THEN  true  EXIT
     THEN      THEN
     drop 2r> false ; Constant num-recognizer      drop 2r> false ;
   
   ' no.extensions dup dup Create r:fail A, A, A,
   
 \ recognizer stack  \ recognizer stack
   
 $10 Constant max-rec#  $10 Constant max-rec#
 Variable forth-recognizer max-rec# cells allot  
   
 : get-recognizers ( rec-addr -- xt1 .. xtn n )  : get-recognizers ( rec-addr -- xt1 .. xtn n )
     dup cell+ swap @ dup >r cells bounds ?DO      dup swap @ dup >r cells bounds swap ?DO
         I @          I @
     cell +LOOP  r> ;      cell -LOOP  r> ;
   
 : set-recognizers ( xt1 .. xtn n rec-addr -- )  : set-recognizers ( xt1 .. xtn n rec-addr -- )
     over max-rec# u>= abort" Too many recognizers"      over max-rec# u>= abort" Too many recognizers"
     2dup ! swap cells bounds swap ?DO      2dup ! cell+ swap cells bounds ?DO
         I !          I !
     cell -LOOP ;      cell +LOOP ;
   
   Variable forth-recognizer
   
 num-recognizer int-recognizer 2 forth-recognizer set-recognizers  ' word-recognizer A, ' num-recognizer A, max-rec# 2 - cells allot
   2 forth-recognizer !
   \ ' num-recognizer ' word-recognizer 2 forth-recognizer set-recognizers
   
 \ recognizer loop  \ recognizer loop
   
Line 77 
Line 80 
     dup cell+ swap @ cells bounds ?DO      dup cell+ swap @ cells bounds ?DO
         I perform IF  UNLOOP  EXIT  THEN          I perform IF  UNLOOP  EXIT  THEN
     cell +LOOP      cell +LOOP
     no.extensions ;      r:fail ;
   
   \ nested recognizer helper
   
   : r:table>flag ( table -- table true | false )
       dup r:fail <> dup 0= IF  nip  THEN ;
   
   \ : nest-recognizer ( addr u -- token table true | addr u false )
   \   xxx-recognizer do-recognizer r:table>flag ;
   
 : interpreter-r ( addr u -- ... xt )  : interpreter-r ( addr u -- ... xt )
     forth-recognizer do-recognizer r>int ;      forth-recognizer do-recognizer r>int @ ;
   
   ' interpreter-r IS parser1
   
 : compiler-r ( addr u -- ... xt )  : compiler-r ( addr u -- ... xt )
     forth-recognizer do-recognizer r>comp ;      forth-recognizer do-recognizer r>comp @ ;
   
 : [ ( -- ) \  core      left-bracket  : [ ( -- ) \  core      left-bracket
     \G Enter interpretation state. Immediate word.      \G Enter interpretation state. Immediate word.
Line 93 
Line 106 
     \G Enter compilation state.      \G Enter compilation state.
     ['] compiler-r     IS parser1 state on  ;      ['] compiler-r     IS parser1 state on  ;
   
   : >int      ( token table -- )  r>int perform ;
   : >comp     ( token table -- )  r>comp perform ;
   : >postpone ( token table -- )
       >r r@ r>lit perform r> r>comp @ compile, ;
   
   : postpone ( "name" -- ) \ core
       \g Compiles the compilation semantics of @i{name}.
       parse-name forth-recognizer do-recognizer >postpone ; immediate
   

Generate output suitable for use with a patch program
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.13
CVS Admin

Powered by ViewCVS 1.0-dev 		(Powered by ViewCVS)

ViewCVS and CVS Help