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

##### Functions

    call              X
    endall            X
    erm               X
    imm_command       X
    init              X
    main              X
    memstat           X
    process           X
    qmalloc           X
    sa_expr           X
    show_call         X
    special           X

##### Variables

    _stack            X
    alloccnt          X
    call_error        X
    dflag             X
    extcmds           X
    hushbaby          X
    in_process        X
    pname             X
    slowterminal      X
    timing            X

##### Macros

    Cllerr            X
    PCLEAK            X
    STATMEM           X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2:
       3: /*
       4:  $Header: b3mai.c,v 1.4 85/08/22 17:15:36 timo Exp $
       5:  */
       6:
       7:
       8: /* B driver for interpreter */
       9:
      10: #include "b.h"
      11: #include "b0fea.h"
      12: #include "b1obj.h"
      13: #include "b1mem.h"
      14: #include "b2nod.h"
      15: #include "b2syn.h"
      16: #include "b2par.h"
      17: #include "b3env.h"
      18: #include "b3scr.h"
      19: #include "b3err.h"
      20: #include "b3fil.h"
      21: #include "b3sig.h"
      22: #include "b3sem.h"
      23: #include "b3sou.h"
      24:
      25: value evalthread();
      26:
      27: Hidden bool call_error, in_process;
      28:
      29: #ifdef INTEGRATION
      30: bool dflag= No; /* -d: debugging output wanted */
      31: bool slowterminal= No;
      32: bool hushbaby= No;
      33: #endif INTEGRATION
      34:
      35: Visible bool timing; /* Set if timing output wanted */
      36: Visible bool extcmds; /* Set if must recognize extended commands */
      37:
      38: main(argc, argv) int argc; string argv[]; {
      39: #ifdef START_MESSAGE
      40:     fprintf(stderr, "Interactive B version %s\n%s\n", rcsid,
      41:         "Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985.");
      42: #endif
      43:     in_process= No; call_error= No;
      44:     call(argc, argv);
      45:     if (call_error) exit(-1);
      46:     in_process= Yes;
      47:     init();
      48:     call(argc, argv);
      49:     bye(0);
      50: }
      51:
      52: #define Cllerr stderr
      53:
      54: Hidden string pname;     /* program name */
      55:
      56: Hidden Procedure erm(m, n, argc, pargc, pargv) string m, n; int argc, pargc; string pargv[]; {
      57:     fprintf(Cllerr,
      58:  "*** There is something I don't quite get in your call of %s\n", pname);
      59:     show_call(argc, pargc, pargv);
      60:     fprintf(Cllerr, "*** The problem is: %s %s\n", m, n);
      61:     if (in_process) bye(-1);
      62:     call_error= Yes;
      63: }
      64:
      65: Hidden Procedure call(pargc, pargv) int pargc; string pargv[]; {
      66:     int argc; string *argv;
      67:
      68:     pname = pargv[0];
      69:     argc = pargc-1;
      70:     argv = pargv+1;
      71:     while (argc >= 0)
      72:     if (argc > 0 && argv[0][0] == '-' && argv[0][1] != '\0') {
      73:         if (argv[0][1] == 'q') { if (in_process) bye(0);
      74: #ifndef INTEGRATION
      75:         } else if (argv[0][1] == 'i') {
      76:             filtered= Yes;
      77:             cmd_prompt= "\001>";
      78:             eg_prompt=  "\001E";
      79:             raw_prompt= "\001R";
      80:             qn_prompt=  "\001Y";
      81: #endif
      82:         } else if (argv[0][1] == 'T') {
      83:             timing = Yes;
      84:         } else if (argv[0][1] == 'E') {
      85:             extcmds = Yes;
      86: #ifdef INTEGRATION
      87: #ifndef NDEBUG
      88:         } else if (argv[0][1] == 'd') {
      89:             dflag= Yes;
      90: #endif NDEBUG
      91: #endif INTEGRATION
      92:         } else erm("I never learned about the option", argv[0], argc, pargc, pargv);
      93:         argc -= 1;
      94:         argv += 1;
      95:     } else {
      96:         if (argc == 0 || (argv[0][0] == '-' && argv[0][1] == '\0')) {
      97:             release(iname);
      98:             iname = Vnil;
      99:             ifile = stdin;
     100:         } else {
     101:             release(iname);
     102:             iname = mk_text(*argv);
     103:             ifile = fopen(*argv, "r");
     104:         }
     105:         if (ifile != NULL) { if (in_process) process();
     106:         } else erm("can't open input file", *argv, argc, pargc, pargv);
     107:         if (ifile != NULL && ifile != stdin) fclose(ifile);
     108:         ++argv; --argc;
     109:     }
     110: }
     111:
     112: Hidden Procedure show_call(eargc, pargc, pargv)
     113:  int eargc, pargc; string pargv[]; {
     114:     int argc= pargc; string *argv= pargv;
     115:     intlet p, pos= 4;
     116:     fprintf(Cllerr, "    ");
     117:     while (argc > 0) {
     118:         fprintf(Cllerr, *argv);
     119:         pos+= strlen(*argv);
     120:         if (argc == eargc) p= pos-1;
     121:         ++argv; --argc;
     122:         if (argc > 0) {
     123:             putc(' ', Cllerr);
     124:             pos++;
     125:         }
     126:     }
     127:     putc('\n', Cllerr);
     128:     for (pos= 0; pos < p; pos++) putc(' ', Cllerr);
     129:     fprintf(Cllerr, "^\n");
     130: }
     131:
     132: #ifdef STATMEM
     133: #ifndef IBMPC
     134: #undef STATMEM
     135: #endif
     136: #endif
     137:
     138: #ifdef ebug
     139: #ifdef IBMPC
     140: #define PCLEAK
     141: #ifndef STATMEM
     142: #define STATMEM
     143: #endif STATMEM
     144: #endif IBMPC
     145: #endif ebug
     146:
     147: #ifdef IBMPC
     148: Visible unsigned _stack= 6000; /* Default stack size */
     149: #endif
     150:
     151: #ifdef STATMEM
     152: Hidden long alloccnt= 0;
     153: #endif
     154:
     155: /* Quick hack to print memory statistics */
     156: Visible Procedure memstat(where) string where; {
     157: #ifdef STATMEM
     158:     long sizmem();
     159:     fprintf(stderr, "*** %s: sizmem=%ld, sizmalloc=%ld.\n",
     160:             where, sizmem(), alloccnt);
     161: #endif
     162: }
     163:
     164: Visible char*
     165: qmalloc(syze)
     166:     unsigned syze;
     167: {
     168: #ifdef STATMEM
     169:     char *p;
     170:     long before, sizmem();
     171:     before= sizmem();
     172:     p= malloc(syze);
     173:     alloccnt += (before - sizmem());
     174:     return p;
     175: #else
     176:     return malloc(syze);
     177: #endif
     178: }
     179:
     180: Hidden Procedure init() {
     181: #ifdef STATMEM
     182:     allmem();
     183:     memstat("before init");
     184: #endif
     185:     set_file_names();
     186: #ifdef INTEGRATION
     187:     initgram(); /* set refcnt to infinity */
     188:     initsugg(); /* set refcnt to infinity */
     189:     memstat("after gram/sugg");
     190: #endif
     191: #ifdef PCLEAK
     192:     initsou();
     193:     initfpr();
     194: #endif
     195:     initmem();
     196:     initenv();
     197:     initnum();
     198:     initsyn();
     199: #ifndef PCLEAK
     200:     initsou();
     201:     initfpr();
     202: #endif
     203:     init_scr();
     204:     initerr();
     205:     initsig();
     206:     initint();
     207: #ifdef TYPE_CHECK
     208:     initpol();
     209:     inittyp();
     210: #endif
     211: #ifdef INTEGRATION
     212:     initfile();
     213:     initkeys();
     214: #ifdef unix
     215:     initunix();
     216: #endif
     217:     initterm();
     218:     initbtop();
     219: #endif
     220:     end_init();
     221:     setprmnv();
     222:     getprmnv();
     223:     memstat("after init");
     224:     showtime("after initialization");
     225: }
     226:
     227: Visible Procedure
     228: endall()
     229: {
     230:     endsou();
     231:     endsyn();
     232:     endnum();
     233:     endenv();
     234:     endsta();
     235: #ifdef INTEGRATION
     236:     endscr();
     237:     endterm();
     238:     /* enddemo(); ? */
     239:     endbtop();
     240: #ifdef unix
     241:     endunix();
     242: #endif
     243:     enderro();
     244:     endsugg();
     245: #endif INTEGRATION
     246: }
     247:
     248: /* ******************************************************************** */
     249: /*		immediate command					*/
     250: /* ******************************************************************** */
     251:
     252: Hidden bool sa_expr(e) parsetree *e; {
     253:     return is_expr(Char(tx)) ? (*e= expr(ceol), Yes) : No;
     254: }
     255:
     256: Hidden Procedure special() {
     257:     switch(Char(tx++)) {
     258:         case ':':       skipsp(&tx);
     259:                 if (Char(tx) == ':') lst_uhds();
     260:                 else edit_unit();
     261:                 break;
     262:         case '=':       skipsp(&tx);
     263:                 if (Char(tx) == '=') lst_ttgs();
     264:                 else edit_target();
     265:                 break;
     266:         case '!':       system(tx); break;
     267:             /* Obey the rest of the line as an OS command */
     268:         default:    syserr(MESS(3700, "special"));
     269:     }
     270: }
     271:
     272: Visible Procedure imm_command() {
     273:     parsetree codeseq= NilTree;
     274:     parsetree c= NilTree, d= NilTree, e= NilTree; value v; int level;
     275:     cntxt= In_command; still_ok= Yes; interrupted= No;
     276:     terminated= No;
     277:     resexp= Voi; lino= 0;
     278:     level= ilev();
     279:     if (!still_ok) return;
     280:     if (level > 0) parerr(MESS(3701, "outer indentation not zero"));
     281:     else if (findceol(), Ceol(tx));
     282:     else if (Char(tx) == ':' || Char(tx) == '=' || Char(tx) == '!')
     283:         if (interactive) special();
     284:         else parerr(MESS(3702, "special commands only interactively"));
     285:     else if (sa_expr(&e)) {
     286:         if (still_ok) fix_nodes(&e, &codeseq);
     287:         showtime("after fix_nodes");
     288:         curline= e; curlino= one;
     289:         v= evalthread(codeseq);
     290:         if (still_ok) { wri(v, Yes, No, No); newline(); }
     291:         release(v); release(e);
     292:         showtime("after evaluation");
     293:     } else if (unit_keyword()) {
     294:         create_unit();
     295:     } else if (quit_keyword()) terminated= Yes;
     296:     else if (term_com(&c)) {
     297:         release(c);
     298:         parerr(MESS(3703, "terminating commands only allowed in units and refinements"));
     299:     } else if (control_command(&c) || simple_command(&c, &d)) {
     300:             /* control_command MUST come before simple above */
     301:         if (still_ok) fix_nodes(&c, &codeseq);
     302:         showtime("after fix_nodes");
     303:         curline= c; curlino= one;
     304:         execthread(codeseq);
     305:         release(c); release(d);
     306:         showtime("after execution");
     307:     } else parerr(MESS(3704, "I don't recognise this as a command"));
     308: }
     309:
     310: Hidden Procedure process() {
     311:     re_screen();
     312:     re_env();
     313:     f_lino= 0;
     314:     while (!Eof && !terminated) {
     315: #ifdef EXT_COMMAND
     316:         e_done();
     317: #endif
     318:         imm_command();
     319:         if (!interactive && !still_ok) bye(1);
     320:     }
     321: }

