# 2.11BSD#431 - /usr/src/ucb/PORT/pascal/pdx/tree/build.c

##### Functions

    build             X

##### Macros

    nextarg           X

##### typedef's

    ARGLIST           X

       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[] = "@(#)build.c	5.1 (Berkeley) 6/6/85";
       9: #endif not lint
      10: /*
      11:  * parse tree building routines
      12:  *
      13:  * Semantics is not checked here, this is done by the "treetype" routine
      14:  * in the SYM directory which returns the type of the newly built tree.
      15:  */
      16:
      17: #include "defs.h"
      18: #include "tree.h"
      19: #include "sym.h"
      20: #include "source.h"
      21: #include "tree.rep"
      22:
      23: /*
      24:  * header for using routines with unknown number and types of arguments
      25:  * I didn't like the looks of the standard varargs.h.
      26:  */
      27:
      28: typedef char *ARGLIST;
      29:
      30: #define nextarg(arglist, type)  ((type *) (arglist += sizeof(type)))[-1]
      31:
      32: /*
      33:  * build a tree
      34:  */
      35:
      36: /*VARARGS1*/
      37: NODE *build(op, args)
      38: OP op;
      39: {
      40:     register NODE *p;
      41:     NODE *p1, *p2;
      42:     register ARGLIST ap;
      43:     SYM *s;
      44:
      45:     p = alloc(1, NODE);
      46:     p->op = op;
      47:     ap = (ARGLIST) &args;
      48:     switch(degree(op)) {
      49:         case BINARY:
      50:             p->left = p1 = nextarg(ap, NODE *);
      51:             p->right = p2 = nextarg(ap, NODE *);
      52:             break;
      53:
      54:         case UNARY:
      55:             p->left = p1 = nextarg(ap, NODE *);
      56:             p->right = NIL;
      57:             break;
      58:
      59:     }
      60:     switch(op) {
      61:         case O_NAME:
      62:         case O_WHICH:
      63:             p->nameval = nextarg(ap, SYM *);
      64:             break;
      65:
      66:         case O_LCON:
      67:             p->lconval = nextarg(ap, long);
      68:             break;
      69:
      70:         case O_FCON:
      71:             p->fconval = nextarg(ap, double);
      72:             break;
      73:
      74:         case O_SCON:
      75:             p->sconval = nextarg(ap, char *);
      76:             break;
      77:
      78:         case O_CALL:
      79:             p->left = nextarg(ap, NODE *);
      80:             p->right = nextarg(ap, NODE *);
      81:             break;
      82:
      83:         case O_CHFILE:
      84:             p->sconval = nextarg(ap, char *);
      85:             break;
      86:
      87:         case O_EDIT:
      88:             p->sconval = nextarg(ap, char *);
      89:             if (p->sconval == NIL) {
      90:                 p->sconval = cursource;
      91:             }
      92:             break;
      93:
      94:         case O_SOURCE:
      95:             p->sconval = nextarg(ap, char *);
      96:             break;
      97:
      98:         case O_PRINT:
      99:         case O_WHATIS:
     100:         case O_LIST:
     101:         case O_XI:
     102:         case O_XD:
     103:             p->left = nextarg(ap, NODE *);
     104:             break;
     105:
     106:         case O_TRACE:
     107:         case O_TRACEI:
     108:         case O_STOP:
     109:         case O_STOPI:
     110:             p->what = nextarg(ap, NODE *);
     111:             p->where = nextarg(ap, NODE *);
     112:             p->cond = nextarg(ap, NODE *);
     113:             break;
     114:
     115:         case O_DELETE:
     116:             p->left = build(O_LCON, nextarg(ap, long));
     117:             break;
     118:
     119:         case O_QLINE: {
     120:             char *s;
     121:
     122:             s = nextarg(ap, char *);
     123:             p->left = alloc(1, NODE);
     124:             p->left->op = O_SCON;
     125:             if (s != cursource) {
     126:                 p->left->sconval = s;
     127:                 s[strlen(s) - 1] = '\0';
     128:             } else {
     129:                 p->left->sconval = strdup(s);
     130:             }
     131:             p->right = nextarg(ap, NODE *);
     132:             break;
     133:         }
     134:
     135:         case O_ALIAS:
     136:             p->left = alloc(1, NODE);
     137:             p->left->op = O_SCON;
     138:             p->left->sconval = nextarg(ap, char *);
     139:             p->right = alloc(1, NODE);
     140:             p->right->op = O_SCON;
     141:             p->right->sconval = nextarg(ap, char *);
     142:             break;
     143:
     144:         default:
     145:             if (op < O_NOP || op > O_LASTOP) {
     146:                 panic("build: bad op %d", op);
     147:             }
     148:             break;
     149:     }
     150:     p->nodetype = treetype(p, (ARGLIST) &args);
     151:     return(p);
     152: }

#### Defined functions

build defined in line 37; used 1 times

- in line 116

#### Defined variables

sccsid defined in line 8; never used

#### Defined typedef's

ARGLIST defined in line 28; used 3 times

- in line 42-47(2), 150

#### Defined macros

nextarg defined in line 30; used 21 times

- in line 50-55(3), 63-88(8), 95, 103, 110-116(4), 122, 131, 138-141(2)

Last modified: 1985-06-07 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 444 |