# 2.11BSD#431 - /usr/src/new/PORT/B/src/bint/b1val.c

##### Functions

    ccopy             X
    ccopybtreenode    X
    copy              X
    copybtree         X
    fix_refcnt        X
    getsyze           X
    grab              X
    grab_com          X
    grab_elt          X
    grab_for          X
    grab_fun          X
    grab_how          X
    grab_lis          X
    grab_node         X
    grab_num          X
    grab_path         X
    grab_per          X
    grab_prd          X
    grab_ptn          X
    grab_rat          X
    grab_ref          X
    grab_sim          X
    grab_tab          X
    grab_tex          X
    grab_tlt          X
    grab_tri          X
    grab_tse          X
    grabbtreenode     X
    mknewroot         X
    prgr              X
    regrab_num        X
    relbtree          X
    release           X
    rrelease          X
    uniql             X
    uniqlbtreenode    X
    xtndlt            X
    xtndtex           X

##### Variables

    Visible           X
    gr                X
    node              X

##### Macros

    Adj               X
    Grabber           X
    Hdrsize           X
    Len               X
    NodOffset         X
    Regrabber         X
    Tsize             X
    Unadj             X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2:
       3: /*
       4:   $Header: b1val.c,v 1.4 85/08/22 16:53:49 timo Exp $
       5: */
       6:
       7: /* General operations for objects */
       8:
       9: #include "b.h"
      10: #include "b0con.h"
      11: #include "b1obj.h"
      12: #include "b1mem.h"
      13: #ifndef INTEGRATION
      14: #include "b1btr.h"
      15: #include "b1val.h"
      16: #endif
      17: #include "b1tlt.h"
      18: #include "b2nod.h" /* for _Nbranches */
      19: #include "b3scr.h" /* TEMPORARY for at_nwl */
      20: #include "b1num.h" /* for ccopy, rrelease, grab, grab_num, grab_rat, grab_approx */
      21: #ifdef INTEGRATION
      22: #include "node.h"
      23: #endif INTEGRATION
      24:
      25: #ifdef vax
      26: /* 4.2 BSD malloc already takes care of using a small number of sizes */
      27: #define Len len
      28: #else
      29: #define Len (len < 200 ? len : ((len-1)/8+1)*8)
      30: #endif
      31:
      32: #define Hdrsize (sizeof(struct value)-sizeof(string))
      33: #define Tsize (sizeof(a_telita))
      34: #define Adj(s) (unsigned) (Hdrsize+(s))
      35: #define Unadj(s) (unsigned) ((s)-Hdrsize)
      36: #define NodOffset (sizeof(int) + 2*sizeof(intlet))
      37:
      38: #define Grabber() {if(len>Maxintlet)syserr(MESS(1800, "big grabber"));}
      39: #define Regrabber() {if(len>Maxintlet)syserr(MESS(1801, "big regrabber"));}
      40:
      41: /*************************** Grabbing ***********************************/
      42:
      43: #ifdef NOT_USED
      44: long gr= 0;
      45:
      46: Visible Procedure prgr() {at_nwl=No;printf(" gr:%ld",gr);gr=0;}
      47: #endif
      48:
      49: Hidden unsigned
      50: getsyze(type, len, pnptrs)
      51:     literal type; intlet len; int *pnptrs;
      52: {
      53:     register unsigned syze= 0;
      54:     register int nptrs= 0;
      55:     switch (type) {
      56:     case Num:
      57:         if (len >= 0) syze= Len*sizeof(digit);     /* Integral */
      58:         else if (len == -1) {
      59: #ifdef EXT_RANGE
      60:             syze= 2*sizeof(double);        /* Approximate */
      61: #else
      62:             syze= sizeof(double);          /* Approximate */
      63: #endif
      64:         }
      65:         else { syze= 2*sizeof(value); nptrs= 2; }  /* Rational */
      66:         break;
      67:     case Ptn: len= _Nbranches(len);
      68:         syze= (len+2)*sizeof(value); nptrs= len; break;
      69:     case Com: syze= len*sizeof(value); nptrs= len; break;
      70:
      71:     case Sim: syze= sizeof(simploc); nptrs= 1; break;
      72:     case Tri: syze= sizeof(trimloc); nptrs= 3; break;
      73:     case Tse: syze= sizeof(tbseloc); nptrs= 2; break;
      74:     case How: syze= sizeof(how); nptrs= 1; break;
      75:     case For: syze= sizeof(formal); nptrs= 1; /*uname!*/ break;
      76:     case Per: syze= sizeof(per); nptrs= 1; break;
      77:     case Fun:
      78:     case Prd: syze= sizeof(funprd); nptrs= 1; break;
      79:     case Ref: syze= sizeof(ref); nptrs= 1; break;
      80: #ifndef INTEGRATION
      81:     case Tex:
      82:     case ELT:
      83:     case Lis:
      84:     case Tab: syze= sizeof(value); nptrs= 1; break;
      85: #else
      86:     case Tex: syze= (len+1)*sizeof(char); break;
      87:     case ELT:
      88:     case Lis:
      89:     case Tab: syze = Len*sizeof(value); nptrs= len; break;
      90:     case Pat: syze= sizeof(struct path) - Hdrsize; nptrs= 2; break;
      91:     case Nod: syze= sizeof(struct node) - Hdrsize - sizeof(node)
      92:             + len*sizeof(node);
      93:           nptrs= len; break;
      94: #endif
      95:     default:
      96:         printf("\ngetsyze{%c}\n", type);
      97:         syserr(MESS(1803, "getsyze called with unknown type"));
      98:     }
      99:     if (pnptrs != NULL) *pnptrs= nptrs;
     100:     return syze;
     101: }
     102:
     103: Hidden value
     104: grab(type, len)
     105:     literal type; intlet len;
     106: {
     107:     unsigned syze= getsyze(type, len, (int*)NULL);
     108:     value v;
     109:     Grabber();
     110:     v= (value) getmem(Adj(syze));
     111:     v->type= type; v->len= len; v->refcnt= 1;
     112: #ifdef NOT_USED
     113:  gr+=1;
     114: #endif
     115:     return v;
     116: }
     117:
     118: #ifndef INTEGRATION
     119:
     120: Visible value grab_tlt(type, it) literal type, it; { return grab(type, it); }
     121:
     122: #else
     123:
     124: Visible value grab_tex(len) intlet len; { return grab(Tex, len); }
     125:
     126: Visible value grab_elt() { return grab(ELT, 0); }
     127:
     128: Visible value grab_lis(len) intlet len; { return grab(Lis, len); }
     129:
     130: Visible value grab_tab(len) intlet len; { return grab(Tab, len); }
     131:
     132: #endif
     133:
     134: Visible value
     135: grab_num(len)
     136:     register int len;
     137: {
     138:     integer v;
     139:     register int i;
     140:
     141:     if (len > Maxintlet) {
     142:         error(MESS(1804, "exceptionally large number"));
     143:         return Vnil;
     144:     }
     145:     if (len < -Maxintlet) len = -2;
     146:     v = (integer) grab(Num, len);
     147:     for (i = Length(v)-1; i >= 0; --i) Digit(v, i) = 0;
     148:     return (value) v;
     149: }
     150:
     151: Visible value grab_rat() { return grab(Num, -2); }
     152:
     153: Visible value
     154: regrab_num(v, len)
     155:     value v; register int len;
     156: {
     157:     register unsigned syze;
     158:
     159:     syze = Len * sizeof(digit);
     160:     uniql(&v);
     161:     regetmem((ptr*)&v, Adj(syze));
     162:     Length(v) = len;
     163:     return v;
     164: }
     165:
     166: Visible value grab_com(len) intlet len; { return grab(Com, len); }
     167:
     168: Visible value grab_ptn(len) intlet len; { return grab(Ptn, len); }
     169:
     170: Visible value grab_sim() { return grab(Sim, 0); }
     171:
     172: Visible value grab_tri() { return grab(Tri, 0); }
     173:
     174: Visible value grab_tse() { return grab(Tse, 0); }
     175:
     176: Visible value grab_how() { return grab(How, 0); }
     177:
     178: Visible value grab_for() { return grab(For, 0); }
     179:
     180: Visible value grab_per() { return grab(Per, 0); }
     181:
     182: Visible value grab_fun() { return grab(Fun, 0); }
     183:
     184: Visible value grab_prd() { return grab(Prd, 0); }
     185:
     186: Visible value grab_ref() { return grab(Ref, 0); }
     187:
     188: #ifdef INTEGRATION
     189:
     190: /*
     191:  * Allocate a node with nch children.
     192:  */
     193:
     194: Visible node
     195: grab_node(nch)
     196:     register int nch;
     197: {
     198:     register node n = (node) grab(Nod, nch);
     199:     register int i;
     200:
     201:     n->n_marks = 0;
     202:     n->n_width = 0;
     203:     n->n_symbol = 0;
     204:     for (i = nch-1; i >= 0; --i)
     205:         n->n_child[i] = Nnil;
     206:     return n;
     207: }
     208:
     209: /*
     210:  * Allocate a path.
     211:  */
     212:
     213: Visible path
     214: grab_path()
     215: {
     216:     register path p = (path) grab(Pat, 0);
     217:
     218:     p->p_parent = PATHnil;
     219:     p->p_tree = Nnil;
     220:     p->p_ichild = 0;
     221:     p->p_ycoord = 0;
     222:     p->p_xcoord = 0;
     223:     p->p_level = 0;
     224:     p->p_addmarks = 0;
     225:     p->p_delmarks = 0;
     226:     return p;
     227: }
     228:
     229: #endif INTEGRATION
     230:
     231:
     232: /******************************* Copying and releasing *********************/
     233:
     234: Visible value
     235: copy(v)
     236:     value v;
     237: {
     238:     if (IsSmallInt(v)) return v;
     239:     if (v != Vnil && v->refcnt < Maxrefcnt) (v->refcnt)++;
     240: #ifdef NOT_USED
     241:  gr+=1;
     242: #endif
     243:     return v;
     244: }
     245:
     246: Visible Procedure
     247: release(v)
     248:     value v;
     249: {
     250: #ifdef IBMPC
     251:     literal *r;
     252: #else
     253:     intlet *r;
     254: #endif
     255:     if (IsSmallInt(v)) return;
     256:     if (v == Vnil) return;
     257:     r= &(v->refcnt);
     258:     if (*r == 0) syserr(MESS(1805, "releasing unreferenced value"));
     259:     if (bugs) {
     260:         printf("releasing: ");
     261:         if (Type(v) == Num) bugs= No;
     262:         wri(v,No,No,No); newline();
     263:         bugs= Yes;
     264:     }
     265:     if (*r < Maxrefcnt && --(*r) == 0) rrelease(v);
     266: #ifdef NOT_USED
     267:  gr-=1;
     268: #endif
     269: }
     270:
     271: Hidden value
     272: ccopy(v)
     273:     value v;
     274: {
     275:     literal type= v->type; intlet len; value w;
     276:     int nptrs; unsigned syze; register string from, to, end;
     277:     register value p, *pp, *pend;
     278:     len= Length(v);
     279:     syze= getsyze(type, len, &nptrs);
     280:     Grabber();
     281:     w= (value) getmem(Adj(syze));
     282:     w->type= type; w->len= len; w->refcnt= 1;
     283:     from= Str(v); to= Str(w); end= to+syze;
     284:     while (to < end) *to++ = *from++;
     285:     pp= Ats(w);
     286: #ifdef INTEGRATION
     287:     if (type == Nod) pp= (value*) ((char*)pp + NodOffset);
     288: #endif
     289:     pend= pp+nptrs;
     290:     while (pp < pend) {
     291:         p= *pp++;
     292:         if (p != Vnil && !IsSmallInt(p) && Refcnt(p) < Maxrefcnt)
     293:             ++Refcnt(p);
     294:     }
     295:     return w;
     296: }
     297:
     298: Visible Procedure
     299: uniql(ll)
     300:     value *ll;
     301: {
     302:     if (*ll != Vnil && !IsSmallInt(*ll) && (*ll)->refcnt > 1) {
     303:         value c= ccopy(*ll);
     304:         release(*ll);
     305:         *ll= c;
     306:     }
     307: }
     308:
     309: Hidden Procedure
     310: rrelease(v)
     311:     value v;
     312: {
     313:     literal type= v->type; intlet len;
     314:     int nptrs; register value *pp, *pend;
     315:     len= Length(v);
     316: #ifndef INTEGRATION
     317:     switch (type) {
     318:     case Tex:
     319:     case Tab:
     320:     case Lis:
     321:     case ELT:
     322:         relbtree(Root(v), Itemtype(v));
     323:         break;
     324:     default:
     325: #endif
     326:         VOID getsyze(type, len, &nptrs);
     327:         pp= Ats(v);
     328: #ifdef INTEGRATION
     329:         if (type == Nod) pp= (value*) ((char*)pp + NodOffset);
     330: #endif
     331:         pend= pp+nptrs;
     332:         while (pp < pend) release(*pp++);
     333: #ifndef INTEGRATION
     334:     }
     335: #endif
     336:     v->type= '\0'; freemem((ptr) v);
     337: }
     338:
     339: #ifdef INTEGRATION
     340:
     341: Visible Procedure
     342: xtndtex(a, d)
     343:     value *a; intlet d;
     344: {
     345:     intlet len= Length(*a)+d;
     346:     Regrabber();
     347:     regetmem((ptr *) a, Adj((len+1)*sizeof(char)));
     348:     (*a)->len= len;
     349: }
     350:
     351: Visible Procedure
     352: xtndlt(a, d)
     353:     value *a; intlet d;
     354: {
     355:     intlet len= Length(*a); intlet l1= Len, l2;
     356:     len+= d; l2= Len;
     357:     if (l1 != l2) {
     358:         Regrabber();
     359:         regetmem((ptr *) a, Adj(l2*sizeof(value)));
     360:     }
     361:     (*a)->len= len;
     362: }
     363:
     364: /*
     365:  * Set an object's refcnt to infinity, so it will never be released.
     366:  */
     367:
     368: Visible Procedure
     369: fix_refcnt(v)
     370:     register value v;
     371: {
     372:     register int i;
     373:     register node n;
     374:     register path p;
     375:
     376:     Assert(v->refcnt > 0);
     377:     v->refcnt = Maxrefcnt;
     378:     switch (v->type) {
     379:     case Tex:
     380:         break;
     381:     case Nod:
     382:         n = (node)v;
     383:         for (i = v->len - 1; i >= 0; --i)
     384:             if (n->n_child[i])
     385:                 fix_refcnt((value)(n->n_child[i]));
     386:         break;
     387:     case Pat:
     388:         p = (path)v;
     389:         if (p->p_parent)
     390:             fix_refcnt((value)(p->p_parent));
     391:         if (p->p_tree)
     392:             fix_refcnt((value)(p->p_tree));
     393:         break;
     394:     default:
     395:         Abort();
     396:     }
     397: }
     398:
     399: #endif INTEGRATION
     400:
     401: #ifndef INTEGRATION
     402:
     403: /*********************************************************************/
     404: /* grab, copy, release of btree(node)s
     405: /*********************************************************************/
     406:
     407: Visible btreeptr
     408: grabbtreenode(flag, it)
     409:     literal flag; literal it;
     410: {
     411:     btreeptr pnode; unsigned syz;
     412:     static intlet isize[]= {
     413:         sizeof(itexnode), sizeof(ilisnode),
     414:         sizeof(itabnode), sizeof(itabnode)};
     415:     static intlet bsize[]= {
     416:         sizeof(btexnode), sizeof(blisnode),
     417:         sizeof(btabnode), sizeof(btabnode)};
     418:     switch (flag) {
     419:     case Inner:
     420:         syz= isize[it];
     421:         break;
     422:     case Bottom:
     423:         syz= bsize[it];
     424:         break;
     425:     case Irange:
     426:     case Crange:
     427:         syz = sizeof(rangenode);
     428:         break;
     429:     }
     430:     pnode = (btreeptr) getmem((unsigned) syz);
     431:     Refcnt(pnode) = 1;
     432:     Flag(pnode) = flag;
     433:     return(pnode);
     434: }
     435:
     436: /* ----------------------------------------------------------------- */
     437:
     438: Visible btreeptr copybtree(pnode) btreeptr pnode; {
     439:     if (pnode != Bnil && Refcnt(pnode) < Maxrefcnt) ++Refcnt(pnode);
     440:     return(pnode);
     441: }
     442:
     443: Visible Procedure uniqlbtreenode(pptr, it) btreeptr *pptr; literal it; {
     444:     if (*pptr NE Bnil && Refcnt(*pptr) > 1) {
     445:         btreeptr qnode = *pptr;
     446:         *pptr = ccopybtreenode(*pptr, it);
     447:         relbtree(qnode, it);
     448:     }
     449: }
     450:
     451: Visible btreeptr ccopybtreenode(pnode, it) btreeptr pnode; literal it; {
     452:     intlet limp;
     453:     btreeptr qnode;
     454:     intlet iw;
     455:
     456:     iw = Itemwidth(it);
     457:     qnode = grabbtreenode(Flag(pnode), it);
     458:     Lim(qnode) = limp = Lim(pnode);
     459:     Size(qnode) = Size(pnode);
     460:     switch (Flag(qnode)) {
     461:     case Inner:
     462:         cpynitms(Piitm(qnode, 0, iw), Piitm(pnode, 0, iw), limp, it);
     463:         cpynptrs(&Ptr(qnode, 0), &Ptr(pnode, 0), limp+1);
     464:         break;
     465:      case Bottom:
     466:         cpynitms(Pbitm(qnode, 0, iw), Pbitm(pnode, 0, iw), limp, it);
     467:         break;
     468:     case Irange:
     469:     case Crange:
     470:         Lwbval(qnode) = copy(Lwbval(pnode));
     471:         Upbval(qnode) = copy(Upbval(pnode));
     472:         break;
     473:     default:
     474:         syserr(MESS(1808, "unknown flag in ccopybtreenode"));
     475:     }
     476:     return(qnode);
     477: }
     478:
     479: /* make a new root (after the old ptr0 split) */
     480:
     481: Visible btreeptr mknewroot(ptr0, pitm0, ptr1, it)
     482:     btreeptr ptr0, ptr1; itemptr pitm0; literal it;
     483: {
     484:     int r;
     485:     intlet iw = Itemwidth(it);
     486:     btreeptr qnode = grabbtreenode(Inner, it);
     487:     Ptr(qnode, 0) = ptr0;
     488:     movnitms(Piitm(qnode, 0, iw), pitm0, 1, iw);
     489:     Ptr(qnode, 1) = ptr1;
     490:     Lim(qnode) = 1;
     491:     r= Sincr(Size(ptr0));
     492:     Size(qnode) = Ssum(r, Size(ptr1));
     493:     return(qnode);
     494: }
     495:
     496: /* ----------------------------------------------------------------- */
     497:
     498: /* release btree */
     499:
     500: Visible Procedure relbtree(pnode, it) btreeptr pnode; literal it; {
     501:     width iw;
     502:
     503:     iw = Itemwidth(it);
     504:     if (pnode EQ Bnil)
     505:         return;
     506:     if (Refcnt(pnode) EQ 0) {
     507:         syserr(MESS(1809, "releasing unreferenced btreenode"));
     508:         return;
     509:     }
     510:     if (Refcnt(pnode) < Maxrefcnt && --Refcnt(pnode) EQ 0) {
     511:         intlet l;
     512:         switch (Flag(pnode)) {
     513:         case Inner:
     514:             for (l = 0; l < Lim(pnode); l++) {
     515:                 relbtree(Ptr(pnode, l), it);
     516:                 switch (it) {
     517:                 case Tt:
     518:                 case Kt:
     519:                     release(Ascval(Piitm(pnode, l, iw)));
     520:                 case Lt:
     521:                     release(Keyval(Piitm(pnode, l, iw)));
     522:                 }
     523:             }
     524:             relbtree(Ptr(pnode, l), it);
     525:             break;
     526:         case Bottom:
     527:             for (l = 0; l < Lim(pnode); l++) {
     528:                 switch (it) {
     529:                 case Tt:
     530:                 case Kt:
     531:                     release(Ascval(Pbitm(pnode, l, iw)));
     532:                 case Lt:
     533:                     release(Keyval(Pbitm(pnode, l, iw)));
     534:                 }
     535:             }
     536:             break;
     537:         case Irange:
     538:         case Crange:
     539:             release(Lwbval(pnode));
     540:             release(Upbval(pnode));
     541:             break;
     542:         default:
     543:             syserr(MESS(1810, "wrong flag in relbtree()"));
     544:         }
     545:         freemem((ptr) pnode);
     546:     }
     547: }
     548:
     549: #endif !INTEGRATION

