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

##### Functions

    copystr           X
    inittree          X
    tralloc           X
    tree              X
    trfree            X

##### Variables

    space             X
    spacep            X
    tract             X
    trspace           X
    ttab              X

##### Macros

    TREENMAX          X

##### struct's

    tr                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[] = "@(#)tree.c	5.1 (Berkeley) 6/5/85";
       9: #endif not lint
      10:
      11: #include "whoami.h"
      12: #include "0.h"
      13:
      14: /*
      15:  * TREE SPACE DECLARATIONS
      16:  */
      17: struct tr {
      18:     int *tr_low;
      19:     int *tr_high;
      20: } ttab[MAXTREE], *tract;
      21:
      22: /*
      23:  * The variable space is the
      24:  * absolute base of the tree segments.
      25:  * (exactly the same as ttab[0].tr_low)
      26:  * Spacep is maintained to point at the
      27:  * beginning of the next tree slot to
      28:  * be allocated for use by the grammar.
      29:  * Spacep is used "extern" by the semantic
      30:  * actions in pas.y.
      31:  * The variable tract is maintained to point
      32:  * at the tree segment out of which we are
      33:  * allocating (the active segment).
      34:  */
      35: int *space, *spacep;
      36:
      37: /*
      38:  * TREENMAX is the maximum width
      39:  * in words that any tree node
      40:  * due to the way in which the parser uses
      41:  * the pointer spacep.
      42:  */
      43: #define TREENMAX    6
      44:
      45: int trspace[ITREE];
      46: int *space  = trspace;
      47: int *spacep = trspace;
      48: struct  tr *tract   = ttab;
      49:
      50: /*
      51:  * Inittree allocates the first tree slot
      52:  * and sets up the first segment descriptor.
      53:  * A lot of this work is actually done statically
      54:  * above.
      55:  */
      56: inittree()
      57: {
      58:
      59:     ttab[0].tr_low = space;
      60:     ttab[0].tr_high = &space[ITREE];
      61: }
      62:
      63: /*
      64:  * Tree builds the nodes in the
      65:  * parse tree. It is rarely called
      66:  * directly, rather calls are made
      67:  * to tree[12345] which supplies the
      68:  * first argument to save space in
      69:  * the code. Tree also guarantees
      70:  * that spacep points to the beginning
      71:  * of the next slot it will return,
      72:  * a property required by the parser
      73:  * which was always true before we
      74:  * segmented the tree space.
      75:  */
      76: /*VARARGS1*/
      77: struct tnode *
      78: tree(cnt, a)
      79:     int cnt;
      80: {
      81:     register int *p, *q;
      82:     register int i;
      83:
      84:     i = cnt;
      85:     p = spacep;
      86:     q = &a;
      87:     do
      88:         *p++ = *q++;
      89:     while (--i);
      90:     q = spacep;
      91:     spacep = p;
      92:     if (p+TREENMAX >= tract->tr_high)
      93:         /*
      94: 		 * this peek-ahead should
      95: 		 * save a great number of calls
      96: 		 * to tralloc.
      97: 		 */
      98:         tralloc(TREENMAX);
      99:     return ((struct tnode *) q);
     100: }
     101:
     102: /*
     103:  * Tralloc preallocates enough
     104:  * space in the tree to allow
     105:  * the grammar to use the variable
     106:  * spacep, as it did before the
     107:  * tree was segmented.
     108:  */
     109: tralloc(howmuch)
     110: {
     111:     register char *cp;
     112:     register i;
     113:
     114:     if (spacep + howmuch >= tract->tr_high) {
     115:         i = TRINC;
     116:         cp = malloc((unsigned) (i * sizeof ( int )));
     117:         if (cp == 0) {
     118:             yerror("Ran out of memory (tralloc)");
     119:             pexit(DIED);
     120:         }
     121:         spacep = (int *) cp;
     122:         tract++;
     123:         if (tract >= &ttab[MAXTREE]) {
     124:             yerror("Ran out of tree tables");
     125:             pexit(DIED);
     126:         }
     127:         tract->tr_low = (int *) cp;
     128:         tract->tr_high = tract->tr_low+i;
     129:     }
     130: }
     131:
     132: extern  int yylacnt;
     133: extern  struct B *bottled;
     134: #ifdef PXP
     135: #endif
     136: /*
     137:  * Free up the tree segments
     138:  * at the end of a block.
     139:  * If there is scanner lookahead,
     140:  * i.e. if yylacnt != 0 or there is bottled output, then we
     141:  * cannot free the tree space.
     142:  * This happens only when errors
     143:  * occur and the forward move extends
     144:  * across "units".
     145:  */
     146: trfree()
     147: {
     148:
     149:     if (yylacnt != 0 || bottled != NIL)
     150:         return;
     151: #ifdef PXP
     152:     if (needtree())
     153:         return;
     154: #endif
     155:     spacep = space;
     156:     while (tract->tr_low > spacep || tract->tr_high <= spacep) {
     157:         free((char *) tract->tr_low);
     158:         tract->tr_low = NIL;
     159:         tract->tr_high = NIL;
     160:         tract--;
     161:         if (tract < ttab)
     162:             panic("ttab");
     163:     }
     164: #ifdef PXP
     165:     packtree();
     166: #endif
     167: }
     168:
     169: /*
     170:  * Copystr copies a token from
     171:  * the "token" buffer into the
     172:  * tree space.
     173:  */
     174: copystr(token)
     175:     register char *token;
     176: {
     177:     register char *cp;
     178:     register int i;
     179:
     180:     i = (strlen(token) + sizeof ( int )) & ~( ( sizeof ( int ) ) - 1 );
     181:     tralloc(i / sizeof ( int ));
     182:     (void) pstrcpy((char *) spacep, token);
     183:     cp = (char *) spacep;
     184:     spacep = ((int *) cp + i);
     185:     tralloc(TREENMAX);
     186:     return ((int) cp);
     187: }

#### Defined functions

copystr defined in line 174; used 4 times

- in /usr/src/ucb/PORT/pascal/src/yylex.c line 128, 136, 174, 210

inittree defined in line 56; used 1 times

- in /usr/src/ucb/PORT/pascal/src/yymain.c line 62

tralloc defined in line 109; used 3 times

- in line 98, 181-185(2)

tree defined in line 77; used 7 times

- in /usr/src/ucb/PORT/pascal/src/0.h line 771
- in /usr/src/ucb/PORT/pascal/src/treen.c line 22, 29, 37, 45, 53
- in /usr/src/ucb/PORT/pascal/src/yyput.c line 54

trfree defined in line 146; used 3 times

- in /usr/src/ucb/PORT/pascal/src/pas.y line 169-178(3)

#### Defined variables

sccsid defined in line 8; never used
space defined in line 46; used 3 times

- in line 59-60(2), 155

spacep defined in line 47; used 13 times

- in line 85-91(3), 114, 121, 155-156(3), 182-184(3)
- in /usr/src/ucb/PORT/pascal/src/yytree.c line 66, 84

tract defined in line 48; used 14 times

- in line 92, 114, 122-128(5), 156-161(7)

trspace defined in line 45; used 2 times

- in line 46-47(2)

ttab defined in line 20; used 5 times

- in line 48, 59-60(2), 123, 161

#### Defined struct's

tr defined in line 17; used 2 times

- in line 48(2)

#### Defined macros

TREENMAX defined in line 43; used 3 times

- in line 92, 98, 185

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