Return to expr0.c CVS log

Up to [Research Unix] / researchv9 / jerq / sgs / ld

Annotation of researchv9/jerq/sgs/ld/expr0.c, revision 1.1

1.1     ! root        1: static char ID[] = "@(#) expr0.c: 1.3 3/13/83";
        !             2: #include "system.h"
        !             3: 
        !             4: #include <stdio.h>
        !             5: #include "structs.h"
        !             6: #include "extrns.h"
        !             7: #include "sgsmacros.h"
        !             8: #include "y.tab.h"
        !             9: #include "ldmacros.h"
        !            10: /*eject*/
        !            11: ENODE *
        !            12: buildtree(op,l,r)
        !            13: int op;
        !            14: ENODE *l,*r; 
        !            15: {
        !            16:  
        !            17: /*
        !            18:  * Build a node in the expression tree and
        !            19:  * return a pointer to it
        !            20:  */
        !            21: 
        !            22:        register ENODE *p;
        !            23: 
        !            24:        p = (ENODE *) myalloc(sizeof(ENODE));
        !            25: 
        !            26:        p->gnode.exop = op;
        !            27:        p->gnode.exleft = l;
        !            28:        p->gnode.exright = r;
        !            29:        return(p);
        !            30: }
        !            31: /*eject*/
        !            32: ENODE *
        !            33: symnode(symp)
        !            34: char *symp;
        !            35: {
        !            36: 
        !            37: /*
        !            38:  * Build an expression node for NAME or DOT
        !            39:  */
        !            40: 
        !            41:        register ENODE *p;
        !            42: 
        !            43: #if ONEPROC
        !            44:        SYMENT sym;
        !            45: #endif
        !            46: 
        !            47:        p = (ENODE *) myalloc(sizeof(ENODE));
        !            48: 
        !            49:        if( symp == NULL ) {            /* special DOT symbol */
        !            50:                p->pnnode.exop = DOT;
        !            51:                }
        !            52:        else {
        !            53: #if ONEPROC
        !            54:                p->nnode.exop = NAME;
        !            55:                zero( (char *) &sym, SYMESZ );
        !            56: #if FLEXNAMES
        !            57:                if (strlen(symp) > 8) {
        !            58:                        sym.n_zeroes = 0L;
        !            59:                        sym.n_nptr = symp;
        !            60:                        }
        !            61:                else
        !            62: #endif
        !            63:                        copy(sym.n_name,symp,8);
        !            64:                sym.n_type = T_INT;
        !            65:                sym.n_sclass = C_EXT;
        !            66:                p->nnode.exsymptr = putsym(makesym(&sym, NULL),1);
        !            67: #else
        !            68:                p->pnnode.exop = NAME;
        !            69:                copy(p->pnnode.symbol,symp,8);
        !            70: #endif
        !            71:                }
        !            72: 
        !            73:        return(p);
        !            74: }
        !            75: /*eject*/
        !            76: ENODE *
        !            77: cnstnode(val)
        !            78: long val;
        !            79: {
        !            80: 
        !            81: /*
        !            82:  * Build an expression node for a constant
        !            83:  */
        !            84: 
        !            85:        register ENODE *p;
        !            86: 
        !            87:        p = (ENODE *) myalloc(sizeof(ENODE));
        !            88: 
        !            89:        p->vnode.exop = INT;
        !            90:        p->vnode.exvalue = val;
        !            91: 
        !            92:        return(p);
        !            93: }

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