#### Defined functions

ccopy defined in line 271; used 1 times

- in line 303

ccopybtreenode defined in line 451; used 2 times

- in line 446
- in /usr/src/new/PORT/B/src/bint/b1val.h line 16

copy defined in line 234; used 142 times

- in line 470-471(2)
- in /usr/src/new/PORT/B/src/bint/b1com.c line 113, 122(3), 131(2), 172, 181
- in /usr/src/new/PORT/B/src/bint/b1lta.c line 137-138(2), 279(2), 406-410(3), 435, 469, 545-546(2), 570, 618-619(2), 640-641(2), 681-689(4), 708-716(4), 938, 944, 970, 978, 1014, 1028, 1072, 1079-1080(2), 1108
- in /usr/src/new/PORT/B/src/bint/b1mem.c line 65
- in /usr/src/new/PORT/B/src/bint/b1nuR.c line 23
- in /usr/src/new/PORT/B/src/bint/b1num.h line 76-77(2)
- in /usr/src/new/PORT/B/src/bint/b1obj.c line 137-140(2)
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 53
- in /usr/src/new/PORT/B/src/bint/b1tex.c line 313, 334, 443, 573, 662
- in /usr/src/new/PORT/B/src/bint/b1tlt.c line 219, 261, 288, 311, 338, 429-430(2), 439, 482, 491, 503, 590-593(2)
- in /usr/src/new/PORT/B/src/bint/b2ana.c line 28, 36
- in /usr/src/new/PORT/B/src/bint/b2cmd.c line 201
- in /usr/src/new/PORT/B/src/bint/b2fix.c line 44, 85, 130
- in /usr/src/new/PORT/B/src/bint/b2gen.c line 423, 441, 512, 528, 558-566(4), 576, 591, 614
- in /usr/src/new/PORT/B/src/bint/b2stc.c line 174, 311, 518, 691
- in /usr/src/new/PORT/B/src/bint/b2tcE.c line 54, 129, 135, 143, 219
- in /usr/src/new/PORT/B/src/bint/b2tcP.c line 53, 145, 161
- in /usr/src/new/PORT/B/src/bint/b2uni.c line 74, 116, 146
- in /usr/src/new/PORT/B/src/bint/b3env.c line 36, 92
- in /usr/src/new/PORT/B/src/bint/b3err.c line 207, 233-237(2), 372
- in /usr/src/new/PORT/B/src/bint/b3in2.c line 73, 80, 151
- in /usr/src/new/PORT/B/src/bint/b3int.c line 252, 377
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 55, 86
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 143, 211, 254-258(2), 394, 400-404(2), 448, 477, 494, 540, 653, 695, 772, 787-788(2), 840-842(2)
- in /usr/src/new/PORT/B/src/bint/b3sta.c line 305, 372-377(2), 390, 422, 465-466(2), 490, 571, 595

