Return to print.c CVS log

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

Annotation of 43BSD/ucb/pascal/pdx/sym/print.c, revision 1.1.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[] = "@(#)print.c    5.1 (Berkeley) 6/6/85";
                      9: #endif not lint
                     10: /*
                     11:  * Routines to print out symbols.
                     12:  */
                     13: 
                     14: #include "defs.h"
                     15: #include "sym.h"
                     16: #include "process.h"
                     17: #include "tree.h"
                     18: #include "runtime.h"
                     19: #include "classes.h"
                     20: #include "sym.rep"
                     21: #include "process/process.rep"
                     22: 
                     23: /*
                     24:  * Note the entry of the given block, unless it's the main program.
                     25:  */
                     26: 
                     27: printentry(s)
                     28: SYM *s;
                     29: {
                     30:        if (s != program) {
                     31:                printf("\nentering %s %s\n", classname(s), s->symbol);
                     32:        }
                     33: }
                     34: 
                     35: /*
                     36:  * Note the exit of the given block
                     37:  */
                     38: 
                     39: printexit(s)
                     40: SYM *s;
                     41: {
                     42:        if (s != program) {
                     43:                printf("leaving %s %s\n\n", classname(s), s->symbol);
                     44:        }
                     45: }
                     46: 
                     47: /*
                     48:  * Note the call of s from t.
                     49:  */
                     50: 
                     51: printcall(s, t)
                     52: SYM *s, *t;
                     53: {
                     54:        printf("calling %s", s->symbol);
                     55:        printparams(s, NIL);
                     56:        printf(" from %s %s\n", classname(t), t->symbol);
                     57: }
                     58: 
                     59: /*
                     60:  * Note the return from s.  If s is a function, print the value
                     61:  * it is returning.  This is somewhat painful, since the function
                     62:  * has actually just returned.
                     63:  */
                     64: 
                     65: printrtn(s)
                     66: SYM *s;
                     67: {
                     68:        register SYM *t;
                     69:        register int len;
                     70: 
                     71:        printf("returning ");
                     72:        if (s->class == FUNC) {
                     73:                len = size(s->type);
                     74:                dread(sp, process->sp, len);
                     75:                sp += len;
                     76:                printval(s->type);
                     77:                putchar(' ');
                     78:        }
                     79:        printf("from %s\n", s->symbol);
                     80: }
                     81: 
                     82: /*
                     83:  * Print the values of the parameters of the given procedure or function.
                     84:  * The frame distinguishes recursive instances of a procedure.
                     85:  */
                     86: 
                     87: printparams(f, frame)
                     88: SYM *f;
                     89: FRAME *frame;
                     90: {
                     91:        SYM *param;
                     92: 
                     93:        for (param = f->chain; param != NIL; param = param->chain) {
                     94:                if (param == f->chain) {
                     95:                        printf("(");
                     96:                }
                     97:                printv(param, frame);
                     98:                if (param->chain != NIL) {
                     99:                        printf(", ");
                    100:                } else {
                    101:                        printf(")");
                    102:                }
                    103:        }
                    104: }
                    105: 
                    106: /*
                    107:  * Print the name and value of a variable.
                    108:  */
                    109: 
                    110: printv(s, frame)
                    111: SYM *s;
                    112: FRAME *frame;
                    113: {
                    114:        ADDRESS addr;
                    115:        int len;
                    116: 
                    117:        if (s->class == REF) {
                    118:                dread(&addr, address(s, frame), sizeof(ADDRESS));
                    119:                len = size(s->type);
                    120:        } else {
                    121:                addr = address(s, frame);
                    122:                len = size(s);
                    123:        }
                    124:        printf("%s = ", s->symbol);
                    125:        if (!rpush(addr, len)) {
                    126:                printf("*** expression too large ***");
                    127:        } else {
                    128:                if (s->class == REF || s->class == VAR) {
                    129:                        printval(s->type);
                    130:                } else {
                    131:                        printval(s);
                    132:                }
                    133:        }
                    134: }
                    135: 
                    136: /*
                    137:  * Print the fully specified variable that is described by the given identifer.
                    138:  */
                    139: 
                    140: printwhich(s)
                    141: SYM *s;
                    142: {
                    143:        printouter(s->func);
                    144:        printf("%s", s->symbol);
                    145: }
                    146: 
                    147: LOCAL printouter(s)
                    148: SYM *s;
                    149: {
                    150:        if (s->func != NIL) {
                    151:                printouter(s->func);
                    152:        }
                    153:        printf("%s.", s->symbol);
                    154: }

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