home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V6 / usr / source / tmg / tmgl.t < prev   
Encoding:
Text File  |  1975-05-13  |  6.6 KB  |  325 lines
  1. begin:    ignore(blanks)
  2. pr1:    comment\pr1
  3.     parse(first)\pr2
  4.     diag(error)
  5. pr2:    comment\pr2
  6.     parse(line)\pr2
  7.     diag(error)\pr2
  8.     putcharcl
  9.     parse(last);
  10.  
  11. first:    parse(( fref = {<1 > 1 *}))
  12.     getfref line = { 2<:> 1 };
  13.  
  14. error:    smark ignore(none) any(!<<>>) string(!<<;>>) scopy 
  15.     ( <;> = {<;>} | null )
  16.     = { * <??? > 2 1 * };
  17.  
  18. line:
  19.     labels
  20.     ( charcl <;>
  21.     | statement
  22.     | numbers
  23.     | trule <;> )
  24.     = { 2 * 1 * };
  25.  
  26. numbers: number <;> numbers/done = { 2 * 1 };
  27.  
  28. labels:    label labels/done = { 2 * 1 };
  29.  
  30. label:    name <:> = { 1 <:> };
  31.  
  32. last:    = {    <.pn:1 .pxs;12> *
  33.         <.tn:1 .txs;12> * };
  34.  
  35. comment: </*>
  36. co1:    ignore(!<<*>>) <*> ignore(none) </>/co1;
  37.  
  38. statement: [csym=0] oldtab(dtt) oldtab(pat)
  39.     ( proc plst tlst <)> = (1){2 1 }
  40.     | = (1){} noelem )
  41. stt1:    bundle    ( frag = (1){ 2(nil) * 1(q1) }\stt1
  42.         | <;>    ( ifelem = { 1(xbit) }
  43.             | ={ 1(nil) * <1 succ> }
  44.         )    );
  45.  
  46. proc:    smark ignore(none) <proc(>;
  47.  
  48. plst:    list(pident)/null remote((octal(npa)))
  49.     = { <params;> 1 * };
  50.  
  51. pident:    ident newtab(pat,npa);
  52.  
  53. tlst:    <;>/null [i=0] list((name [i++])) remote((octal(i)))
  54.     = { <push;> 1 * 2 * };
  55.  
  56. frag:    prule = (1){ 1(nil,q1) }
  57.     | labels noelem = (1){ 1 };
  58.  
  59. /*in sequel q2 is where to go on fail,q1 is exit bit*/
  60.  
  61. prule:    [sndt=ndt] disj
  62.     ( <|> [ndt=sndt] fref
  63.         ( ifeasy prule = (2){3(nil,nil)*<salt;>2*
  64.                 1(q2,q1)*2<:>}
  65.         | prule fref = (2){4({*<alt;>1},q1)*<goto;>3*
  66.                 1<:>2(q2,q1)*3<:>} )
  67.         noelem
  68.     | () );
  69.  
  70. disj:    pelem pdot
  71.     ( disj = (2){2(q2,nil) * 1(nil,q1)} ifelem/done ishard
  72.     | () );
  73.  
  74. pelem:    pprim = (2){1(q1)$2} iseasy
  75.     | <(>    push(1,sndt)
  76.         ( prule <)>
  77.         | <)> = (2){} noelem );
  78.  
  79. pprim:    ( special
  80.     | rname    ( <:> fail
  81.         | (spdot|()) ignore(none)
  82.             ( <(> ignore(blanks) list(parg) <)>
  83.                 = (1){$1 2 * 1}
  84.             | = (1){$1 1}  )))
  85.     ( (</> = {<alt;>} | <\>={<salt;>})
  86.         rname = (1){3(nil)*$1 2 1}
  87.     | () );
  88.  
  89. pdot:    <.>/done ignore(none) ident\alias
  90.     ([dtt?] | table(dtt) [ndt=0]) [ndt++];
  91. spdot:    <.> ignore(none) not(( any(letter) ))
  92. alias:    newtab(dtt,ndt);
  93.  
  94. parg:    rname | remote(specparg);
  95.  
  96. specparg: number
  97.     | charcl
  98.     | <<> longlit
  99.     | <*> = { <\n\0> }
  100.     | <(> ( <)> = {<1 succ>}
  101.         | push(3,dtt,ndt,sndt) [dtt=0]
  102.             prule <)> oldtab(dtt)
  103.             ( ifelem = {1(nil,xbit) }
  104.             | = {1(nil,nil)*<1 succ>} 
  105.         )    );
  106.  
  107. iseasy:    [easy = 1];
  108. ishard:    [easy = 0];
  109. noelem:    [easy = 2];
  110. ifelem:    [easy!=2?];
  111. ifeasy:    [easy==1?];
  112.  
  113. special: <=> (rname | remote(trule))
  114.         = (1){ $1 <trans;1 > 1 }
  115.     | <<> literal = (1){ $1 <.px> 1 }
  116.     | <*> = (1){ $1 <.pn> }
  117.     | <[> expr
  118.         ( <?> = {<.t>}
  119.         | = {<.p>} )
  120.         <]> = (1){ 2 * $1 1 };
  121.  
  122. rname:    ( name tabval(pat,npa)/done
  123.     | <$> number )
  124.     = { <[-> 1 <\<1]> };
  125.  
  126. trule:    oldtab(ptt)
  127.     ( tbody
  128.     | <(> (number|tra) <)> tbody = {<gpar;> 2 * 1 } );
  129. tra:    list(tident) octal(npt);
  130.  
  131. tident:    ident newtab(ptt,npt);
  132.  
  133. tbody: <{>    ( <}> = { <1 generate> }
  134.         | trb);
  135. trb:    telem    ( <}> = {  xbit 1 }
  136.         | trb = { 2 * 1 } );
  137.  
  138. telem:    <<> literal = { <.tx> 1 }
  139.     | <*> = {<.tn>}
  140.     | <$> number = { <.tq;> 1 }
  141.     | number tdot = tpt
  142.     | name te1\done te2\done;
  143.  
  144. te1:    tabval(dtt,ndt) tdot = tpt;
  145. te2:    tabval(ptt,npt) = {<.tq;>1};
  146.  
  147. tdot:    (<.> number | ={<0>})
  148.     ( <(> list(targ) <)> | null)
  149.     = { 2 <;> 1 };
  150.  
  151. targ:    name|remote(tbody);
  152.  
  153. tpt:    { <.tp;.byte > 2 <,> 1 };
  154.  
  155. literal: ( shortlit
  156.     | remote(longlit) = { <;> 1} );
  157.  
  158. shortlit: ignore(none) smark any(litch) <>> scopy = { <s;'> 1 };
  159.  
  160. longlit: ignore(none) (<>> = { <\> <>> } | null) litb <>>
  161.     = { <<> 2 1 <\0> <>;.even> };
  162.  
  163. litb:    smark string(litch) scopy <\>/done
  164.     litb = { 2 <\\> 1 };
  165.  
  166. expr:    assignment | rv ;
  167.  
  168. assignment: lv assign expr = { 3 * 1 * 2 };
  169.  
  170. rv:    prime
  171. rv1:    bundle    ( infix prime = { 3 * 1 * 2 }\rv1
  172.         | rva = { 2 * 1 }
  173.         | () );
  174. rva:    <?> rv <:> rv fref fref 
  175.     = { <.t;alt;> 2 * 4 * <salt;> 1 * 2 <:> 3 * 1 <:> };
  176.  
  177. prime:
  178.     lv suffix/done = { 2 * 1 }
  179.     | prefix lv = { 1 * 2 }
  180.     | <(> expr <)> 
  181.     | unary prime = { 1 * 2 }
  182.     | remote(number) = { <.l;> 1 };
  183.  
  184. lv:    ( rname = { <.l;> 1 }
  185.     | <(> lv <)>
  186.     | <*> prime = { 1 * <.rv> } )
  187. lv1:    <[>/done bundle expr <]> = { 2 * 1 * <.f> }\lv1;
  188.  
  189. assign:    <=> ignore(none) ( infix = { 1 * <.u> }
  190.             | = { <.st> } );
  191.  
  192. infix:    smark ignore(none)
  193.     ( <+> not((<+> not((<+>)) )) = {<.a>}
  194.     | <-> = {<.s>}
  195.     | <*> = {<.m>}
  196.     | </> = {<.q>}
  197.     | <%> = {<.r>}
  198.     | <|> = {<.o>}
  199.     | <^> = {<.x>}
  200.     | <&> = {<.n>}
  201.     | <==> = {<.eq>}
  202.     | <!=> = {<.ne>}
  203.     | <<=> = {<.le>}
  204.     | <>=> = {<.ge>}
  205.     | <<<> = {<.sl>}
  206.     | <<> = {<.lt>}
  207.     | <>>    (  <>> = {<.sr>}
  208.         | = {<.gt>} )
  209.     );
  210.  
  211. prefix:    smark ignore(none)
  212.     ( <&> = {<.lv>}
  213.     | <++> = {<.ib>}
  214.     | <--> = {<.db>}
  215.     );
  216.  
  217. suffix:    smark ignore(none)
  218.     ( <++> = {<.ia>}
  219.     | <--> = {<.da>}
  220.     );
  221.  
  222. unary:    ( <!> = {<.nt>}
  223.     | <-> = {<.ng>}
  224.     | <~> = {<.cm>}
  225.     );
  226.  
  227. charcl:
  228.     ( <!> ccla cclb | ccla )
  229.     octal(classmask);
  230. ccla:    (<<<>) [classmask = 1<<nclass++] [classmask?]/cherr
  231. ccl1:    cclc <<<>\ccl1;
  232. cclc:    ignore(none)
  233.  
  234. ccl3:    <>>\ccl4 ccle\ccl3;
  235. ccl4:    (<>> | cclx fail) (not((<>>)) | ccle);
  236. ccle:    char(n) [*(2*n+&classes) =| classmask];
  237. cclb:    zeron
  238. ccl5:    [*(&classes+n) =^ classmask] testn\ccl5;
  239. cclx:    [nclass--] zeron
  240. ccl6:    [*(&classes+n) =& ~classmask] testn\ccl6;
  241. cherr:    diag(( ={<too many char classes>} ));
  242.  
  243. zeron:    [n=0];
  244. testn:    [(n=+2)<400?];
  245.  
  246. putcharcl: zeron [classes=0] 
  247.     parse(( = { * <.globl classtab> * <classtab:> * } ))
  248. ptc1:    [w = *(&classes+n)] parse((octal(w) = {1*}))
  249.     bundle testn\ptc1;
  250.  
  251. classmask: 0;
  252. nclass:    0;
  253. classes:
  254. cl1:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  255. cl2:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  256. cl3:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  257. cl4:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  258. cl5:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  259. cl6:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  260. cl7:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  261. cl8:    0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;
  262.  
  263. done:    ;
  264.  
  265. create:    [csym++]
  266. getcsym: octal(csym) = {<.> 1};
  267.  
  268. fref:    [fsym++]
  269. getfref: octal(fsym) = { <..> 1 };
  270.  
  271. not:    params(1) $1/done fail;
  272.  
  273. list:    params(1) $1
  274. list1:    bundle <,>/done $1 = { 2 * 1 }\list1;
  275.  
  276. remote:    params(1) create parse(rem1,$1);
  277. rem1:    params(1) getcsym $1 = { 2 <=.> * 1 * };
  278.  
  279. number: smark ignore(none) any(digit) string(digit) scopy;
  280.  
  281. name:    ident scopy;
  282.  
  283. ident:    smark ignore(none) any(letter) string(alpha);
  284.  
  285. oldtab:    params(1) [$1?]/done discard($1) [$1=0];
  286.  
  287. newtab:    params(2) ([$2?] | table($2) [$1=0])
  288.     enter($2,i) [$2[i] = $1++];
  289.  
  290. tabval:    params(2) [$2?] find($2,i) [i=$1-$2[i]] octal(i);
  291.  
  292. null:    = nil;
  293.  
  294. xbit:    {<1 >};
  295.  
  296. q1:    { $1 };
  297. q2:    { $2 };
  298.  
  299. nil:    {};
  300.  
  301. blanks:    <<     
  302.     >>;
  303. digit:    <<0123456789>>;
  304. letter:    <<abcdefghijklmnopqrstuvwxyz>>
  305.     <<ABCDEFGHIJKLMNOPQRSTUVWXYZ>>;
  306. alpha:    <<0123456789>>
  307.     <<abcdefghijklmnopqrstuvwxyz>>
  308.     <<ABCDEFGHIJKLMNOPQRSTUVWXYZ>>;
  309. litch:    !<<\>>>;
  310. none:    <<>>;
  311.  
  312. csym:    0;
  313. fsym:    0;
  314. easy:    0;
  315. w:    0;
  316. n:    0;
  317. dtt:    0;    /*delivered translation table*/
  318. ndt:    0;    /*numb of delivered translations*/
  319. sndt:    0;    /*saved ndt at beginning of disjunctive term*/
  320. pat:    0;    /*parsing rule parameter table*/
  321. npa:    0;    /*number of parsing rule params*/
  322. ptt:    0;    /*table of params of translation*/
  323. npt:    0;    /*number of params of translation*/
  324. i:    0;
  325.