Return to lab.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / pi

Annotation of 3BSD/cmd/pi/lab.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1979 Regents of the University of California */
                      2: #
                      3: /*
                      4:  * pi - Pascal interpreter code translator
                      5:  *
                      6:  * Charles Haley, Bill Joy UCB
                      7:  * Version 1.2 November 1978
                      8:  */
                      9: 
                     10: #include "whoami"
                     11: #include "0.h"
                     12: #include "tree.h"
                     13: #include "opcode.h"
                     14: 
                     15: /*
                     16:  * Label enters the definitions
                     17:  * of the label declaration part
                     18:  * into the namelist.
                     19:  */
                     20: label(r, l)
                     21:        int *r, l;
                     22: {
                     23: #ifndef PI0
                     24:        register *ll;
                     25:        register struct nl *p, *lp;
                     26: 
                     27:        lp = NIL;
                     28: #else
                     29:        send(REVLAB, r);
                     30: #endif
                     31:        line = l;
                     32: #ifndef PI1
                     33:        if (parts & (CPRT|TPRT|VPRT))
                     34:                error("Label declarations must precede const, type and var declarations");
                     35:        if (parts & LPRT)
                     36:                error("All labels must be declared in one label part");
                     37:        parts |= LPRT;
                     38: #endif
                     39: #ifndef PI0
                     40:        for (ll = r; ll != NIL; ll = ll[2]) {
                     41:                l = getlab();
                     42:                p = enter(defnl(ll[1], LABEL, 0, l));
                     43:                /*
                     44:                 * Get the label for the eventual target
                     45:                 */
                     46:                p->value[1] = getlab();
                     47:                p->chain = lp;
                     48:                p->nl_flags |= (NFORWD|NMOD);
                     49:                p->value[NL_GOLEV] = NOTYET;
                     50:                p->entloc = l;
                     51:                lp = p;
                     52:                /*
                     53:                 * This operator is between
                     54:                 * the bodies of two procedures
                     55:                 * and provides a target for
                     56:                 * gotos for this label via TRA.
                     57:                 */
                     58:                putlab(l);
                     59:                put2(O_GOTO | cbn<<9, p->value[1]);
                     60:        }
                     61:        gotos[cbn] = lp;
                     62: #      ifdef PTREE
                     63:            {
                     64:                pPointer        Labels = LabelDCopy( r );
                     65: 
                     66:                pDEF( PorFHeader[ nesting ] ).PorFLabels = Labels;
                     67:            }
                     68: #      endif
                     69: #endif
                     70: }
                     71: 
                     72: #ifndef PI0
                     73: /*
                     74:  * Gotoop is called when
                     75:  * we get a statement "goto label"
                     76:  * and generates the needed tra.
                     77:  */
                     78: gotoop(s)
                     79:        char *s;
                     80: {
                     81:        register struct nl *p;
                     82: 
                     83:        gocnt++;
                     84:        p = lookup(s);
                     85:        if (p == NIL)
                     86:                return (NIL);
                     87:        put2(O_TRA4, p->entloc);
                     88:        if (bn == cbn)
                     89:                if (p->nl_flags & NFORWD) {
                     90:                        if (p->value[NL_GOLEV] == NOTYET) {
                     91:                                p->value[NL_GOLEV] = level;
                     92:                                p->value[NL_GOLINE] = line;
                     93:                        }
                     94:                } else
                     95:                        if (p->value[NL_GOLEV] == DEAD) {
                     96:                                recovered();
                     97:                                error("Goto %s is into a structured statement", p->symbol);
                     98:                        }
                     99: }
                    100: 
                    101: /*
                    102:  * Labeled is called when a label
                    103:  * definition is encountered, and
                    104:  * marks that it has been found and
                    105:  * patches the associated GOTO generated
                    106:  * by gotoop.
                    107:  */
                    108: labeled(s)
                    109:        char *s;
                    110: {
                    111:        register struct nl *p;
                    112: 
                    113:        p = lookup(s);
                    114:        if (p == NIL)
                    115:                return (NIL);
                    116:        if (bn != cbn) {
                    117:                error("Label %s not defined in correct block", s);
                    118:                return;
                    119:        }
                    120:        if ((p->nl_flags & NFORWD) == 0) {
                    121:                error("Label %s redefined", s);
                    122:                return;
                    123:        }
                    124:        p->nl_flags &= ~NFORWD;
                    125:        patch4(p->entloc);
                    126:        if (p->value[NL_GOLEV] != NOTYET)
                    127:                if (p->value[NL_GOLEV] < level) {
                    128:                        recovered();
                    129:                        error("Goto %s from line %d is into a structured statement", s, p->value[NL_GOLINE]);
                    130:                }
                    131:        p->value[NL_GOLEV] = level;
                    132: }
                    133: #endif

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