4.3BSD - /usr/src/new/B/src/bed/line.c

   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
   2: static char rcsid[] = "$Header: line.c,v 2.4 85/08/22 16:04:53 timo Exp $";
   3: 
   4: /*
   5:  * B editor -- Routines for treating the parse tree as a sequence of lines.
   6:  *
   7:  * WARNING: The routines in this file (and many others!) assume that a
   8:  * `newline' can only occur in the zero'th representation string of a node
   9:  * (i.e., rp[0]).
  10:  */
  11: 
  12: #include "b.h"
  13: #include "bobj.h"
  14: #include "node.h"
  15: #include "gram.h"
  16: #include "supr.h"
  17: 
  18: 
  19: /*
  20:  * Compute equality of subtrees, based on common descent.
  21:  * Strings are not checked for characterwise equality, but must
  22:  * be the same pointer; other nodes must have the same symbol and
  23:  * their children must be equal in this sense (equal pointers are
  24:  * always used as a shortcut).
  25:  *
  26:  * (Used by screen update algorithm only.)
  27:  */
  28: 
  29: Visible bool
  30: eqlines(n1, n2)
  31:     node n1;
  32:     node n2;
  33: {
  34:     register node nn1;
  35:     register node nn2;
  36:     register int w1;
  37:     register int w2;
  38:     register int nch;
  39:     register int i;
  40: 
  41:     if (n1 == n2)
  42:         return Yes;
  43:     if (Type(n1) != Nod || Type(n2) != Nod)
  44:         return No;
  45:     if (symbol(n1) != symbol(n2))
  46:         return No;
  47:     nch = nchildren(n1);
  48:     Assert(nch == nchildren(n2));
  49:     for (i = 1; i <= nch; ++i) {
  50:         nn1 = child(n1, i);
  51:         nn2 = child(n2, i);
  52:         w1 = width(nn1);
  53:         w2 = width(nn2);
  54:         if (w1 >= 0 && w2 >= 0) {
  55:             if (!eqlines(nn1, nn2))
  56:                 return No;
  57:         }
  58:         else {
  59:             if (nn1 == nn2)
  60:                 return Yes;
  61:             if (fwidth(noderepr(nn1)[0]) < 0 || fwidth(noderepr(nn2)[0]) < 0)
  62:                 return linelen(n1) == linelen(n2);
  63:             return eqlines(nn1, nn2);
  64:         }
  65:     }
  66:     return Yes;
  67: }
  68: 
  69: 
  70: /*
  71:  * Compute the length of the line beginning at the current node.
  72:  */
  73: 
  74: Visible int
  75: linelen(n)
  76:     node n;
  77: {
  78:     register node nn;
  79:     register string *rp = noderepr(n);
  80:     register int w;
  81:     register int nch = nchildren(n);
  82:     register int i;
  83:     register int len = fwidth(rp[0]);
  84: 
  85:     if (len < 0)
  86:         len = 0;
  87:     for (i = 1; i <= nch; ++i) {
  88:         nn = child(n, i);
  89:         w = width(nn);
  90:         if (w >= 0)
  91:             len += w;
  92:         else {
  93:             n = nn;
  94:             i = 0;
  95:             nch = nchildren(n);
  96:             rp = noderepr(n);
  97:         }
  98:         w = Fwidth(rp[i]);
  99:         if (w < 0)
 100:             break;
 101:         len += w;
 102:     }
 103:     return len;
 104: }
 105: 
 106: 
 107: /*
 108:  * Move the focus to the next line.
 109:  * NB: This is a building block for use in the 'show' module;
 110:  * it cannot set ep->mode or call higher() properly!
 111:  */
 112: 
 113: Visible bool
 114: nextline(pp)
 115:     register path *pp;
 116: {
 117:     register node n;
 118:     register node nn;
 119:     register int w;
 120:     register int nch;
 121:     register int i = 0;
 122: 
 123:     for (;;) {
 124:         n = tree(*pp);
 125:         if (width(n) < 0) {
 126:             nch = nchildren(n);
 127:             while (++i <= nch) {
 128:                 nn = child(n, i);
 129:                 w = width(nn);
 130:                 if (w < 0) {
 131:                     downi(pp, i) || Abort();
 132:                     n = tree(*pp);
 133:                     if (fwidth(noderepr(n)[0]) < 0)
 134:                         return Yes;
 135:                     nch = nchildren(n);
 136:                     i = 0;
 137:                 }
 138:             }
 139:         }
 140:         /* Must go upward in the tree */
 141:         i = ichild(*pp);
 142:         if (!up(pp))
 143:             return No;
 144:     }
 145: }
 146: 
 147: 
 148: /*
 149:  * Compute the current line number.  If the current node begins with
 150:  * a `newline', add one because the first character is actually
 151:  * on the next line.
 152:  */
 153: 
 154: Visible int
 155: lineno(ep)
 156:     register environ *ep;
 157: {
 158:     register int y;
 159: 
 160:     y = -focoffset(ep);
 161:     if (y < 0)
 162:         y = 0;
 163:     if (focchar(ep) == '\n')
 164:         ++y;
 165:     return y + Ycoord(ep->focus);
 166: }
 167: 
 168: /*
 169:  * Similarly, compute the current column number.
 170:  * (Hope the abovementioned trick isn't necessary.)
 171:  */
 172: 
 173: Visible int
 174: colno(ep)
 175:     environ *ep;
 176: {
 177:     int x= focoffset(ep);
 178: 
 179:     if (x < 0)
 180:         x= 0; /* In fact, give up */
 181:     return x + Xcoord(ep->focus);
 182: }
 183: 
 184: 
 185: /*
 186:  * Make the focus exactly one line wide (if at all possible).
 187:  */
 188: 
 189: Visible Procedure
 190: oneline(ep)
 191:     register environ *ep;
 192: {
 193:     register node n;
 194:     node nn;
 195:     register string *rp;
 196:     register int s1;
 197:     register int s2;
 198:     register int len;
 199:     int ich;
 200:     int nch;
 201: 
 202:     ich = 1;
 203:     while (width(tree(ep->focus)) >= 0) {
 204:         ich = ichild(ep->focus);
 205:         if (!up(&ep->focus)) {
 206:             ep->mode = WHOLE;
 207:             higher(ep);
 208:             return;
 209:         }
 210:     }
 211:     higher(ep);
 212:     n = tree(ep->focus);
 213:     nch = nchildren(n);
 214:     rp = noderepr(n);
 215:     for (s1 = 2*ich-1; s1 >= 1; --s1) {
 216:         if (s1&1)
 217:             len = fwidth(rp[s1/2]);
 218:         else {
 219:             nn = child(n, s1/2);
 220:             len = width(nn);
 221:         }
 222:         if (len < 0)
 223:             break;
 224:     }
 225:     for (s2 = 2*ich+1; s2 <= 2*nch+1; ++s2) {
 226:         if (s2&1)
 227:             len = fwidth(rp[s2/2]);
 228:         else {
 229:             nn = child(n, s2/2);
 230:             len = width(nn);
 231:         }
 232:         if (len < 0)
 233:             break;
 234:     }
 235:     ep->mode = SUBSET;
 236:     ep->s1 = s1+1;
 237:     ep->s2 = s2-1;
 238: }

Defined functions

Defined variables