Return to beauty.y CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / struct

Annotation of 43BSD/usr.bin/struct/beauty.y, revision 1.1

1.1     ! root        1: %term  xxif 300 xxelse 301 xxwhile 302 xxrept 303 xxdo 304 xxrb 305 xxpred 306
        !             2: %term xxident 307 xxle 308 xxge 309 xxne 310 xxnum 311 xxcom 312
        !             3: %term xxstring 313 xxexplist 314 xxidpar 315 xxelseif 316  xxlb 318 xxend 319
        !             4: %term xxcase 320 xxswitch 321 xxuntil 322 xxdefault 323 
        !             5: %term xxeq 324
        !             6: 
        !             7: %left  '|'
        !             8: %left  '&'
        !             9: %left  '!'
        !            10: %binary        '<' '>' xxeq xxne xxge xxle
        !            11: %left  '+' '-'
        !            12: %left  '*' '/'
        !            13: %left  xxuminus
        !            14: %right '^'
        !            15: 
        !            16: %{
        !            17: #ifndef lint
        !            18: static char sccsid[] = "@(#)beauty.y   4.1     (Berkeley)      2/11/83";
        !            19: #endif not lint
        !            20: 
        !            21: #include "b.h"
        !            22: #include <stdio.h>
        !            23: %}
        !            24: 
        !            25: %%
        !            26: %{
        !            27: struct node *t;
        !            28: %}
        !            29: 
        !            30: 
        !            31: allprog:       prog xxnew
        !            32:        ;
        !            33: 
        !            34: prog:  stat
        !            35:        |       prog stat
        !            36:        ;
        !            37: 
        !            38: stat:           iftok pred nlevel elsetok nlevel
        !            39:        |        iftok  pred  nlevel
        !            40:        |       xxtab whtok  pred  nlevel
        !            41:        |       xxtab rpttok nlevel optuntil
        !            42:        |       xxtab dotok nlevel
        !            43:        |       xxtab swtok oppred pindent lbtok caseseq xxtab rbtok mindent
        !            44:        |       xxtab fstok
        !            45:        |       lbtok prog xxtab rbtok
        !            46:        |       lbtok rbtok
        !            47:        |        labtok stat
        !            48:        |       xxnl comtok stat
        !            49:        |       error
        !            50:        ;
        !            51: 
        !            52: 
        !            53: xxtab:         =       {
        !            54:                        if (!xxlablast) tab(xxindent);
        !            55:                        xxlablast = 0;
        !            56:                        }
        !            57: 
        !            58: xxnl:  =       newline();
        !            59: xxnew: =       putout('\n',"\n");
        !            60: nlevel:        pindent stat mindent;
        !            61: pindent:               =
        !            62:                                {
        !            63:                                if (xxstack[xxstind] != xxlb)
        !            64:                                        ++xxindent;
        !            65:                                };
        !            66: mindent:                       =
        !            67:                                {if (xxstack[xxstind] != xxlb && xxstack[xxstind] != xxelseif)
        !            68:                                        --xxindent;
        !            69:                                pop();
        !            70:                                };
        !            71: caseseq:       casetok caseseq
        !            72:        |       casetok
        !            73:        ;
        !            74: 
        !            75: casetok:       xxtab xxctok predlist pindent prog mindent
        !            76:        |       xxtab xxctok predlist pindent mindent
        !            77:        |       xxtab deftok pindent prog mindent
        !            78:        |       xxnl comtok casetok
        !            79:        ;
        !            80: 
        !            81: xxctok:        xxcase          =       {putout(xxcase,"case "); free ($1); push(xxcase); }
        !            82: 
        !            83: 
        !            84: deftok:                xxdefault ':'           =               {
        !            85:                                                putout(xxcase,"default");
        !            86:                                                free($1);
        !            87:                                                putout(':',":");
        !            88:                                                free($2);
        !            89:                                                push(xxcase);
        !            90:                                                }
        !            91: swtok: xxswitch                        =       {putout(xxswitch,"switch"); free($1); push(xxswitch); }
        !            92: 
        !            93: fstok: xxend           =       {
        !            94:                                free($1);
        !            95:                                putout(xxident,"end");
        !            96:                                putout('\n',"\n");
        !            97:                                putout('\n',"\n");
        !            98:                                putout('\n',"\n");
        !            99:                                }
        !           100:        |       xxident =       {
        !           101:                                putout(xxident,$1);
        !           102:                                free($1);
        !           103:                                newflag = 1;
        !           104:                                forst();
        !           105:                                newflag = 0;
        !           106:                                };
        !           107: 
        !           108:                
        !           109: 
        !           110: identtok:      xxident '(' explist ')' =       {
        !           111:                                xxt = addroot($1,xxident,0,0);
        !           112:                                $$ = addroot("",xxidpar,xxt,$3);
        !           113:                                }
        !           114: 
        !           115:        |       xxident         =       $$ = addroot($1,xxident,0,0);
        !           116:        ;
        !           117: 
        !           118: predlist:      explist  ':'            =       {
        !           119:                                yield($1,0);
        !           120:                                putout(':',":");
        !           121:                                freetree($1);
        !           122:                                }
        !           123: explist:       expr ',' explist                =       $$ = addroot($2,xxexplist,checkneg($1,0),$3);
        !           124:        |       expr                                    =       $$ = checkneg($1,0);
        !           125:        ;
        !           126: 
        !           127: 
        !           128: oppred:        pred
        !           129:        |
        !           130:        ;
        !           131: 
        !           132: pred:  '(' expr ')'    =       { t = checkneg($2,0);
        !           133:                                yield(t,100);  freetree(t);     };
        !           134: 
        !           135: expr:          '(' expr ')'    =       $$ = $2;
        !           136:        |       '-' expr        %prec xxuminus  =       $$ = addroot($1,xxuminus,$2,0);
        !           137:        |       '!' expr        =       $$ = addroot($1,'!',$2,0);
        !           138:        |       expr '+' expr   =       $$ = addroot($2,'+',$1,$3);
        !           139:        |       expr '-' expr   =       $$ = addroot($2,'-',$1,$3);
        !           140:        |       expr '*' expr   =       $$ = addroot($2,'*',$1,$3);
        !           141:        |       expr '/' expr   =       $$ = addroot($2,'/',$1,$3);
        !           142:        |       expr '^' expr   =       $$ = addroot($2,'^',$1,$3);
        !           143:        |       expr '|' expr   =       $$ = addroot($2,'|',$1,$3);
        !           144:        |       expr '&' expr   =       $$ = addroot($2,'&',$1,$3);
        !           145:        |       expr '>' expr   =       $$ = addroot($2,'>',$1,$3);
        !           146:        |       expr '<' expr   =       $$ = addroot($2,'<',$1,$3);
        !           147:        |       expr xxeq expr  =       $$ = addroot($2,xxeq,$1,$3);
        !           148:        |       expr xxle expr  =       $$ = addroot($2,xxle,$1,$3);
        !           149:        |       expr xxge expr  =       $$ = addroot($2,xxge,$1,$3);
        !           150:        |       expr xxne expr  =       $$ = addroot($2,xxne,$1,$3);
        !           151:        |       identtok                =       $$ = $1;
        !           152:        |       xxnum           =       $$ = addroot($1,xxnum,0,0);
        !           153:        |       xxstring                =       $$ = addroot($1,xxstring,0,0);
        !           154:        ;
        !           155: 
        !           156: iftok: xxif            =
        !           157:                                {
        !           158:                                if (xxstack[xxstind] == xxelse && !xxlablast)
        !           159:                                        {
        !           160:                                        --xxindent;
        !           161:                                        xxstack[xxstind] = xxelseif;
        !           162:                                        putout(' '," ");
        !           163:                                        }
        !           164:                                else
        !           165:                                        {
        !           166:                                        if (!xxlablast)
        !           167:                                                tab(xxindent);
        !           168:                                        xxlablast = 0;
        !           169:                                        }
        !           170:                                putout(xxif,"if");
        !           171:                                free($1);
        !           172:                                push(xxif);
        !           173:                                }
        !           174: elsetok:       xxelse  =
        !           175:                                {
        !           176:                                tab(xxindent);
        !           177:                                putout(xxelse,"else");
        !           178:                                free($1);
        !           179:                                push(xxelse);
        !           180:                                }
        !           181: whtok: xxwhile         =       {
        !           182:                                putout(xxwhile,"while");
        !           183:                                free($1);
        !           184:                                push(xxwhile);
        !           185:                                }
        !           186: rpttok:        xxrept  =                       {
        !           187:                                        putout(xxrept,"repeat");
        !           188:                                        free($1);
        !           189:                                        push(xxrept);
        !           190:                                        }
        !           191: optuntil:      xxtab unttok pred
        !           192:                |
        !           193:                ;
        !           194: 
        !           195: unttok:        xxuntil   =     {
        !           196:                        putout('\t',"\t");
        !           197:                        putout(xxuntil,"until");
        !           198:                        free($1);
        !           199:                        }
        !           200: dotok: dopart opdotok
        !           201:        ;
        !           202: dopart:        xxdo    identtok '=' expr  ',' expr             =
        !           203:                                        {push(xxdo);
        !           204:                                        putout(xxdo,"do");
        !           205:                                        free($1);
        !           206:                                        puttree($2);
        !           207:                                        putout('=',"=");
        !           208:                                        free($3);
        !           209:                                        puttree($4);
        !           210:                                        putout(',',",");
        !           211:                                        free($5);
        !           212:                                        puttree($6);
        !           213:                                        }
        !           214: opdotok:       ',' expr                =       {
        !           215:                                                putout(',',",");
        !           216:                                                puttree($2);
        !           217:                                                }
        !           218:        |       ;
        !           219: lbtok: '{'             =       {
        !           220:                                putout('{'," {");
        !           221:                                push(xxlb);
        !           222:                                }
        !           223: rbtok: '}'                     =       { putout('}',"}");  pop();   }
        !           224: labtok:        xxnum           =       {
        !           225:                                tab(xxindent);
        !           226:                                putout(xxnum,$1);
        !           227:                                putout(' ',"  ");
        !           228:                                xxlablast = 1;
        !           229:                                }
        !           230: comtok:        xxcom           =       { putout(xxcom,$1);  free($1);  xxlablast = 0; }
        !           231:        |       comtok xxcom            = { putout ('\n',"\n"); putout(xxcom,$2);  free($2);  xxlablast = 0; };
        !           232: %%
        !           233: #define ASSERT(X,Y)    if (!(X)) error("struct bug: assertion 'X' invalid in routine Y","","");
        !           234: 
        !           235: yyerror(s)
        !           236: char *s;
        !           237:        {
        !           238:        extern int yychar;
        !           239:        fprintf(stderr,"\n%s",s);
        !           240:        fprintf(stderr," in beautifying, output line %d,",xxlineno + 1);
        !           241:        fprintf(stderr," on input: ");
        !           242:                switch (yychar) {
        !           243:                        case '\t': fprintf(stderr,"\\t\n"); return;
        !           244:                        case '\n': fprintf(stderr,"\\n\n"); return;
        !           245:                        case '\0': fprintf(stderr,"$end\n"); return;
        !           246:                        default: fprintf(stderr,"%c\n",yychar); return;
        !           247:                        }
        !           248:        }
        !           249: 
        !           250: yyinit(argc, argv)                     /* initialize pushdown store */
        !           251: int argc;
        !           252: char *argv[];
        !           253:        {
        !           254:        xxindent = 0;
        !           255:        xxbpertab = 8;
        !           256:        xxmaxchars = 120;
        !           257:        }
        !           258: 
        !           259: 
        !           260: #include <signal.h>
        !           261: main()
        !           262:        {
        !           263:        int exit();
        !           264:        if ( signal(SIGINT, SIG_IGN) != SIG_IGN)
        !           265:                signal(SIGINT, exit);
        !           266:        yyinit();
        !           267:        yyparse();
        !           268:        }
        !           269: 
        !           270: 
        !           271: putout(type,string)                    /* output string with proper indentation */
        !           272: int type;
        !           273: char *string;
        !           274:        {
        !           275:        static int lasttype;
        !           276:        if ( (lasttype != 0) && (lasttype != '\n') && (lasttype != ' ') && (lasttype != '\t') && (type == xxcom))
        !           277:                accum("\t");
        !           278:        else if (lasttype == xxcom && type != '\n')
        !           279:                tab(xxindent);
        !           280:        else
        !           281:                if (lasttype == xxif    ||
        !           282:                        lasttype == xxwhile     ||
        !           283:                        lasttype == xxdo        ||
        !           284:                        type == '='     ||
        !           285:                        lasttype == '=' ||
        !           286:                        (lasttype == xxident && (type == xxident || type == xxnum) )    ||
        !           287:                        (lasttype == xxnum && type == xxnum) )
        !           288:                        accum(" ");
        !           289:        accum(string);
        !           290:        lasttype = type;
        !           291:        }
        !           292: 
        !           293: 
        !           294: accum(token)           /* fill output buffer, generate continuation lines */
        !           295: char *token;
        !           296:        {
        !           297:        static char *buffer;
        !           298:        static int lstatus,llen,bufind;
        !           299:        int tstatus,tlen,i;
        !           300: 
        !           301: #define NEW    0
        !           302: #define MID    1
        !           303: #define CONT   2
        !           304: 
        !           305:        if (buffer == 0)
        !           306:                {
        !           307:                buffer = malloc(xxmaxchars);
        !           308:                if (buffer == 0) error("malloc out of space","","");
        !           309:                }
        !           310:        tlen = slength(token);
        !           311:        if (tlen == 0) return;
        !           312:        for (i = 0; i < tlen; ++i)
        !           313:                ASSERT(token[i] != '\n' || tlen == 1,accum);
        !           314:        switch(token[tlen-1])
        !           315:                {
        !           316:                case '\n':      tstatus = NEW;
        !           317:                                break;
        !           318:                case '+':
        !           319:                case '-':
        !           320:                case '*':
        !           321:                case ',':
        !           322:                case '|':
        !           323:                case '&':
        !           324:                case '(':       tstatus = CONT;
        !           325:                                break;
        !           326:                default:        tstatus = MID;
        !           327:                }
        !           328:        if (llen + bufind + tlen > xxmaxchars && lstatus == CONT && tstatus != NEW)
        !           329:                {
        !           330:                putchar('\n');
        !           331:                ++xxlineno;
        !           332:                for (i = 0; i < xxindent; ++i)
        !           333:                        putchar('\t');
        !           334:                putchar(' ');putchar(' ');
        !           335:                llen = 2 + xxindent * xxbpertab;
        !           336:                lstatus = NEW;
        !           337:                }
        !           338:        if (lstatus == CONT && tstatus == MID)
        !           339:                {                       /* store in buffer in case need \n after last CONT char */
        !           340:                ASSERT(bufind + tlen < xxmaxchars,accum);
        !           341:                for (i = 0; i < tlen; ++i)
        !           342:                        buffer[bufind++] = token[i];
        !           343:                }
        !           344:        else
        !           345:                {
        !           346:                for (i = 0; i < bufind; ++i)
        !           347:                        putchar(buffer[i]);
        !           348:                llen += bufind;
        !           349:                bufind = 0;
        !           350:                for (i = 0; i < tlen; ++i)
        !           351:                        putchar(token[i]);
        !           352:                if (tstatus == NEW) ++xxlineno;
        !           353:                llen = (tstatus == NEW) ? 0 : llen + tlen;
        !           354:                lstatus = tstatus;
        !           355:                }
        !           356:        }
        !           357: 
        !           358: tab(n)
        !           359: int n;
        !           360:        {
        !           361:        int i;
        !           362:        newline();
        !           363:        for ( i = 0;  i < n; ++i)
        !           364:                putout('\t',"\t");
        !           365:        }
        !           366: 
        !           367: newline()
        !           368:        {
        !           369:        static int already;
        !           370:        if (already)
        !           371:                putout('\n',"\n");
        !           372:        else
        !           373:                already = 1;
        !           374:        }
        !           375: 
        !           376: error(mess1, mess2, mess3)
        !           377: char *mess1, *mess2, *mess3;
        !           378:        {
        !           379:        fprintf(stderr,"\nerror in beautifying, output line %d: %s %s %s \n",
        !           380:                xxlineno, mess1, mess2, mess3);
        !           381:        exit(1);
        !           382:        }
        !           383: 
        !           384: 
        !           385: 
        !           386: 
        !           387: 
        !           388: 
        !           389: 
        !           390: push(type)
        !           391: int type;
        !           392:        {
        !           393:        if (++xxstind > xxtop)
        !           394:                error("nesting too deep, stack overflow","","");
        !           395:        xxstack[xxstind] = type;
        !           396:        }
        !           397: 
        !           398: pop()
        !           399:        {
        !           400:        if (xxstind <= 0)
        !           401:                error("stack exhausted, can't be popped as requested","","");
        !           402:        --xxstind;
        !           403:        }
        !           404: 
        !           405: 
        !           406: forst()
        !           407:        {
        !           408:        while( (xxval = yylex()) != '\n')
        !           409:                {
        !           410:                putout(xxval, yylval);
        !           411:                free(yylval);
        !           412:                }
        !           413:        free(yylval);
        !           414:        }

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