Return to prsym.c CVS log

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

Annotation of 43BSD/ingres/source/ovqp/prsym.c, revision 1.1.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     8.2     1/17/85)
                      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 & I1MASK;
                     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:                printf("%d [AND] (operator)", p->sym_op.opno);
                     47:                break;
                     48:          case AOP:
                     49:                printf("%d [AOP] (operator)", p->sym_op.opno);
                     50:                break;
                     51:          case BOP:
                     52:                printf("%d [BOP] (operator)", p->sym_op.opno);
                     53:                break;
                     54:          case OR:
                     55:                printf("%d [OR] (operator)", p->sym_op.opno);
                     56:                break;
                     57:          case RESDOM:
                     58:                printf("%d [RESDOM] (operator)", p->sym_op.opno);
                     59:                break;
                     60:          case UOP:
                     61:                printf("%d [UOP] (operator)", p->sym_op.opno);
                     62:                break;
                     63:          case COP:
                     64:                printf("%d [COP] (operator)", p->sym_op.opno);
                     65:                break;
                     66: 
                     67:          case INT:
                     68:                switch (len)
                     69:                {
                     70:                  case 1:
                     71:                        printf("%d", p->sym_data.i1type);
                     72:                        break;
                     73: 
                     74:                  case 2:
                     75:                        printf("%d", p->sym_data.i2type);
                     76:                        break;
                     77: 
                     78:                  case 4:
                     79:                        printf("%ld", p->sym_data.i4type);
                     80:                }
                     81:                break;
                     82: 
                     83:          case FLOAT:
                     84:                printf("%10.3f", p->sym_data.f4type);
                     85:                break;
                     86: 
                     87:          case RESULTID:
                     88:          case SOURCEID:
                     89:          case CHAR:
                     90:                printf("%x=", p->sym_data.c0type);
                     91:                prstr(p->sym_data.c0type, len);
                     92:                break;
                     93: 
                     94:          case AGHEAD:
                     95:                printf("AGHEAD (delim)");
                     96:                break;
                     97:          case BYHEAD:
                     98:                printf("BYHEAD (delim)");
                     99:                break;
                    100:          case QLEND:
                    101:                printf("QLEND (delim)");
                    102:                break;
                    103:          case ROOT:
                    104:                printf("ROOT (delim)");
                    105:                break;
                    106:          case TREE:
                    107:                printf("TREE (delim)");
                    108:                break;
                    109: 
                    110:          case CHANGESTRAT:
                    111:          case REOPENRES:
                    112:          case EXIT:
                    113:          case QMODE:
                    114:          case RETVAL:
                    115:          case USERQRY:
                    116:                if (len)
                    117:                        printf("%d", p->sym_op.opno);
                    118:                printf(" (status)");
                    119:                break;
                    120: 
                    121:          default:
                    122:                printf("\nError in prsym: bad type= %d\n", type);
                    123:        }
                    124:        printf("'\n");
                    125: }
                    126: 
                    127: 
                    128: prstack(s)
                    129: register SYMBOL        *s;
                    130: {
                    131:        if (s->type == CHAR)
                    132:        {
                    133:                printf("c%d:value='%x=", s->len,s->value.sym_data.cptype);
                    134:                prstr(s->value.sym_data.cptype, s->len & I1MASK);
                    135:                printf("'\n");
                    136:        }
                    137:        else
                    138:                prsym(s);
                    139: }
                    140: 
                    141: 
                    142: 
                    143: prstr(p, l)
                    144: register char  *p;
                    145: register int   l;
                    146: {
                    147:        while (--l >= 0)
                    148:                putchar(*p++);
                    149: }

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