home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume2 / basic / part2 / newbs / bsgram.y < prev    next >
Encoding:
Text File  |  1986-11-30  |  8.7 KB  |  445 lines
  1.     /* bsgram.y -- grammer specification for bs.
  2.      */
  3. %{
  4. #include "bsdefs.h"
  5.  
  6. char *p;        /* the generic pointer */
  7. int i;            /* the generic counter */
  8. int (*l[300])();    /* array to generate the code list into. */
  9. int lp;            /* pointer to current spot in l[] */
  10.  
  11. struct stk {
  12.     int stack[40];
  13.     int stkp;
  14. };
  15.  
  16. struct stk ifstk,whstk,forstk,repstk,lpstk;
  17. int gomax=0, ifmax=0, whmax=0, formax=0, repmax=0, lpmax=0;
  18.  
  19. extern char *yytext;
  20. extern char *bsyysval;
  21. extern int yyleng;
  22. %}
  23.  
  24. %term EQUAL    NEQ    LE    LT    GE    WHILE
  25. %term GT    OR    AND    NOT    RET    REPEAT
  26. %term IF    THEN    ELSE    GOTO    GOSUB    UNTIL
  27. %term STOP    END    INTEGER    REAL    SCONST    ELIHW
  28. %term LET    SWORD    PRINT    INPUT    DATA    CFOR
  29. %term FOR    TO    STEP    READ    WRITE    NEXT
  30. %term DEFINE    LFUN    SFUN    FDEF    SYMBOL    DIM
  31. %term VALUE    IWORD    RWORD    ROFC    LOOP    EXITIF
  32. %term ITOR    RTOI    ITOA    RTOA    LEAVE    CONTINUE
  33. %term POOL
  34.  
  35. %left ',' ';'
  36. %right '='
  37. %nonassoc OR AND
  38. %nonassoc LE LT GE GT EQUAL NEQ
  39. %left '+' '-'
  40. %left '*' '/' '%'
  41. %left UNARY
  42. %left '('
  43.  
  44.  
  45. %start lines
  46.  
  47. %%
  48.  
  49. lines        : /* empty */
  50.         | lines line
  51.         ;
  52.  
  53. line        : lnum stat '\n'
  54.             { printf("\n"); }
  55.         | '\n'
  56.         ;
  57.  
  58. lnum        : INTEGER
  59.             { bundle(2,_line,atoi($1); }
  60.         ;
  61.  
  62. stat        : LET let_xpr
  63.         | let_xpr
  64.         | PRINT pe
  65.             { bundle(1,_print); }
  66.         | GOTO INTEGER
  67.             {
  68.                 sprintf(s,"LN%s",$2);
  69.                 bundle(4,_rlabel,gvadr(s,T_LBL),_goto,0);
  70.             }
  71.         | GOSUB INTEGER
  72.             {
  73.                 sprintf(s,"LN%s",$2);
  74.                 bundle(4,_rlabel,gvadr(s,T_LBL),_gosub,0); 
  75.             }
  76.         | LEAVE
  77.             { bundle(2,_leave,0); }
  78.         | CONTINUE
  79.             { bundle(2,_contin,0); }
  80.         | RET
  81.             { bundle(1,_return); }
  82.         | IF bexpr
  83.             {
  84.                 lpush(&ifstk,ifmax);
  85.                 sprintf(s,"IF%d",ifmax);
  86.                 bundle(4,_rlabel,gvadr(s,T_LBL),_if,0);
  87.                 ifmax += 2;
  88.             }
  89.           THEN stat
  90.             {
  91.                 i = ltop(&ifstk);
  92.                 sprintf(s,"IF%d",i+1);
  93.                 bundle(4,_rlabel,gvadr(s,T_LBL),_goto,0);
  94.             }
  95.           if_else
  96.         | INPUT 
  97.             { bundle(2,_pushstate,M_INPUT); }
  98.           var_lst
  99.             { bundle(1,_popstate); }
  100.         | STOP
  101.             { bundle(1,_stop); }
  102.         | END
  103.             { bundle(1,_end); }
  104.         | FOR nvar '=' rexpr TO rexpr for_step
  105.             {
  106.                 lpush(&forstk,formax);
  107.                 sprintf(s,"FOR%d",formax+2);
  108.                 bundle(2,_rlabel,gvadr(s,T_LBL));
  109.                 sprintf(s,"FOR%d",formax+1);
  110.                 bundle(3,_rlabel,gvadr(s,T_LBL),_enter);
  111.                 sprintf(s,"FOR%d",formax+1);
  112.                 bundle(5,_icon,(long)0,_rlabel,gvadr(s,T_LBL));
  113.                 sprintf(s,"FOR%d",formax);
  114.                 bundle(4,_dlabel,gvadr(s,T_LBL),_for,0);
  115.                 formax += 3;
  116.             }
  117.         | NEXT
  118.             {
  119.                 i = ltop(&forstk);
  120.                 sprintf(s,"FOR%d",i+2);
  121.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  122.             }
  123.           nvar
  124.             {
  125.                 i = lpop(&forstk);
  126.                 sprintf(s,"FOR%d",i);
  127.                 bundle(5,_next,_rlabel,gvadr(s,T_LBL),_goto,0);
  128.                 sprintf(s,"FOR%d",i+1);
  129.                 bundle(3,_dlabel,gvadr(s,T_LBL),_exitlp);
  130.             }
  131.         | READ 
  132.             { bundle(2,_pushstate,M_READ); }
  133.           var_lst
  134.             { bundle(1,_popstate); }
  135.         | DATA 
  136.             { bundle(2,_data,0); }
  137.            data_lst
  138.         | LOOP
  139.             {
  140.                 lpush(&lpstk,lpmax);
  141.                 sprintf(s,"LP%d",lpmax+2);
  142.                 bundle(2,_rlabel,gvadr(s,T_LBL));
  143.                 sprintf(s,"LP%d",lpmax+1);
  144.                 bundle(3,_rlabel,gvadr(s,T_LBL),_enter);
  145.                 sprintf(s,"LP%d",lpmax);
  146.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  147.                 lpmax += 3;
  148.             }
  149.         | EXITIF bexpr
  150.             {
  151.                 i = ltop(&lpstk);
  152.                 sprintf(s,"LP%d",i+1);
  153.                 bundle(5,_not,_rlabel,gvadr(s,T_LBL),_if,0);
  154.             }
  155.         | POOL
  156.             {
  157.                 i = lpop(&lpstk);
  158.                 sprintf(s,"LP%d",i+2);
  159.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  160.                 sprintf(s,"LP%d",i);
  161.                 bundle(4,_rlabel,gvadr(s,T_LBL),_goto,0);
  162.                 sprintf(s,"LP%d",i+1);
  163.                 bundle(3,_dlabel,gvadr(s,T_LBL),_exitlp);
  164.             }
  165.         | WHILE
  166.             {
  167.                 lpush(&whstk,whmax);
  168.                 sprintf(s,"WH%d",whmax+2);
  169.                 bundle(2,_rlabel,gvadr(s,T_LBL));
  170.                 sprintf(s,"WH%d",whmax+1);
  171.                 bundle(3,_rlabel,gvadr(s,T_LBL),_enter);
  172.                 sprintf(s,"WH%d",whmax);
  173.                 bundle(2,_rlabel,gvadr(s,T_LBL));
  174.                 whmax += 3;
  175.             }
  176.           bexpr
  177.             {
  178.                 i = ltop(&whstk);
  179.                 sprintf(s,"WH%d",i+1);
  180.                 bundle(4,_rlabel,gvadr(s,T+LBL),_if,0);
  181.             }
  182.         | ELIHW
  183.             {
  184.                 i = lpop(&whstk);
  185.                 sprintf(s,"WH%d",i+2);
  186.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  187.                 sprintf(s,"WH%d",i)
  188.                 bundle(4,_rlabel,gvadr(s,T_LBL),_goto,0);
  189.                 sprintf(s,"WH%d",i+1);
  190.                 bundle(3,_dlabel,gvadr(s,T_LBL),_exitlp);
  191.             }
  192.         | REPEAT
  193.             {
  194.                 lpush(&repstk,repmax);
  195.                 sprintf(s,"REP%d",repmax+1);
  196.                 bundle(2,_rlabel,gvadr(s,T_LBL));
  197.                 sprintf(s,"REP%d",repmax+2);
  198.                 bundle(3,_rlabel,gvadr(s,T_LBL),_enter);
  199.                 sprintf(s,"REP%d",repmax);
  200.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  201.                 repmax += 3;
  202.             }
  203.         | UNTIL
  204.             {
  205.                 i = ltop(&repstk);
  206.                 sprintf(s,"REP%d",i+1);
  207.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  208.             }
  209.           bexpr
  210.             {
  211.                 i = lpop(&repstk);
  212.                 sprintf(s,"REP%d",i);
  213.                 bundle(5,_not,_rlabel,gvadr(s,T_LBL),_if,0);
  214.                 sprintf(s,"REP%d",i+2);
  215.                 bundle(3,_dlabel,gvadr(s,T_LBL),_exitlp);
  216.             }
  217.         ;
  218.  
  219. nvar        : ivar
  220.         | rvar
  221.         ;
  222.  
  223. let_xpr        : ivar '=' rexpr
  224.             { bundle(4,_rtoi,_store,T_DBL,_pop); }
  225.         | rvar '=' rexpr
  226.             { bundle(3,_store,T_DBL,_pop); }
  227.         | svar '=' sexpr
  228.             { bundle(3,_store,T_CHR,spop); }
  229.         ;
  230.  
  231. data_lst    : rexpr
  232.             { bundle(2,_dsep,0); }
  233.         | sexpr
  234.             { bundle(1,_dsep); }
  235.         | data_lst ',' rexpr
  236.             { bundle(1,_dsep); }
  237.         | data_lst ',' sexpr
  238.             { bundle(1,_dsep); }
  239.         ;
  240.  
  241. ind_lst        : rexpr
  242.         | ind_lst ',' rexpr
  243.         ;
  244.  
  245. for_step    : /* empty */
  246.             { bundle(3,_icon,(long)0); }
  247.         | STEP rexpr
  248.         ;
  249.  
  250. if_else        : /* empty */
  251.             {
  252.                 i = lpop(&ifstk);
  253.                 sprintf(s,"IF%d",i);
  254.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  255.                 sprintf(s,"IF%d",i+1);
  256.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  257.             }
  258.         | ELSE 
  259.             {
  260.                 i = ltop(&ifstk);
  261.                 sprintf(s,"IF%d",i);
  262.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  263.             }
  264.           stat
  265.             {
  266.                 i = lpop(&ifstk);
  267.                 sprintf(s,"IF%d",i+1);
  268.                 bundle(2,_dlabel,gvadr(s,T_LBL));
  269.             }
  270.         ;
  271.  
  272.  
  273. pe        : sexpr ','
  274.             { bundle(3,_scon,"",_comma); }
  275.         | sexpr ';'
  276.         | sexpr
  277.             { bundle(3,_scon,"\\n",_scolon); }
  278.         | /* empty */
  279.             { bundle(2,_scon,"\\n"); }
  280.         ;
  281.  
  282.  
  283. var_lst        : ivar
  284.         | rvar
  285.         | svar
  286.         | var_lst ',' var_lst
  287.         ;
  288.  
  289. sexpr        : SCONST
  290.             { p=myalloc(yyleng); strcpy(p,$1); bundle(2,_scon,p); }
  291.         | svar
  292.             { bundle(2,_val,T_CHR); }
  293.         | rexpr
  294.             { bundle(1,_rtoa); }
  295.         | svar '=' sexpr
  296.             { bundle(2,_store,T_CHR); }
  297.         | sexpr ';' sexpr
  298.             { bundle(1,_scolon); }
  299.         | sexpr '+' sexpr
  300.             { bundle(1,_scolon); }
  301.         | sexpr ',' sexpr
  302.             { bundle(1,_comma); }
  303.         | '(' sexpr ')'
  304.         ;
  305. sbe        : sexpr EQUAL sexpr
  306.             { bundle(1,_seq); }
  307.         | sexpr NEQ sexpr
  308.             { bundle(1,_sneq); }
  309.         | sexpr LE sexpr
  310.             { bundle(1,_sleq); }
  311.         | sexpr LT sexpr
  312.             { bundle(1,_slt); }
  313.         | sexpr GE sexpr
  314.             { bundle(1,_sgeq); }
  315.         | sexpr GT sexpr
  316.             { bundle(1,_sgt); }
  317.         ;
  318.  
  319. ivar        : IWORD
  320.             { bundle(2,_var,gvadr($1,T_INT)); }
  321.         | IWORD '(' 
  322.             { bundle(2,_pushstate,M_EXECUTE); }
  323.           ind_lst ')'
  324.             { bundle(3,_popstate,_var,gvadr($1,T_INT+Q_ARY)); }
  325.         ;
  326. rvar        : RWORD
  327.             { bundle(2,_var,gvadr($1,T_DBL)); }
  328.         | RWORD '(' 
  329.             { bundle(2,_pushstate,M_EXECUTE); }
  330.           ind_lst ')'
  331.             { bundle(3,_popstate,_var,gvadr($1,T_DBL+Q_ARY)); }
  332.         ;
  333.  
  334. svar        : SWORD
  335.             { bundle(2,_var,gvadr($1,T_CHR)); }
  336.         | SWORD '(' 
  337.             { bundle(2,_pushstate,M_EXECUTE); }
  338.           ind_lst ')'
  339.             { bundle(3,_popstate,_var,gvadr($1,T_CHR+Q_ARY)); }
  340.         ;
  341.  
  342.  
  343.  
  344. rexpr        : rvar
  345.             { bundle(2,_val,T_DBL); }
  346.         | REAL
  347.             { bundle(5,_rcon,(double)atof($1)); }
  348.         | INTEGER
  349.             { bundle(5,_rcon,(double)atof($1)); }
  350.         | ivar
  351.             { bundle(3,_val,T_INT,_itor); }
  352.         | rvar '=' rexpr
  353.             { bundle(2,_store,T_DBL); }
  354.         | '(' rexpr ')'
  355.         | rexpr '+' rexpr
  356.             { bundle(1,_radd); }
  357.         | rexpr '-' rexpr
  358.             { bundle(1,_rsub); }
  359.         | rexpr '*' rexpr
  360.             { bundle(1,_rmult); }
  361.         | rexpr '/' rexpr
  362.             { bundle(1,_rdiv); }
  363.         | '+' rexpr    %prec UNARY
  364.         | '-' rexpr    %prec UNARY
  365.             { bundle(6,_rcon,(double)(-1),_rmult); }
  366.         ;
  367.  
  368. rbe        : rexpr EQUAL rexpr
  369.             { bundle(1,_req); }
  370.         | rexpr NEQ rexpr
  371.             { bundle(1,_rneq); }
  372.         | rexpr LE rexpr
  373.             { bundle(1,_rleq); }
  374.         | rexpr LT rexpr
  375.             { bundle(1,_rlt); }
  376.         | rexpr GE rexpr
  377.             { bundle(1,_rgeq); }
  378.         | rexpr GT rexpr
  379.             { bundle(1,_rgt); }
  380.         ;
  381. bexpr        : sbe
  382.         | rbe
  383.         | NOT bexpr    %prec UNARY
  384.             { bundle(1,_not); }
  385.         | bexpr OR bexpr
  386.             { bundle(1,_or); }
  387.         | bexpr AND bexpr
  388.             { bundle(1,_and); }
  389.         | '(' bexpr ')'
  390.         ;
  391. %%
  392.  
  393. main()
  394. {
  395.     rdlin(bsin);
  396.     return(yyparse());
  397. }
  398.  
  399. yyerror(s)
  400. char *s;
  401. {
  402.     fprintf(stderr,"%s\n",s);
  403. }
  404.  
  405. lpush(stack,val) struct stk *stack; int val;
  406. {
  407.     stack->stack[stack->stkp++] = val; 
  408. }
  409.  
  410. int ltop(stack) struct stk *stack;
  411. { 
  412.     return(stack->stack[stack->stkp-1]); 
  413. }
  414.  
  415. int lpop(stack) struct stk *stack;
  416. { 
  417.     return(stack->stack[--stack->stkp]); 
  418. }
  419.  
  420. /* bundle() -- append argument list to l[].  Idea tooken from bc.y.
  421.  *
  422.  * Usage:  bundle(cnt,arg,arg,...,arg)
  423.  *
  424.  * The "arg"'s can be anything.  "cnt" is a count of the number of integers
  425.  * it would take to hold all the args.
  426.  *
  427.  * e.g.  bundle(4,(double)a); is the correct count for a.
  428.  *
  429.  *    ******* NOTE *******
  430.  *
  431.  * This routine is machine dependant.  It depends on the way arguments are
  432.  * passed on the stack on the PDP-11 machines.  It may not work elsewhere.
  433.  */
  434. bundle(a)
  435. int a;
  436. {
  437.     register int *p;
  438.     register int sz;
  439.  
  440.     p = &a;
  441.     sz = *p++;
  442.     while(sz-- > 0) 
  443.     l[lp++] = *p++;
  444. }
  445.