home *** CD-ROM | disk | FTP | other *** search
/ Carousel Volume 2 #1 / carousel.iso / mactosh / code / microema.sit / src / exec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-09  |  22.1 KB  |  1,160 lines  |  [TEXT/Earl]
  1. /*    This file is for functions dealing with execution of
  2.     commands, command lines, buffers, files and startup files
  3.  
  4.     written 1986 by Daniel Lawrence             */
  5.  
  6. #include    <stdio.h>
  7. #include    "estruct.h"
  8. #include    "edef.h"
  9.  
  10. /* namedcmd:    execute a named command even if it is not bound */
  11.  
  12. namedcmd(f, n)
  13.  
  14. int f, n;    /* command arguments [passed through to command executed] */
  15.  
  16. {
  17.     register int (*kfunc)(); /* ptr to the requexted function to bind to */
  18.     int (*getname())();
  19.  
  20.     /* prompt the user to type a named command */
  21.     mlwrite(": ");
  22.  
  23.     /* and now get the function name to execute */
  24.     kfunc = getname();
  25.     if (kfunc == NULL) {
  26.         mlwrite("[No such function]");
  27.         return(FALSE);
  28.     }
  29.  
  30.     /* and then execute the command */
  31.     return((*kfunc)(f, n));
  32. }
  33.  
  34. /*    execcmd:    Execute a command line command to be typed in
  35.             by the user                    */
  36.  
  37. execcmd(f, n)
  38.  
  39. int f, n;    /* default Flag and Numeric argument */
  40.  
  41. {
  42.     register int status;        /* status return */
  43.     char cmdstr[NSTRING];        /* string holding command to execute */
  44.  
  45.     /* get the line wanted */
  46.     if ((status = mlreply(": ", cmdstr, NSTRING)) != TRUE)
  47.         return(status);
  48.  
  49.     execlevel = 0;
  50.     return(docmd(cmdstr));
  51. }
  52.  
  53. /*    docmd:    take a passed string as a command line and translate
  54.         it to be executed as a command. This function will be
  55.         used by execute-command-line and by all source and
  56.         startup files. Lastflag/thisflag is also updated.
  57.  
  58.     format of the command line is:
  59.  
  60.         {# arg} <command-name> {<argument string(s)>}
  61.  
  62. */
  63.  
  64. docmd(cline)
  65.  
  66. char *cline;    /* command line to execute */
  67.  
  68. {
  69.     register int f;     /* default argument flag */
  70.     register int n;     /* numeric repeat value */
  71.     int (*fnc)();        /* function to execute */
  72.     int status;        /* return status of function */
  73.     int oldcle;        /* old contents of clexec flag */
  74.     char *oldestr;        /* original exec string */
  75.     char tkn[NSTRING];    /* next token off of command line */
  76.     int (*fncmatch())();
  77.         
  78.     /* if we are scanning and not executing..go back here */
  79.     if (execlevel)
  80.         return(TRUE);
  81.  
  82.     oldestr = execstr;    /* save last ptr to string to execute */
  83.     execstr = cline;    /* and set this one as current */
  84.  
  85.     /* first set up the default command values */
  86.     f = FALSE;
  87.     n = 1;
  88.     lastflag = thisflag;
  89.     thisflag = 0;
  90.  
  91.     if ((status = macarg(tkn)) != TRUE) {    /* and grab the first token */
  92.         execstr = oldestr;
  93.         return(status);
  94.     }
  95.  
  96.     /* process leadin argument */
  97.     if (gettyp(tkn) != TKCMD) {
  98.         f = TRUE;
  99.         strcpy(tkn, getval(tkn));
  100.         n = atoi(tkn);
  101.  
  102.         /* and now get the command to execute */
  103.         if ((status = macarg(tkn)) != TRUE) {
  104.             execstr = oldestr;
  105.             return(status); 
  106.         }    
  107.     }
  108.  
  109.     /* and match the token to see if it exists */
  110.     if ((fnc = fncmatch(tkn)) == NULL) {
  111.         mlwrite("[No such Function]");
  112.         execstr = oldestr;
  113.         return(FALSE);
  114.     }
  115.     
  116.     /* save the arguments and go execute the command */
  117.     oldcle = clexec;        /* save old clexec flag */
  118.     clexec = TRUE;            /* in cline execution */
  119.     status = (*fnc)(f, n);        /* call the function */
  120.     cmdstatus = status;        /* save the status */
  121.     clexec = oldcle;        /* restore clexec flag */
  122.     execstr = oldestr;
  123.     return(status);
  124. }
  125.  
  126. /* token:    chop a token off a string
  127.         return a pointer past the token
  128. */
  129.  
  130. char *token(src, tok, size)
  131.  
  132. char *src, *tok;    /* source string, destination token string */
  133. int size;        /* maximum size of token */
  134.  
  135. {
  136.     register int quotef;    /* is the current string quoted? */
  137.     register char c;    /* temporary character */
  138.  
  139.     /* first scan past any whitespace in the source string */
  140.     while (*src == ' ' || *src == '\t')
  141.         ++src;
  142.  
  143.     /* scan through the source string */
  144.     quotef = FALSE;
  145.     while (*src) {
  146.         /* process special characters */
  147.         if (*src == '~') {
  148.             ++src;
  149.             if (*src == 0)
  150.                 break;
  151.             switch (*src++) {
  152.                 case 'r':    c = CR; break;
  153.                 case 'n':    c = EOLCHAR; break;
  154.                 case 't':    c = 9;    break;
  155.                 case 'b':    c = 8;    break;
  156.                 case 'f':    c = 12; break;
  157.                 default:    c = *(src-1);
  158.             }
  159.             if (--size > 0) {
  160.                 *tok++ = c;
  161.             }
  162.         } else {
  163.             /* check for the end of the token */
  164.             if (quotef) {
  165.                 if (*src == '"')
  166.                     break;
  167.             } else {
  168.                 if (*src == ' ' || *src == '\t')
  169.                     break;
  170.             }
  171.  
  172.             /* set quote mode if quote found */
  173.             if (*src == '"')
  174.                 quotef = TRUE;
  175.  
  176.             /* record the character */
  177.             c = *src++;
  178.             if (--size > 0)
  179.                 *tok++ = c;
  180.         }
  181.     }
  182.  
  183.     /* terminate the token and exit */
  184.     if (*src)
  185.         ++src;
  186.     *tok = 0;
  187.     return(src);
  188. }
  189.  
  190. macarg(tok)    /* get a macro line argument */
  191.  
  192. char *tok;    /* buffer to place argument */
  193.  
  194. {
  195.     int savcle;    /* buffer to store original clexec */
  196.     int status;
  197.  
  198.     savcle = clexec;    /* save execution mode */
  199.     clexec = TRUE;        /* get the argument */
  200.     status = nextarg("", tok, NSTRING, ctoec(EOLCHAR));
  201.     clexec = savcle;    /* restore execution mode */
  202.     return(status);
  203. }
  204.  
  205. /*    nextarg:    get the next argument    */
  206.  
  207. nextarg(prompt, buffer, size, terminator)
  208.  
  209. char *prompt;        /* prompt to use if we must be interactive */
  210. char *buffer;        /* buffer to put token into */
  211. int size;        /* size of the buffer */
  212. int terminator;     /* terminating char to be used on interactive fetch */
  213.  
  214. {
  215.     /* if we are interactive, go get it! */
  216.     if (clexec == FALSE)
  217.         return(getstring(prompt, buffer, size, terminator));
  218.  
  219.     /* grab token and advance past */
  220.     execstr = token(execstr, buffer, size);
  221.  
  222.     /* evaluate it */
  223.     strcpy(buffer, getval(buffer));
  224.     return(TRUE);
  225. }
  226.  
  227. /*    storemac:    Set up a macro buffer and flag to store all
  228.             executed command lines there            */
  229.  
  230. storemac(f, n)
  231.  
  232. int f;        /* default flag */
  233. int n;        /* macro number to use */
  234.  
  235. {
  236.     register struct BUFFER *bp;    /* pointer to macro buffer */
  237.     char bname[NBUFN];        /* name of buffer to use */
  238.  
  239.     /* must have a numeric argument to this function */
  240.     if (f == FALSE) {
  241.         mlwrite("No macro specified");
  242.         return(FALSE);
  243.     }
  244.  
  245.     /* range check the macro number */
  246.     if (n < 1 || n > 40) {
  247.         mlwrite("Macro number out of range");
  248.         return(FALSE);
  249.     }
  250.  
  251.     /* construct the macro buffer name */
  252.     strcpy(bname, "[Macro xx]");
  253.     bname[7] = '0' + (n / 10);
  254.     bname[8] = '0' + (n % 10);
  255.  
  256.     /* set up the new macro buffer */
  257.     if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
  258.         mlwrite("Can not create macro");
  259.         return(FALSE);
  260.     }
  261.  
  262.     /* and make sure it is empty */
  263.     bclear(bp);
  264.  
  265.     /* and set the macro store pointers to it */
  266.     mstore = TRUE;
  267.     bstore = bp;
  268.     return(TRUE);
  269. }
  270.  
  271. #if    PROC
  272. /*    storeproc:    Set up a procedure buffer and flag to store all
  273.             executed command lines there            */
  274.  
  275. storeproc(f, n)
  276.  
  277. int f;        /* default flag */
  278. int n;        /* macro number to use */
  279.  
  280. {
  281.     register struct BUFFER *bp;    /* pointer to macro buffer */
  282.     register int status;        /* return status */
  283.     char bname[NBUFN];        /* name of buffer to use */
  284.  
  285.     /* a numeric argument means its a numbered macro */
  286.     if (f == TRUE)
  287.         return(storemac(f, n));
  288.  
  289.     /* get the name of the procedure */
  290.     if ((status = mlreply("Procedure name: ", &bname[1], NBUFN-2)) != TRUE)
  291.         return(status);
  292.  
  293.     /* construct the macro buffer name */
  294.     bname[0] = '[';
  295.     strcat(bname, "]");
  296.  
  297.     /* set up the new macro buffer */
  298.     if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
  299.         mlwrite("Can not create macro");
  300.         return(FALSE);
  301.     }
  302.  
  303.     /* and make sure it is empty */
  304.     bclear(bp);
  305.  
  306.     /* and set the macro store pointers to it */
  307.     mstore = TRUE;
  308.     bstore = bp;
  309.     return(TRUE);
  310. }
  311.  
  312. /*    execproc:    Execute a procedure                */
  313.  
  314. execproc(f, n)
  315.  
  316. int f, n;    /* default flag and numeric arg */
  317.  
  318. {
  319.     register BUFFER *bp;        /* ptr to buffer to execute */
  320.     register int status;        /* status return */
  321.     char bufn[NBUFN+2];        /* name of buffer to execute */
  322.  
  323.     /* find out what buffer the user wants to execute */
  324.     if ((status = mlreply("Execute procedure: ", &bufn[1], NBUFN)) != TRUE)
  325.         return(status);
  326.  
  327.     /* construct the buffer name */
  328.     bufn[0] = '[';
  329.     strcat(bufn, "]");
  330.  
  331.     /* find the pointer to that buffer */
  332.     if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
  333.         mlwrite("No such procedure");
  334.         return(FALSE);
  335.     }
  336.  
  337.     /* and now execute it as asked */
  338.     while (n-- > 0)
  339.         if ((status = dobuf(bp)) != TRUE)
  340.             return(status);
  341.     return(TRUE);
  342. }
  343. #endif
  344.  
  345. /*    execbuf:    Execute the contents of a buffer of commands    */
  346.  
  347. execbuf(f, n)
  348.  
  349. int f, n;    /* default flag and numeric arg */
  350.  
  351. {
  352.     register BUFFER *bp;        /* ptr to buffer to execute */
  353.     register int status;        /* status return */
  354.     char bufn[NSTRING];        /* name of buffer to execute */
  355.  
  356.     /* find out what buffer the user wants to execute */
  357.     if ((status = mlreply("Execute buffer: ", bufn, NBUFN)) != TRUE)
  358.         return(status);
  359.  
  360.     /* find the pointer to that buffer */
  361.     if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
  362.         mlwrite("No such buffer");
  363.         return(FALSE);
  364.     }
  365.  
  366.     /* and now execute it as asked */
  367.     while (n-- > 0)
  368.         if ((status = dobuf(bp)) != TRUE)
  369.             return(status);
  370.     return(TRUE);
  371. }
  372.  
  373. /*    dobuf:    execute the contents of the buffer pointed to
  374.         by the passed BP
  375.  
  376.     Directives start with a "!" and include:
  377.  
  378.     !endm        End a macro
  379.     !if (cond)    conditional execution
  380.     !else
  381.     !endif
  382.     !return     Return (terminating current macro)
  383.     !goto <label>    Jump to a label in the current macro
  384.     !force        Force macro to continue...even if command fails
  385.     !while (cond)    Execute a loop if the condition is true
  386.     !endwhile
  387.     
  388.     Line Labels begin with a "*" as the first nonblank char, like:
  389.  
  390.     *LBL01
  391. */
  392.  
  393. dobuf(bp)
  394.  
  395. BUFFER *bp;    /* buffer to execute */
  396.  
  397. {
  398.     register int status;    /* status return */
  399.     register LINE *lp;    /* pointer to line to execute */
  400.     register LINE *hlp;    /* pointer to line header */
  401.     register LINE *glp;    /* line to goto */
  402.     LINE *mp;        /* Macro line storage temp */
  403.     int dirnum;        /* directive index */
  404.     int linlen;        /* length of line to execute */
  405.     int i;            /* index */
  406.     int c;            /* temp character */
  407.     int force;        /* force TRUE result? */
  408.     WINDOW *wp;        /* ptr to windows to scan */
  409.     WHBLOCK *whlist;    /* ptr to !WHILE list */
  410.     WHBLOCK *scanner;    /* ptr during scan */
  411.     WHBLOCK *whtemp;    /* temporary ptr to a WHBLOCK */
  412.     char *einit;        /* initial value of eline */
  413.     char *eline;        /* text of line to execute */
  414.     char tkn[NSTRING];    /* buffer to evaluate an expresion in */
  415.  
  416. #if    DEBUGM
  417.     char *sp;            /* temp for building debug string */
  418.     register char *ep;    /* ptr to end of outline */
  419. #endif
  420.  
  421.     /* clear IF level flags/while ptr */
  422.     execlevel = 0;
  423.     whlist = NULL;
  424.     scanner = NULL;
  425.  
  426.     /* scan the buffer to execute, building WHILE header blocks */
  427.     hlp = bp->b_linep;
  428.     lp = hlp->l_fp;
  429.     while (lp != hlp) {
  430.         /* scan the current line */
  431.         eline = lp->l_text;
  432.         i = lp->l_used;
  433.  
  434.         /* trim leading whitespace */
  435.         while (i-- > 0 && (*eline == ' ' || *eline == '\t'))
  436.             ++eline;
  437.  
  438.         /* if theres nothing here, don't bother */
  439.         if (i <= 0)
  440.             goto nxtscan;
  441.  
  442.         /* if is a while directive, make a block... */
  443.         if (eline[0] == '!' && eline[1] == 'w' && eline[2] == 'h') {
  444.             whtemp = (WHBLOCK *)malloc(sizeof(WHBLOCK));
  445.             if (whtemp == NULL) {
  446. noram:                mlwrite("%%Out of memory during while scan");
  447. failexit:            freewhile(scanner);
  448.                 freewhile(whlist);
  449.                 return(FALSE);
  450.             }
  451.             whtemp->w_begin = lp;
  452.             whtemp->w_type = BTWHILE;
  453.             whtemp->w_next = scanner;
  454.             scanner = whtemp;
  455.         }
  456.  
  457.         /* if is a BREAK directive, make a block... */
  458.         if (eline[0] == '!' && eline[1] == 'b' && eline[2] == 'r') {
  459.             if (scanner == NULL) {
  460.                 mlwrite("%%!BREAK outside of any !WHILE loop");
  461.                 goto failexit;
  462.             }
  463.             whtemp = (WHBLOCK *)malloc(sizeof(WHBLOCK));
  464.             if (whtemp == NULL)
  465.                 goto noram;
  466.             whtemp->w_begin = lp;
  467.             whtemp->w_type = BTBREAK;
  468.             whtemp->w_next = scanner;
  469.             scanner = whtemp;
  470.         }
  471.  
  472.         /* if it is an endwhile directive, record the spot... */
  473.         if (eline[0] == '!' && strncmp(&eline[1], "endw", 4) == 0) {
  474.             if (scanner == NULL) {
  475.                 mlwrite("%%!ENDWHILE with no preceding !WHILE in '%s'",
  476.                     bp->b_bname);
  477.                 goto failexit;
  478.             }
  479.             /* move top records from the scanner list to the
  480.                whlist until we have moved all BREAK records
  481.                and one WHILE record */
  482.             do {
  483.                 scanner->w_end = lp;
  484.                 whtemp = whlist;
  485.                 whlist = scanner;
  486.                 scanner = scanner->w_next;
  487.                 whlist->w_next = whtemp;
  488.             } while (whlist->w_type == BTBREAK);
  489.         }
  490.  
  491. nxtscan:    /* on to the next line */
  492.         lp = lp->l_fp;
  493.     }
  494.  
  495.     /* while and endwhile should match! */
  496.     if (scanner != NULL) {
  497.         mlwrite("%%!WHILE with no matching !ENDWHILE in '%s'",
  498.             bp->b_bname);
  499.         goto failexit;
  500.     }
  501.  
  502.     /* let the first command inherit the flags from the last one..*/
  503.     thisflag = lastflag;
  504.  
  505.     /* starting at the beginning of the buffer */
  506.     hlp = bp->b_linep;
  507.     lp = hlp->l_fp;
  508.     while (lp != hlp) {
  509.         /* allocate eline and copy macro line to it */
  510.         linlen = lp->l_used;
  511.         if ((einit = eline = malloc(linlen+1)) == NULL) {
  512.             mlwrite("%%Out of Memory during macro execution");
  513.             freewhile(whlist);
  514.             return(FALSE);
  515.         }
  516.         strncpy(eline, lp->l_text, linlen);
  517.         eline[linlen] = 0;    /* make sure it ends */
  518.  
  519.         /* trim leading whitespace */
  520.         while (*eline == ' ' || *eline == '\t')
  521.             ++eline;
  522.  
  523.         /* dump comments and blank lines */
  524.         if (*eline == ';' || *eline == 0)
  525.             goto onward;
  526.  
  527. #if    DEBUGM
  528.         /* if $debug == TRUE, every line to execute
  529.            gets echoed and a key needs to be pressed to continue
  530.            ^G will abort the command */
  531.     
  532.         if (macbug) {
  533.             strcpy(outline, "<<<");
  534.     
  535.             /* debug macro name */
  536.             strcat(outline, bp->b_bname);
  537.             strcat(outline, ":");
  538.     
  539.             /* debug if levels */
  540.             strcat(outline, itoa(execlevel));
  541.             strcat(outline, ":");
  542.  
  543.             /* and lastly the line */
  544.             strcat(outline, eline);
  545.             strcat(outline, ">>>");
  546.     
  547.             /* change all '%' to ':' so mlwrite won't expect arguments */
  548.             sp = outline;
  549.             while (*sp)
  550.             if (*sp++ == '%') {
  551.                 /* advance to the end */
  552.                 ep = --sp;
  553.                 while (*ep++)
  554.                     ;
  555.                 /* null terminate the string one out */
  556.                 *(ep + 1) = 0;
  557.                 /* copy backwards */
  558.                 while(ep-- > sp)
  559.                     *(ep + 1) = *ep;
  560.  
  561.                 /* and advance sp past the new % */
  562.                 sp += 2;                    
  563.             }
  564.     
  565.             /* write out the debug line */
  566.             mlforce(outline);
  567.             update(TRUE);
  568.     
  569.             /* and get the keystroke */
  570.             if ((c = get1key()) == abortc) {
  571.                 mlforce("[Macro aborted]");
  572.                 freewhile(whlist);
  573.                 return(FALSE);
  574.             }
  575.  
  576.             if (c == metac)
  577.                 macbug = FALSE;
  578.         }
  579. #endif
  580.  
  581.         /* Parse directives here.... */
  582.         dirnum = -1;
  583.         if (*eline == '!') {
  584.             /* Find out which directive this is */
  585.             ++eline;
  586.             for (dirnum = 0; dirnum < NUMDIRS; dirnum++)
  587.                 if (strncmp(eline, dname[dirnum],
  588.                         strlen(dname[dirnum])) == 0)
  589.                     break;
  590.  
  591.             /* and bitch if it's illegal */
  592.             if (dirnum == NUMDIRS) {
  593.                 mlwrite("%%Unknown Directive");
  594.                 freewhile(whlist);
  595.                 return(FALSE);
  596.             }
  597.  
  598.             /* service only the !ENDM macro here */
  599.             if (dirnum == DENDM) {
  600.                 mstore = FALSE;
  601.                 bstore = NULL;
  602.                 goto onward;
  603.             }
  604.  
  605.             /* restore the original eline....*/
  606.             --eline;
  607.         }
  608.  
  609.         /* if macro store is on, just salt this away */
  610.         if (mstore) {
  611.             /* allocate the space for the line */
  612.             linlen = strlen(eline);
  613.             if ((mp=lalloc(linlen)) == NULL) {
  614.                 mlwrite("Out of memory while storing macro");
  615.                 return (FALSE);
  616.             }
  617.     
  618.             /* copy the text into the new line */
  619.             for (i=0; i<linlen; ++i)
  620.                 lputc(mp, i, eline[i]);
  621.     
  622.             /* attach the line to the end of the buffer */
  623.             bstore->b_linep->l_bp->l_fp = mp;
  624.             mp->l_bp = bstore->b_linep->l_bp;
  625.             bstore->b_linep->l_bp = mp;
  626.             mp->l_fp = bstore->b_linep;
  627.             goto onward;
  628.         }
  629.     
  630.  
  631.         force = FALSE;
  632.  
  633.         /* dump comments */
  634.         if (*eline == '*')
  635.             goto onward;
  636.  
  637.         /* now, execute directives */
  638.         if (dirnum != -1) {
  639.             /* skip past the directive */
  640.             while (*eline && *eline != ' ' && *eline != '\t')
  641.                 ++eline;
  642.             execstr = eline;
  643.  
  644.             switch (dirnum) {
  645.             case DIF:    /* IF directive */
  646.                 /* grab the value of the logical exp */
  647.                 if (execlevel == 0) {
  648.                     if (macarg(tkn) != TRUE)
  649.                         goto eexec;
  650.                     if (stol(tkn) == FALSE)
  651.                         ++execlevel;
  652.                 } else
  653.                     ++execlevel;
  654.                 goto onward;
  655.  
  656.             case DWHILE:    /* WHILE directive */
  657.                 /* grab the value of the logical exp */
  658.                 if (execlevel == 0) {
  659.                     if (macarg(tkn) != TRUE)
  660.                         goto eexec;
  661.                     if (stol(tkn) == TRUE)
  662.                         goto onward;
  663.                 }
  664.                 /* drop down and act just like !BREAK */
  665.  
  666.             case DBREAK:    /* BREAK directive */
  667.                 if (dirnum == DBREAK && execlevel)
  668.                     goto onward;
  669.  
  670.                 /* jump down to the endwhile */
  671.                 /* find the right while loop */
  672.                 whtemp = whlist;
  673.                 while (whtemp) {
  674.                     if (whtemp->w_begin == lp)
  675.                         break;
  676.                     whtemp = whtemp->w_next;
  677.                 }
  678.             
  679.                 if (whtemp == NULL) {
  680.                     mlwrite("%%Internal While loop error");
  681.                     freewhile(whlist);
  682.                     return(FALSE);
  683.                 }
  684.             
  685.                 /* reset the line pointer back.. */
  686.                 lp = whtemp->w_end;
  687.                 goto onward;
  688.  
  689.             case DELSE:    /* ELSE directive */
  690.                 if (execlevel == 1)
  691.                     --execlevel;
  692.                 else if (execlevel == 0 )
  693.                     ++execlevel;
  694.                 goto onward;
  695.  
  696.             case DENDIF:    /* ENDIF directive */
  697.                 if (execlevel)
  698.                     --execlevel;
  699.                 goto onward;
  700.  
  701.             case DGOTO:    /* GOTO directive */
  702.                 /* .....only if we are currently executing */
  703.                 if (execlevel == 0) {
  704.  
  705.                     /* grab label to jump to */
  706.                     eline = token(eline, golabel, NPAT);
  707.                     linlen = strlen(golabel);
  708.                     glp = hlp->l_fp;
  709.                     while (glp != hlp) {
  710.                         if (*glp->l_text == '*' &&
  711.                             (strncmp(&glp->l_text[1], golabel,
  712.                                 linlen) == 0)) {
  713.                             lp = glp;
  714.                             goto onward;
  715.                         }
  716.                         glp = glp->l_fp;
  717.                     }
  718.                     mlwrite("%%No such label");
  719.                     freewhile(whlist);
  720.                     return(FALSE);
  721.                 }
  722.                 goto onward;
  723.     
  724.             case DRETURN:    /* RETURN directive */
  725.                 if (execlevel == 0)
  726.                     goto eexec;
  727.                 goto onward;
  728.  
  729.             case DENDWHILE: /* ENDWHILE directive */
  730.                 if (execlevel) {
  731.                     --execlevel;
  732.                     goto onward;
  733.                 } else {
  734.                     /* find the right while loop */
  735.                     whtemp = whlist;
  736.                     while (whtemp) {
  737.                         if (whtemp->w_type == BTWHILE &&
  738.                             whtemp->w_end == lp)
  739.                             break;
  740.                         whtemp = whtemp->w_next;
  741.                     }
  742.         
  743.                     if (whtemp == NULL) {
  744.                         mlwrite("%%Internal While loop error");
  745.                         freewhile(whlist);
  746.                         return(FALSE);
  747.                     }
  748.         
  749.                     /* reset the line pointer back.. */
  750.                     lp = whtemp->w_begin->l_bp;
  751.                     goto onward;
  752.                 }
  753.  
  754.             case DFORCE:    /* FORCE directive */
  755.                 force = TRUE;
  756.  
  757.             }
  758.         }
  759.  
  760.         /* execute the statement */
  761.         status = docmd(eline);
  762.         if (force)        /* force the status */
  763.             status = TRUE;
  764.  
  765.         /* check for a command error */
  766.         if (status != TRUE) {
  767.             /* look if buffer is showing */
  768.             wp = wheadp;
  769.             while (wp != NULL) {
  770.                 if (wp->w_bufp == bp) {
  771.                     /* and point it */
  772.                     wp->w_dotp = lp;
  773.                     wp->w_doto = 0;
  774.                     wp->w_flag |= WFHARD;
  775.                 }
  776.                 wp = wp->w_wndp;
  777.             }
  778.             /* in any case set the buffer . */
  779.             bp->b_dotp = lp;
  780.             bp->b_doto = 0;
  781.             free(einit);
  782.             execlevel = 0;
  783.             freewhile(whlist);
  784.             return(status);
  785.         }
  786.  
  787. onward:     /* on to the next line */
  788.         free(einit);
  789.         lp = lp->l_fp;
  790.     }
  791.  
  792. eexec:    /* exit the current function */
  793.     execlevel = 0;
  794.     freewhile(whlist);
  795.     return(TRUE);
  796. }
  797.  
  798. freewhile(wp)    /* free a list of while block pointers */
  799.  
  800. WHBLOCK *wp;    /* head of structure to free */
  801.  
  802. {
  803.     if (wp == NULL)
  804.         return;
  805.     if (wp->w_next)
  806.         freewhile(wp->w_next);
  807.     free(wp);
  808. }
  809.  
  810. execfile(f, n)    /* execute a series of commands in a file */
  811.  
  812. int f, n;    /* default flag and numeric arg to pass on to file */
  813.  
  814. {
  815.     register int status;    /* return status of name query */
  816.     char fname[NSTRING];    /* name of file to execute */
  817.     char *fspec;        /* full file spec */
  818. #if MAC
  819. if(!clexec){        /* Interactive, use SFGetFile. */
  820.     int s;
  821.     if ((s=xgetfile(fname) != TRUE))
  822.       return(s);
  823.     }
  824. else
  825. #endif
  826.         
  827.     if ((status = mlreply("File to execute: ", fname, NSTRING -1)) != TRUE)
  828.         return(status);
  829.  
  830. #if    1
  831.     /* look up the path for the file */
  832.     fspec = flook(fname,
  833. #if MAC
  834.             clexec); /* Look in current directory if interactive. */
  835. #else
  836.             TRUE);
  837. #endif
  838.  
  839.     /* if it isn't around */
  840.     if (fspec == NULL)
  841.         return(FALSE);
  842.  
  843. #endif
  844.     /* otherwise, execute it */
  845.     while (n-- > 0)
  846.         if ((status=dofile(fspec)) != TRUE)
  847.             return(status);
  848.  
  849.     return(TRUE);
  850. }
  851.  
  852. /*    dofile: yank a file into a buffer and execute it
  853.         if there are no errors, delete the buffer on exit */
  854.  
  855. dofile(fname)
  856.  
  857. char *fname;    /* file name to execute */
  858.  
  859. {
  860.     register BUFFER *bp;    /* buffer to place file to exeute */
  861.     register BUFFER *cb;    /* temp to hold current buf while we read */
  862.     register int status;    /* results of various calls */
  863.     char bname[NBUFN];    /* name of buffer */
  864.  
  865.     makename(bname, fname);     /* derive the name of the buffer */
  866.     unqname(bname);         /* make sure we don't stomp things */
  867.     if ((bp = bfind(bname, TRUE, 0)) == NULL) /* get the needed buffer */
  868.         return(FALSE);
  869.  
  870.     bp->b_mode = MDVIEW;    /* mark the buffer as read only */
  871.     cb = curbp;        /* save the old buffer */
  872.     curbp = bp;        /* make this one current */
  873.     /* and try to read in the file to execute */
  874.     if ((status = readin(fname, FALSE)) != TRUE) {
  875.         curbp = cb;    /* restore the current buffer */
  876.         return(status);
  877.     }
  878.  
  879.     /* go execute it! */
  880.     curbp = cb;        /* restore the current buffer */
  881.     if ((status = dobuf(bp)) != TRUE)
  882.         return(status);
  883.  
  884.     /* if not displayed, remove the now unneeded buffer and exit */
  885.     if (bp->b_nwnd == 0)
  886.         zotbuf(bp);
  887.     return(TRUE);
  888. }
  889.  
  890. /*    cbuf:    Execute the contents of a numbered buffer    */
  891.  
  892. cbuf(f, n, bufnum)
  893.  
  894. int f, n;    /* default flag and numeric arg */
  895. int bufnum;    /* number of buffer to execute */
  896.  
  897. {
  898.     register BUFFER *bp;        /* ptr to buffer to execute */
  899.     register int status;        /* status return */
  900.     static char bufname[] = "[Macro xx]";
  901.  
  902.     /* make the buffer name */
  903.     bufname[7] = '0' + (bufnum / 10);
  904.     bufname[8] = '0' + (bufnum % 10);
  905.  
  906.     /* find the pointer to that buffer */
  907.     if ((bp=bfind(bufname, FALSE, 0)) == NULL) {
  908.         mlwrite("Macro not defined");
  909.         return(FALSE);
  910.     }
  911.  
  912.     /* and now execute it as asked */
  913.     while (n-- > 0)
  914.         if ((status = dobuf(bp)) != TRUE)
  915.             return(status);
  916.     return(TRUE);
  917. }
  918.  
  919. cbuf1(f, n)
  920.  
  921. {
  922.     cbuf(f, n, 1);
  923. }
  924.  
  925. cbuf2(f, n)
  926.  
  927. {
  928.     cbuf(f, n, 2);
  929. }
  930.  
  931. cbuf3(f, n)
  932.  
  933. {
  934.     cbuf(f, n, 3);
  935. }
  936.  
  937. cbuf4(f, n)
  938.  
  939. {
  940.     cbuf(f, n, 4);
  941. }
  942.  
  943. cbuf5(f, n)
  944.  
  945. {
  946.     cbuf(f, n, 5);
  947. }
  948.  
  949. cbuf6(f, n)
  950.  
  951. {
  952.     cbuf(f, n, 6);
  953. }
  954.  
  955. cbuf7(f, n)
  956.  
  957. {
  958.     cbuf(f, n, 7);
  959. }
  960.  
  961. cbuf8(f, n)
  962.  
  963. {
  964.     cbuf(f, n, 8);
  965. }
  966.  
  967. cbuf9(f, n)
  968.  
  969. {
  970.     cbuf(f, n, 9);
  971. }
  972.  
  973. cbuf10(f, n)
  974.  
  975. {
  976.     cbuf(f, n, 10);
  977. }
  978.  
  979. cbuf11(f, n)
  980.  
  981. {
  982.     cbuf(f, n, 11);
  983. }
  984.  
  985. cbuf12(f, n)
  986.  
  987. {
  988.     cbuf(f, n, 12);
  989. }
  990.  
  991. cbuf13(f, n)
  992.  
  993. {
  994.     cbuf(f, n, 13);
  995. }
  996.  
  997. cbuf14(f, n)
  998.  
  999. {
  1000.     cbuf(f, n, 14);
  1001. }
  1002.  
  1003. cbuf15(f, n)
  1004.  
  1005. {
  1006.     cbuf(f, n, 15);
  1007. }
  1008.  
  1009. cbuf16(f, n)
  1010.  
  1011. {
  1012.     cbuf(f, n, 16);
  1013. }
  1014.  
  1015. cbuf17(f, n)
  1016.  
  1017. {
  1018.     cbuf(f, n, 17);
  1019. }
  1020.  
  1021. cbuf18(f, n)
  1022.  
  1023. {
  1024.     cbuf(f, n, 18);
  1025. }
  1026.  
  1027. cbuf19(f, n)
  1028.  
  1029. {
  1030.     cbuf(f, n, 19);
  1031. }
  1032.  
  1033. cbuf20(f, n)
  1034.  
  1035. {
  1036.     cbuf(f, n, 20);
  1037. }
  1038.  
  1039. cbuf21(f, n)
  1040.  
  1041. {
  1042.     cbuf(f, n, 21);
  1043. }
  1044.  
  1045. cbuf22(f, n)
  1046.  
  1047. {
  1048.     cbuf(f, n, 22);
  1049. }
  1050.  
  1051. cbuf23(f, n)
  1052.  
  1053. {
  1054.     cbuf(f, n, 23);
  1055. }
  1056.  
  1057. cbuf24(f, n)
  1058.  
  1059. {
  1060.     cbuf(f, n, 24);
  1061. }
  1062.  
  1063. cbuf25(f, n)
  1064.  
  1065. {
  1066.     cbuf(f, n, 25);
  1067. }
  1068.  
  1069. cbuf26(f, n)
  1070.  
  1071. {
  1072.     cbuf(f, n, 26);
  1073. }
  1074.  
  1075. cbuf27(f, n)
  1076.  
  1077. {
  1078.     cbuf(f, n, 27);
  1079. }
  1080.  
  1081. cbuf28(f, n)
  1082.  
  1083. {
  1084.     cbuf(f, n, 28);
  1085. }
  1086.  
  1087. cbuf29(f, n)
  1088.  
  1089. {
  1090.     cbuf(f, n, 29);
  1091. }
  1092.  
  1093. cbuf30(f, n)
  1094.  
  1095. {
  1096.     cbuf(f, n, 30);
  1097. }
  1098.  
  1099. cbuf31(f, n)
  1100.  
  1101. {
  1102.     cbuf(f, n, 31);
  1103. }
  1104.  
  1105. cbuf32(f, n)
  1106.  
  1107. {
  1108.     cbuf(f, n, 32);
  1109. }
  1110.  
  1111. cbuf33(f, n)
  1112.  
  1113. {
  1114.     cbuf(f, n, 33);
  1115. }
  1116.  
  1117. cbuf34(f, n)
  1118.  
  1119. {
  1120.     cbuf(f, n, 34);
  1121. }
  1122.  
  1123. cbuf35(f, n)
  1124.  
  1125. {
  1126.     cbuf(f, n, 35);
  1127. }
  1128.  
  1129. cbuf36(f, n)
  1130.  
  1131. {
  1132.     cbuf(f, n, 36);
  1133. }
  1134.  
  1135. cbuf37(f, n)
  1136.  
  1137. {
  1138.     cbuf(f, n, 37);
  1139. }
  1140.  
  1141. cbuf38(f, n)
  1142.  
  1143. {
  1144.     cbuf(f, n, 38);
  1145. }
  1146.  
  1147. cbuf39(f, n)
  1148.  
  1149. {
  1150.     cbuf(f, n, 39);
  1151. }
  1152.  
  1153. cbuf40(f, n)
  1154.  
  1155. {
  1156.     cbuf(f, n, 40);
  1157. }
  1158.  
  1159.  
  1160.