2.11BSD#431 - /usr/src/ucb/PORT/pascal/pdx/sym/printdecl.c

   1: /*
   2:  * Copyright (c) 1980 Regents of the University of California.
   3:  * All rights reserved.  The Berkeley software License Agreement
   4:  * specifies the terms and conditions for redistribution.
   5:  */
   6: 
   7: #ifndef lint
   8: static char sccsid[] = "@(#)printdecl.c	5.2 (Berkeley) 6/7/85";
   9: #endif not lint
  10: 
  11: /*
  12:  * Print out the type of a symbol.
  13:  */
  14: 
  15: #include "defs.h"
  16: #include "sym.h"
  17: #include "symtab.h"
  18: #include "tree.h"
  19: #include "btypes.h"
  20: #include "classes.h"
  21: #include "sym.rep"
  22: 
  23: printdecl(s)
  24: SYM *s;
  25: {
  26:     register SYM *t;
  27:     BOOLEAN semicolon;
  28: 
  29:     semicolon = TRUE;
  30:     switch(s->class) {
  31:     case CONST:
  32:         t = rtype(s->type);
  33:         if (t->class == SCAL) {
  34:         printf("(enumeration constant, ord %ld)", s->symvalue.iconval);
  35:         } else {
  36:         printf("const %s = ", s->symbol);
  37:         if (t == t_real) {
  38:             printf("%g", s->symvalue.fconval);
  39:         } else {
  40:             printordinal(s->symvalue.iconval, t);
  41:         }
  42:         }
  43:         break;
  44: 
  45:     case TYPE:
  46:         printf("type %s = ", s->symbol);
  47:         printtype(s, s->type);
  48:         break;
  49: 
  50:     case VAR:
  51:         if (isparam(s)) {
  52:         printf("(parameter) %s : ", s->symbol);
  53:         } else {
  54:         printf("var %s : ", s->symbol);
  55:         }
  56:         printtype(s, s->type);
  57:         break;
  58: 
  59:     case REF:
  60:         printf("(var parameter) %s : ", s->symbol);
  61:         printtype(s, s->type);
  62:         break;
  63: 
  64:     case RANGE:
  65:     case ARRAY:
  66:     case RECORD:
  67:     case VARNT:
  68:     case PTR:
  69:         printtype(s, s);
  70:         semicolon = FALSE;
  71:         break;
  72: 
  73:     case FVAR:
  74:         printf("(function variable) %s : ", s->symbol);
  75:         printtype(s, s->type);
  76:         break;
  77: 
  78:     case FIELD:
  79:         printf("(field) %s : ", s->symbol);
  80:         printtype(s, s->type);
  81:         break;
  82: 
  83:     case PROC:
  84:         printf("procedure %s", s->symbol);
  85:         listparams(s);
  86:         break;
  87: 
  88:     case PROG:
  89:         printf("program %s", s->symbol);
  90:         t = s->chain;
  91:         if (t != NIL) {
  92:         printf("(%s", t->symbol);
  93:         for (t = t->chain; t != NIL; t = t->chain) {
  94:             printf(", %s", t->symbol);
  95:         }
  96:         printf(")");
  97:         }
  98:         break;
  99: 
 100:     case FUNC:
 101:         printf("function %s", s->symbol);
 102:         listparams(s);
 103:         printf(" : ");
 104:         printtype(s, s->type);
 105:         break;
 106: 
 107:     default:
 108:         error("class %s in printdecl", classname(s));
 109:     }
 110:     if (semicolon) {
 111:     putchar(';');
 112:     }
 113:     putchar('\n');
 114: }
 115: 
 116: /*
 117:  * Recursive whiz-bang procedure to print the type portion
 118:  * of a declaration.  Doesn't work quite right for variant records.
 119:  *
 120:  * The symbol associated with the type is passed to allow
 121:  * searching for type names without getting "type blah = blah".
 122:  */
 123: 
 124: LOCAL printtype(s, t)
 125: SYM *s;
 126: SYM *t;
 127: {
 128:     register SYM *tmp;
 129:     long r0, r1;
 130: 
 131:     tmp = findtype(t);
 132:     if (tmp != NIL && tmp != s) {
 133:     printf("%s", tmp->symbol);
 134:     return;
 135:     }
 136:     switch(t->class) {
 137:     case VAR:
 138:     case CONST:
 139:     case FUNC:
 140:     case PROC:
 141:         panic("printtype: class %s", classname(t));
 142:         break;
 143: 
 144:     case ARRAY:
 145:         printf("array[");
 146:         tmp = t->chain;
 147:         for (;;) {
 148:         printtype(tmp, tmp);
 149:         tmp = tmp->chain;
 150:         if (tmp == NIL) {
 151:             break;
 152:         }
 153:         printf(", ");
 154:         }
 155:         printf("] of ");
 156:         printtype(t, t->type);
 157:         break;
 158: 
 159:     case RECORD:
 160:         printf("record\n");
 161:         if (t->chain != NIL) {
 162:         printtype(t->chain, t->chain);
 163:         }
 164:         printf("end");
 165:         break;
 166: 
 167:     case FIELD:
 168:         if (t->chain != NIL) {
 169:         printtype(t->chain, t->chain);
 170:         }
 171:         printf("\t%s : ", t->symbol);
 172:         printtype(t, t->type);
 173:         printf(";\n");
 174:         break;
 175: 
 176:     case RANGE:
 177:         r0 = t->symvalue.rangev.lower;
 178:         r1 = t->symvalue.rangev.upper;
 179:         printordinal(r0, rtype(t->type));
 180:         printf("..");
 181:         printordinal(r1, rtype(t->type));
 182:         break;
 183: 
 184:     case PTR:
 185:         putchar('^');
 186:         printtype(t, t->type);
 187:         break;
 188: 
 189:     case TYPE:
 190:         if (t->symbol != NIL) {
 191:         printf("%s", t->symbol);
 192:         } else {
 193:         printtype(t, t->type);
 194:         }
 195:         break;
 196: 
 197:     case SCAL:
 198:         printf("(");
 199:         t = t->type->chain;
 200:         if (t != NIL) {
 201:         printf("%s", t->symbol);
 202:         t = t->chain;
 203:         while (t != NIL) {
 204:             printf(", %s", t->symbol);
 205:             t = t->chain;
 206:         }
 207:         } else {
 208:         panic("empty enumeration");
 209:         }
 210:         printf(")");
 211:         break;
 212: 
 213:     default:
 214:         printf("(class %d)", t->class);
 215:         break;
 216:     }
 217: }
 218: 
 219: /*
 220:  * List the parameters of a procedure or function.
 221:  * No attempt is made to combine like types.
 222:  */
 223: 
 224: listparams(s)
 225: SYM *s;
 226: {
 227:     SYM *t;
 228: 
 229:     if (s->chain != NIL) {
 230:     putchar('(');
 231:     for (t = s->chain; t != NIL; t = t->chain) {
 232:         switch (t->class) {
 233:         case REF:
 234:             printf("var ");
 235:             break;
 236: 
 237:         case FPROC:
 238:             printf("procedure ");
 239:             break;
 240: 
 241:         case FFUNC:
 242:             printf("function ");
 243:             break;
 244: 
 245:         case VAR:
 246:             break;
 247: 
 248:         default:
 249:             panic("unexpected class %d for parameter", t->class);
 250:         }
 251:         printf("%s : ", t->symbol);
 252:         printtype(t, t->type);
 253:         if (t->chain != NIL) {
 254:         printf("; ");
 255:         }
 256:     }
 257:     putchar(')');
 258:     }
 259: }

Defined functions

Defined variables