copybtree defined in line 438; used 4 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 82, 327, 496
- in /usr/src/new/PORT/B/src/bint/b1val.h line 14

fix_refcnt defined in line 368; used 3 times

- in line 385-392(3)

getsyze defined in line 49; used 3 times

- in line 107, 279, 326

grab defined in line 103; used 20 times

- in line 120-130(5), 146-151(2), 166-186(11), 198, 216

grab_com defined in line 166; used 3 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 1078
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 38, 142

grab_elt defined in line 126; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 39
- in /usr/src/new/PORT/B/src/bint/b1tlt.c line 353

grab_for defined in line 178; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 47
- in /usr/src/new/PORT/B/src/bint/b3sta.c line 499

grab_fun defined in line 182; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 139
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 49

grab_how defined in line 176; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 161
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 46

grab_lis defined in line 128; used 6 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 942, 967, 991, 1023-1025(2)
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 40

grab_node defined in line 194; never used
grab_num defined in line 134; used 10 times

- in /usr/src/new/PORT/B/src/bint/b1nuA.c line 55
- in /usr/src/new/PORT/B/src/bint/b1nuC.c line 227
- in /usr/src/new/PORT/B/src/bint/b1nuI.c line 149, 173, 239, 282
- in /usr/src/new/PORT/B/src/bint/b1nuQ.c line 24, 51, 129
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 34

