Return to printdecl.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / pdx / sym

Annotation of 43BSDReno/pgrm/pascal/pdx/sym/printdecl.c, revision 1.1

1.1     ! root        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: }

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