Return to eqn.y CVS log

Up to [Research Unix] / researchv10no / cmd / eqn

Annotation of researchv10no/cmd/eqn/eqn.y, revision 1.1

1.1     ! root        1: %term  CONTIG QTEXT SPACE THIN TAB
        !             2: %term  MATRIX LCOL CCOL RCOL COL ABOVE
        !             3: %term  MARK LINEUP
        !             4: %term  SUM INT PROD UNION INTER
        !             5: %term  DEFINE TDEFINE NDEFINE DELIM GSIZE GFONT INCLUDE SPACE IFDEF
        !             6: %term  DOTEQ DOTEN
        !             7: 
        !             8: %right FROM TO
        !             9: %left  OVER SQRT
        !            10: %right SUP SUB
        !            11: %right SIZE FONT ROMAN ITALIC BOLD FAT
        !            12: %right UP DOWN BACK FWD
        !            13: %left  LEFT RIGHT
        !            14: %right DOT DOTDOT HAT TILDE BAR LOWBAR HIGHBAR UNDER VEC DYAD UTILDE
        !            15: 
        !            16: %{
        !            17: #include "e.h"
        !            18: 
        !            19: int    yylex(void);
        !            20: %}
        !            21: 
        !            22: %%
        !            23: 
        !            24: stuff  : eqn           { putout($1); }
        !            25:        | error         { ERROR "syntax error" WARNING; }       /* should be SYNTAX */
        !            26:        |               { eqnreg = 0; }
        !            27:        ;
        !            28: 
        !            29: eqn    : box
        !            30:        | eqn box       { eqnbox($1, $2, 0); }
        !            31:        | eqn lineupbox { eqnbox($1, $2, 1); }
        !            32:        | LINEUP        { lineup(0); }
        !            33:        ;
        !            34: 
        !            35: lineupbox: LINEUP box  { $$ = $2; lineup(1); }
        !            36:        ;
        !            37: 
        !            38: sbox   : SUP box       %prec SUP       { $$ = $2; }
        !            39:        |               %prec SUP       { $$ = 0; }
        !            40:        ;
        !            41: 
        !            42: tbox   : TO box        %prec TO        { $$ = $2; }
        !            43:        |               %prec FROM      { $$ = 0; }
        !            44:        ;
        !            45: 
        !            46: box    : '{' eqn '}'   { $$ = $2; }
        !            47:        | QTEXT         { text(QTEXT, (char *) $1); }
        !            48:        | CONTIG        { text(CONTIG, (char *) $1); }
        !            49:        | SPACE         { text(SPACE, (char *) 0); }
        !            50:        | THIN          { text(THIN, (char *) 0); }
        !            51:        | TAB           { text(TAB, (char *) 0); }
        !            52:        | SUM           { funny(SUM); }
        !            53:        | PROD          { funny(PROD); }
        !            54:        | UNION         { funny(UNION); }
        !            55:        | INTER         { funny(INTER); }
        !            56:        | box OVER box                  { boverb($1, $3); }
        !            57:        | MARK box                      { mark($2); }
        !            58:        | size box      %prec SIZE      { size($1, $2); }
        !            59:        | font box      %prec FONT      { font($1, $2); }
        !            60:        | FAT box                       { fatbox($2); }
        !            61:        | SQRT box                      { sqrt($2); }
        !            62:        | box SUB {ps -= deltaps;} box sbox     %prec SUB       { subsup($1, $4, $5); }
        !            63:        | box SUP {ps -= deltaps;} box          %prec SUP       { subsup($1, 0, $4); }
        !            64:        | int SUB {ps -= deltaps;} box sbox     %prec SUB       { integral($1, $4, $5); }
        !            65:        | int SUP {ps -= deltaps;} box          %prec SUP       { integral($1, 0, $4); }
        !            66:        | int                                   { integral($1, 0, 0); }
        !            67:        | box FROM {ps -= deltaps;} box tbox    %prec FROM      { fromto($1, $4, $5); }
        !            68:        | box TO {ps -= deltaps;} box           %prec TO        { fromto($1, 0, $4); }
        !            69:        | left eqn right                        { paren($1, $2, $3); }
        !            70:        | left eqn                              { paren($1, $2, 0); }
        !            71:        | box diacrit                   { diacrit($1, $2); }
        !            72:        | fwd box       %prec UP        { move(FWD, $1, $2); }
        !            73:        | up box        %prec UP        { move(UP, $1, $2); }
        !            74:        | back box      %prec UP        { move(BACK, $1, $2); }
        !            75:        | down box      %prec UP        { move(DOWN, $1, $2); }
        !            76:        | column                        { pile($1); ct = $1; }
        !            77:        | MATRIX {$$=ct;} '{' collist '}'       { matrix($2); ct = $2; }
        !            78:        ;
        !            79: 
        !            80: int    : INT           { setintegral(); }
        !            81:        ;
        !            82: 
        !            83: fwd    : FWD text      { $$ = atoi((char *) $1); } ;
        !            84: up     : UP text       { $$ = atoi((char *) $1); } ;
        !            85: back   : BACK text     { $$ = atoi((char *) $1); } ;
        !            86: down   : DOWN text     { $$ = atoi((char *) $1); } ;
        !            87: 
        !            88: diacrit        : HAT           { $$ = HAT; }
        !            89:        | VEC           { $$ = VEC; }
        !            90:        | DYAD          { $$ = DYAD; }
        !            91:        | BAR           { $$ = BAR; }
        !            92:        | LOWBAR        { $$ = LOWBAR; }
        !            93:        | HIGHBAR       { $$ = HIGHBAR; }
        !            94:        | UNDER         { $$ = UNDER; } /* underbar */
        !            95:        | DOT           { $$ = DOT; }
        !            96:        | TILDE         { $$ = TILDE; }
        !            97:        | UTILDE        { $$ = UTILDE; }
        !            98:        | DOTDOT        { $$ = DOTDOT; } /* umlaut = double dot */
        !            99:        ;
        !           100: 
        !           101: left   : LEFT text     { $$ = ((char *)$2)[0]; }
        !           102:        | LEFT '{'      { $$ = '{'; }
        !           103:        ;
        !           104: 
        !           105: right  : RIGHT text    { $$ = ((char *)$2)[0]; }
        !           106:        | RIGHT '}'     { $$ = '}'; }
        !           107:        ;
        !           108: 
        !           109: collist        : column
        !           110:        | collist column
        !           111:        ;
        !           112: 
        !           113: column : col '{' list '}'                              { column($1, DEFGAP); }
        !           114:        | col text {$$=atoi((char*)$2);} '{' list '}'   { column($1, $3); }
        !           115:        ;
        !           116: 
        !           117: col    : LCOL          { $$ = startcol(LCOL); }
        !           118:        | CCOL          { $$ = startcol(CCOL); }
        !           119:        | RCOL          { $$ = startcol(RCOL); }
        !           120:        | COL           { $$ = startcol(COL); }
        !           121:        ;
        !           122: 
        !           123: list   : eqn                   { lp[ct++] = $1; }
        !           124:        | list ABOVE eqn        { lp[ct++] = $3; }
        !           125:        ;
        !           126: 
        !           127: size   : SIZE text     { $$ = ps; setsize((char *) $2); }
        !           128:        ;
        !           129: 
        !           130: font    : ROMAN         { static char R[]="R"; setfont(R); }
        !           131:         | ITALIC        { static char I[]="I"; setfont(I); }
        !           132:         | BOLD          { static char B[]="B"; setfont(B); }
        !           133:         | FONT text     { setfont((char *)$2); }
        !           134:         ;
        !           135: 
        !           136: text   : CONTIG
        !           137:        | QTEXT
        !           138:        ;
        !           139: 
        !           140: %%

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.