Return to readqry.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / ctlmod

Annotation of 43BSD/ingres/source/ctlmod/readqry.c, revision 1.1

1.1     ! root        1: # include      "ctlmod.h"
        !             2: # include      <ingres.h>
        !             3: # include      <aux.h>
        !             4: # include      <tree.h>
        !             5: # include      <symbol.h>
        !             6: # include      <sccs.h>
        !             7: # include      <errors.h>
        !             8: 
        !             9: SCCSID(@(#)readqry.c   8.3     12/8/85)
        !            10: 
        !            11: 
        !            12: /*
        !            13: ** READQRY
        !            14: **
        !            15: **     Reads in query symbols from input pipe into core
        !            16: **     locations and sets up information needed for later 
        !            17: **     processing.
        !            18: **
        !            19: **     Returns ptr to root of querytree
        !            20: **
        !            21: **     Locbuf is a 'struct srcid' since that is the largest node of
        !            22: **     a QMODE, SOURCEID, or RESULTVAR node.
        !            23: */
        !            24: 
        !            25: QTREE *
        !            26: readqry(rdfn, fnparam, initialize)
        !            27: int    (*rdfn)();      /* tree read function */
        !            28: int    fnparam;        /* parameter to pass to rdfn */
        !            29: bool   initialize;     /* if set, initialize Qbuf */
        !            30: {
        !            31:        register QTREE  *q;
        !            32:        register QTREE  *rtval;
        !            33:        register DESC   *d;
        !            34:        extern QTREE    *readtree();
        !            35:        extern char     *xalloc();
        !            36:        extern QTREE    *trbuild();
        !            37:        int             mark;
        !            38:        extern QTREE    *readsym();
        !            39:        int             i;
        !            40:        int             j;
        !            41: 
        !            42: #      ifdef xCTR1
        !            43:        if (tTf(10, 8))
        !            44:                printf("READQRY:\n");
        !            45: #      endif
        !            46: 
        !            47:        if (initialize)
        !            48:        {
        !            49:                /* initialize for new query block */
        !            50:                clrrange();
        !            51:                Qt.qt_resvar = -1;
        !            52:                Qt.qt_qmode = -1;
        !            53:        }
        !            54:        for (i = 0; i < MAXRANGE; i++)
        !            55:                Qt.qt_remap[i] = i;
        !            56: 
        !            57:        mark = markbuf(Qbuf);
        !            58: 
        !            59:        /* read symbols from input */
        !            60:        for (;;)
        !            61:        {
        !            62:                freebuf(Qbuf, mark);
        !            63:                q = readsym(rdfn, fnparam);
        !            64:                switch (q->sym.type)
        !            65:                {
        !            66:                  case QMODE:
        !            67:                        if (Qt.qt_qmode != -1)
        !            68:                                syserr("readqry: two qmodes");
        !            69:                        Qt.qt_qmode = q->sym.value.sym_data.i2type;
        !            70:                        break;
        !            71: 
        !            72:                  case RESULTVAR:
        !            73:                        if (Qt.qt_resvar != -1)
        !            74:                                syserr("readqry: two resultvars");
        !            75:                        Qt.qt_resvar = q->sym.value.sym_data.i2type;
        !            76:                        break;
        !            77: 
        !            78:                  case SOURCEID:
        !            79:                        d = (DESC *) xalloc(sizeof *d);
        !            80:                        bmove((char *) &q->sym.value.sym_srcid.srcdesc, (char *) d, sizeof *d);
        !            81:                        i = q->sym.value.sym_srcid.srcvar;
        !            82:                        j = declare(i, d);
        !            83:                        if (j != i && initialize)
        !            84:                                syserr("readqry: declare(%d)=%d", i, j);
        !            85:                        Qt.qt_remap[i] = j;
        !            86:                        break;
        !            87: 
        !            88:                  case TREE:    /* beginning of tree, no more other stuff */
        !            89:                        q = readtree(q, rdfn, fnparam);
        !            90:                        rtval = trbuild(q);
        !            91:                        if (rtval == NULL)
        !            92:                                error(STACKFULL, 0);
        !            93:                        return (rtval);
        !            94: 
        !            95:                  default:
        !            96:                        syserr("readqry: bad symbol %d", q->sym.type);
        !            97:                }
        !            98:        }
        !            99: }
        !           100: /*
        !           101: **  READSYM
        !           102: **     reads in one symbol from pipe into symbol struct.
        !           103: */
        !           104: 
        !           105: QTREE *
        !           106: readsym(rdfn, fnparam)
        !           107: int    (*rdfn)();      /* tree read function */
        !           108: char   *fnparam;
        !           109: {
        !           110:        register int    len;
        !           111:        register int    t;
        !           112:        register QTREE  *q;
        !           113:        extern char     *need();
        !           114:        int             rlen;
        !           115: 
        !           116:        q = (QTREE *) need(Qbuf, QT_HDR_SIZ);
        !           117:        if ((*rdfn)(fnparam, &q->sym, TYP_LEN_SIZ) < TYP_LEN_SIZ) 
        !           118:                syserr("readsym: read sym");
        !           119:        rlen = len = q->sym.len & I1MASK;
        !           120:        t = q->sym.type;
        !           121: 
        !           122:        switch (t)
        !           123:        {
        !           124:          case AND:
        !           125:                if (len < 6)
        !           126:                        len = 6;
        !           127:                break;
        !           128: 
        !           129:          case ROOT:
        !           130:          case AGHEAD:
        !           131:                if (len < 8)
        !           132:                        len = 8;
        !           133:                break;
        !           134:        }
        !           135: 
        !           136:        q->sym.len = len;
        !           137: 
        !           138: 
        !           139:        if (len != 0)
        !           140:        {
        !           141:                /* this will be contiguous with above need call */
        !           142:                need(Qbuf, len);
        !           143:        }
        !           144:        if (rlen != 0)
        !           145:        {
        !           146:                if ((*rdfn)(fnparam, &q->sym.value, rlen) < rlen) 
        !           147:                        syserr("readsym: read val (sym=%d,%d)", t, rlen);
        !           148:        }
        !           149: 
        !           150:        switch (t)
        !           151:        {
        !           152:          case ROOT:
        !           153:                q->sym.value.sym_root.rootuser = TRUE;
        !           154:                break;
        !           155:          case AGHEAD:
        !           156:                q->sym.value.sym_root.rootuser = FALSE;
        !           157:                break;
        !           158:        }
        !           159: # ifdef xCTR1
        !           160:        if (tTf(10, 9))
        !           161:                nodepr(q);
        !           162: # endif xCTR1
        !           163: 
        !           164:        return (q);
        !           165: }
        !           166: /*
        !           167: **  READTREE
        !           168: **
        !           169: **     reads in tree symbols into a buffer up to a root (end) symbol
        !           170: **
        !           171: */
        !           172: 
        !           173: QTREE *
        !           174: readtree(tresym, rdfn, fnparam)
        !           175: QTREE  *tresym;
        !           176: int    (*rdfn)();
        !           177: char   *fnparam;
        !           178: {
        !           179:        register QTREE  *q;
        !           180:        register QTREE  *rtval;
        !           181:        extern char     *need();
        !           182: 
        !           183:        rtval = tresym;
        !           184: 
        !           185:        for(;;)
        !           186:        {
        !           187:                /* space for left & right pointers */
        !           188:                q = readsym(rdfn, fnparam);
        !           189:                if (q->sym.type == ROOT)
        !           190:                        return (rtval);
        !           191:        }
        !           192: }
        !           193: /*
        !           194: **  TRBUILD -- Rebuild a tree in memory
        !           195: **
        !           196: **     Trbuild is called with a pointer to the TREE node of
        !           197: **     a query already in memory. It rebuilds the pointer
        !           198: **     structure assuming the querytree is in postfix order.
        !           199: **
        !           200: **     Parameters:
        !           201: **             bufptr - a pointer to the TREE node
        !           202: **
        !           203: **     Returns:
        !           204: **             NULL - Internal stack overflow (STACKSIZ)
        !           205: **             pointer to the ROOT node
        !           206: **
        !           207: **     Side Effects:
        !           208: **             All left & right pointers are rebuilt.
        !           209: **
        !           210: **     Called By:
        !           211: **             readqry
        !           212: **
        !           213: **     Syserrs:
        !           214: **             syserr if there are too many leaf nodes or too
        !           215: **             few child nodes
        !           216: */
        !           217: 
        !           218: 
        !           219: QTREE *
        !           220: trbuild(bufptr)
        !           221: QTREE  *bufptr;
        !           222: {
        !           223:        register QTREE  **stackptr;
        !           224:        register char   *p;
        !           225:        register SYMBOL *s;
        !           226:        QTREE           *treestack[STACKSIZ];
        !           227:        extern bool     leaf();
        !           228: 
        !           229: 
        !           230:        stackptr = treestack;
        !           231: 
        !           232: /*XXX*/        for (p = (char *) bufptr;; p += QT_HDR_SIZ + ((s->len + 3) & 0374))
        !           233:        {
        !           234:                s = &((QTREE *)p)->sym;
        !           235:                ((QTREE *)p)->left = ((QTREE *)p)->right = 0;
        !           236: 
        !           237:                /* reunite p with left and right children on stack, if any*/
        !           238:                if (!leaf((QTREE *) p))         /* this node has children */
        !           239:                {
        !           240:                        if (s->type != UOP)
        !           241:                                if (stackptr <= treestack) 
        !           242:                                {
        !           243:                                err:
        !           244:                                        syserr("trbuild:too few nodes");
        !           245:                                }
        !           246:                                else
        !           247:                                        ((QTREE *)p)->right = *(--stackptr);
        !           248:                        if (s->type != AOP)
        !           249:                                if (stackptr <= treestack) 
        !           250:                                        goto err;
        !           251:                                else
        !           252:                                        ((QTREE *)p)->left = *(--stackptr);
        !           253:                }
        !           254: 
        !           255:                /*
        !           256:                ** If this is a ROOT node then the tree is complete.
        !           257:                ** verify that there are no extra nodes in the
        !           258:                ** treestack.
        !           259:                */
        !           260:                if (s->type == ROOT)            /* root node */
        !           261:                {
        !           262:                        if (stackptr != treestack)
        !           263:                                syserr("trbuild:xtra nodes");
        !           264:                        return ((QTREE *)p);
        !           265:                }
        !           266: 
        !           267:                /* stack p */
        !           268:                if (stackptr-treestack >= STACKSIZ) 
        !           269:                        return (NULL);  /* error:stack full */
        !           270:                *(stackptr++) = (QTREE *) p;
        !           271: 
        !           272:        }
        !           273: }
        !           274: 
        !           275: 
        !           276: bool
        !           277: leaf(p)
        !           278: QTREE *p;
        !           279: {
        !           280:        switch (p->sym.type)
        !           281:        {
        !           282:          case VAR:
        !           283:          case TREE:
        !           284:          case QLEND:
        !           285:          case INT:
        !           286:          case FLOAT:
        !           287:          case CHAR:
        !           288:          case COP:
        !           289:                return(TRUE);
        !           290: 
        !           291:          default:
        !           292:                return(FALSE);
        !           293:        }
        !           294: }

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