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

   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
   2: static char rcsid[] = "$Header: outp.c,v 2.4 85/08/22 16:05:48 timo Exp $";
   3: 
   4: /*
   5:  * B editor -- Screen management package, lower level output part.
   6:  */
   7: 
   8: #include <ctype.h>
   9: 
  10: #include "b.h"
  11: #include "bobj.h"
  12: #include "node.h"
  13: #include "supr.h"
  14: #include "gram.h"
  15: #include "cell.h"
  16: 
  17: 
  18: #define SOBIT 0200
  19: #define CHAR 0177
  20: 
  21: 
  22: /*
  23:  * Variables used for communication with outfocus.
  24:  */
  25: 
  26: Hidden node thefocus;
  27: Hidden environ wherebuf;
  28: Hidden environ *where = &wherebuf;
  29: Hidden bool realvhole;
  30: Hidden int multiline; /* Height of focus */
  31: Hidden int yfocus;
  32: 
  33: Visible int focy; /* Where the cursor must go */
  34: Visible int focx;
  35: 
  36: 
  37: /*
  38:  * Save position of the focus for use by outnode/outfocus.
  39:  */
  40: 
  41: Visible Procedure
  42: savefocus(ep)
  43:     register environ *ep;
  44: {
  45:     register int sym;
  46:     register int w;
  47: 
  48:     realvhole = No;
  49:     thefocus = Nnil;
  50:     multiline = 0;
  51:     yfocus = Ycoord(ep->focus);
  52:     w = focoffset(ep);
  53:     if (w < 0)
  54:         yfocus += -w;
  55:     w = focwidth(ep);
  56:     if (w < 0) {
  57:         multiline = -w;
  58:         if (focchar(ep) == '\n')
  59:             ++yfocus;
  60:         else
  61:             ++multiline;
  62:         return;
  63:     }
  64:     if (ep->mode == WHOLE) {
  65:         sym = symbol(tree(ep->focus));
  66:         if (sym == Optional)
  67:             ep->mode = ATBEGIN;
  68:     }
  69:     switch(ep->mode) {
  70:     case VHOLE:
  71:         if (ep->s1&1)
  72:             ep->mode = FHOLE;
  73:     case ATBEGIN:
  74:     case ATEND:
  75:     case FHOLE:
  76:         ritevhole(ep);
  77:         switch (ep->mode) {
  78:         case ATBEGIN:
  79:         case FHOLE:
  80:             sym = symbol(tree(ep->focus));
  81:             if (sym == Hole && (ep->mode == ATBEGIN || ep->s2 == 0)) {
  82:                 ep->mode = WHOLE;
  83:                 break;
  84:             }
  85:             /* Fall through */
  86:         case VHOLE:
  87:         case ATEND:
  88:             leftvhole(ep);
  89:             realvhole = 1 + ep->spflag;
  90:         }
  91:     }
  92:     touchpath(&ep->focus); /* Make sure it is a unique pointer */
  93:     thefocus = tree(ep->focus); /* No copy; used for comparison only! */
  94:     where->mode = ep->mode;
  95:     where->s1 = ep->s1;
  96:     where->s2 = ep->s2;
  97:     where->s3 = ep->s3;
  98:     where->spflag = ep->spflag;
  99: }
 100: 
 101: 
 102: /*
 103:  * Incorporate the information saved about the focus.
 104:  */
 105: 
 106: Visible Procedure
 107: setfocus(tops)
 108:     register cell *tops;
 109: {
 110:     register cell *p;
 111:     register int i;
 112: 
 113:     for (p = tops, i = 0; i < yfocus; ++i, p = p->c_link) {
 114:         if (!p) {
 115: #ifndef NDEBUG
 116:             debug("[Focus lost (setfocus)]");
 117: #endif NDEBUG
 118:             return;
 119:         }
 120:     }
 121:     p->c_newvhole = realvhole;
 122:     i = multiline;
 123:     do {
 124:         p->c_newfocus = Yes;
 125:         p = p->c_link;
 126:     } while (--i > 0);
 127: }
 128: 
 129: 
 130: /*
 131:  * Signal that actual updata is started.
 132:  */
 133: 
 134: Visible Procedure
 135: startactupdate(nofocus)
 136:     bool nofocus;
 137: {
 138:     if (nofocus) {
 139:         multiline = 0;
 140:         thefocus = Nnil;
 141:     }
 142: }
 143: 
 144: 
 145: /*
 146:  * Signal the end of the actual update.
 147:  */
 148: 
 149: Visible Procedure
 150: endactupdate()
 151: {
 152: }
 153: 
 154: 
 155: /*
 156:  * Output a line of text.
 157:  */
 158: 
 159: Visible Procedure
 160: outline(p, lineno)
 161:     register cell *p;
 162:     register int lineno;
 163: {
 164:     register node n = p->c_data;
 165:     register int w = width(n);
 166:     register string buf =
 167:         malloc((unsigned) (p->c_newindent + 4 + (w < 0 ? linelen(n) : w)));
 168:             /* some 4 extra for spflag and vhole */
 169:     auto string bp = buf;
 170:     register int i;
 171:     register int endarea = lineno+Space(p)-1;
 172: 
 173:     if (endarea >= winheight)
 174:         endarea = winheight-1;
 175:     for (i = p->c_newindent; i-- > 0; )
 176:         *bp++ = ' ';
 177:     if (!p->c_newfocus) {
 178:         smash(&bp, n, 0);
 179:         *bp = 0;
 180:     }
 181:     else {
 182:         if (multiline)
 183:             smash(&bp, n, SOBIT);
 184:         else if (n == thefocus)
 185:             focsmash(&bp, n);
 186:         else
 187:             smash(&bp, n, 0);
 188:         *bp = 0;
 189:         for (bp = buf; *bp && !(*bp&SOBIT); ++bp)
 190:             ;
 191:         if (*bp&SOBIT) {
 192:             if (focy == Nowhere) {
 193:                 focx = indent + bp-buf;
 194:                 focy = lineno + focx/llength;
 195:                 focx %= llength;
 196:             }
 197:             if (multiline <= 1 && !(bp[1]&SOBIT))
 198:                 *bp &= ~SOBIT; /* Clear mask if just one char in focus */
 199:         }
 200:     }
 201:     trmputdata(lineno, endarea, indent, buf);
 202: }
 203: 
 204: 
 205: /*
 206:  * Smash -- produce a linear version of a node in a buffer (which had
 207:  * better be long enough!).  The buffer pointer is moved to the end of
 208:  * the resulting string.
 209:  * Care is taken to represent the focus.
 210:  * Characters in the focus have their upper bit set.
 211:  */
 212: 
 213: #define Outvhole() \
 214:     (where->spflag && strsmash(pbuf, " ", 0), strsmash(pbuf, "?", SOBIT))
 215: 
 216: Hidden Procedure
 217: focsmash(pbuf, n)
 218:     string *pbuf;
 219:     node n;
 220: {
 221:     value v;
 222:     string str;
 223:     register string *rp;
 224:     register int maxs2;
 225:     register int i;
 226:     register bool ok;
 227:     register int j;
 228:     register int mask;
 229: 
 230:     switch (where->mode) {
 231: 
 232:     case WHOLE:
 233:         smash(pbuf, n, SOBIT);
 234:         break;
 235: 
 236:     case ATBEGIN:
 237:         Outvhole();
 238:         smash(pbuf, n, 0);
 239:         break;
 240: 
 241:     case ATEND:
 242:         smash(pbuf, n, 0);
 243:         Outvhole();
 244:         break;
 245: 
 246:     case VHOLE:
 247:         if (!(where->s1&1)) {
 248:             v = (value) child(n, where->s1/2);
 249:             Assert(Type(v) == Tex);
 250:             subsmash(pbuf, Str(v), where->s2, 0);
 251:             Outvhole();
 252:             strsmash(pbuf, Str(v) + where->s2, 0);
 253:             break;
 254:         }
 255:         /* Else, fall through */
 256:     case FHOLE:
 257:         rp = noderepr(n);
 258:         maxs2 = 2*nchildren(n) + 1;
 259:         for (ok = Yes, i = 1; ok && i <= maxs2; ++i) {
 260:             if (i&1) {
 261:                 if (i == where->s1) {
 262:                     subsmash(pbuf, rp[i/2], where->s2, 0);
 263:                     Outvhole();
 264:                     if (rp[i/2])
 265:                         strsmash(pbuf, rp[i/2] + where->s2, 0);
 266:                 }
 267:                 else
 268:                     strsmash(pbuf, rp[i/2], 0);
 269:             }
 270:             else
 271:                 ok = chismash(pbuf, n, i/2, 0);
 272:         }
 273:         break;
 274: 
 275:     case SUBRANGE:
 276:         rp = noderepr(n);
 277:         maxs2 = 2*nchildren(n) + 1;
 278:         for (ok = Yes, i = 1; ok && i <= maxs2; ++i) {
 279:             if (i&1) {
 280:                 if (i == where->s1) {
 281:                     subsmash(pbuf, rp[i/2], where->s2,0);
 282:                     if (rp[i/2])
 283:                         subsmash(pbuf, rp[i/2] + where->s2,
 284:                             where->s3 - where->s2 + 1, SOBIT);
 285:                     if (rp[i/2])
 286:                         strsmash(pbuf, rp[i/2] + where->s3 + 1, 0);
 287:                 }
 288:                 else
 289:                     strsmash(pbuf, rp[i/2], 0);
 290:             }
 291:             else if (i == where->s1) {
 292:                 v = (value)child(n, i/2);
 293:                 Assert(Type(v) == Tex);
 294:                 str = Str(v);
 295:                 subsmash(pbuf, str, where->s2, 0);
 296:                 subsmash(pbuf, str + where->s2, where->s3 - where->s2 + 1,
 297:                     SOBIT);
 298:                 strsmash(pbuf, str + where->s3 + 1, 0);
 299:             }
 300:             else
 301:                 ok = chismash(pbuf, n, i/2, 0);
 302:         }
 303:         break;
 304: 
 305:     case SUBLIST:
 306:         for (ok = Yes, j = where->s3; j > 0; --j) {
 307:             rp = noderepr(n);
 308:             maxs2 = 2*nchildren(n) - 1;
 309:             for (i = 1; ok && i <= maxs2; ++i) {
 310:                 if (i&1)
 311:                     strsmash(pbuf, rp[i/2], SOBIT);
 312:                 else
 313:                     ok = chismash(pbuf, n, i/2, SOBIT);
 314:             }
 315:             if (ok)
 316:                 n = lastchild(n);
 317:         }
 318:         if (ok)
 319:             smash(pbuf, n, 0);
 320:         break;
 321: 
 322:     case SUBSET:
 323:         rp = noderepr(n);
 324:         maxs2 = 2*nchildren(n) + 1;
 325:         mask = 0;
 326:         for (ok = Yes, i = 1; ok && i <= maxs2; ++i) {
 327:             if (i == where->s1)
 328:                 mask = SOBIT;
 329:             if (i&1)
 330:                 strsmash(pbuf, rp[i/2], mask);
 331:             else
 332:                 ok = chismash(pbuf, n, i/2, mask);
 333:             if (i == where->s2)
 334:                 mask = 0;
 335:         }
 336:         break;
 337: 
 338:     default:
 339:         Abort();
 340:     }
 341: }
 342: 
 343: Hidden Procedure
 344: smash(pbuf, n, mask)
 345:     register string *pbuf;
 346:     register node n;
 347:     register int mask;
 348: {
 349:     register string *rp;
 350:     register int i;
 351:     register int nch;
 352: 
 353:     rp = noderepr(n);
 354:     strsmash(pbuf, rp[0], mask);
 355:     nch = nchildren(n);
 356:     for (i = 1; i <= nch; ++i) {
 357:         if (!chismash(pbuf, n, i, mask))
 358:             break;
 359:         strsmash(pbuf, rp[i], mask);
 360:     }
 361: }
 362: 
 363: Hidden Procedure
 364: strsmash(pbuf, str, mask)
 365:     register string *pbuf;
 366:     register string str;
 367:     register int mask;
 368: {
 369:     if (!str)
 370:         return;
 371:     for (; *str; ++str) {
 372:         if (isprint(*str) || *str == ' ')
 373:             **pbuf = *str|mask, ++*pbuf;
 374:     }
 375: }
 376: 
 377: Hidden Procedure
 378: subsmash(pbuf, str, len, mask)
 379:     register string *pbuf;
 380:     register string str;
 381:     register int len;
 382:     register int mask;
 383: {
 384:     if (!str)
 385:         return;
 386:     for (; len > 0 && *str; --len, ++str) {
 387:         if (isprint(*str) || *str == ' ')
 388:             **pbuf = *str|mask, ++*pbuf;
 389:     }
 390: }
 391: 
 392: 
 393: /*
 394:  * Smash a node's child.
 395:  * Return No if it contained a newline (to stop the parent).
 396:  */
 397: 
 398: Hidden bool
 399: chismash(pbuf, n, i, mask)
 400:     register string *pbuf;
 401:     register node n;
 402:     register int i;
 403: {
 404:     register node nn = child(n, i);
 405:     register int w;
 406: 
 407:     if (Type(nn) == Tex) {
 408:         strsmash(pbuf, Str((value)nn), mask);
 409:         return Yes;
 410:     }
 411:     w = width(nn);
 412:     if (w < 0 && Fw_negative(noderepr(nn)[0]))
 413:         return No;
 414:     if (nn == thefocus)
 415:         focsmash(pbuf, nn);
 416:     else
 417:         smash(pbuf, nn, mask);
 418:     return w >= 0;
 419: }

Defined functions

Defined variables

Defined macros