grab_path defined in line 213; never used
grab_per defined in line 180; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 180
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 48

grab_prd defined in line 184; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 150
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 50

grab_ptn defined in line 168; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 30
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 42

grab_rat defined in line 151; used 6 times

- in /usr/src/new/PORT/B/src/bint/b1nuR.c line 52, 159, 235, 272-276(2)
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 36

grab_ref defined in line 186; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 171
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 51

grab_sim defined in line 170; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 112
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 43

grab_tab defined in line 130; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 1105
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 41

grab_tex defined in line 124; used 9 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 37
- in /usr/src/new/PORT/B/src/bint/b1tex.c line 492, 517-521(2), 550-555(2), 603, 612, 625

grab_tlt defined in line 120; used 11 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 495, 613, 632
- in /usr/src/new/PORT/B/src/bint/b1tex.c line 136, 286, 294, 303, 311, 335
- in /usr/src/new/PORT/B/src/bint/b1tlt.c line 27
- in /usr/src/new/PORT/B/src/bint/b1val.h line 11

grab_tri defined in line 172; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 121
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 44

grab_tse defined in line 174; used 2 times

- in /usr/src/new/PORT/B/src/bint/b1com.c line 130
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 45

grabbtreenode defined in line 407; used 11 times

- in line 457, 486
- in /usr/src/new/PORT/B/src/bint/b1lta.c line 182, 338, 360, 617, 637
- in /usr/src/new/PORT/B/src/bint/b1tex.c line 111, 251, 265
- in /usr/src/new/PORT/B/src/bint/b1val.h line 13

