2.11BSD#431 - /usr/src/new/PORT/B/src/bed/bobj.c

   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
   2: static char rcsid[] = "$Header: bobj.c,v 2.5 85/08/22 15:59:59 timo Exp $";
   3: 
   4: /*
   5:  * B editor -- A shrunken version of the B interpreter's run-time system.
   6:  */
   7: 
   8: #include "b.h"
   9: #include "bobj.h"
  10: #include "node.h"
  11: 
  12: #define COMPOUNDS
  13: 
  14: string malloc();
  15: string calloc();
  16: string realloc();
  17: string strcpy();
  18: 
  19: extern bool dflag;
  20: 
  21: struct head {
  22:     char type;
  23:     intlet refcnt;
  24:     intlet len;
  25: };
  26: #define Intsize (sizeof(int))
  27: #define Hsize (sizeof(struct head))
  28: #define Headsize (((Hsize-1)/Intsize + 1) * Intsize)
  29: 
  30: #define Field(v, i) (((value *)&(v)->cts)[i])
  31: 
  32: #ifndef NDEBUG
  33: 
  34: /* Statistics on allocation/sharing */
  35: 
  36: int nobjs;
  37: int nrefs;
  38: 
  39: #define Increfs ++nrefs
  40: #define Decrefs --nrefs
  41: 
  42: #else NDEBUG
  43: 
  44: #define Increfs
  45: #define Decrefs
  46: 
  47: #endif NDEBUG
  48: 
  49: 
  50: #define Copy(v) if ((v) && Refcnt(v) < Maxintlet) { ++Refcnt(v); Increfs; }
  51: #define Release(v) if (!(v) || Refcnt(v) == Maxintlet) ; else RRelease(v)
  52: #define RRelease(v) \
  53:     if (Refcnt(v) > 1) { --Refcnt(v); Decrefs; } else release(v)
  54: 
  55: 
  56: /*
  57:  * Allocate a value with nbytes of data after the usual type, len, refcnt
  58:  * fields.
  59:  */
  60: 
  61: value
  62: grabber(nbytes)
  63:     register int nbytes;
  64: {
  65:     register value v = (value) malloc((unsigned) (Headsize + nbytes));
  66: 
  67:     if (!v)
  68:         syserr("grabber: malloc");
  69: #ifndef NDEBUG
  70:     if (dflag)
  71:         newval(v);
  72: #endif
  73: #ifndef NDEBUG
  74:     ++nobjs;
  75: #endif
  76:     Increfs;
  77:     v->refcnt = 1;
  78:     return v;
  79: }
  80: 
  81: 
  82: /*
  83:  * Reallocate a value with nbytes of data after the usual type, len, refcnt
  84:  * fields.
  85:  */
  86: 
  87: value
  88: regrabber(v, nbytes)
  89:     register value v;
  90:     register int nbytes;
  91: {
  92:     Assert(v && v->refcnt == 1);
  93:     v = (value) realloc((char*)v, (unsigned) (Headsize + nbytes));
  94:     if (!v)
  95:         syserr("regrabber: realloc");
  96:     return v;
  97: }
  98: 
  99: 
 100: /*
 101:  * Set an object's refcnt to infinity, so it will never be released.
 102:  */
 103: 
 104: fix(v)
 105:     register value v;
 106: {
 107:     register int i;
 108:     register node n;
 109:     register path p;
 110: 
 111:     Assert(v->refcnt > 0);
 112: #ifndef NDEBUG
 113:     if (v->refcnt < Maxintlet)
 114:         nrefs -= v->refcnt;
 115: #endif
 116:     v->refcnt = Maxintlet;
 117: #if OBSOLETE
 118:     switch (v->type) {
 119:     case Tex:
 120:         break;
 121:     case Nod:
 122:         n = (node)v;
 123:         for (i = v->len - 1; i >= 0; --i)
 124:             if (n->n_child[i])
 125:                 fix((value)(n->n_child[i]));
 126:         break;
 127:     case Pat:
 128:         p = (path)v;
 129:         if (p->p_parent)
 130:             fix((value)(p->p_parent));
 131:         if (p->p_tree)
 132:             fix((value)(p->p_tree));
 133:         break;
 134: #ifdef COMPOUNDS
 135:     case Com:
 136:         for (i = v->len-1; i >= 0; --i)
 137:             if (Field(v, i))
 138:                 fix(Field(v, i));
 139:         break;
 140: #endif COMPOUNDS
 141: #ifdef SLOW_INTS
 142:     case Num:
 143: #endif SLOW_INTS
 144:     default:
 145:         Abort();
 146:     }
 147: #endif OBSOLETE
 148: }
 149: 
 150: 
 151: #ifdef COMPOUNDS
 152: /*
 153:  * Allocate a compound with n fields.
 154:  */
 155: 
 156: Visible value
 157: grab_com(n)
 158:     int n;
 159: {
 160:     value v = grabber(n*sizeof(value));
 161: 
 162:     v->type = Com;
 163:     v->len = n;
 164:     for (--n; n >= 0; --n)
 165:         Field(v, n) = Vnil;
 166:     return v;
 167: }
 168: #endif COMPOUNDS
 169: 
 170: 
 171: /*
 172:  * Allocate a node with nch children.
 173:  */
 174: 
 175: node
 176: grab_node(nch)
 177:     register int nch;
 178: {
 179:     register node n = (node) grabber(
 180:             sizeof(struct node) - Headsize +
 181:             sizeof(value) * (nch-1));
 182:     register int i;
 183: 
 184:     n->type = Nod;
 185:     n->len = nch;
 186:     n->n_marks = 0;
 187:     n->n_width = 0;
 188:     n->n_symbol = 0;
 189:     for (i = nch-1; i >= 0; --i)
 190:         n->n_child[i] = Nnil;
 191:     return n;
 192: }
 193: 
 194: 
 195: /*
 196:  * Allocate a path.
 197:  */
 198: 
 199: path
 200: grab_path()
 201: {
 202:     register path p = (path) grabber(
 203:             sizeof(struct path) - Headsize);
 204: 
 205:     p->type = Pat;
 206:     p->p_parent = Pnil;
 207:     p->p_tree = Nnil;
 208:     p->p_ichild = 0;
 209:     p->p_ycoord = 0;
 210:     p->p_xcoord = 0;
 211:     p->p_level = 0;
 212:     p->p_addmarks = 0;
 213:     p->p_delmarks = 0;
 214:     return p;
 215: }
 216: 
 217: 
 218: #ifdef SLOW_INTS
 219: /*
 220:  * Make an integer.
 221:  */
 222: 
 223: value
 224: mk_integer(i)
 225:     int i;
 226: {
 227:     value v;
 228:     static value tab[128];
 229: 
 230:     if (!i)
 231:         return Vnil;
 232:     if (!(i&~127) && tab[i])
 233:         return tab[i];
 234: 
 235:     v = grabber(sizeof(value));
 236:     v->type = Num;
 237:     Field(v, 0) = (value) i;
 238:     if (!(i&~127)) {
 239:         tab[i] = v;
 240:         v->refcnt = Maxintlet;
 241:     }
 242:     return v;
 243: }
 244: #endif SLOW_INTS
 245: 
 246: 
 247: /*
 248:  * Make a text object out of a C string.
 249:  */
 250: 
 251: value
 252: mk_text(str)
 253:     register string str;
 254: {
 255:     register int len = strlen(str);
 256:     register value v = grabber(len+1);
 257: 
 258:     v->type = Tex;
 259:     v->len = len;
 260:     strcpy(Str(v), str);
 261:     return v;
 262: }
 263: 
 264: 
 265: /*
 266:  * Concatenate a C string to a text object (at the end).
 267:  */
 268: 
 269: concato(pv, str)
 270:     register value *pv;
 271:     register string str;
 272: {
 273:     register value v = *pv;
 274:     register int vlen = v->len;
 275:     register int len = strlen(str);
 276: 
 277:     Assert(v && v->refcnt > 0);
 278:     if (!len)
 279:         return;
 280: 
 281:     len += vlen;
 282:     if (v->refcnt == 1)
 283:         v = regrabber(v, len+1);
 284:     else {
 285:         v = grabber(len+1);
 286:         v->type = Tex;
 287:         strcpy(Str(v), Str(*pv));
 288:         Release(*pv);
 289:     }
 290:     strcpy(Str(v) + vlen, str);
 291:     v->len = len;
 292:     *pv = v;
 293: }
 294: 
 295: 
 296: /*
 297:  * Return a substring (trim) of a text object.
 298:  */
 299: 
 300: value
 301: trim(v, behead, curtail)
 302:     register value v;
 303:     register int behead;
 304:     register int curtail;
 305: {
 306:     register value w;
 307:     register int c;
 308: 
 309:     Assert(v && v->refcnt > 0);
 310:     Assert(behead >= 0 && curtail >= 0 && behead+curtail <= v->len);
 311:     if (behead + curtail == 0) {
 312:         Copy(v);
 313:         return v;
 314:     }
 315: 
 316:     c = Str(v)[v->len - curtail];
 317:     Str(v)[v->len - curtail] = 0; /* TEMPORARILY */
 318:     w = mk_text(Str(v) + behead);
 319:     Str(v)[v->len - curtail] = c;
 320:     return w;
 321: }
 322: 
 323: 
 324: #ifdef SLOW_INTS
 325: /*
 326:  * Return the C value if an integer object.
 327:  */
 328: 
 329: int
 330: intval(v)
 331:     register value v;
 332: {
 333:     if (!v)
 334:         return 0;
 335:     return (int) Field(v, 0);
 336: }
 337: #endif SLOW_INTS
 338: 
 339: 
 340: /*
 341:  * Make sure a location (pointer variable) contains a unique object.
 342:  */
 343: 
 344: uniql(pv)
 345:     register value *pv;
 346: {
 347:     register value v = *pv;
 348:     register value w;
 349:     register path p;
 350:     register node n;
 351:     register int i;
 352: 
 353:     Assert(v && v->refcnt > 0);
 354:     if (v->refcnt == 1)
 355:         return;
 356: 
 357:     switch (v->type) {
 358: 
 359:     case Nod:
 360:         n = grab_node(v->len);
 361:         for (i = v->len - 1; i >= 0; --i) {
 362:             w = (value) (n->n_child[i] = ((node)v)->n_child[i]);
 363:             Copy(w); /* This is ugly */
 364:         }
 365:         n->n_marks = ((node)v)->n_marks;
 366:         n->n_width = ((node)v)->n_width;
 367:         n->n_symbol = ((node)v)->n_symbol;
 368:         w = (value)n;
 369:         break;
 370: 
 371:     case Pat:
 372:         p = grab_path();
 373:         p->p_parent = ((path)v)->p_parent;
 374:         Copy(p->p_parent);
 375:         p->p_tree = ((path)v)->p_tree;
 376:         Copy(p->p_tree);
 377:         p->p_ichild = ((path)v)->p_ichild;
 378:         p->p_ycoord = ((path)v)->p_ycoord;
 379:         p->p_xcoord = ((path)v)->p_xcoord;
 380:         p->p_level = ((path)v)->p_level;
 381:         w = (value)p;
 382:         break;
 383: 
 384: #ifdef SLOW_INTS
 385:     case Num:
 386:         w = mk_integer(intval(v));
 387:         break;
 388: #endif SLOW_INTS
 389: 
 390: #ifdef COMPOUNDS
 391:     case Com:
 392:         w = grab_com(v->len);
 393:         for (i = v->len - 1; i >= 0; --i) {
 394:             n = (node) (Field(w, i) = Field(v, i));
 395:             Copy(n); /* This is uglier */
 396:         }
 397:         break;
 398: #endif COMPOUNDS
 399: 
 400:     case Tex:
 401:         w = mk_text(Str(v));
 402:         break;
 403: 
 404:     default:
 405:         Abort();
 406: 
 407:     }
 408:     Release(v);
 409:     *pv = w;
 410: }
 411: 
 412: 
 413: /*
 414:  * Increase the reference count of an object, unless it is infinite.
 415:  */
 416: 
 417: value
 418: copy(v)
 419:     value v;
 420: {
 421:     if (!v)
 422:         return v;
 423: 
 424:     Assert(v->refcnt > 0);
 425:     if (v->refcnt < Maxintlet) {
 426:         ++v->refcnt;
 427:         Increfs;
 428:     }
 429:     return v;
 430: }
 431: 
 432: 
 433: /*
 434:  * Decrease the reference count of an object, unless it is infinite.
 435:  * If it reaches zero, free the storage occupied by the object.
 436:  */
 437: 
 438: release(v)
 439:     register value v;
 440: {
 441:     register int i;
 442:     register value w;
 443: 
 444:     if (!v)
 445:         return;
 446:     Assert(v->refcnt > 0);
 447:     if (v->refcnt == Maxintlet)
 448:         return;
 449: 
 450:     Decrefs;
 451:     --v->refcnt;
 452:     if (v->refcnt == 0) {
 453:         switch (v->type) {
 454: #ifdef SLOW_INTS
 455:         case Num:
 456: #endif SLOW_INTS
 457:         case Tex:
 458:             break;
 459: #ifdef COMPOUNDS
 460:         case Com:
 461:             for (i = v->len - 1; i >= 0; --i) {
 462:                 w = Field(v, i);
 463:                 Release(w);
 464:             }
 465:             break;
 466: #endif COMPOUNDS
 467:         case Nod:
 468:             for (i = v->len - 1; i >= 0; --i) {
 469:                 w = (value)(((node)v)->n_child[i]);
 470:                 Release(w);
 471:             }
 472:             break;
 473:         case Pat:
 474:             w = (value)(((path)v)->p_parent);
 475:             Release(w);
 476:             w = (value)(((path)v)->p_tree);
 477:             Release(w);
 478:             break;
 479:         default:
 480:             Abort();
 481:         }
 482: #ifndef NDEBUG
 483:         if (dflag)
 484:             delval(v);
 485:         --nobjs;
 486: #endif NDEBUG
 487:         free((string)v);
 488:     }
 489: }
 490: 
 491: objstats()
 492: {
 493: #ifndef NDEBUG
 494:     fprintf(stderr, "*** Object statistics: %d objects, %d references\n",
 495:         nobjs, nrefs);
 496: #ifdef MSTATS
 497:     mstats("(at end)"); /* A routine which some malloc versions have to print
 498: 	             memory statistics. Remove if your malloc hasn't. */
 499: #endif MSTATS
 500: #endif NDEBUG
 501: }
 502: 
 503: #ifndef NDEBUG
 504: valdump(v)
 505:     value v;
 506: {
 507:     if (!v)
 508:         fputs("(nil)", stderr);
 509:     else {
 510:         fprintf(stderr, "v=0x%x, type='%c', len=%d, refcnt=",
 511:             v, v->type, v->len);
 512:         if (v->refcnt == Maxintlet)
 513:             putc('*', stderr);
 514:         else
 515:             fprintf(stderr, "%d", v->refcnt);
 516:         fputs(": ", stderr);
 517:         wrval(v);
 518: 
 519:     }
 520:     putc('\n', stderr);
 521: }
 522: 
 523: #define QUOTE '\''
 524: 
 525: wrval(v)
 526:     value v;
 527: {
 528:     register string cp;
 529:     register int c;
 530: 
 531:     if (!v) {
 532:         fputs("nil", stderr);
 533:         return;
 534:     }
 535: 
 536:     switch (v->type) {
 537: 
 538: #ifdef SLOW_INTS
 539:     case Num:
 540:         fprintf(stderr, "%d", intval(v));
 541:         break;
 542: #endif SLOW_INTS
 543: 
 544:     case Tex:
 545:         putc(QUOTE, stderr);
 546:         for (cp = Str(v); c = *cp; ++cp) {
 547:             if (' ' <= c && c < 0177) {
 548:                 putc(c, stderr);
 549:                 if (c == QUOTE)
 550:                     putc(c, stderr);
 551:             }
 552:             else if (0 <= c && c < ' ')
 553:                 putc('^', stderr), putc(c + '@', stderr);
 554:             else
 555:                 fprintf(stderr, "\\%03o", c);
 556:         }
 557:         putc(QUOTE, stderr);
 558:         break;
 559: 
 560: #ifdef COMPOUNDS
 561:     case Com:
 562:       {
 563:         int i;
 564:         value f;
 565:         putc('(', stderr);
 566:         for (i = 0; i < v->len; ++i) {
 567:             if (i)
 568:                 putc(',', stderr), putc(' ', stderr);
 569:             f = Field(v, i);
 570:             if (!f || f->refcnt == 1 || f->type != Com) {
 571:                 if (f && f->type == Com)
 572:                     fprintf(stderr, "0x%x=", f);
 573:                 wrval(f);
 574:             }
 575:             else
 576:                 fprintf(stderr, "0x%x", f);
 577:         }
 578:         putc(')', stderr);
 579:         break;
 580:       }
 581: #endif COMPOUNDS
 582: 
 583:     default:
 584:         fprintf(stderr, "0x%x", v);
 585: 
 586:     }
 587: }
 588: 
 589: static struct list {
 590:     struct list *link;
 591:     value val;
 592: } head;
 593: #endif NDEBUG
 594: 
 595: objdump()
 596: {
 597: #ifndef NDEBUG
 598:     struct list *l;
 599: 
 600:     for (l = head.link; l; l = l->link)
 601:         valdump(l->val);
 602: #endif NDEBUG
 603: }
 604: 
 605: objcheck()
 606: {
 607: #ifndef NDEBUG
 608:     struct list *l;
 609: 
 610:     for (l = head.link; l; l = l->link)
 611:         if (l->val->refcnt != Maxintlet)
 612:             valdump(l->val);
 613: #endif NDEBUG
 614: }
 615: 
 616: #ifndef NDEBUG
 617: newval(v)
 618:     register value v;
 619: {
 620:     register struct list *l =
 621:             (struct list *) malloc((unsigned) sizeof(struct list));
 622: 
 623:     if (!l)
 624:         syserr("newval: malloc");
 625:     l->link = head.link;
 626:     l->val = v;
 627:     head.link = l;
 628: }
 629: 
 630: delval(v)
 631:     register value v;
 632: {
 633:     register struct list *l;
 634:     register struct list *p;
 635: 
 636:     for (p = &head, l = head.link; l; p = l, l = l->link) {
 637:         if (l->val == v) {
 638:             p->link = l->link;
 639:             free((string)l);
 640:             return;
 641:         }
 642:     }
 643:     Abort();
 644: }
 645: #endif NDEBUG

Defined functions

Defined variables

Defined struct's

Defined macros