4.3BSD - /usr/src/new/B/src/bint/b1tlt.c

   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2: 
   3: /*
   4:   $Header: b1tlt.c,v 1.4 85/08/22 16:53:20 timo Exp $
   5: */
   6: 
   7: /* generic routines for B texts, lists and tables */
   8: 
   9: #include "b.h"
  10: #include "b0fea.h"
  11: #include "b1obj.h"
  12: #ifndef INTEGRATION
  13: #include "b0con.h"
  14: #include "b1btr.h"
  15: #include "b1val.h"
  16: #endif
  17: #include "b1tlt.h"
  18: #include "b3err.h"
  19: 
  20: #ifndef INTEGRATION
  21: 
  22: /* From b1lta.c */
  23: int l2size();
  24: value l2min(), l2max();
  25: 
  26: Visible value mk_elt() { /* {}, internal only */
  27:     value e = grab_tlt(ELT, Lt);
  28:     Root(e) = Bnil;
  29:     return e;
  30: }
  31: 
  32: Visible bool empty(v) value v; { /* #v=0, internal only */
  33:     switch (Type(v)) {
  34:     case ELT:
  35:     case Lis:
  36:     case Tex:
  37:     case Tab:
  38:         return Root(v) EQ Bnil;
  39:     default:
  40:         return No;
  41:         /* Some routines must test empty(t) end return an error
  42: 		   message if it fails, before testing Type(t).
  43: 		   In this way, they won't give the wrong error message. */
  44:     }
  45: }
  46: 
  47: /* return size of (number of items in) dependent tree */
  48: 
  49: Hidden value treesize(pnode) btreeptr pnode; {
  50:     int psize;
  51:     value vsize, childsize, u;
  52:     intlet l;
  53:     psize = Size(pnode);
  54:     if (psize EQ Bigsize) {
  55:     switch (Flag(pnode)) {
  56:     case Inner:
  57:         vsize = mk_integer((int) Lim(pnode));
  58:         for (l = 0; l <= Lim(pnode); l++) {
  59:         childsize = treesize(Ptr(pnode, l));
  60:         u = vsize;
  61:         vsize = sum(vsize, childsize);
  62:         release(u);
  63:         release(childsize);
  64:         }
  65:         break;
  66:     case Irange:
  67:         u = diff(Upbval(pnode), Lwbval(pnode));
  68:         vsize = sum(u, one);
  69:         release(u);
  70:         break;
  71:     case Bottom:
  72:     case Crange:
  73:         syserr(MESS(1700, "Bigsize in Bottom or Crange"));
  74:     }
  75:     return(vsize);
  76:     }
  77:     return mk_integer(psize);
  78: }
  79: 
  80: Visible value size(t) value t; { /* #t */
  81:     int tsize;
  82:     switch (Type(t)) {
  83:     case ELT:
  84:     case Lis:
  85:     case Tex:
  86:     case Tab:
  87:         tsize = Tltsize(t);
  88:         if (tsize EQ Bigsize) return treesize(Root(t));
  89:         return mk_integer(tsize);
  90:     default:
  91:         reqerr(MESS(1701, "in #t, t is not a text, list or table"));
  92:         return zero;
  93:     }
  94: }
  95: 
  96: Visible value th_of(num, v) value num, v; { /* num th'of v */
  97:     value m= Vnil;
  98:     if (!Is_tlt(v))
  99:         error(MESS(1702, "in n th'of t, t is not a text, list or table"));
 100:     else if (!Is_number(num))
 101:         error(MESS(1703, "in n th'of t, n is not a number"));
 102:     else if (empty(v))
 103:         error(MESS(1704, "in n th'of t, t is empty"));
 104:     else if (numcomp(num, one) < 0)
 105:         error(MESS(1705, "in n th'of t, n is < 1"));
 106:     else {
 107:         /*RANGES?*/
 108:         m= thof(intval(num), v);
 109:         if (m == Vnil && still_ok)
 110:             error(MESS(1706, "in n th'of t, n exceeds #t"));
 111:     }
 112:     return m;
 113: }
 114: 
 115: /*
 116:  * 'Walktree' handles functions on texts and associates of tables.
 117:  * The actual function performed is determined by the 'visit' function.
 118:  * The tree is walked (possibly recursively) and all items are visited.
 119:  * The return value of walktree() and visit() is used to determine whether
 120:  * the walk should continue (Yes == continue, No == stop now).
 121:  * Global variables are used to communicate the result, and the parameters
 122:  * of the function. The naming convention is according to "e func t".
 123:  */
 124: 
 125: Hidden intlet tt;       /* type of walked value t */
 126: Hidden intlet wt;       /* width of items in walked value t */
 127: Hidden value ve;        /* value of e, if func is dyadic */
 128: Hidden char ce;         /* C char in e, if t is a text */
 129: 
 130: Hidden int count;       /* result of size2 */
 131: Hidden bool found;      /* result for in */
 132: Hidden intlet m_char;       /* result for min/max on texts */
 133: Hidden value m_val;     /* result for min/max on tables */
 134: 
 135: #define Lowchar (-Maxintlet)    /* -infinity for characters */
 136: #define Highchar (Maxintlet)    /* +infinity */
 137: 
 138: Hidden bool walktree(p, visit) btreeptr p; bool (*visit)(); {
 139:     intlet l;
 140: 
 141:     if (p EQ Bnil) return Yes; /* i.e., not found (used by in() !) */
 142:     for (l=0; l < Lim(p); l++) {
 143:         switch (Flag(p)) {
 144:         case Inner:
 145:             if (!walktree(Ptr(p, l), visit) || !still_ok)
 146:                 return No;
 147:             if (!(*visit)(Piitm(p, l, wt)) || !still_ok)
 148:                 return No;
 149:             break;
 150:         case Bottom:
 151:             if (!(*visit)(Pbitm(p, l, wt)) || !still_ok)
 152:                 return No;
 153:         }
 154:     }
 155:     return Flag(p) EQ Bottom || walktree(Ptr(p, l), visit);
 156: }
 157: 
 158: /* Common code for min/max-1/2, size2, in. */
 159: 
 160: Hidden Procedure tlt_func(e, t, where, li_func, te_visit, ta_visit)
 161:     value e, t;             /* [e] func t */
 162:     string where;           /* "in [e] func_name t" */
 163:     value (*li_func)();         /* func for lists */
 164:     bool (*te_visit)(), (*ta_visit)(); /* 'visit' for walktree */
 165: {
 166:     m_val = Vnil;
 167:     if (empty(t)) {
 168:         error3(MESSMAKE(where), Vnil, MESS(1707, ", t is empty"));
 169:         return;
 170:     }
 171:     wt = Itemwidth(Itemtype(t));
 172:     tt = Type(t);
 173:     switch (tt) {
 174:     case Lis:
 175:         m_val = (*li_func)(e, t);
 176:         break;
 177:     case Tex:
 178:         if (e NE Vnil) {
 179:             if (!Character(e)) {
 180:                 error3(MESSMAKE(where), Vnil,
 181:             MESS(1708, ", t is a text, but e is not a character"));
 182:                 return;
 183:             }
 184:             ce = Bchar(Root(e), 0);
 185:         }
 186:         found = !walktree(Root(t), te_visit);
 187:         if (m_char NE Lowchar && m_char NE Highchar)
 188:             m_val = mkchar(m_char);
 189:         break;
 190:     case Tab:
 191:         ve = e;
 192:         found = !walktree(Root(t), ta_visit);
 193:         break;
 194:     default:
 195:         error3(MESSMAKE(where), Vnil,
 196:             MESS(1709, ", t is not a text list or table"));
 197:     }
 198: }
 199: 
 200: Hidden value li2size(e, t) value e, t; {
 201:     count = l2size(e, t);
 202:     return Vnil;
 203: }
 204: 
 205: Hidden bool te2size(pitm) itemptr pitm; {
 206:     if (ce EQ Charval(pitm))
 207:         count++;
 208:     return Yes;
 209: }
 210: 
 211: Hidden bool ta2size(pitm) itemptr pitm; {
 212:     if (compare(ve, Ascval(pitm)) EQ 0)
 213:         count++;
 214:     return Yes;
 215: }
 216: 
 217: Visible value size2(e, t) value e, t; { /* e#t */
 218:     if (empty(t)) /* Must check here because tlt_func would complain */
 219:         return copy(zero);
 220:     m_char = Lowchar;
 221:     count = 0;
 222:     tlt_func(e, t, "in e#t", li2size, te2size, ta2size);
 223:     return mk_integer(count);
 224: }
 225: 
 226: Hidden value li_in(e, t) value e, t; {
 227:     found = in_keys(e, t);
 228:     return Vnil;
 229: }
 230: 
 231: Hidden bool te_in(pitm) itemptr pitm; {
 232:     return Charval(pitm) NE ce;
 233: }
 234: 
 235: Hidden bool ta_in(pitm) itemptr pitm; {
 236:     return compare(ve, Ascval(pitm)) NE 0;
 237: }
 238: 
 239: Visible bool in(e, t) value e, t; {
 240:     if (empty(t)) /* Must check here because tlt_func would complain */
 241:         return No;
 242:     m_char = Lowchar;
 243:     found = No;
 244:     tlt_func(e, t, "in the test e in t", li_in, te_in, ta_in);
 245:     return found;
 246: }
 247: 
 248: Hidden value li_min(e, t) value e, t; {
 249:     return th_of(one, t);
 250: }
 251: 
 252: Hidden bool te_min(pitm) itemptr pitm; {
 253:     if (m_char > Charval(pitm))
 254:         m_char = Charval(pitm);
 255:     return Yes;
 256: }
 257: 
 258: Hidden bool ta_min(pitm) itemptr pitm; {
 259:     if (m_val EQ Vnil || compare(m_val, Ascval(pitm)) > 0) {
 260:         release(m_val);
 261:         m_val = copy(Ascval(pitm));
 262:     }
 263:     return Yes;
 264: }
 265: 
 266: Visible value min1(t) value t; {
 267:     m_char = Highchar;
 268:     tlt_func(Vnil, t, "in min t", li_min, te_min, ta_min);
 269:     return m_val;
 270: }
 271: 
 272: Hidden value li_max(e, t) value e, t; {
 273:     value v= size(t);
 274:     m_val = th_of(v, t);
 275:     release(v);
 276:     return m_val;
 277: }
 278: 
 279: Hidden bool te_max(pitm) itemptr pitm; {
 280:     if (m_char < Charval(pitm))
 281:         m_char = Charval(pitm);
 282:     return Yes;
 283: }
 284: 
 285: Hidden bool ta_max(pitm) itemptr pitm; {
 286:     if (m_val EQ Vnil || compare(Ascval(pitm), m_val) > 0) {
 287:         release(m_val);
 288:         m_val = copy(Ascval(pitm));
 289:     }
 290:     return Yes;
 291: }
 292: 
 293: Visible value max1(t) value t; {
 294:     m_char = Lowchar;
 295:     tlt_func(Vnil, t, "in max t", li_max, te_max, ta_max);
 296:     return m_val;
 297: }
 298: 
 299: Hidden bool te2min(pitm) itemptr pitm; {
 300:     if (m_char > Charval(pitm) && Charval(pitm) > ce) {
 301:         m_char = Charval(pitm);
 302:     }
 303:     return Yes;
 304: }
 305: 
 306: Hidden bool ta2min(pitm) itemptr pitm; {
 307:     if (compare(Ascval(pitm), ve) > 0
 308:         &&
 309:         (m_val EQ Vnil || compare(m_val, Ascval(pitm)) > 0)) {
 310:         release(m_val);
 311:         m_val = copy(Ascval(pitm));
 312:     }
 313:     return Yes;
 314: }
 315: 
 316: Visible value min2(e, t) value e, t; {
 317:     m_char = Highchar;
 318:     tlt_func(e, t, "in e min t", l2min, te2min, ta2min);
 319:     if (m_val EQ Vnil && still_ok)
 320:         reqerr(MESS(1710, "in e min t, no element of t exceeds e"));
 321:     return m_val;
 322: }
 323: 
 324: /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 325: 
 326: Hidden bool te2max(pitm) itemptr pitm; {
 327:     if (ce > Charval(pitm) && Charval(pitm) > m_char) {
 328:         m_char = Charval(pitm);
 329:     }
 330:     return Yes;
 331: }
 332: 
 333: Hidden bool ta2max(pitm) itemptr pitm; {
 334:     if (compare(ve, Ascval(pitm)) > 0
 335:         &&
 336:         (m_val EQ Vnil || compare(Ascval(pitm), m_val) > 0)) {
 337:         release(m_val);
 338:         m_val = copy(Ascval(pitm));
 339:     }
 340:     return Yes;
 341: }
 342: 
 343: Visible value max2(e, t) value e, t; {
 344:     m_char = Lowchar;
 345:     tlt_func(e, t, "in e max t", l2max, te2max, ta2max);
 346:     if (m_val EQ Vnil && still_ok)
 347:         reqerr(MESS(1711, "in e max t, no element of t is less than e"));
 348:     return m_val;
 349: }
 350: 
 351: #else INTEGRATION
 352: 
 353: Visible value mk_elt() { return grab_elt(); }
 354: 
 355: Visible value size(x) value x; { /* monadic # operator */
 356:     if (!Is_tlt(x))
 357:         error(MESS(1712, "in #t, t is not a text, list or table"));
 358:     return mk_integer((int) Length(x));
 359: }
 360: 
 361: #define Lisent(tp,k) (*(tp+(k)))
 362: 
 363: Visible value size2(v, t) value v, t; { /* Dyadic # operator */
 364:     intlet len= Length(t), n= 0, k; value *tp= Ats(t);
 365:     if (!Is_tlt(t)) {
 366:         error(MESS(1713, "in e#t, t is not a text, list or table"));
 367:         return mk_integer((int) n);
 368:     }
 369:     switch (Type(t)) {
 370:     case Tex:
 371:         {string cp= (string)tp; char c;
 372:             if (Type(v) != Tex)
 373:                 error(MESS(1714, "in e#t, t is a text but e is not"));
 374:             if (Length(v) != 1)
 375:                 error(MESS(1715, "in e#t, e is a text but not a character"));
 376:             c= *Str(v);
 377:             Overall if (*cp++ == c) n++;
 378:         } break;
 379:     case ELT:
 380:         break;
 381:     case Lis:
 382:         {intlet lo= -1, mi, xx, mm, hi= len; relation c;
 383:         bins:   if (hi-lo < 2) break;
 384:             mi= (lo+hi)/2;
 385:             if ((c= compare(v, Lisent(tp,mi))) == 0) goto some;
 386:             if (c < 0) hi= mi; else lo= mi;
 387:             goto bins;
 388:         some:   xx= mi;
 389:             while (xx-lo > 1) {
 390:                 mm= (lo+xx)/2;
 391:                 if (compare(v, Lisent(tp,mm)) == 0) xx= mm;
 392:                 else lo= mm;
 393:             }
 394:             xx= mi;
 395:             while (hi-xx > 1) {
 396:                 mm= (xx+hi)/2;
 397:                 if (compare(v, Lisent(tp,mm)) == 0) xx= mm;
 398:                 else hi= mm;
 399:             }
 400:             n= hi-lo-1;
 401:         } break;
 402:     case Tab:
 403:         Overall if (compare(v, Dts(*tp++)) == 0) n++;
 404:         break;
 405:     default:
 406:         syserr(MESS(1716, "e#t with non text, list or table"));
 407:         break;
 408:     }
 409:     return mk_integer((int) n);
 410: }
 411: 
 412: Hidden bool less(r) relation r;    { return r<0; }
 413: Hidden bool greater(r) relation r; { return r>0; }
 414: 
 415: Hidden value mm1(t, rel) value t; bool (*rel)(); {
 416:     intlet len= Length(t), k; value m, *tp= Ats(t);
 417:     switch (Type(t)) {
 418:     case Tex:
 419:         {string cp= (string) tp; char mc= '\0', mm[2];
 420:             Overall {
 421:                 if (mc == '\0' || ((*rel)(*cp < mc ? -1 : (*cp > mc ? 1 : 0))))
 422:                     mc= *cp;
 423:                 cp++;
 424:             }
 425:             mm[0]= mc; mm[1]= '\0';
 426:             m= mk_text(mm);
 427:         } break;
 428:     case Lis:
 429:         if ((*rel)(-1)) /*min*/ m= copy(*Ats(t));
 430:         else m= copy(*(Ats(t)+len-1));
 431:         break;
 432:     case Tab:
 433:         {value dm= Vnil;
 434:             Overall {
 435:                 if (dm == Vnil || (*rel)(compare(Dts(*tp), dm)))
 436:                     dm= Dts(*tp);
 437:                 tp++;
 438:             }
 439:             m= copy(dm);
 440:         } break;
 441:     default:
 442:         syserr(MESS(1717, "min or max t, with non text, list or table"));
 443:     }
 444:     return m;
 445: }
 446: 
 447: #ifdef NO_ABS
 448: 
 449: Hidden int abs(i) int i; {
 450:     return i >= 0 ? i : -i;
 451: }
 452: 
 453: #endif
 454: 
 455: Hidden value mm2(v, t, rel) value v, t; bool (*rel)(); {
 456:     intlet len= Length(t), k; value m= Vnil, *tp= Ats(t);
 457:     switch (Type(t)) {
 458:     case Tex:
 459:         {string cp= (string) tp; char c, mc= '\0', mm[2];
 460:             c= *Str(v);
 461:             Overall {
 462:                 if ((*rel)(c < *cp ? -1 : c > *cp ? 1 : 0)) {
 463:                     if (mc == '\0' || (*rel)(*cp < mc ? -1 : *cp>mc ? 1 : 0))
 464:                         mc= *cp;
 465:                 }
 466:                 cp++;
 467:             }
 468:             if (mc != '\0') {
 469:                 mm[0]= mc; mm[1]= '\0';
 470:                 m= mk_text(mm);
 471:             }
 472:         } break;
 473:     case Lis:
 474:         {intlet lim1, mid, lim2;
 475:             if ((*rel)(-1)) { /*min*/
 476:                 lim1= 1; lim2= len-1;
 477:             } else {
 478:                 lim2= 1; lim1= len-1;
 479:             }
 480:             if (!(*rel)(compare(v, Lisent(tp,lim2)))) break;
 481:             if (len == 1 || (*rel)(compare(v, Lisent(tp,lim1)))) {
 482:                 m= copy(Lisent(tp,lim1));
 483:                 break;
 484:             }
 485:             /* v rel tp[lim2] && !(v rel tp[lim1]) */
 486:             while (abs(lim2-lim1) > 1) {
 487:                 mid= (lim1+lim2)/2;
 488:                 if ((*rel)(compare(v, Lisent(tp,mid)))) lim2= mid;
 489:                 else lim1= mid;
 490:             }
 491:             m= copy(Lisent(tp,lim2));
 492:         } break;
 493:     case Tab:
 494:         {value dm= Vnil;
 495:             Overall {
 496:                 if ((*rel)(compare(v, Dts(*tp)))) {
 497:                     if (dm == Vnil ||
 498:                         (*rel)(compare(Dts(*tp), dm)))
 499:                         dm= Dts(*tp);
 500:                 }
 501:                 tp++;
 502:             }
 503:             if (dm != Vnil) m= copy(dm);
 504:         } break;
 505:     default:
 506:         syserr(MESS(1718, "min2 or max2 with non text, list or table"));
 507:         break;
 508:     }
 509:     return m;
 510: }
 511: 
 512: Visible value min1(t) value t; { /* Monadic min */
 513:     value m= Vnil;
 514:     if (!Is_tlt(t))
 515:         error(MESS(1719, "in min t, t is not a text, list or table"));
 516:     else if (Length(t) == 0)
 517:         error(MESS(1720, "in min t, t is empty"));
 518:     else m= mm1(t, less);
 519:     return m;
 520: }
 521: 
 522: Visible value min2(v, t) value v, t; {
 523:     value m= Vnil;
 524:     if (!Is_tlt(t))
 525:         error(MESS(1721, "in e min t, t is not a text, list or table"));
 526:     else if (Length(t) == 0)
 527:         error(MESS(1722, "in e min t, t is empty"));
 528:     else if (Is_text(t)) {
 529:         if (!Is_text(v))
 530:             error(MESS(1723, "in e min t, t is a text but e is not"));
 531:         else if (Length(v) != 1)
 532:             error(MESS(1724, "in e min t, e is a text but not a character"));
 533:     }
 534:     if (still_ok) {
 535:         m= mm2(v, t, less);
 536:         if (m == Vnil)
 537:             error(MESS(1725, "in e min t, no element of t exceeds e"));
 538:     }
 539:     return m;
 540: }
 541: 
 542: Visible value max1(t) value t; {
 543:     value m= Vnil;
 544:     if (!Is_tlt(t))
 545:         error(MESS(1726, "in max t, t is not a text, list or table"));
 546:     else if (Length(t) == 0)
 547:         error(MESS(1727, "in max t, t is empty"));
 548:     else m= mm1(t, greater);
 549:     return m;
 550: }
 551: 
 552: Visible value max2(v, t) value v, t; {
 553:     value m= Vnil;
 554:     if (!Is_tlt(t))
 555:         error(MESS(1728, "in e max t, t is not a text, list or table"));
 556:     else if (Length(t) == 0)
 557:         error(MESS(1729, "in e max t, t is empty"));
 558:     else if (Is_text(t)) {
 559:         if (!Is_text(v))
 560:             error(MESS(1730, "in e max t, t is a text but e is not"));
 561:         else if (Length(v) != 1)
 562:             error(MESS(1731, "in e max t, e is a text but not a character"));
 563:     }
 564:     if (still_ok) {
 565:         m= mm2(v, t, greater);
 566:         if (m == Vnil)
 567:             error(MESS(1732, "in e max t, no element of t is less than e"));
 568:     }
 569:     return m;
 570: }
 571: 
 572: Visible value th_of(n, t) value n, t; {
 573:     return thof(intval(n), t);
 574: }
 575: 
 576: Visible value thof(n, t) int n; value t; {
 577:     intlet len= Length(t); value w= Vnil;
 578:     if (!Is_tlt(t))
 579:         error(MESS(1733, "in n th'of t, t is not a text, list or table"));
 580:     else if (n <= 0 || n > len)
 581:         error(MESS(1734, "in n th'of t, n is out of bounds"));
 582:     else {
 583:         switch (Type(t)) {
 584:         case Tex:
 585:             {char ww[2];
 586:                 ww[0]= *(Str(t)+n-1); ww[1]= '\0';
 587:                 w= mk_text(ww);
 588:             } break;
 589:         case Lis:
 590:             w= copy(*(Ats(t)+n-1));
 591:             break;
 592:         case Tab:
 593:             w= copy(Dts(*(Ats(t)+n-1)));
 594:             break;
 595:         default:
 596:             syserr(MESS(1735, "th'of with non text, list or table"));
 597:         }
 598:     }
 599:     return w;
 600: }
 601: 
 602: Visible bool found(elem, v, probe, where)
 603:     value (*elem)(), v, probe; intlet *where;
 604:     /* think of elem(v,lo-1) as -Infinity and elem(v,hi+1) as +Infinity.
 605: 	   found and where at the end satisfy:
 606: 	   SELECT:
 607: 	       SOME k IN {lo..hi} HAS probe = elem(v,k):
 608: 		   found = Yes AND where = k
 609: 	       ELSE: found = No AND elem(v,where-1) < probe < elem(v,where).
 610: 	*/
 611: {relation c; intlet lo=0, hi= Length(v)-1;
 612:     if (lo > hi) { *where= lo; return No; }
 613:     if ((c= compare(probe, (*elem)(v, lo))) == 0) {*where= lo; return Yes; }
 614:     if (c < 0) { *where=lo; return No; }
 615:     if (lo == hi) { *where=hi+1; return No; }
 616:     if ((c= compare(probe, (*elem)(v, hi))) == 0) { *where=hi; return Yes; }
 617:     if (c > 0) { *where=hi+1; return No; }
 618:     /* elem(lo) < probe < elem(hi) */
 619:     while (hi-lo > 1) {
 620:         if ((c= compare(probe, (*elem)(v, (lo+hi)/2))) == 0) {
 621:             *where= (lo+hi)/2; return Yes;
 622:         }
 623:         if (c < 0) hi= (lo+hi)/2; else lo= (lo+hi)/2;
 624:     }
 625:     *where= hi; return No;
 626: }
 627: 
 628: Visible bool in(v, t) value v, t; {
 629:     intlet where, k, len= Length(t); value *tp= Ats(t);
 630:     if (!Is_tlt(t)) {
 631:         error(MESS(1736, "in the test e in t, t is not a text, list or table"));
 632:         return No;
 633:     }
 634:     switch (Type(t)) {
 635:     case Tex:
 636:         if (Type(v) != Tex)
 637:             error(MESS(1737, "in the test e in t, t is a text but e is not"));
 638:         else if (Length(v) != 1)
 639:             error(MESS(1738, "in the test e in t, e is a text but not a character"));
 640:         else return index((string) tp, *Str(v)) != 0;
 641:         return No;
 642:     case ELT:
 643:         return No;
 644:     case Lis:
 645:         return found(list_elem, t, v, &where);
 646:     case Tab:
 647:         Overall if (compare(v, Dts(*tp++)) == 0) return Yes;
 648:         return No;
 649:     default:
 650:         syserr(MESS(1739, "e in t with non text, list or table"));
 651:         return No;
 652:     }
 653: }
 654: 
 655: Visible bool empty(v) value v; {
 656:     switch (Type(v)) {
 657:     case Tex:
 658:     case Lis:
 659:     case Tab:
 660:     case ELT:
 661:         return (Length(v) == 0);
 662:     default:
 663:         syserr(MESS(1740, "empty() on non tlt value"));
 664:         return (No);
 665:     }
 666: }
 667: 
 668: #endif INTEGRATION

Defined functions

Defined variables

Defined macros