mknewroot defined in line 481; used 3 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 387
- in /usr/src/new/PORT/B/src/bint/b1tex.c line 275
- in /usr/src/new/PORT/B/src/bint/b1val.h line 17

prgr defined in line 46; never used
regrab_num defined in line 153; used 4 times

- in /usr/src/new/PORT/B/src/bint/b1nuG.c line 103
- in /usr/src/new/PORT/B/src/bint/b1nuI.c line 94, 247
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 35

relbtree defined in line 500; used 6 times

- in line 322, 447, 515, 524
- in /usr/src/new/PORT/B/src/bint/b1lta.c line 167, 328

release defined in line 246; used 466 times

- in line 304, 332, 519-521(2), 531-533(2), 539-540(2)
- in /usr/src/new/PORT/B/src/bint/b1fun.c line 60-65(3), 79-80(2), 185-189(3), 212-215(2), 227, 238, 249-250(3), 264-268(3), 292-295(2), 310-312(2), 329, 367-370(3), 379, 522, 536-537(3), 554, 583, 591, 598, 607(2), 615(2)
- in /usr/src/new/PORT/B/src/bint/b1lta.c line 269-274(2), 280, 287-290(3), 312-313(2), 405, 519-524(3), 575, 663-664(2), 941, 960, 966, 983-985(2), 1071, 1099-1104(2)
- in /usr/src/new/PORT/B/src/bint/b1mem.c line 36, 53, 82-83(2)
- in /usr/src/new/PORT/B/src/bint/b1nuA.c line 208(3), 246(3)
- in /usr/src/new/PORT/B/src/bint/b1nuC.c line 58, 71, 84-94(6), 259, 285-291(3)
- in /usr/src/new/PORT/B/src/bint/b1nuG.c line 64, 172-178(3), 185-186(2)
- in /usr/src/new/PORT/B/src/bint/b1nuI.c line 70, 76, 83-88(2), 257
- in /usr/src/new/PORT/B/src/bint/b1nuQ.c line 188-204(6), 226, 232
- in /usr/src/new/PORT/B/src/bint/b1nuR.c line 65, 74-77(3), 98-99(4), 114-115(4), 128(2), 146(2), 205-210(2), 221-226(2), 232-234(3), 267(2), 282-283(2)
- in /usr/src/new/PORT/B/src/bint/b1num.c line 126, 166, 176, 184, 195, 213, 234
- in /usr/src/new/PORT/B/src/bint/b1obj.c line 31-33(7), 102, 109, 128, 146-149(2), 158-164(3), 174-179(4), 190-203(8), 226-235(5)
- in /usr/src/new/PORT/B/src/bint/b1tex.c line 317, 323-325(2), 341-344(2), 400, 537(2), 578, 635, 680, 689, 699-702(2)
- in /usr/src/new/PORT/B/src/bint/b1tlt.c line 62-63(2), 69, 260, 275, 287, 310, 337
- in /usr/src/new/PORT/B/src/bint/b2ana.c line 44-52(6)
- in /usr/src/new/PORT/B/src/bint/b2cmd.c line 157(2), 204, 340
- in /usr/src/new/PORT/B/src/bint/b2dis.c line 194(2), 226, 279-283(2)
- in /usr/src/new/PORT/B/src/bint/b2exp.c line 264, 552, 590, 602
- in /usr/src/new/PORT/B/src/bint/b2fix.c line 34, 57, 69-71(4), 133, 213
- in /usr/src/new/PORT/B/src/bint/b2gen.c line 522, 578, 586, 593, 609, 616, 631
- in /usr/src/new/PORT/B/src/bint/b2stc.c line 156, 175-178(2), 358, 597(2)
- in /usr/src/new/PORT/B/src/bint/b2syn.c line 342-347(2)
- in /usr/src/new/PORT/B/src/bint/b2tcE.c line 38, 58, 66(2), 75, 208, 229-231(4)
- in /usr/src/new/PORT/B/src/bint/b2tcP.c line 155, 165, 292
- in /usr/src/new/PORT/B/src/bint/b2tes.c line 180-183(3)
- in /usr/src/new/PORT/B/src/bint/b2uni.c line 41, 68, 81-83(2), 124-126(2), 154-156(2), 202, 214, 226, 310, 326
- in /usr/src/new/PORT/B/src/bint/b3env.c line 46, 67-70(4), 91, 102, 144
- in /usr/src/new/PORT/B/src/bint/b3err.c line 202-206(2), 284, 399
- in /usr/src/new/PORT/B/src/bint/b3fil.c line 272
- in /usr/src/new/PORT/B/src/bint/b3fpr.c line 113(3), 127(3)
- in /usr/src/new/PORT/B/src/bint/b3in2.c line 47, 64, 125-127(2), 163-165(3)
- in /usr/src/new/PORT/B/src/bint/b3int.c line 30-34(6), 40-41(3), 106, 127-133(6), 157(2), 172, 228(2), 234(2), 240, 246-251(3), 260-264(3), 276, 290(2), 314(2), 325(2), 331, 337(2)
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 56, 110-111(2), 117-121(5), 140-141(2), 148-152(5), 314-317(6), 324
- in /usr/src/new/PORT/B/src/bint/b3mai.c line 97-101(2), 291(2), 297, 305(2)
- in /usr/src/new/PORT/B/src/bint/b3scr.c line 99, 127, 151, 393, 409, 418, 426, 441
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 70, 105, 149, 161, 171, 183, 211-216(4), 232, 279, 296, 317(2), 329-330(2), 339(2), 353-355(3), 400-404(2), 414-416(4), 448, 457-460(2), 483, 494, 500-501(6), 555, 620, 634, 658-660(2), 691-699(4), 717, 747, 766, 774(2), 794-800(7), 820, 836, 847-849(4), 855, 870-873(4), 892
- in /usr/src/new/PORT/B/src/bint/b3sta.c line 268, 344, 364, 384, 398-400(2), 415, 422-425(2), 464, 538, 594, 604
- in /usr/src/new/PORT/B/src/bint/b3typ.c line 24, 40, 67(2), 76(2), 100(2)

