Return to prsym.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / ovqp

Annotation of 42BSD/ingres/source/ovqp/prsym.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <symbol.h>
        !             4: # include      <tree.h>
        !             5: # include      "../decomp/globs.h"
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)prsym.c     7.2     3/6/81)
        !             9: 
        !            10: prsym(s)
        !            11: register SYMBOL        *s;
        !            12: {
        !            13:        register union symvalue *p;
        !            14:        register int            type;
        !            15:        register int            len;
        !            16:        union symvalue          temp;
        !            17: 
        !            18:        type = s->type;
        !            19:        len = s->len & 0377;
        !            20:        p = &s->value;
        !            21:        if (type == S_VAR)
        !            22:        {
        !            23:                /* actually, S_VAR's are rendered the same as VAR's
        !            24:                 * by call_ovqp70.c's ovqpnod()
        !            25:                 */
        !            26:                printf("s_");   /* first part of "s_var" message */
        !            27:                type = VAR;     /* execute var portion */
        !            28:        }
        !            29:        if (type == VAR)
        !            30:        {
        !            31:                printf("var:att#=%d:", p->sym_var.attno);
        !            32:                type = p->sym_var.varfrmt;
        !            33:                len = p->sym_var.varfrml;
        !            34:                if (type != CHAR)
        !            35:                {
        !            36:                        /* move anytype to symvalue boundary */
        !            37:                        bmove((char *)p->sym_var.valptr, (char *)&temp, sizeof *p);
        !            38:                        p = &temp;
        !            39:                }
        !            40:        }
        !            41:        xputchar(type);
        !            42:        printf("%d:value='", len);
        !            43:        switch (type)
        !            44:        {
        !            45:          case AND:
        !            46:          case AOP:
        !            47:          case BOP:
        !            48:          case OR:
        !            49:          case RESDOM:
        !            50:          case UOP:
        !            51:          case COP:
        !            52:                printf("%d (operator)", p->sym_op.opno);
        !            53:                break;
        !            54: 
        !            55:          case INT:
        !            56:                switch (len)
        !            57:                {
        !            58:                  case 1:
        !            59:                        printf("%d", p->sym_data.i1type);
        !            60:                        break;
        !            61: 
        !            62:                  case 2:
        !            63:                        printf("%d", p->sym_data.i2type);
        !            64:                        break;
        !            65: 
        !            66:                  case 4:
        !            67:                        printf("%ld", p->sym_data.i4type);
        !            68:                }
        !            69:                break;
        !            70: 
        !            71:          case FLOAT:
        !            72:                printf("%10.3f", p->sym_data.f4type);
        !            73:                break;
        !            74: 
        !            75:          case RESULTID:
        !            76:          case SOURCEID:
        !            77:          case CHAR:
        !            78:                printf("%x=", p->sym_data.c0type);
        !            79:                prstr(p->sym_data.c0type, len);
        !            80:                break;
        !            81: 
        !            82:          case AGHEAD:
        !            83:          case BYHEAD:
        !            84:          case QLEND:
        !            85:          case ROOT:
        !            86:          case TREE:
        !            87:                printf(" (delim)");
        !            88:                break;
        !            89: 
        !            90:          case CHANGESTRAT:
        !            91:          case REOPENRES:
        !            92:          case EXIT:
        !            93:          case QMODE:
        !            94:          case RETVAL:
        !            95:          case USERQRY:
        !            96:                if (len)
        !            97:                        printf("%d", p->sym_op.opno);
        !            98:                printf(" (status)");
        !            99:                break;
        !           100: 
        !           101:          default:
        !           102:                printf("\nError in prsym: bad type= %d\n", type);
        !           103:        }
        !           104:        printf("'\n");
        !           105: }
        !           106: 
        !           107: 
        !           108: prstack(s)
        !           109: register SYMBOL        *s;
        !           110: {
        !           111:        if (s->type == CHAR)
        !           112:        {
        !           113:                printf("c%d:value='%x=", s->len,s->value.sym_data.cptype);
        !           114:                prstr(s->value.sym_data.cptype, s->len & 0377);
        !           115:                printf("'\n");
        !           116:        }
        !           117:        else
        !           118:                prsym(s);
        !           119: }
        !           120: 
        !           121: 
        !           122: 
        !           123: prstr(p, l)
        !           124: register char  *p;
        !           125: register int   l;
        !           126: {
        !           127:        while (--l >= 0)
        !           128:                putchar(*p++);
        !           129: }

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