home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lifeos2.zip / LIFE-1.02 / TESTS / FILES / Z_GCTOKE.1 < prev   
Text File  |  1996-06-04  |  4KB  |  257 lines
  1. %% This is the input file for the tokenizer.
  2.  
  3. %
  4. % Tokenizer for Life
  5. %
  6.  
  7. main :- tokenize("token.lf").
  8.  
  9. tokenize(File) :- 
  10.         W = readf(File), 
  11.     setq(rest,[]), setq(listTokens,[]),
  12.     tokens(words => W, rest => []).
  13.  
  14.  
  15. dynamic(tokens) ?
  16.  
  17. tokens([],words=>[]) :- !.
  18. tokens(T) --> 
  19.     tokenN(L), 
  20.     tokens(Ls), 
  21.     #( T = append(L,Ls)) ?
  22.  
  23. tokenN( TokenNs, rest => RestN, words => Words) :-
  24.         token_N( Tokens, 50, rest => Rest, words => Words),
  25.         setEco(rest,Rest),
  26.         setEco(listTokens,Tokens),
  27.         fail ; 
  28.         TokenNs = listTokens,
  29.         RestN = rest.
  30.  
  31. token_N( [], 0) --> ! ?
  32. token_N( Tokens, Counter) -->
  33.     void_chars,
  34.     (
  35.         token( Token),
  36.         !, 
  37.         token_N( NewToks, Counter - 1),
  38.         #( Tokens = [ Token| NewToks]) ;
  39.         #( Tokens = [])
  40.     ) ?
  41.  
  42. void_chars --> [{32;9;10}],!, void_chars ?         % blanc, tab, return
  43. void_chars --> [37],!, comment_chars, void_chars ? % commentaires
  44. void_chars --> [] ?
  45.  
  46. comment_chars --> [10], ! ?                     % un commentaire s'arrete avec
  47.                         % return.
  48. comment_chars --> [X], comment_chars ?
  49.  
  50.  
  51.  
  52. dynamic(token) ?
  53.  
  54. token( words => []) :- !, fail.
  55. token(T) --> 
  56.     ( 
  57.         variable(Y), 
  58.         #( !, T = variable(Y)) ;
  59.         syntact_object(Y), 
  60.         #( !, T = syntact_object(Y)) ;
  61.         construct( Y, type => Z), 
  62.         #( T = construct( Y, type => Z))
  63.     ) ?
  64.  
  65.  
  66. %
  67. %
  68. % variables
  69. % 
  70. %
  71.  
  72. variable(_) -->                               % @
  73.     [64], ! ?          
  74. variable(X) -->                               % _...
  75.     [95], !,
  76.     simple_atom_cars(Y), 
  77.     #((Y = "", ! ); X = strcon("_",Y)) ?
  78. variable(X) -->                               % M...
  79.     majuscule(Y), 
  80.     simple_atom_cars(Z), 
  81.     #( X = strcon(Y,Z)) ?
  82.  
  83.  
  84. %
  85. %
  86. % syntactic objects
  87. %
  88. %
  89.  
  90. syntact_object(X) --> 
  91.     [Y:{40;41;44;46;59;63;91;93;123;124;125}],
  92.     #( !, X = charac(Y)) ?
  93.  
  94.  
  95.  
  96. %
  97. %
  98. % constructors
  99. %
  100. %
  101.  
  102.  
  103. construct( Y, type=>T) --> 
  104.     quote(Y), #( !, T = quote);
  105.     simple_atom(Y), #( !, T = simple_atom); 
  106.     quoted_atom(Y), #( !, T = quoted_atom); 
  107.     number(Y), #( !, T = number);
  108.     car_chaine(Y), #( !, T = car_chaine); 
  109.     op_atom(Y), #( !, T = op_atom) ?
  110.  
  111. %
  112. % quote
  113. %
  114.  
  115. quote("`") --> [96] ?
  116.  
  117. %
  118. % simple atoms
  119. %             
  120.  
  121. simple_atom(X) --> 
  122.     minuscule(Y), 
  123.     simple_atom_cars(Z), 
  124.     #( X = strcon(Y,Z)) ?
  125.  
  126. simple_atom_cars(Z) --> 
  127.     simple_atom_car(X), !,
  128.     simple_atom_cars(Y), 
  129.     #( Z = strcon(X,Y)) ?
  130. simple_atom_cars("") --> [] ?
  131.  
  132. simple_atom_car(X) --> 
  133.     [Y], 
  134.     #( Y >= 48,
  135.        cond( Y =< 57,                                  % chiffre
  136.                  succeed,
  137.                  ( 
  138.              Y >= 65 , 
  139.              cond( Y =< 90 ,                       % majuscule
  140.                    succeed,
  141.                cond( Y =:= 95,                 % underscore
  142.                  succeed,
  143.                  ( Y >= 97 , Y =< 122)))   % minuscule
  144.          )
  145.           ),
  146.       X = charac(Y)) ?
  147.  
  148. %
  149. % quoted atoms
  150. %
  151.  
  152. quoted_atom(X) --> 
  153.     [39],
  154.         quoted_atom_end(X) ?
  155.  
  156. quoted_atom_end(X) --> 
  157.     [39], !,
  158.     ( [39], quoted_atom_end(Y), X = strcon("'",Y) ; 
  159.           # ( X = "" )) ?
  160. quoted_atom_end(X) --> 
  161.     quoted_atom_car(Y),
  162.     quoted_atom_end(Z),
  163.     #(  X = strcon(Y,Z)) ?
  164.  
  165. quoted_atom_car(Y) -->
  166.     [X], #( Y = charac(X) ) ?
  167.  
  168.  
  169. %
  170. % Numbers
  171. %
  172.  
  173. number(X) --> 
  174.     digits(V1),
  175.     ( [46], digits(V2,length => L2), !;
  176.           #( V2 = 0, L2= 0) ),
  177.     ( [101], !,exponent(E) ;
  178.       #(E = 0) ),
  179.     #( X = (V1 + V2 * 10^(-L2)) * 10^(E)) ?
  180.  
  181. digits(V, length=>L) --> 
  182.     digit( V1), 
  183.     ( digits(V2, length=>L2),!,
  184.       #( L = L2+1, V = V1*10^L2 + V2) ;
  185.           #( V = V1, L = 1)) ?
  186.  
  187. sign(-1) --> [45],! ?
  188. sign(1)  --> [43],! ?
  189. sign(1)  --> [] ?
  190.  
  191. exponent(V) --> sign(S), digits(V1), #(V = S*V1) ?
  192.  
  193. digit(N:int) --> [48+N], #(N =< 9, N >= 0)  ?
  194.  
  195.  
  196. %
  197. % Strings
  198. %
  199.  
  200. car_chaine(X) --> 
  201.     [34],
  202.         car_chaine_end(X) ?
  203.  
  204. car_chaine_end(X) --> 
  205.     [34], !,
  206.     ( [34], !,car_chaine_end(Y), #(X = strcon("""",Y)) ; 
  207.           # ( X = "" )) ?
  208. car_chaine_end(X) --> 
  209.     car_chaine_car(Y),
  210.     car_chaine_end(Z),
  211.     #(  X = strcon(Y,Z)) ?
  212.  
  213. car_chaine_car(Y) -->
  214.     [X], #( Y = charac(X) ) ?
  215.  
  216.  
  217. %
  218. % op_atoms
  219. %
  220.  
  221. op_atom(X) --> 
  222.     op_atom_car(Y),!, 
  223.     op_atom_cars(Z),
  224.     #(  X = strcon(Y,Z)) ?
  225.  
  226. op_atom_car(X) -->
  227.     [Y:{33;35;36;37;38;42;43;45;47;58;60;61;62;92;94;126}],!,
  228.     #( X = charac(Y)) ?
  229.  
  230. op_atom_cars(X) --> 
  231.     op_atom_car(Y),!, 
  232.     op_atom_cars(Z),
  233.     #(  X = strcon(Y,Z)) ?
  234. op_atom_cars("") -->
  235.     [] ?
  236.                       
  237.  
  238. minuscule(Y) --> [X], #( X >= 97, X =< 122, Y = charac(X) ) ?
  239. majuscule(Y) --> [X], #( X >= 65, X =< 90,  Y = charac(X) ) ?
  240.  
  241. charac(Z) -> psi2str(chr(Z)) .
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257.