rrelease defined in line 309; used 1 times

- in line 265

uniql defined in line 298; used 16 times

- in line 160
- in /usr/src/new/PORT/B/src/bint/b1lta.c line 218, 481, 1052-1053(2), 1060, 1068-1070(2)
- in /usr/src/new/PORT/B/src/bint/b1nuG.c line 74, 92
- in /usr/src/new/PORT/B/src/bint/b3env.c line 90, 102
- in /usr/src/new/PORT/B/src/bint/b3in2.c line 157
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 48-51(2), 58

uniqlbtreenode defined in line 443; used 3 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 222, 305, 346

xtndlt defined in line 351; used 4 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 935, 962, 1075, 1101

xtndtex defined in line 341; used 1 times

- in /usr/src/new/PORT/B/src/bint/b1tex.c line 531

#### Defined variables

Visible defined in line 194; never used
gr defined in line 44; used 5 times

- in line 46(2), 113, 241, 267

node defined in line 194; used 6 times

- in line 91-92(2), 198(2), 373, 382

#### Defined macros

Adj defined in line 34; used 5 times

- in line 110, 161, 281, 347, 359

Grabber defined in line 38; used 2 times

- in line 109, 280

Hdrsize defined in line 32; used 4 times

- in line 34-35(2), 90-91(2)

Len defined in line 29; used 5 times

- in line 57, 89, 159, 355-356(2)

NodOffset defined in line 36; used 2 times

- in line 287, 329

Regrabber defined in line 39; used 2 times

- in line 346, 358

Tsize defined in line 33; never used
Unadj defined in line 35; never used

Last modified: 1985-08-27 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1773 |