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

##### Functions

    abs               X
    empty             X
    found             X
    greater           X
    in                X
    less              X
    li2size           X
    li_in             X
    li_max            X
    li_min            X
    max1              X
    max2              X
    min1              X
    min2              X
    mk_elt            X
    mm1               X
    mm2               X
    size              X
    size2             X
    ta2max            X
    ta2min            X
    ta2size           X
    ta_in             X
    ta_max            X
    ta_min            X
    te2max            X
    te2min            X
    te2size           X
    te_in             X
    te_max            X
    te_min            X
    th_of             X
    thof              X
    tlt_func          X
    treesize          X
    walktree          X

##### Variables

    Visible           X
    ce                X
    count             X
    m_char            X
    m_val             X
    tt                X
    ve                X
    wt                X

##### Macros

    Highchar          X
    Lisent            X
    Lowchar           X

       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

abs defined in line 449; used 1 times

- in line 486

empty defined in line 655; used 17 times

- in line 102, 167, 218, 240
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 179
- in /usr/src/new/PORT/B/src/bint/b3in2.c line 114, 160
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 68, 298, 310
- in /usr/src/new/PORT/B/src/bint/b3typ.c line 38, 65, 72, 98-103(4)

found defined in line 602; used 14 times

- in line 186, 192, 227, 243-245(2), 645
- in /usr/src/new/PORT/B/src/bint/b1lta.c line 933, 955, 1046-1051(2), 1066, 1088, 1096
- in /usr/src/new/PORT/B/src/bint/b1tlt.h line 43

greater defined in line 413; used 2 times

- in line 548, 565

in defined in line 628; used 19 times

- in /usr/src/new/PORT/B/src/bint/b1mem.c line 45-47(2), 76
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 167
- in /usr/src/new/PORT/B/src/bint/b2cmd.c line 199
- in /usr/src/new/PORT/B/src/bint/b2fix.c line 70
- in /usr/src/new/PORT/B/src/bint/b2tcE.c line 34
- in /usr/src/new/PORT/B/src/bint/b2uni.c line 69, 173-181(5)
- in /usr/src/new/PORT/B/src/bint/b3fil.c line 271
- in /usr/src/new/PORT/B/src/bint/b3fpr.c line 192-193(2)
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 331, 345
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 123

less defined in line 412; used 2 times

- in line 518, 535

li2size defined in line 200; used 1 times

- in line 222

li_in defined in line 226; used 1 times

- in line 244

li_max defined in line 272; used 1 times

- in line 295

li_min defined in line 248; used 1 times

- in line 268

max1 defined in line 542; used 1 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 173

max2 defined in line 552; used 1 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 174

min1 defined in line 512; used 4 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 171
- in /usr/src/new/PORT/B/src/bint/b3typ.c line 66, 99(2)

min2 defined in line 522; used 1 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 172

mk_elt defined in line 353; used 34 times

- in /usr/src/new/PORT/B/src/bint/b1lta.c line 270, 281, 978
- in /usr/src/new/PORT/B/src/bint/b1mem.c line 59
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 165
- in /usr/src/new/PORT/B/src/bint/b2ana.c line 25-34(5)
- in /usr/src/new/PORT/B/src/bint/b2stc.c line 47
- in /usr/src/new/PORT/B/src/bint/b2syn.c line 339
- in /usr/src/new/PORT/B/src/bint/b2tcE.c line 26
- in /usr/src/new/PORT/B/src/bint/b2uni.c line 65, 76-78(2), 111, 119-121(2), 141, 149-151(2)
- in /usr/src/new/PORT/B/src/bint/b3env.c line 61-63(2)
- in /usr/src/new/PORT/B/src/bint/b3int.c line 269-272(2), 284
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 777, 862-863(2)
- in /usr/src/new/PORT/B/src/bint/b3sta.c line 283
- in /usr/src/new/PORT/B/src/bint/b3typ.c line 62-64(2), 71

mm1 defined in line 415; used 2 times

- in line 518, 548

mm2 defined in line 455; used 2 times

- in line 535, 565

size defined in line 355; used 12 times

- in line 273
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 169
- in /usr/src/new/PORT/B/src/bint/b2dis.c line 277-281(2)
- in /usr/src/new/PORT/B/src/bint/b2tcE.c line 220
- in /usr/src/new/PORT/B/src/bint/b3in2.c line 64, 118
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 108, 139, 313
- in /usr/src/new/PORT/B/src/bint/b3scr.c line 96
- in /usr/src/new/PORT/B/src/bint/b3typ.c line 22

size2 defined in line 363; used 1 times

- in /usr/src/new/PORT/B/src/bint/b1obj.h line 170

ta2max defined in line 333; used 1 times

- in line 345

ta2min defined in line 306; used 1 times

- in line 318

ta2size defined in line 211; used 1 times

- in line 222

ta_in defined in line 235; used 1 times

- in line 244

ta_max defined in line 285; used 1 times

- in line 295

ta_min defined in line 258; used 1 times

- in line 268

te2max defined in line 326; used 1 times

- in line 345

te2min defined in line 299; used 1 times

- in line 318

te2size defined in line 205; used 1 times

- in line 222

te_in defined in line 231; used 1 times

- in line 244

te_max defined in line 279; used 1 times

- in line 295

te_min defined in line 252; used 1 times

- in line 268

th_of defined in line 572; used 7 times

- in line 249, 274
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 175
- in /usr/src/new/PORT/B/src/bint/b2tcE.c line 222
- in /usr/src/new/PORT/B/src/bint/b3in2.c line 127
- in /usr/src/new/PORT/B/src/bint/b3loc.c line 317
- in /usr/src/new/PORT/B/src/bint/b3typ.c line 38

thof defined in line 576; used 11 times

- in line 108, 573
- in /usr/src/new/PORT/B/src/bint/b1mem.c line 75
- in /usr/src/new/PORT/B/src/bint/b1obj.c line 100, 108, 142, 173
- in /usr/src/new/PORT/B/src/bint/b1obj.h line 176
- in /usr/src/new/PORT/B/src/bint/b3env.c line 139
- in /usr/src/new/PORT/B/src/bint/b3scr.c line 123, 150

tlt_func defined in line 160; used 6 times

- in line 222, 244, 268, 295, 318, 345

treesize defined in line 49; used 3 times

- in line 59, 88
- in /usr/src/new/PORT/B/src/bint/b1btr.h line 58

walktree defined in line 138; used 4 times

- in line 145, 155, 186, 192

#### Defined variables

Visible defined in line 355; never used
ce defined in line 128; used 5 times

- in line 184, 206, 232, 300, 327

count defined in line 130; used 5 times

- in line 201, 207, 213, 221-223(2)

m_char defined in line 132; used 17 times

- in line 187-188(3), 220, 242, 253-254(2), 267, 280-281(2), 294, 300-301(2), 317, 327-328(2), 344

m_val defined in line 133; used 27 times

- in line 166, 175, 188, 259-261(4), 269-276(3), 286-288(4), 296, 309-311(4), 319-321(2), 336-338(4), 346-348(2)

tt defined in line 125; used 2 times

- in line 172-173(2)

ve defined in line 127; used 5 times

- in line 191, 212, 236, 307, 334

wt defined in line 126; used 3 times

- in line 147-151(2), 171

#### Defined macros

Highchar defined in line 136; used 3 times

- in line 187, 267, 317

Lisent defined in line 361; used 8 times

- in line 385, 391, 397, 480-482(3), 488-491(2)

Lowchar defined in line 135; used 5 times

- in line 187, 220, 242, 294, 344

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