Return to pNodeBodies.h CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / pi

Annotation of 3BSD/cmd/pi/pNodeBodies.h, revision 1.1

1.1     ! root        1: union pNodeBodies {
        !             2: 
        !             3:     struct IntNode {
        !             4:        long            IntValue;
        !             5:     };
        !             6: 
        !             7:     struct RealNode {
        !             8:        float           RealValue;
        !             9:     };
        !            10: 
        !            11:        /*
        !            12:         *      these are actually allocated by
        !            13:         *      pNewNode( StringTAG , strlen( string ) + 1 )
        !            14:         */
        !            15:     struct StringNode {
        !            16:        char            StringValue[1];
        !            17:     };
        !            18: 
        !            19:     struct ListNode {
        !            20:        pPointer        ListUp;
        !            21:        pPointer        ListDown;
        !            22:        pPointer        ListItem;
        !            23:     };
        !            24: 
        !            25:     struct ThreadNode {
        !            26:        pPointer        ThreadPointer;
        !            27:     };
        !            28: 
        !            29:        /*
        !            30:         *      note that the first several GlobNodes fields are
        !            31:         *      one pPointer off from PorFNodes.
        !            32:         *      this so the simple-minded code in fdec works,
        !            33:         *      attaching the program to GlobProg as a PorFPFs
        !            34:         */
        !            35:     struct GlobNode {
        !            36:        pPointer        GlobaAlign;
        !            37:        pPointer        GlobbAlign;
        !            38:        pPointer        GlobConsts;
        !            39:        pPointer        GlobTypes;
        !            40:        pPointer        GlobVars;
        !            41:        pPointer        GlobPFs;
        !            42:        pPointer        GlobProg;
        !            43:     };
        !            44: 
        !            45: 
        !            46:     struct PorFNode {
        !            47:        pPointer        PorFName;
        !            48:        pPointer        PorFParams;
        !            49:        pPointer        PorFLabels;
        !            50:        pPointer        PorFConsts;
        !            51:        pPointer        PorFTypes;
        !            52:        pPointer        PorFVars;
        !            53:        pPointer        PorFPFs;
        !            54:        pPointer        PorFBody;
        !            55:        pPointer        PorFReturns;
        !            56:        short           PorFForward;
        !            57:     };
        !            58: 
        !            59:     struct BConstNode {
        !            60:        pPointer        BConstName;
        !            61:     };
        !            62: 
        !            63:     struct BTypeNode {
        !            64:        pPointer        BTypeName;
        !            65:     };
        !            66: 
        !            67:     struct BVarNode {
        !            68:        pPointer        BVarName;
        !            69:     };
        !            70: 
        !            71:     struct BFuncNode {
        !            72:        pPointer        BFuncName;
        !            73:     };
        !            74: 
        !            75:     struct BProcNode {
        !            76:        pPointer        BProcName;
        !            77:     };
        !            78: 
        !            79:     struct LabelDNode {
        !            80:        pPointer        LabelDName;
        !            81:     };
        !            82: 
        !            83:     struct ConstDNode {
        !            84:        pPointer        ConstDName;
        !            85:        pPointer        ConstDValue;
        !            86:     };
        !            87: 
        !            88:        /*
        !            89:         * used to head lists of identically typed names: e.g. vars and fields.
        !            90:         * also for overlays with TypeDNodes, VarDNodes, FieldDNodes, etc.
        !            91:         */
        !            92:     struct TypedNode {
        !            93:        pPointer        TypedNames;
        !            94:        pPointer        TypedType;
        !            95:     };
        !            96: 
        !            97:     struct TypeDNode {
        !            98:        pPointer        TypeDName;
        !            99:        pPointer        TypeDType;
        !           100:     };
        !           101: 
        !           102:     struct EnumTNode {
        !           103:        pPointer        EnumTScalars;
        !           104:     };
        !           105: 
        !           106:     struct ScalDNode {
        !           107:        pPointer        ScalDName;
        !           108:     };
        !           109: 
        !           110:     struct RangeTNode {
        !           111:        pPointer        RangeTLower;
        !           112:        pPointer        RangeTUpper;
        !           113:     };
        !           114: 
        !           115:     struct SetTNode {
        !           116:        pPointer        SetTType;
        !           117:     };
        !           118: 
        !           119:     struct FileTNode {
        !           120:        pPointer        FileTType;
        !           121:     };
        !           122: 
        !           123:     struct PtrTNode {
        !           124:        pPointer        PtrTType;
        !           125:     };
        !           126: 
        !           127:     struct PackTNode {
        !           128:        pPointer        PackTType;
        !           129:     };
        !           130: 
        !           131:     struct ArrayTNode {
        !           132:        pPointer        ArrayTDims;
        !           133:        pPointer        ArrayTType;
        !           134:     };
        !           135: 
        !           136:     struct RecTNode {
        !           137:        pPointer        RecTFldlst;
        !           138:     };
        !           139: 
        !           140:     struct FldlstNode {
        !           141:        pPointer        FldlstFixed;
        !           142:        pPointer        FldlstVariants;
        !           143:     };
        !           144: 
        !           145:     struct FieldDNode {
        !           146:        pPointer        FieldDName;
        !           147:        pPointer        FieldDType;
        !           148:     };
        !           149: 
        !           150:     struct VarntNode {
        !           151:        pPointer        VarntTag;
        !           152:        pPointer        VarntCases;
        !           153:     };
        !           154: 
        !           155:     struct VCaseNode {
        !           156:        pPointer        VCaseConst;
        !           157:        pPointer        VCaseRec;
        !           158:     };
        !           159: 
        !           160:     struct VarDNode {
        !           161:        pPointer        VarDName;
        !           162:        pPointer        VarDType;
        !           163:     };
        !           164: 
        !           165:        /*
        !           166:         *      not really in the tree,
        !           167:         *      used as an overlay for ValPNodes and VarPNodes in ParamCopy
        !           168:         */
        !           169:     struct ParamDNode {
        !           170:        pPointer        ParamDName;
        !           171:        pPointer        ParamDType;
        !           172:     };
        !           173: 
        !           174:     struct ValPNode {
        !           175:        pPointer        ValPName;
        !           176:        pPointer        ValPType;
        !           177:     };
        !           178: 
        !           179:     struct VarPNode {
        !           180:        pPointer        VarPName;
        !           181:        pPointer        VarPType;
        !           182:     };
        !           183: 
        !           184:     struct AssignNode {
        !           185:        pPointer        AssignVar;
        !           186:        pPointer        AssignExpr;
        !           187:     };
        !           188: 
        !           189:     struct PCallNode {
        !           190:        pPointer        PCallId;
        !           191:        pPointer        PCallActuals;
        !           192:     };
        !           193: 
        !           194:     struct IfNode {
        !           195:        pPointer        IfCond;
        !           196:        pPointer        IfThen;
        !           197:        pPointer        IfElse;
        !           198:     };
        !           199: 
        !           200:     struct WhileNode {
        !           201:        pPointer        WhileExpr;
        !           202:        pPointer        WhileStat;
        !           203:     };
        !           204: 
        !           205:     struct RepeatNode {
        !           206:        pPointer        RepeatStat;
        !           207:        pPointer        RepeatExpr;
        !           208:     };
        !           209: 
        !           210:     struct ForUNode {
        !           211:        pPointer        ForUAssign;
        !           212:        pPointer        ForUExpr;
        !           213:        pPointer        ForUStat;
        !           214:     };
        !           215: 
        !           216:     struct ForDNode {
        !           217:        pPointer        ForDAssign;
        !           218:        pPointer        ForDExpr;
        !           219:        pPointer        ForDStat;
        !           220:     };
        !           221: 
        !           222:     struct CaseSNode {
        !           223:        pPointer        CaseSExpr;
        !           224:        pPointer        CaseSStat;
        !           225:     };
        !           226: 
        !           227:     struct CasedNode {
        !           228:        pPointer        CasedLabel;
        !           229:        pPointer        CasedStat;
        !           230:     };
        !           231: 
        !           232:     struct GotoNode {
        !           233:        pPointer        GotoLabel;
        !           234:     };
        !           235: 
        !           236:     struct LabelNode {
        !           237:        pPointer        LabelLabel;
        !           238:     };
        !           239: 
        !           240:     struct WithNode {
        !           241:        pPointer        WithVars;
        !           242:        pPointer        WithStat;
        !           243:     };
        !           244: 
        !           245:     struct AssertNode {
        !           246:        pPointer        AssertExpr;
        !           247:     };
        !           248: 
        !           249:        /*
        !           250:         * not actually in the tree,
        !           251:         * for use as overlay with binary operator pNodes
        !           252:         */
        !           253:     struct BinOpNode {
        !           254:        pPointer        BinOpLeft;
        !           255:        pPointer        BinOpRight;
        !           256:     };
        !           257: 
        !           258:     struct AndNode {
        !           259:        pPointer        AndLeft;
        !           260:        pPointer        AndRight;
        !           261:     };
        !           262: 
        !           263:     struct OrNode {
        !           264:        pPointer        OrLeft;
        !           265:        pPointer        OrRight;
        !           266:     };
        !           267: 
        !           268:     struct EqNode {
        !           269:        pPointer        EqLeft;
        !           270:        pPointer        EqRight;
        !           271:     };
        !           272: 
        !           273:     struct NeNode {
        !           274:        pPointer        NeLeft;
        !           275:        pPointer        NeRight;
        !           276:     };
        !           277: 
        !           278:     struct LtNode {
        !           279:        pPointer        LtLeft;
        !           280:        pPointer        LtRight;
        !           281:     };
        !           282: 
        !           283:     struct GtNode {
        !           284:        pPointer        GtLeft;
        !           285:        pPointer        GtRight;
        !           286:     };
        !           287: 
        !           288:     struct LeNode {
        !           289:        pPointer        LeLeft;
        !           290:        pPointer        LeRight;
        !           291:     };
        !           292: 
        !           293:     struct GeNode {
        !           294:        pPointer        GeLeft;
        !           295:        pPointer        GeRight;
        !           296:     };
        !           297: 
        !           298:     struct InNode {
        !           299:        pPointer        InLeft;
        !           300:        pPointer        InRight;
        !           301:     };
        !           302: 
        !           303:     struct AddNode {
        !           304:        pPointer        AddLeft;
        !           305:        pPointer        AddRight;
        !           306:     };
        !           307: 
        !           308:     struct SubNode {
        !           309:        pPointer        SubLeft;
        !           310:        pPointer        SubRight;
        !           311:     };
        !           312: 
        !           313:     struct MultNode {
        !           314:        pPointer        MultLeft;
        !           315:        pPointer        MultRight;
        !           316:     };
        !           317: 
        !           318:     struct DivdNode {
        !           319:        pPointer        DivdLeft;
        !           320:        pPointer        DivdRight;
        !           321:     };
        !           322: 
        !           323:     struct DivNode {
        !           324:        pPointer        DivLeft;
        !           325:        pPointer        DivRight;
        !           326:     };
        !           327: 
        !           328:     struct ModNode {
        !           329:        pPointer        ModLeft;
        !           330:        pPointer        ModRight;
        !           331:     };
        !           332: 
        !           333:     /*
        !           334:      * not actually in the tree,
        !           335:      * for use as overlay with unary operator pNodes
        !           336:      */
        !           337:     struct UnOpNode {
        !           338:        pPointer        UnOpExpr;
        !           339:     };
        !           340: 
        !           341:     struct PlusNode {
        !           342:        pPointer        PlusExpr;
        !           343:     };
        !           344: 
        !           345:     struct MinusNode {
        !           346:        pPointer        MinusExpr;
        !           347:     };
        !           348: 
        !           349:     struct NotNode {
        !           350:        pPointer        NotExpr;
        !           351:     };
        !           352: 
        !           353:     struct FCallNode {
        !           354:        pPointer        FCallId;
        !           355:        pPointer        FCallActuals;
        !           356:     };
        !           357: 
        !           358:     struct SetNode {
        !           359:        pPointer        SetElements;
        !           360:     };
        !           361: 
        !           362:     struct RangeNode {
        !           363:        pPointer        RangeLower;
        !           364:        pPointer        RangeUpper;
        !           365:     };
        !           366: 
        !           367:     struct VarNode {
        !           368:        pPointer        VarId;
        !           369:        pPointer        VarQuals;
        !           370:     };
        !           371: 
        !           372:        /*
        !           373:         *      one of these indicates pointer indirection.
        !           374:         *      they are actually allocated by pNewNode( PtrTAG , 0 )
        !           375:         */
        !           376:     struct PtrNode {
        !           377:        char            PtrPrescence;
        !           378:     };
        !           379: 
        !           380:     struct SubscNode {
        !           381:        pPointer        SubscSubsc;
        !           382:     };
        !           383: 
        !           384:     struct SelNode {
        !           385:        pPointer        SelField;
        !           386:     };
        !           387: 
        !           388:        /*
        !           389:         *      one of these indicates the value NIL
        !           390:         *      they are actually allocated by pNewNode( NilTAG , 0 )
        !           391:         */
        !           392:     struct NilNode {
        !           393:        char            NilValue;
        !           394:     };
        !           395: 
        !           396:     struct WidthNode {
        !           397:        pPointer        WidthExpr;
        !           398:        pPointer        WidthWidth;
        !           399:        pPointer        WidthPlaces;
        !           400:        pPointer        WidthRadix;
        !           401:     };
        !           402: 
        !           403:        /*
        !           404:         *      one of these indicates octal radix conversion
        !           405:         *      they are actually allocated by pNewNode( OctTAG , 0 )
        !           406:         */
        !           407:     struct OctNode {
        !           408:        char            OctRadix;
        !           409:     };
        !           410: 
        !           411:        /*
        !           412:         *      one of these indicates hexadecimal radix conversion
        !           413:         *      they are actually allocated by pNewNode( HexTAG , 0 )
        !           414:         */
        !           415:     struct HexNode {
        !           416:        char            HexRadix;
        !           417:     };
        !           418: 
        !           419: };
        !           420: 

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