Return to 4.out.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / struct

Annotation of 41BSD/cmd/struct/4.out.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "def.h"
        !             3: #include "4.def.h"
        !             4: #include "3.def.h"
        !             5: 
        !             6: outrat(v,tab,tabfirst)
        !             7: VERT v;
        !             8: int tab;               /* number of tabs to indent */
        !             9: LOGICAL tabfirst;      /* FALSE if doing IF of ELSE IF */
        !            10:        {
        !            11:        LOGICAL ndcomma;
        !            12:        VERT w;
        !            13:        int type,i;
        !            14:        type = NTYPE(v);
        !            15:        if (hascom[type])
        !            16:                prcom(v);
        !            17:        if (!LABEL(v) && type == FMTVX)
        !            18:                {
        !            19:                OUTSTR("#following unreferenced format statement commented out\n");
        !            20:                OUTSTR("#");
        !            21:                }
        !            22:        if (LABEL(v) && type != ITERVX)
        !            23:                {
        !            24:                ASSERT(tabfirst, outrat);
        !            25:                prlab(LABEL(v),tab);
        !            26:                }
        !            27:        else if (tabfirst && type != DUMVX && type != ITERVX)
        !            28:                TABOVER(tab);
        !            29: 
        !            30:        switch(type)
        !            31:                {
        !            32:                case DUMVX:
        !            33:                        newlevel(v,0,tab,YESTAB);
        !            34:                        break;
        !            35:                case GOVX:
        !            36:                        OUTSTR("go to ");
        !            37:                        OUTNUM(LABEL(ARC(v,0)));
        !            38:                        OUTSTR("\n");
        !            39:                        break;
        !            40:                case STOPVX:
        !            41:                        if (progtype != blockdata)
        !            42:                                OUTSTR("stop\n");
        !            43:                        break;
        !            44:                case RETVX:
        !            45:                        OUTSTR("return\n");
        !            46:                        break;
        !            47:                case BRKVX:
        !            48:                        if (!levbrk)
        !            49:                                {
        !            50:                                ASSERT(LEVEL(v) == 1,outrat);
        !            51:                                OUTSTR("break\n");
        !            52:                                }
        !            53:                        else
        !            54:                                {
        !            55:                                OUTSTR("break ");
        !            56:                                OUTNUM(LEVEL(v));
        !            57:                                OUTSTR("\n");
        !            58:                                }
        !            59:                        break;
        !            60:                case NXTVX:
        !            61:                        if (!levnxt)
        !            62:                                {
        !            63:                                ASSERT(LEVEL(v) == 1,outrat);
        !            64:                                OUTSTR("next\n");
        !            65:                                }
        !            66:                        else
        !            67:                                {
        !            68:                                OUTSTR("next ");
        !            69:                                OUTNUM(LEVEL(v));
        !            70:                                OUTSTR("\n");
        !            71:                                }
        !            72:                        break;
        !            73:                case ASGOVX:
        !            74:                case COMPVX:
        !            75:                        OUTSTR("goto ");
        !            76:                        if (type == ASGOVX)
        !            77:                                {
        !            78:                                OUTSTR(EXP(v));
        !            79:                                OUTSTR(",");
        !            80:                                }
        !            81:                        OUTSTR("(");
        !            82:                        for (i = ARCNUM(v)-1; i >=0; --i)               /* arcs were stored backward */
        !            83:                                {
        !            84:                                OUTNUM(LABEL(ARC(v,i)));
        !            85:                                if (i > 0) OUTSTR(",");
        !            86:                                }
        !            87:                        OUTSTR(")");
        !            88:                        if (type == COMPVX)
        !            89:                                {
        !            90:                                OUTSTR(",");
        !            91:                                OUTSTR(EXP(v));
        !            92:                                }
        !            93:                        OUTSTR("\n");
        !            94:                        break;
        !            95:                case ASVX:
        !            96:                        OUTSTR("assign ");
        !            97:                        OUTNUM(LABEL(LABREF(v)));
        !            98:                        OUTSTR(" to ");
        !            99:                        OUTSTR(EXP(v));
        !           100:                        OUTSTR("\n");
        !           101:                        break;
        !           102:                case IFVX:
        !           103:                        OUTSTR("IF");
        !           104:                        prpred(v,TRUE);
        !           105:                        if (IFTHEN(v))
        !           106:                                newlevel(v,THEN,tab+1,YESTAB);
        !           107:                        else
        !           108:                                {
        !           109:                                newlevel(v,THEN,tab+1,YESTAB);
        !           110:                                TABOVER(tab);
        !           111:                                OUTSTR("ELSE ");
        !           112:                                w = LCHILD(v,ELSE);
        !           113:                                ASSERT(DEFINED(w),outrat);
        !           114:                                if (NTYPE(w) == IFVX && !LABEL(w) && !DEFINED(RSIB(w)) &&
        !           115:                                        !HASBRACE(v,ELSE) )
        !           116:                                        newlevel(v,ELSE,tab,NOTAB);
        !           117:                                else
        !           118:                                        newlevel(v,ELSE,tab+1,YESTAB);
        !           119:                                }
        !           120:                        break;
        !           121:                case ITERVX:
        !           122:                        newlevel(v,0,tab,YESTAB);
        !           123:                        ASSERT(DEFINED(NXT(v)),outrat);
        !           124:                        if (LABEL(NXT(v)))
        !           125:                                {
        !           126:                                prlab(LABEL(NXT(v)),tab);
        !           127:                                OUTSTR("continue\n");
        !           128:                                }
        !           129:                        break;
        !           130:                case DOVX:
        !           131:                        OUTSTR("DO ");
        !           132:                        OUTSTR(INC(v));
        !           133:                        newlevel(v,0,tab+1,YESTAB);
        !           134:                        break;
        !           135:                case LOOPVX:
        !           136:                case UNTVX:
        !           137:                        OUTSTR("REPEAT");
        !           138:                        newlevel(v,0,tab+1,YESTAB);
        !           139:                        if (type == UNTVX)
        !           140:                                {
        !           141:                                TABOVER(tab+1);
        !           142:                                OUTSTR("UNTIL");
        !           143:                                ASSERT(DEFINED(ARC(v,0)),outrat);
        !           144:                                prpred(LPRED(ARC(v,0)),TRUE);
        !           145:                                OUTSTR("\n");
        !           146:                                }
        !           147:                        break;
        !           148:                case WHIVX:
        !           149:                        OUTSTR("WHILE");
        !           150:                        ASSERT(DEFINED(ARC(v,0)),outrat);
        !           151:                        ASSERT(DEFINED(LPRED(ARC(v,0))),outrat);
        !           152:                        prpred(LPRED(ARC(v,0)),TRUE);
        !           153:                        newlevel(v,0,tab+1,YESTAB);
        !           154:                        break;
        !           155:                case STLNVX:
        !           156:                case FMTVX:
        !           157:                        prstln(v,tab);
        !           158:                        break;
        !           159:                case SWCHVX:
        !           160:                                OUTSTR("SWITCH");
        !           161:                                if (DEFINED(EXP(v)))
        !           162:                                        {
        !           163:                                        OUTSTR("(");
        !           164:                                        OUTSTR(EXP(v));
        !           165:                                        OUTSTR(")");
        !           166:                                        }
        !           167:                                newlevel(v,0,tab+1,YESTAB);
        !           168:                                break;
        !           169:                case ICASVX:
        !           170:                case ACASVX:
        !           171:                        OUTSTR("CASE ");
        !           172:                        if (type == ACASVX)
        !           173:                                prpred(v,FALSE);
        !           174:                        else
        !           175:                                OUTSTR(EXP(v));
        !           176:                        OUTSTR(":\n");
        !           177:                        newlevel(v,0,tab+1,YESTAB);
        !           178:                        if (type == ACASVX &&DEFINED(LCHILD(v,ELSE)))
        !           179:                                {
        !           180:                                TABOVER(tab);
        !           181:                                OUTSTR("DEFAULT:\n");
        !           182:                                newlevel(v,1,tab+1,YESTAB);
        !           183:                                }
        !           184:                        break;
        !           185:                case IOVX:
        !           186:                        OUTSTR(PRERW(v));
        !           187:                        ndcomma = FALSE;
        !           188:                        if (DEFINED(FMTREF(v)))
        !           189:                                {
        !           190:                                OUTNUM(LABEL(FMTREF(v)));
        !           191:                                ndcomma = TRUE;
        !           192:                                }
        !           193:                        if (DEFINED(ARC(v,ENDEQ)))
        !           194:                                {
        !           195:                                if (ndcomma) 
        !           196:                                        OUTSTR(",");
        !           197:                                OUTSTR("end = ");
        !           198:                                OUTNUM(LABEL(ARC(v,ENDEQ)));
        !           199:                                ndcomma = TRUE;
        !           200:                                }
        !           201:                        if (DEFINED(ARC(v,ERREQ)))
        !           202:                                {
        !           203:                                if (ndcomma)
        !           204:                                        OUTSTR(",");
        !           205:                                OUTSTR("err = ");
        !           206:                                OUTNUM(LABEL(ARC(v,ERREQ)));
        !           207:                                ndcomma = TRUE;
        !           208:                                }
        !           209:                        OUTSTR(POSTRW(v));
        !           210:                        OUTSTR("\n");
        !           211:                        break;
        !           212:                }
        !           213:        }
        !           214: 
        !           215: 
        !           216: newlevel(v,ch,tab,tabfirst)
        !           217: VERT v;
        !           218: int ch;                /* number of lchild of v being processed */
        !           219: int tab;               /* number of tabs to indent */
        !           220: LOGICAL tabfirst;      /* same as for outrat */
        !           221:        {
        !           222:        LOGICAL addbrace;
        !           223:        VERT w;
        !           224:        if (NTYPE(v) == ACASVX || NTYPE(v) == ICASVX)
        !           225:                addbrace = FALSE;
        !           226:        else
        !           227:                addbrace = HASBRACE(v,ch);
        !           228:        ASSERT(tabfirst || !addbrace,newlevel);
        !           229:        if (addbrace)
        !           230:                OUTSTR(" {");
        !           231:        if(tabfirst && NTYPE(v)!=ITERVX && NTYPE(v)!=DUMVX) OUTSTR("\n");
        !           232:        for (w = LCHILD(v,ch); DEFINED(w); w = RSIB(w))
        !           233:                outrat(w,tab,tabfirst);
        !           234:        if (addbrace)
        !           235:                {
        !           236:                TABOVER(tab);
        !           237:                OUTSTR("}\n");
        !           238:                }
        !           239:        }
        !           240: 
        !           241: 
        !           242: 
        !           243: 
        !           244: 
        !           245: prpred(v,addpar)
        !           246: VERT v;
        !           247: LOGICAL addpar;
        !           248:        {
        !           249:        if (addpar)
        !           250:                OUTSTR("(");
        !           251:        if (NEG(v)) OUTSTR("!(");
        !           252:        OUTSTR(PRED(v));
        !           253:        if (NEG(v)) OUTSTR(")");
        !           254:        if (addpar)
        !           255:                OUTSTR(")");
        !           256:        }
        !           257: 
        !           258: prlab(n,tab)
        !           259: int n,tab;
        !           260:        {
        !           261:        TABOVER(tab);
        !           262:        OUTSTR("~");
        !           263:        OUTNUM(n);
        !           264:        OUTSTR(" ");
        !           265:        }
        !           266: 
        !           267: prstln(v,tab)
        !           268: VERT v;
        !           269: int tab;
        !           270:        {
        !           271:        ASSERT(NTYPE(v) == STLNVX || NTYPE(v) == FMTVX,prstln);
        !           272:        if (!ONDISK(v))
        !           273:                {
        !           274:                OUTSTR(BEGCODE(v));
        !           275:                OUTSTR("\n");
        !           276:                }
        !           277:        else
        !           278:                {
        !           279:                empseek(BEGCODE(v));
        !           280:                prcode(ONDISK(v),tab);
        !           281:                }
        !           282:        }
        !           283: 
        !           284: prcom(v)
        !           285: VERT v;
        !           286:        {
        !           287:        if (DEFINED(BEGCOM(v)))
        !           288:                {
        !           289:                empseek(BEGCOM(v));
        !           290:                comprint();
        !           291:                }
        !           292:        }

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