![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to b2syn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bint|
Return to b2syn.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bint |
1.1 ! root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ ! 2: ! 3: /* ! 4: $Header: b2syn.c,v 1.4 85/08/22 16:56:25 timo Exp $ ! 5: */ ! 6: ! 7: #include "b.h" ! 8: #include "b0con.h" ! 9: #include "b1obj.h" ! 10: #include "b2key.h" ! 11: #include "b2syn.h" ! 12: #include "b3scr.h" ! 13: #include "b3env.h" ! 14: #include "b3err.h" ! 15: ! 16: #define TABSIZE 8 /* Number of spaces assumed for a tab on a file. ! 17: (Some editors insist on emitting tabs wherever ! 18: they can, and always assume 8 spaces for a tab. ! 19: Even when the editor can be instructed not to ! 20: do this, beginning users won't know about this, ! 21: so we'll always assume the default tab size. ! 22: Advanced users who used to instruct their editor ! 23: to set tab stops every 4 spaces will have to ! 24: unlearn this habit. But that's the price for ! 25: over-cleverness :-) ! 26: The indent increment is still 4 spaces! ! 27: When the B interpreter outputs text, it never uses ! 28: tabs but always emits 4 spaces for each indent level. ! 29: Note that the B editor also has a #defined constant ! 30: which sets the number of spaces for a tab on a file. ! 31: Finally the B editor *displays* indents as 3 spaces, ! 32: but *writes* them to the file as 4, so a neat ! 33: lay-out on the screen may look a bit garbled ! 34: when the file is printed. Sorry. */ ! 35: ! 36: Visible txptr tx, ceol; ! 37: ! 38: Visible Procedure skipsp(tx) txptr *tx; { ! 39: while(Space(Char(*tx))) (*tx)++; ! 40: } ! 41: ! 42: Visible bool keymark(c) char c; { ! 43: return Cap(c) || Dig(c) || c=='\'' || c=='"'; ! 44: } ! 45: ! 46: Hidden bool tagmark(c) char c; { ! 47: return Letter(c) || Dig(c) || c=='\'' || c=='"'; ! 48: } ! 49: ! 50: Hidden bool keytagmark(c) char c; { ! 51: return keymark(c) || Letter(c); ! 52: } ! 53: ! 54: Visible bool is_expr(c) char c; { ! 55: return Letter(c) || c == '(' || Dig(c) || c == '.' || ! 56: c == '\'' || c == '"' || c == '{' || ! 57: c=='~' || ! 58: c=='*' || c=='/' || c=='+' || c=='-' || c=='#'; ! 59: } ! 60: ! 61: /* ******************************************************************** */ ! 62: /* cr_text */ ! 63: /* ******************************************************************** */ ! 64: ! 65: Visible value cr_text(p, q) txptr p, q; { ! 66: /* Messes with the input line, which is a bit nasty, ! 67: but considered preferable to copying to a separate buffer */ ! 68: value t; ! 69: char save= Char(q); ! 70: Char(q)= '\0'; ! 71: t= mk_text(p); ! 72: Char(q)= save; ! 73: return t; ! 74: } ! 75: ! 76: /* ******************************************************************** */ ! 77: /* find, findceol, req, findrel */ ! 78: /* ******************************************************************** */ ! 79: ! 80: #define Ptr (*ftx) ! 81: #define Nokeymark '+' ! 82: ! 83: Hidden bool E_number(tx) txptr tx; { ! 84: return Char(tx) == 'E' && Dig(Char(tx+1)) && ! 85: (Dig(Char(tx-1)) || Char(tx-1) == '.'); ! 86: } ! 87: ! 88: Hidden bool search(find_kw, s, q, ftx, ttx) ! 89: bool find_kw; string s; txptr q, *ftx, *ttx; { ! 90: ! 91: intlet parcnt= 0; bool outs= Yes, kw= No; char aq, lc= Nokeymark; ! 92: while (Ptr < q) { ! 93: if (outs) { ! 94: if (parcnt == 0) { ! 95: if (find_kw) { ! 96: if (Cap(Char(Ptr)) && !E_number(Ptr)) ! 97: return Yes; ! 98: } else if (Char(Ptr) == *s) { ! 99: string t= s+1; ! 100: *ttx= Ptr+1; ! 101: while (*t && *ttx < q) { ! 102: if (*t != Char(*ttx)) break; ! 103: else { t++; (*ttx)++; } ! 104: } ! 105: if (*t); ! 106: else if (Cap(*s) && ! 107: (kw || keymark(Char(*ttx)))); ! 108: else return Yes; ! 109: } ! 110: } ! 111: switch (Char(Ptr)) { ! 112: case '(': case '{': case '[': ! 113: parcnt++; break; ! 114: case ')': case '}': case ']': ! 115: if (parcnt > 0) parcnt--; break; ! 116: case '\'': case '"': ! 117: if (!keytagmark(lc)) { ! 118: outs= No; aq= Char(Ptr); ! 119: } ! 120: break; ! 121: default: ! 122: break; ! 123: } ! 124: lc= Char(Ptr); kw= kw ? keymark(lc) : Cap(lc); ! 125: } else { ! 126: if (Char(Ptr) == aq) ! 127: { outs= Yes; kw= No; lc= Nokeymark; } ! 128: else if (Char(Ptr) == '`') { ! 129: Ptr++; ! 130: if (!search(No, "`", q, &Ptr, ttx)) return No; ! 131: } ! 132: } ! 133: Ptr++; ! 134: } ! 135: return No; ! 136: } ! 137: ! 138: /* ******************************************************************** */ ! 139: ! 140: Visible bool find(s, q, ftx, ttx) string s; txptr q, *ftx, *ttx; { ! 141: return search(No, s, q, (*ftx= tx, ftx), ttx); ! 142: } ! 143: ! 144: Forward txptr lcol(); ! 145: ! 146: Visible Procedure findceol() { ! 147: txptr q= lcol(), ttx; ! 148: if (!find("\\", q, &ceol, &ttx)) ceol= q; ! 149: } ! 150: ! 151: Visible Procedure req(s, q, ftx, ttx) string s; txptr q, *ftx, *ttx; { ! 152: if (!find(s, q, ftx, ttx)) { ! 153: parerr2(MESS(2400, "cannot find expected "), MESSMAKE(s)); ! 154: *ftx= tx; *ttx= q; ! 155: } ! 156: } ! 157: ! 158: Hidden bool relsearch(s, q, ftx) string s; txptr q, *ftx; { ! 159: txptr ttx; ! 160: Ptr= tx; ! 161: while (search(No, s, q, &Ptr, &ttx)) ! 162: switch (Char(Ptr)) { ! 163: case '<': if (Char(Ptr+1) == '<') Ptr= ++ttx; ! 164: else if (Char(Ptr-1) == '>') Ptr= ttx; ! 165: else return Yes; ! 166: break; ! 167: case '>': if (Char(Ptr+1) == '<') Ptr= ++ttx; ! 168: else if (Char(Ptr+1) == '>') Ptr= ++ttx; ! 169: else return Yes; ! 170: break; ! 171: case '=': return Yes; ! 172: default: return No; ! 173: } ! 174: return No; ! 175: } ! 176: ! 177: Visible bool findrel(q, ftx) txptr q, *ftx; { ! 178: txptr ttx; ! 179: Ptr= q; ! 180: if (relsearch("<", Ptr, &ttx)) Ptr= ttx; ! 181: if (relsearch(">", Ptr, &ttx)) Ptr= ttx; ! 182: if (relsearch("=", Ptr, &ttx)) Ptr= ttx; ! 183: return Ptr < q; ! 184: } ! 185: ! 186: /* ******************************************************************** */ ! 187: /* tag, keyword, findkw */ ! 188: /* ******************************************************************** */ ! 189: ! 190: Visible bool is_tag(v) value *v; { ! 191: if (!Letter(Char(tx))) return No; ! 192: *v= tag(); ! 193: return Yes; ! 194: } ! 195: ! 196: Visible value tag() { ! 197: txptr tx0= tx; ! 198: if (!Letter(Char(tx))) parerr(MESS(2401, "no tag where expected")); ! 199: while (tagmark(Char(tx))) tx++; ! 200: return cr_text(tx0, tx); ! 201: } ! 202: ! 203: Visible bool is_keyword(v) value *v; { ! 204: if (!Cap(Char(tx))) return No; ! 205: *v= keyword(); ! 206: return Yes; ! 207: } ! 208: ! 209: Visible value keyword() { ! 210: txptr tx0= tx; ! 211: if (!Cap(Char(tx))) parerr(MESS(2402, "no keyword where expected")); ! 212: while (keymark(Char(tx))) tx++; ! 213: return cr_text(tx0, tx); ! 214: } ! 215: ! 216: Visible bool findkw(q, ftx) txptr q, *ftx; { ! 217: txptr ttx; ! 218: Ptr= tx; ! 219: return search(Yes, "", q, &Ptr, &ttx); ! 220: } ! 221: ! 222: /* ******************************************************************** */ ! 223: /* upto, nothing, ateol, atkw, need */ ! 224: /* ******************************************************************** */ ! 225: ! 226: Visible Procedure upto(q, s) txptr q; string s; { ! 227: skipsp(&tx); ! 228: if (Text(q)) { ! 229: parerr2(MESS(2403, "something unexpected following "), ! 230: MESSMAKE(s)); ! 231: tx= q; ! 232: } ! 233: } ! 234: ! 235: Visible bool nothing(q, s) txptr q; string s; { ! 236: if (!Text(q)) { ! 237: if (Char(tx-1) == ' ') tx--; ! 238: parerr2(MESS(2404, "nothing instead of expected "), ! 239: MESSMAKE(s)); ! 240: return Yes; ! 241: } ! 242: return No; ! 243: } ! 244: ! 245: Hidden bool looked_ahead= No; ! 246: Visible intlet cur_ilev; ! 247: ! 248: Visible bool ateol() { ! 249: if (looked_ahead) return Yes; ! 250: skipsp(&tx); ! 251: return Eol(tx); ! 252: } ! 253: ! 254: Visible bool atkw(s) string s; { ! 255: txptr tx0= tx; ! 256: while (*s) if (*s++ != Char(tx0++)) return No; ! 257: if (keymark(Char(tx0))) return No; ! 258: tx= tx0; ! 259: return Yes; ! 260: } ! 261: ! 262: Visible Procedure need(s) string s; { ! 263: string t= s; ! 264: skipsp(&tx); ! 265: while (*t) ! 266: if (*t++ != Char(tx++)) { ! 267: tx--; ! 268: parerr2(MESS(2405, "according to the syntax I expected "), ! 269: MESSMAKE(s)); ! 270: return; ! 271: } ! 272: } ! 273: ! 274: /* ******************************************************************** */ ! 275: /* buffer handling */ ! 276: /* ******************************************************************** */ ! 277: ! 278: Visible txptr first_col; ! 279: ! 280: Visible txptr fcol() { /* the first position of the current line */ ! 281: return first_col; ! 282: } ! 283: ! 284: Hidden txptr lcol() { /* the position beyond the last character of the line */ ! 285: txptr ax= tx; ! 286: while (!Eol(ax)) ax++; ! 287: return ax; ! 288: } ! 289: ! 290: Visible intlet ilev() { ! 291: intlet i; ! 292: if (looked_ahead) { ! 293: looked_ahead= No; ! 294: return cur_ilev; ! 295: } else { ! 296: first_col= tx= getline(); ! 297: looked_ahead= No; ! 298: lino++; ! 299: f_lino++; ! 300: i= 0; ! 301: while (Space(Char(tx))) ! 302: if (Char(tx++) == ' ') i++; ! 303: else i= (i/TABSIZE+1)*TABSIZE; ! 304: if (Char(tx) == '\\') return cur_ilev= 0; ! 305: if (Char(tx) == '\n') return cur_ilev= 0; ! 306: if (i%4 == 2) ! 307: parerr(MESS(2406, "cannot make out indentation; use tab to indent")); ! 308: return cur_ilev= (i+1)/4; /* small deviation accepted */ ! 309: } ! 310: } ! 311: ! 312: Visible Procedure veli() { /* After a look-ahead call of ilev */ ! 313: looked_ahead= Yes; ! 314: } ! 315: ! 316: Visible Procedure first_ilev() { /* initialise read buffer for new input */ ! 317: looked_ahead= No; ! 318: VOID ilev(); ! 319: findceol(); ! 320: } ! 321: ! 322: /* ******************************************************************** */ ! 323: ! 324: /* The reserved keywords that a user command may not begin with: */ ! 325: ! 326: Visible value kwlist; ! 327: ! 328: Hidden string kwtab[] = { ! 329: K_SHARE, K_CHECK, K_CHOOSE, K_DELETE, K_DRAW, K_FAIL, K_FOR, ! 330: K_HOW_TO, K_IF, K_INSERT, K_PUT, K_QUIT, K_READ, K_REMOVE, ! 331: K_REPORT, K_RETURN, K_SELECT, K_SET_RANDOM, K_SUCCEED, ! 332: K_TEST, K_WHILE, K_WRITE, K_YIELD, K_ELSE, ! 333: "" ! 334: }; ! 335: ! 336: Visible Procedure initsyn() { ! 337: value v; ! 338: string *kw; ! 339: kwlist= mk_elt(); ! 340: for (kw= kwtab; **kw != '\0'; kw++) { ! 341: insert(v= mk_text(*kw), &kwlist); ! 342: release(v); ! 343: } ! 344: } ! 345: ! 346: Visible Procedure endsyn() { ! 347: release(kwlist); kwlist= Vnil; ! 348: } ! 349: ! 350: /* ******************************************************************** */ ! 351: /* signs */ ! 352: /* ******************************************************************** */ ! 353: ! 354: Visible string textsign; ! 355: ! 356: Hidden bool la_denum(tx0) txptr tx0; { ! 357: char l, r; ! 358: switch (l= Char(++tx0)) { ! 359: case '/': r= '*'; break; ! 360: case '*': r= '/'; break; ! 361: default: return Yes; ! 362: } ! 363: do if (Char(++tx0) != r) return No; while (Char(++tx0) == l); ! 364: return Yes; ! 365: } ! 366: ! 367: #ifdef NOT_USED ! 368: Visible bool colon_sign() { ! 369: return Char(tx) == ':' ? (tx++, Yes) : No; ! 370: } ! 371: #endif ! 372: ! 373: Visible bool comment_sign() { ! 374: return Char(tx) == '\\' ? (tx++, Yes) : No; ! 375: } ! 376: ! 377: Visible bool nwl_sign() { ! 378: return Char(tx) == '/' && !la_denum(tx-1) ? (tx++, Yes) : No; ! 379: } ! 380: ! 381: Visible bool open_sign() { ! 382: return Char(tx) == '(' ? (tx++, Yes) : No; ! 383: } ! 384: ! 385: #ifdef NOT_USED ! 386: Visible bool close_sign() { ! 387: return Char(tx) == ')' ? (tx++, Yes) : No; ! 388: } ! 389: #endif ! 390: ! 391: #ifdef NOT_USED ! 392: Visible bool comma_sign() { ! 393: return Char(tx) == ',' ? (tx++, Yes) : No; ! 394: } ! 395: #endif ! 396: ! 397: Visible bool point_sign() { ! 398: return Char(tx) == '.' ? (tx++, Yes) : No; ! 399: } ! 400: ! 401: Visible bool apostrophe_sign() { ! 402: return Char(tx) == '\'' ? (tx++, textsign= "'", Yes) : No; ! 403: } ! 404: ! 405: Visible bool quote_sign() { ! 406: return Char(tx) == '"' ? (tx++, textsign= "\"", Yes) : No; ! 407: } ! 408: ! 409: Visible bool conv_sign() { ! 410: return Char(tx) == '`' ? (tx++, Yes) : No; ! 411: } ! 412: ! 413: Visible bool curlyopen_sign() { ! 414: return Char(tx) == '{' ? (tx++, Yes) : No; ! 415: } ! 416: ! 417: Visible bool curlyclose_sign() { ! 418: return Char(tx) == '}' ? (tx++, Yes) : No; ! 419: } ! 420: ! 421: Visible bool sub_sign() { ! 422: return Char(tx) == '[' ? (tx++, Yes) : No; ! 423: } ! 424: ! 425: #ifdef NOT_USED ! 426: Visible bool bus_sign() { ! 427: return Char(tx) == ']' ? (tx++, Yes) : No; ! 428: } ! 429: #endif ! 430: ! 431: Visible bool behead_sign() { ! 432: return Char(tx) == '@' ? (tx++, textsign= "@", Yes) : No; ! 433: } ! 434: ! 435: Visible bool curtl_sign() { ! 436: return Char(tx) == '|' ? (tx++, textsign= "|", Yes) : No; ! 437: } ! 438: ! 439: Visible bool about_sign() { ! 440: return Char(tx) == '~' ? (tx++, textsign= "~", Yes) : No; ! 441: } ! 442: ! 443: Visible bool plus_sign() { ! 444: return Char(tx) == '+' ? (tx++, textsign= "+", Yes) : No; ! 445: } ! 446: ! 447: Visible bool minus_sign() { ! 448: return Char(tx) == '-' ? (tx++, textsign= "-", Yes) : No; ! 449: } ! 450: ! 451: Visible bool times_sign() { ! 452: return Char(tx) == '*' && la_denum(tx) ! 453: ? (tx++, textsign= "*", Yes) : No; ! 454: } ! 455: ! 456: Visible bool over_sign() { ! 457: return Char(tx) == '/' && la_denum(tx) ! 458: ? (tx++, textsign= "/", Yes) : No; ! 459: } ! 460: ! 461: Visible bool power_sign() { ! 462: return Char(tx) == '*' && Char(tx+1) == '*' && la_denum(tx+1) ! 463: ? (tx+= 2, textsign= "**", Yes) : No; ! 464: } ! 465: ! 466: Visible bool numtor_sign() { ! 467: return Char(tx) == '*' && Char(tx+1) == '/' && la_denum(tx+1) ! 468: ? (tx+= 2, textsign= "*/", Yes) : No; ! 469: } ! 470: ! 471: Visible bool denomtor_sign() { ! 472: return Char(tx) == '/' && Char(tx+1) == '*' && la_denum(tx+1) ! 473: ? (tx+= 2, textsign= "/*", Yes) : No; ! 474: } ! 475: ! 476: Visible bool join_sign() { ! 477: return Char(tx) == '^' && Char(tx+1) != '^' ! 478: ? (tx++, textsign= "^", Yes) : No; ! 479: } ! 480: ! 481: Visible bool reptext_sign() { ! 482: return Char(tx) == '^' && Char(tx+1) == '^' ! 483: ? (tx+= 2, textsign= "^^", Yes) : No; ! 484: } ! 485: ! 486: Visible bool leftadj_sign() { ! 487: return Char(tx) == '<' && Char(tx+1) == '<' ! 488: ? (tx+= 2, textsign= "<<", Yes) : No; ! 489: } ! 490: ! 491: Visible bool center_sign() { ! 492: return Char(tx) == '>' && Char(tx+1) == '<' ! 493: ? (tx+= 2, textsign= "><", Yes) : No; ! 494: } ! 495: ! 496: Visible bool rightadj_sign() { ! 497: return Char(tx) == '>' && Char(tx+1) == '>' ! 498: ? (tx+= 2, textsign= ">>", Yes) : No; ! 499: } ! 500: ! 501: Visible bool number_sign() { ! 502: return Char(tx) == '#' ? (tx++, textsign= "#", Yes) : No; ! 503: } ! 504: ! 505: Visible bool less_than_sign() { ! 506: return Char(tx) == '<' && Char(tx+1) != '=' && ! 507: Char(tx+1) != '>' && Char(tx+1) != '<' ! 508: ? (tx++, Yes) : No; ! 509: } ! 510: ! 511: Visible bool at_most_sign() { ! 512: return Char(tx) == '<' && Char(tx+1) == '=' ? (tx+= 2, Yes) : No; ! 513: } ! 514: ! 515: Visible bool equals_sign() { ! 516: return Char(tx) == '=' ? (tx++, Yes) : No; ! 517: } ! 518: ! 519: Visible bool unequal_sign() { ! 520: return Char(tx) == '<' && Char(tx+1) == '>' ? (tx+= 2, Yes) : No; ! 521: } ! 522: ! 523: Visible bool at_least_sign() { ! 524: return Char(tx) == '>' && Char(tx+1) == '=' ? (tx+= 2, Yes) : No; ! 525: } ! 526: ! 527: Visible bool greater_than_sign() { ! 528: return Char(tx) == '>' && Char(tx+1) != '=' ! 529: && Char(tx+1) != '>' && Char(tx+1) != '<' ! 530: ? (tx++, Yes) : No; ! 531: } ! 532: ! 533: Visible bool dyamon_sign() { ! 534: return plus_sign() || minus_sign() || number_sign(); ! 535: } ! 536: ! 537: Visible bool dya_sign() { ! 538: return times_sign() || over_sign() || power_sign() || ! 539: join_sign() || reptext_sign() || ! 540: leftadj_sign() || center_sign() || rightadj_sign(); ! 541: } ! 542: ! 543: Visible bool mon_sign() { ! 544: return about_sign() || numtor_sign() || denomtor_sign(); ! 545: } ! 546: ! 547: Visible bool trim_sign() { ! 548: return behead_sign() || curtl_sign(); ! 549: } ! 550: ! 551: Visible bool check_keyword() { return atkw(K_CHECK); } ! 552: Visible bool choose_keyword() { return atkw(K_CHOOSE); } ! 553: Visible bool delete_keyword() { return atkw(K_DELETE); } ! 554: Visible bool draw_keyword() { return atkw(K_DRAW); } ! 555: Visible bool insert_keyword() { return atkw(K_INSERT); } ! 556: Visible bool put_keyword() { return atkw(K_PUT); } ! 557: Visible bool read_keyword() { return atkw(K_READ); } ! 558: Visible bool remove_keyword() { return atkw(K_REMOVE); } ! 559: Visible bool setrandom_keyword() { return atkw(K_SET_RANDOM); } ! 560: Visible bool write_keyword() { return atkw(K_WRITE); } ! 561: Visible bool fail_keyword() { return atkw(K_FAIL); } ! 562: Visible bool quit_keyword() { return atkw(K_QUIT); } ! 563: Visible bool return_keyword() { return atkw(K_RETURN); } ! 564: Visible bool report_keyword() { return atkw(K_REPORT); } ! 565: Visible bool succeed_keyword() { return atkw(K_SUCCEED); } ! 566: Visible bool if_keyword() { return atkw(K_IF); } ! 567: Visible bool select_keyword() { return atkw(K_SELECT); } ! 568: Visible bool while_keyword() { return atkw(K_WHILE); } ! 569: Visible bool for_keyword() { return atkw(K_FOR); } ! 570: Visible bool else_keyword() { return atkw(K_ELSE); } ! 571: #ifdef NOT_USED ! 572: Visible bool and_keyword() { return atkw(K_AND); } ! 573: Visible bool or_keyword() { return atkw(K_OR); } ! 574: #endif ! 575: Visible bool not_keyword() { return atkw(K_NOT); } ! 576: Visible bool some_keyword() { return atkw(K_SOME); } ! 577: Visible bool each_keyword() { return atkw(K_EACH); } ! 578: Visible bool no_keyword() { return atkw(K_NO); } ! 579: Visible bool how_to_keyword() { return atkw(K_HOW_TO); } ! 580: Visible bool yield_keyword() { return atkw(K_YIELD); } ! 581: Visible bool test_keyword() { return atkw(K_TEST); } ! 582: Visible bool share_keyword() { return atkw(K_SHARE); }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.