#### Defined functions

call defined in line 65; used 2 times

- in line 44-48(2)

endall defined in line 227; used 1 times

- in /usr/src/new/PORT/B/src/bint/b3err.c line 410

erm defined in line 56; used 2 times

- in line 92, 106

imm_command defined in line 272; used 1 times

- in line 318

init defined in line 180; used 1 times

- in line 47

main defined in line 38; never used
memstat defined in line 156; used 4 times

- in line 183, 189, 223
- in /usr/src/new/PORT/B/src/bint/b3err.c line 416

process defined in line 310; used 1 times

- in line 105

qmalloc defined in line 164; never used
sa_expr defined in line 252; used 1 times

- in line 285

show_call defined in line 112; used 1 times

- in line 59

special defined in line 256; used 1 times

- in line 283

#### Defined variables

_stack defined in line 148; never used
alloccnt defined in line 152; used 2 times

- in line 160, 173

call_error defined in line 27; used 3 times

- in line 43-45(2), 62

dflag defined in line 30; used 1 times

- in line 89

extcmds defined in line 36; used 1 times

- in line 85

hushbaby defined in line 32; never used
in_process defined in line 27; used 5 times

- in line 43-46(2), 61, 73, 105

pname defined in line 54; used 2 times

- in line 58, 68

slowterminal defined in line 31; never used
timing defined in line 35; used 1 times

- in line 83

#### Defined macros

Cllerr defined in line 52; used 8 times

- in line 57-60(2), 116-129(6)

PCLEAK defined in line 140; used 2 times

- in line 191, 199

STATMEM defined in line 142; used 7 times

- in line 132-134(2), 141, 151, 157, 168, 181

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