home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / WINDOWS / MISC / MEWIN10S.ZIP / EXEC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-14  |  33.1 KB  |  1,501 lines
  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    "eproto.h"
  9. #include    "edef.h"
  10. #include    "elang.h"
  11.  
  12. /* namedcmd:    execute a named command even if it is not bound */
  13.  
  14. PASCAL NEAR namedcmd(f, n)
  15.  
  16. int f, n;    /* command arguments [passed through to command executed] */
  17.  
  18. {
  19.     int (PASCAL NEAR *kfunc)();     /* ptr to the function to execute */
  20.     char buffer[NSTRING];        /* buffer to store function name */
  21.     int status;
  22.  
  23.     /* if we are non-interactive.... force the command interactivly */
  24.     if (clexec == TRUE) {
  25.         /* grab token and advance past */
  26.         execstr = token(execstr, buffer, NPAT);
  27.  
  28.         /* evaluate it */
  29.         strcpy(buffer, fixnull(getval(buffer)));
  30.         if (strcmp(buffer, errorm) == 0)
  31.             return(FALSE);
  32.  
  33.         /* and look it up */
  34.         if ((kfunc = fncmatch(buffer)) == NULL) {
  35.             mlwrite(TEXT16);
  36. /*                          "[No such Function]" */
  37.             return(FALSE);
  38.         }
  39.         
  40.         /* and execute it  INTERACTIVE */
  41.         clexec = FALSE;
  42.         status = (*kfunc)(f, n);    /* call the function */
  43.         clexec = TRUE;
  44.         return(status);
  45.     }
  46.  
  47.     /* prompt the user to type a named command */
  48.     /* and get the function name to execute */
  49.     kfunc = getname(": ");
  50.     if (kfunc == NULL) {
  51.         mlwrite(TEXT16);
  52. /*                      "[No such function]" */
  53.         return(FALSE);
  54.     }
  55.  
  56.     /* and then execute the command */
  57.     return((*kfunc)(f, n));
  58. }
  59.  
  60. /*    execcmd:    Execute a command line command to be typed in
  61.             by the user                    */
  62.  
  63. PASCAL NEAR execcmd(f, n)
  64.  
  65. int f, n;    /* default Flag and Numeric argument */
  66.  
  67. {
  68.     register int status;        /* status return */
  69.     char cmdstr[NSTRING];        /* string holding command to execute */
  70.  
  71.     /* get the line wanted */
  72.     if ((status = mlreply(": ", cmdstr, NSTRING)) != TRUE)
  73.         return(status);
  74.  
  75.     execlevel = 0;
  76.     return(docmd(cmdstr));
  77. }
  78.  
  79. /*    docmd:    take a passed string as a command line and translate
  80.         it to be executed as a command. This function will be
  81.         used by execute-command-line and by all source and
  82.         startup files. Lastflag/thisflag is also updated.
  83.  
  84.     format of the command line is:
  85.  
  86.         {# arg} <command-name> {<argument string(s)>}
  87.  
  88. */
  89.  
  90. PASCAL NEAR docmd(cline)
  91.  
  92. char *cline;    /* command line to execute */
  93.  
  94. {
  95.     register int f;        /* default argument flag */
  96.     register int n;        /* numeric repeat value */
  97.     int (PASCAL NEAR *fnc)();/* function to execute */
  98.     BUFFER *bp;        /* buffer to execute */
  99.     int status;        /* return status of function */
  100.     int oldcle;        /* old contents of clexec flag */
  101.     char *oldestr;        /* original exec string */
  102.     char tkn[NSTRING];    /* next token off of command line */
  103.         char bufn[NBUFN+2];    /* name of buffer to execute */
  104.  
  105.     /* if we are scanning and not executing..go back here */
  106.     if (execlevel)
  107.         return(TRUE);
  108.  
  109.     oldestr = execstr;    /* save last ptr to string to execute */
  110.     execstr = cline;    /* and set this one as current */
  111.  
  112.     /* first set up the default command values */
  113.     f = FALSE;
  114.     n = 1;
  115.     lastflag = thisflag;
  116.     thisflag = 0;
  117.  
  118.     if ((status = macarg(tkn)) != TRUE) {    /* and grab the first token */
  119.         execstr = oldestr;
  120.         return(status);
  121.     }
  122.  
  123.     /* process leadin argument */
  124.     if (gettyp(tkn) != TKCMD) {
  125.         f = TRUE;
  126.         strcpy(tkn, fixnull(getval(tkn)));
  127.         n = asc_int(tkn);
  128.  
  129.         /* and now get the command to execute */
  130.         if ((status = macarg(tkn)) != TRUE) {
  131.             execstr = oldestr;
  132.             return(status);
  133.         }
  134.     }
  135.  
  136.     /* and match the token to see if it exists */
  137.     if ((fnc = fncmatch(tkn)) == NULL) {
  138.  
  139.         /* construct the buffer name */
  140.         strcpy(bufn, "[");
  141.         strcat(bufn, tkn);
  142.         strcat(bufn, "]");
  143.  
  144.         /* find the pointer to that buffer */
  145.             if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
  146.             mlwrite(TEXT16);
  147. /*                          "[No such Function]" */
  148.             execstr = oldestr;
  149.             return(FALSE);
  150.         }
  151.  
  152.         /* execute the buffer */
  153.         oldcle = clexec;    /* save old clexec flag */
  154.         clexec = TRUE;        /* in cline execution */
  155.         while (n-- > 0)
  156.             if ((status = dobuf(bp)) != TRUE)
  157.                 break;
  158.         cmdstatus = status;    /* save the status */
  159.         clexec = oldcle;    /* restore clexec flag */
  160.         execstr = oldestr;
  161.         return(status);
  162.     }
  163.     
  164.     /* save the arguments and go execute the command */
  165.     oldcle = clexec;        /* save old clexec flag */
  166.     clexec = TRUE;            /* in cline execution */
  167.     status = (*fnc)(f, n);        /* call the function */
  168.     cmdstatus = status;        /* save the status */
  169.     clexec = oldcle;        /* restore clexec flag */
  170.     execstr = oldestr;
  171.     return(status);
  172. }
  173.  
  174. /* token:    chop a token off a string
  175.         return a pointer past the token
  176. */
  177.  
  178. char *PASCAL NEAR token(src, tok, size)
  179.  
  180. char *src, *tok;    /* source string, destination token string */
  181. int size;        /* maximum size of token */
  182.  
  183. {
  184.     register int quotef;    /* is the current string quoted? */
  185.     register char c;    /* temporary character */
  186.  
  187.     /* first scan past any whitespace in the source string */
  188.     while (*src == ' ' || *src == '\t')
  189.         ++src;
  190.  
  191.     /* scan through the source string */
  192.     quotef = FALSE;
  193.     while (*src) {
  194.         /* process special characters */
  195.         if (*src == '~') {
  196.             ++src;
  197.             if (*src == 0)
  198.                 break;
  199.             switch (*src++) {
  200.                 case 'r':    c = 13; break;
  201.                 case 'n':    c = 13; break;
  202.                 case 'l':    c = 10; break;
  203.                 case 't':    c = 9;  break;
  204.                 case 'b':    c = 8;  break;
  205.                 case 'f':    c = 12; break;
  206.                 default:    c = *(src-1);
  207.             }
  208.             if (--size > 0) {
  209.                 *tok++ = c;
  210.             }
  211.         } else {
  212.             /* check for the end of the token */
  213.             if (quotef) {
  214.                 if (*src == '"')
  215.                     break;
  216.             } else {
  217.                 if (*src == ' ' || *src == '\t')
  218.                     break;
  219.             }
  220.  
  221.             /* set quote mode if quote found */
  222.             if (*src == '"')
  223.                 quotef = TRUE;
  224.  
  225.             /* record the character */
  226.             c = *src++;
  227.             if (--size > 0)
  228.                 *tok++ = c;
  229.         }
  230.     }
  231.  
  232.     /* terminate the token and exit */
  233.     if (*src)
  234.         ++src;
  235.     *tok = 0;
  236.     return(src);
  237. }
  238.  
  239. PASCAL NEAR macarg(tok)    /* get a macro line argument */
  240.  
  241. char *tok;    /* buffer to place argument */
  242.  
  243. {
  244.     int savcle;    /* buffer to store original clexec */
  245.     int status;
  246.  
  247.     savcle = clexec;    /* save execution mode */
  248.     clexec = TRUE;        /* get the argument */
  249.     status = nextarg("", tok, NSTRING, ctoec('\r'));
  250.     clexec = savcle;    /* restore execution mode */
  251.     return(status);
  252. }
  253.  
  254. /*    nextarg:    get the next argument    */
  255.  
  256. PASCAL NEAR nextarg(prompt, buffer, size, terminator)
  257.  
  258. char *prompt;        /* prompt to use if we must be interactive */
  259. char *buffer;        /* buffer to put token into */
  260. int size;        /* size of the buffer */
  261. int terminator;        /* terminating char to be used on interactive fetch */
  262.  
  263. {
  264.     register char *sp;    /* return pointer from getval() */
  265.  
  266.     /* if we are interactive, go get it! */
  267.     if (clexec == FALSE)
  268.         return(getstring(prompt, buffer, size, terminator));
  269.  
  270.     /* grab token and advance past */
  271.     execstr = token(execstr, buffer, size);
  272.  
  273.     /* evaluate it */
  274.     if ((sp = getval(buffer)) == NULL)
  275.         return(FALSE);
  276.     strcpy(buffer, sp);
  277.     return(TRUE);
  278. }
  279.  
  280. /*    storemac:    Set up a macro buffer and flag to store all
  281.             executed command lines there            */
  282.  
  283. PASCAL NEAR storemac(f, n)
  284.  
  285. int f;        /* default flag */
  286. int n;        /* macro number to use */
  287.  
  288. {
  289.     register struct BUFFER *bp;    /* pointer to macro buffer */
  290.     char bname[NBUFN];        /* name of buffer to use */
  291.  
  292.     /* must have a numeric argument to this function */
  293.     if (f == FALSE) {
  294.         mlwrite(TEXT111);
  295. /*                      "No macro specified" */
  296.         return(FALSE);
  297.     }
  298.  
  299.     /* range check the macro number */
  300.     if (n < 1 || n > 40) {
  301.         mlwrite(TEXT112);
  302. /*                      "Macro number out of range" */
  303.         return(FALSE);
  304.     }
  305.  
  306.     /* construct the macro buffer name */
  307.     strcpy(bname, "[Macro xx]");
  308.     bname[7] = '0' + (n / 10);
  309.     bname[8] = '0' + (n % 10);
  310.  
  311.     /* set up the new macro buffer */
  312.     if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
  313.         mlwrite(TEXT113);
  314. /*                      "Can not create macro" */
  315.         return(FALSE);
  316.     }
  317.  
  318.     /* and make sure it is empty */
  319.     bclear(bp);
  320.  
  321.     /* and set the macro store pointers to it */
  322.     mstore = TRUE;
  323.     bstore = bp;
  324.     return(TRUE);
  325. }
  326.  
  327. /*    storeproc:    Set up a procedure buffer and flag to store all
  328.             executed command lines there            */
  329.  
  330. PASCAL NEAR storeproc(f, n)
  331.  
  332. int f;        /* default flag */
  333. int n;        /* macro number to use */
  334.  
  335. {
  336.     register struct BUFFER *bp;    /* pointer to macro buffer */
  337.     register int status;        /* return status */
  338.     char bname[NBUFN];        /* name of buffer to use */
  339.  
  340.     /* a numeric argument means its a numbered macro */
  341.     if (f == TRUE)
  342.         return(storemac(f, n));
  343.  
  344.     /* get the name of the procedure */
  345.         if ((status = mlreply(TEXT114, &bname[1], NBUFN-2)) != TRUE)
  346. /*                            "Procedure name: " */
  347.                 return(status);
  348.  
  349.     /* construct the macro buffer name */
  350.     bname[0] = '[';
  351.     strcat(bname, "]");
  352.  
  353.     /* set up the new macro buffer */
  354.     if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
  355.         mlwrite(TEXT113);
  356. /*                      "Can not create macro" */
  357.         return(FALSE);
  358.     }
  359.  
  360.     /* and make sure it is empty */
  361.     bclear(bp);
  362.  
  363.     /* and set the macro store pointers to it */
  364.     mstore = TRUE;
  365.     bstore = bp;
  366.     return(TRUE);
  367. }
  368.  
  369. /*    execproc:    Execute a procedure                */
  370.  
  371. PASCAL NEAR execproc(f, n)
  372.  
  373. int f, n;    /* default flag and numeric arg */
  374.  
  375. {
  376.         register BUFFER *bp;        /* ptr to buffer to execute */
  377.         register int status;        /* status return */
  378.         char bufn[NBUFN+2];        /* name of buffer to execute */
  379.  
  380.     /* find out what buffer the user wants to execute */
  381.         if ((status = mlreply(TEXT115, &bufn[1], NBUFN)) != TRUE)
  382. /*                            "Execute procedure: " */
  383.                 return(status);
  384.  
  385.     /* construct the buffer name */
  386.     bufn[0] = '[';
  387.     strcat(bufn, "]");
  388.  
  389.     /* find the pointer to that buffer */
  390.         if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
  391.         mlwrite(TEXT116);
  392. /*                      "No such procedure" */
  393.                 return(FALSE);
  394.         }
  395.  
  396.     /* and now execute it as asked */
  397.     while (n-- > 0)
  398.         if ((status = dobuf(bp)) != TRUE)
  399.             return(status);
  400.     return(TRUE);
  401. }
  402.  
  403. /*    execbuf:    Execute the contents of a buffer of commands    */
  404.  
  405. PASCAL NEAR execbuf(f, n)
  406.  
  407. int f, n;    /* default flag and numeric arg */
  408.  
  409. {
  410.         register BUFFER *bp;        /* ptr to buffer to execute */
  411.         register int status;        /* status return */
  412.         char bufn[NSTRING];        /* name of buffer to execute */
  413.  
  414.     /* find out what buffer the user wants to execute */
  415.         if ((status = mlreply(TEXT117, bufn, NBUFN)) != TRUE)
  416. /*                            "Execute buffer: " */
  417.                 return(status);
  418.  
  419.     /* find the pointer to that buffer */
  420.         if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
  421.         mlwrite(TEXT118);
  422. /*                      "No such buffer" */
  423.                 return(FALSE);
  424.         }
  425.  
  426.     /* and now execute it as asked */
  427.     while (n-- > 0)
  428.         if ((status = dobuf(bp)) != TRUE)
  429.             return(status);
  430.     return(TRUE);
  431. }
  432.  
  433. /*    dobuf:    execute the contents of the buffer pointed to
  434.         by the passed BP
  435.  
  436.     Directives start with a "!" and include:
  437.  
  438.     !endm        End a macro
  439.     !if (cond)    conditional execution
  440.     !else
  441.     !endif
  442.     !return        Return (terminating current macro)
  443.     !goto <label>    Jump to a label in the current macro
  444.     !force        Force macro to continue...even if command fails
  445.     !while (cond)    Execute a loop if the condition is true
  446.     !endwhile
  447.     
  448.     Line Labels begin with a "*" as the first nonblank char, like:
  449.  
  450.     *LBL01
  451. */
  452.  
  453. PASCAL NEAR dobuf(bp)
  454.  
  455. BUFFER *bp;    /* buffer to execute */
  456.  
  457. {
  458.         register int status;    /* status return */
  459.     register LINE *lp;    /* pointer to line to execute */
  460.     register LINE *hlp;    /* pointer to line header */
  461.     register LINE *glp;    /* line to goto */
  462.     LINE *mp;        /* Macro line storage temp */
  463.     int dirnum;        /* directive index */
  464.     int linlen;        /* length of line to execute */
  465.     int i;            /* index */
  466.     int force;        /* force TRUE result? */
  467.     WINDOW *wp;        /* ptr to windows to scan */
  468.     WHBLOCK *whlist;    /* ptr to !WHILE list */
  469.     WHBLOCK *scanner;    /* ptr during scan */
  470.     WHBLOCK *whtemp;    /* temporary ptr to a WHBLOCK */
  471.     char *einit;        /* initial value of eline */
  472.     char *eline;        /* text of line to execute */
  473.     char tkn[NSTRING];    /* buffer to evaluate an expresion in */
  474. #if    LOGFLG
  475.     FILE *fp;        /* file handle for log file */
  476. #endif
  477. #if    DEBUGM
  478.     int skipflag;        /* are we skipping debugging a function? */
  479. #endif
  480.  
  481.     /* clear IF level flags/while ptr */
  482.     execlevel = 0;
  483.     whlist = NULL;
  484.     scanner = NULL;
  485.  
  486.     /* flag we are executing the buffer */
  487.     bp->b_exec += 1;
  488.  
  489. #if    DEBUGM
  490.     /* we are not skipping a function yet (for the debugger) */
  491.     skipflag = FALSE;
  492. #endif
  493.  
  494.     /* scan the buffer to execute, building WHILE header blocks */
  495.     hlp = bp->b_linep;
  496.     lp = hlp->l_fp;
  497.     while (lp != hlp) {
  498.         /* scan the current line */
  499.         eline = lp->l_text;
  500.         i = lp->l_used;
  501.  
  502.         /* trim leading whitespace */
  503.         while (i-- > 0 && (*eline == ' ' || *eline == '\t'))
  504.             ++eline;
  505.  
  506.         /* if theres nothing here, don't bother */
  507.         if (i <= 0)
  508.             goto nxtscan;
  509.  
  510.         /* if is a while directive, make a block... */
  511.         if (eline[0] == '!' && eline[1] == 'w' && eline[2] == 'h') {
  512.             whtemp = (WHBLOCK *)malloc(sizeof(WHBLOCK));
  513.             if (whtemp == NULL) {
  514. noram:                errormesg(TEXT119, bp, lp);
  515. /*                                        "%%Out of memory during while scan" */
  516. failexit:            freewhile(scanner);
  517.                 freewhile(whlist);
  518.                 bp->b_exec -= 1;
  519.                 return(FALSE);
  520.             }
  521.             whtemp->w_begin = lp;
  522.             whtemp->w_type = BTWHILE;
  523.             whtemp->w_next = scanner;
  524.             scanner = whtemp;
  525.         }
  526.  
  527.         /* if is a BREAK directive, make a block... */
  528.         if (eline[0] == '!' && eline[1] == 'b' && eline[2] == 'r') {
  529.             if (scanner == NULL) {
  530.                 errormesg(TEXT120, bp, lp);
  531. /*                                        "%%!BREAK outside of any !WHILE loop" */
  532.                 goto failexit;
  533.             }
  534.             whtemp = (WHBLOCK *)malloc(sizeof(WHBLOCK));
  535.             if (whtemp == NULL)
  536.                 goto noram;
  537.             whtemp->w_begin = lp;
  538.             whtemp->w_type = BTBREAK;
  539.             whtemp->w_next = scanner;
  540.             scanner = whtemp;
  541.         }
  542.  
  543.         /* if it is an endwhile directive, record the spot... */
  544.         if (eline[0] == '!' && strncmp(&eline[1], "endw", 4) == 0) {
  545.             if (scanner == NULL) {
  546.                 errormesg(TEXT121, bp, lp);
  547. /*                                      "%%!ENDWHILE with no preceding !WHILE" */
  548.                 goto failexit;
  549.             }
  550.             /* move top records from the scanner list to the
  551.                whlist until we have moved all BREAK records
  552.                and one WHILE record */
  553.             do {
  554.                 scanner->w_end = lp;
  555.                 whtemp = whlist;
  556.                 whlist = scanner;
  557.                 scanner = scanner->w_next;
  558.                 whlist->w_next = whtemp;
  559.             } while (whlist->w_type == BTBREAK);
  560.         }
  561.  
  562. nxtscan:    /* on to the next line */
  563.         lp = lp->l_fp;
  564.     }
  565.  
  566.     /* while and endwhile should match! */
  567.     if (scanner != NULL) {
  568.         errormesg(TEXT122, bp, lp);
  569. /*                      "%%!WHILE with no matching !ENDWHILE" */
  570.         goto failexit;
  571.     }
  572.  
  573.     /* let the first command inherit the flags from the last one..*/
  574.     thisflag = lastflag;
  575.  
  576.     /* starting at the beginning of the buffer */
  577.     hlp = bp->b_linep;
  578.     lp = hlp->l_fp;
  579.     while (lp != hlp && eexitflag == FALSE) {
  580.  
  581.         /* allocate eline and copy macro line to it */
  582.         linlen = lp->l_used;
  583.         if ((einit = eline = malloc(linlen+1)) == NULL) {
  584.             errormesg(TEXT123, bp, lp);
  585. /*                              "%%Out of Memory during macro execution" */
  586.             freewhile(whlist);
  587.             bp->b_exec -= 1;
  588.             return(FALSE);
  589.         }
  590.         bytecopy(eline, lp->l_text, linlen);
  591.         eline[linlen] = 0;    /* make sure it ends */
  592.  
  593.         /* trim leading whitespace */
  594.         while (*eline == ' ' || *eline == '\t')
  595.             ++eline;
  596.  
  597.         /* dump comments and blank lines */
  598.         if (*eline == ';' || *eline == 0)
  599.             goto onward;
  600.  
  601. #if    LOGFLG
  602.         /* append the current command to the log file */
  603.         fp = fopen("emacs.log", "a");
  604.         strcpy(outline, eline);
  605.         fprintf(fp, "%s\n", outline);
  606.         fclose(fp);
  607. #endif
  608.     
  609. #if    DEBUGM
  610.         /* only do this if we are debugging */
  611.         if (macbug && !mstore && (execlevel == 0))
  612.             if (debug(bp, eline, &skipflag) == FALSE) {
  613.                 errormesg(TEXT54, bp, lp);
  614. /*                                      "[Macro aborted]" */
  615.                 freewhile(whlist);
  616.                 bp->b_exec -= 1;
  617.                 return(FALSE);
  618.             }
  619. #endif
  620.  
  621.         /* Parse directives here.... */
  622.         dirnum = -1;
  623.         if (*eline == '!') {
  624.             /* Find out which directive this is */
  625.             ++eline;
  626.             for (dirnum = 0; dirnum < NUMDIRS; dirnum++)
  627.                 if (strncmp(eline, dname[dirnum],
  628.                             strlen(dname[dirnum])) == 0)
  629.                     break;
  630.  
  631.             /* and bitch if it's illegal */
  632.             if (dirnum == NUMDIRS) {
  633.                 errormesg(TEXT124, bp, lp);
  634. /*                                      "%%Unknown Directive" */
  635.                 freewhile(whlist);
  636.                 bp->b_exec -= 1;
  637.                 return(FALSE);
  638.             }
  639.  
  640.             /* service only the !ENDM macro here */
  641.             if (dirnum == DENDM) {
  642.                 mstore = FALSE;
  643.                 bstore = NULL;
  644.                 goto onward;
  645.             }
  646.  
  647.             /* restore the original eline....*/
  648.             --eline;
  649.         }
  650.  
  651.         /* if macro store is on, just salt this away */
  652.         if (mstore) {
  653.             /* allocate the space for the line */
  654.             linlen = strlen(eline);
  655.             if ((mp=lalloc(linlen)) == NULL) {
  656.                 errormesg(TEXT125, bp, lp);
  657. /*                                      "Out of memory while storing macro" */
  658.                 bp->b_exec -= 1;
  659.                 return(FALSE);
  660.             }
  661.     
  662.             /* copy the text into the new line */
  663.             for (i=0; i<linlen; ++i)
  664.                 lputc(mp, i, eline[i]);
  665.     
  666.             /* attach the line to the end of the buffer */
  667.                    bstore->b_linep->l_bp->l_fp = mp;
  668.             mp->l_bp = bstore->b_linep->l_bp;
  669.             bstore->b_linep->l_bp = mp;
  670.             mp->l_fp = bstore->b_linep;
  671.             goto onward;
  672.         }
  673.     
  674.         force = FALSE;
  675.  
  676.         /* dump comments */
  677.         if (*eline == '*')
  678.             goto onward;
  679.  
  680.         /* now, execute directives */
  681.         if (dirnum != -1) {
  682.             /* skip past the directive */
  683.             while (*eline && *eline != ' ' && *eline != '\t')
  684.                 ++eline;
  685.             execstr = eline;
  686.  
  687.             switch (dirnum) {
  688.             case DIF:    /* IF directive */
  689.                 /* grab the value of the logical exp */
  690.                 if (execlevel == 0) {
  691.                     if (macarg(tkn) != TRUE)
  692.                         goto eexec;
  693.                     if (stol(tkn) == FALSE)
  694.                         ++execlevel;
  695.                 } else
  696.                     ++execlevel;
  697.                 goto onward;
  698.  
  699.             case DWHILE:    /* WHILE directive */
  700.                 /* grab the value of the logical exp */
  701.                 if (execlevel == 0) {
  702.                     if (macarg(tkn) != TRUE)
  703.                         goto eexec;
  704.                     if (stol(tkn) == TRUE)
  705.                         goto onward;
  706.                 }
  707.                 /* drop down and act just like !BREAK */
  708.  
  709.             case DBREAK:    /* BREAK directive */
  710.                 if (dirnum == DBREAK && execlevel)
  711.                     goto onward;
  712.  
  713.                 /* jump down to the endwhile */
  714.                 /* find the right while loop */
  715.                 whtemp = whlist;
  716.                 while (whtemp) {
  717.                     if (whtemp->w_begin == lp)
  718.                         break;
  719.                     whtemp = whtemp->w_next;
  720.                 }
  721.             
  722.                 if (whtemp == NULL) {
  723.                     errormesg(TEXT126, bp, lp);
  724. /*                                              "%%Internal While loop error" */
  725.                     freewhile(whlist);
  726.                     bp->b_exec -= 1;
  727.                     return(FALSE);
  728.                 }
  729.             
  730.                 /* reset the line pointer back.. */
  731.                 lp = whtemp->w_end;
  732.                 goto onward;
  733.  
  734.             case DELSE:    /* ELSE directive */
  735.                 if (execlevel == 1)
  736.                     --execlevel;
  737.                 else if (execlevel == 0 )
  738.                     ++execlevel;
  739.                 goto onward;
  740.  
  741.             case DENDIF:    /* ENDIF directive */
  742.                 if (execlevel)
  743.                     --execlevel;
  744.                 goto onward;
  745.  
  746.             case DGOTO:    /* GOTO directive */
  747.                 /* .....only if we are currently executing */
  748.                 if (execlevel == 0) {
  749.  
  750. #if     WINDOW_MSWIN
  751.                         longop(TRUE);
  752. #endif
  753.                     /* grab label to jump to */
  754.                     eline = token(eline, golabel, NPAT);
  755.                     linlen = strlen(golabel);
  756.                     glp = hlp->l_fp;
  757.                     while (glp != hlp) {
  758.                         if (*glp->l_text == '*' &&
  759.                             (strncmp(&glp->l_text[1], golabel,
  760.                                     linlen) == 0)) {
  761.                             lp = glp;
  762.                             goto onward;
  763.                         }
  764.                         glp = glp->l_fp;
  765.                     }
  766.                     errormesg(TEXT127, bp, lp);
  767. /*                                              "%%No such label" */
  768.                     freewhile(whlist);
  769.                     bp->b_exec -= 1;
  770.                     return(FALSE);
  771.                 }
  772.                 goto onward;
  773.     
  774.             case DRETURN:    /* RETURN directive */
  775.                 if (execlevel == 0)
  776.                     goto eexec;
  777.                 goto onward;
  778.  
  779.             case DENDWHILE:    /* ENDWHILE directive */
  780.                 if (execlevel) {
  781.                     --execlevel;
  782.                     goto onward;
  783.                 } else {
  784. #if     WINDOW_MSWIN
  785.                         longop(TRUE);
  786. #endif
  787.                     /* find the right while loop */
  788.                     whtemp = whlist;
  789.                     while (whtemp) {
  790.                         if (whtemp->w_type == BTWHILE &&
  791.                             whtemp->w_end == lp)
  792.                             break;
  793.                         whtemp = whtemp->w_next;
  794.                     }
  795.         
  796.                     if (whtemp == NULL) {
  797.                         errormesg(TEXT126, bp, lp);
  798. /*                                                      "%%Internal While loop error" */
  799.                         freewhile(whlist);
  800.                         bp->b_exec -= 1;
  801.                         return(FALSE);
  802.                     }
  803.         
  804.                     /* reset the line pointer back.. */
  805.                     lp = whtemp->w_begin->l_bp;
  806.                     goto onward;
  807.                 }
  808.  
  809.             case DFORCE:    /* FORCE directive */
  810.                 force = TRUE;
  811.  
  812.             }
  813.         }
  814.  
  815.         /* execute the statement */
  816.         status = docmd(eline);
  817.         if (force)        /* force the status */
  818.             status = TRUE;
  819.  
  820.         /* check for a command error */
  821.         if (status != TRUE) {
  822.  
  823.             /* look if buffer is showing */
  824.             wp = wheadp;
  825.             while (wp != NULL) {
  826.                 if (wp->w_bufp == bp) {
  827.                     /* and point it */
  828.                     wp->w_dotp = lp;
  829.                     wp->w_doto = 0;
  830.                     wp->w_flag |= WFHARD;
  831.                 }
  832.                 wp = wp->w_wndp;
  833.             }
  834.  
  835.             /* in any case set the buffer . */
  836.             bp->b_dotp = lp;
  837.             bp->b_doto = 0;
  838.             free(einit);
  839.             execlevel = 0;
  840.             freewhile(whlist);
  841.  
  842.             errormesg(TEXT219, bp, lp);
  843. /*                  "%%Macro Failed" */
  844.             bp->b_exec -= 1;
  845.             return(status);
  846.         }
  847.  
  848. onward:        /* on to the next line */
  849.         free(einit);
  850.         lp = lp->l_fp;
  851. #if    DEBUGM
  852.         if (skipflag)
  853.             macbug = TRUE;
  854. #endif
  855.     }
  856.  
  857. eexec:    /* exit the current function */
  858.     execlevel = 0;
  859.     freewhile(whlist);
  860.     bp->b_exec -= 1;
  861.         return(TRUE);
  862. }
  863.  
  864. /* errormesg:    display a macro execution error along with the buffer and
  865.         line currently being executed */
  866.  
  867. errormesg(mesg, bp, lp)
  868.  
  869. char *mesg;    /* error message to display */
  870. BUFFER *bp;    /* buffer error occured in */
  871. LINE *lp;    /* line " */
  872.  
  873. {
  874.     char buf[NSTRING];
  875.  
  876.     exec_error = TRUE;
  877.  
  878.     /* build error message line */
  879.     strcpy(buf, "\n");
  880.     strcat(buf, mesg);
  881.     strcat(buf, " in <");
  882.     strcat(buf, bp->b_bname);
  883.     strcat(buf, "> at line ");
  884.     strcat(buf, int_asc(getlinenum(bp, lp)));
  885.     mlforce(buf);
  886. }
  887.  
  888. #if    DEBUGM
  889. /*        Interactive debugger
  890.  
  891.         if $debug == TRUE, The interactive debugger is invoked
  892.         commands are listed out with the ? key            */
  893.  
  894. PASCAL NEAR debug(bp, eline, skipflag)
  895.  
  896. BUFFER *bp;    /* buffer to execute */
  897. char *eline;    /* text of line to debug */
  898. int *skipflag;    /* are we skipping debugging? */
  899.  
  900. {
  901.     register int oldcmd;        /* original command display flag */
  902.     register int oldinp;        /* original connamd input flag */
  903.     register int oldstatus;        /* status of last command */
  904.     register int c;            /* temp character */
  905.     register KEYTAB *key;        /* ptr to a key entry */
  906.     static char track[NSTRING] = "";/* expression to track value of */
  907.     char temp[NSTRING];        /* command or expression */
  908.  
  909. dbuild:    /* Build the information line to be presented to the user */
  910.  
  911.     strcpy(outline, "<<<");
  912.  
  913.     /* display the tracked expression */
  914.     if (track[0] != 0) {
  915.         oldstatus = cmdstatus;
  916.         docmd(track);
  917.         cmdstatus = oldstatus;
  918.         strcat(outline, "[=");
  919.         strcat(outline, gtusr("track"));
  920.         strcat(outline, "]");
  921.     }
  922.  
  923.     /* debug macro name */
  924.     strcat(outline, bp->b_bname);
  925.     strcat(outline, ":");
  926.  
  927.     /* and lastly the line */
  928.     strcat(outline, eline);
  929.     strcat(outline, ">>>");
  930.  
  931.     /* expand the %'s so mlwrite() won't interpret them */
  932.     makelit(outline);
  933.  
  934.     /* write out the debug line */
  935. dinput:    outline[term.t_ncol - 1] = 0;
  936.     mlforce(outline);
  937.     update(TRUE);
  938.  
  939.     /* and get the keystroke */
  940.     c = getkey();
  941.  
  942.     /* META key turns off debugging */
  943.     key = getbind(c);
  944.     if (key && key->k_ptr.fp == meta)
  945.         macbug = FALSE;
  946.  
  947.     else if (c == abortc) {
  948.         return(FALSE);
  949.  
  950.     } else switch (c) {
  951.  
  952.         case '?': /* list commands */
  953.             strcpy(outline, TEXT128);
  954. /*"(e)val exp, (c/x)ommand, (t)rack exp, (^G)abort, <SP>exec, <META> stop debug"*/
  955.             goto dinput;
  956.  
  957.         case 'c': /* execute statement */
  958.             oldcmd = discmd;
  959.             discmd = TRUE;
  960.             oldinp = disinp;
  961.             disinp = TRUE;
  962.             execcmd(FALSE, 1);
  963.             discmd = oldcmd;
  964.             disinp = oldinp;
  965.             goto dbuild;
  966.  
  967.         case 'x': /* execute extended command */
  968.             oldcmd = discmd;
  969.             discmd = TRUE;
  970.             oldinp = disinp;
  971.             disinp = TRUE;
  972.             oldstatus = cmdstatus;
  973.             namedcmd(FALSE, 1);
  974.             cmdstatus = oldstatus;
  975.             discmd = oldcmd;
  976.             disinp = oldinp;
  977.             goto dbuild;
  978.  
  979.         case 'e': /* evaluate expresion */
  980.             strcpy(temp, "set %track ");
  981.             oldcmd = discmd;
  982.             discmd = TRUE;
  983.             oldinp = disinp;
  984.             disinp = TRUE;
  985.             getstring("Exp: ", &temp[11], NSTRING, ctoec('\r'));
  986.             discmd = oldcmd;
  987.             disinp = oldinp;
  988.             oldstatus = cmdstatus;
  989.             docmd(temp);
  990.             cmdstatus = oldstatus;
  991.             strcpy(temp, " = [");
  992.             strcat(temp, gtusr("track"));
  993.             strcat(temp, "]");
  994.             mlforce(temp);
  995.             c = getkey();
  996.             goto dinput;
  997.  
  998.         case 't': /* track expresion */
  999.             oldcmd = discmd;
  1000.             discmd = TRUE;
  1001.             oldinp = disinp;
  1002.             disinp = TRUE;
  1003.             getstring("Exp: ", temp, NSTRING, ctoec('\r'));
  1004.             discmd = oldcmd;
  1005.             disinp = oldinp;
  1006.             strcpy(track, "set %track ");
  1007.             strcat(track, temp);
  1008.             goto dbuild;
  1009.  
  1010.         case 's': /* execute a function */
  1011.             *skipflag = TRUE;
  1012.             macbug = FALSE;
  1013.             break;
  1014.  
  1015.         case ' ': /* execute a statement */
  1016.             break;
  1017.  
  1018.         default: /* illegal command */
  1019.             TTbeep();
  1020.             goto dbuild;
  1021.     }
  1022.     return(TRUE);
  1023. }
  1024. #endif
  1025.  
  1026. PASCAL NEAR makelit(s)        /* expand all "%" to "%%" */
  1027.  
  1028. char *s;    /* string to expand */
  1029.  
  1030. {
  1031.     register char *sp;    /* temp for expanding string */
  1032.     register char *ep;    /* ptr to end of string to expand */
  1033.  
  1034.     sp = s;
  1035.     while (*sp)
  1036.     if (*sp++ == '%') {
  1037.         /* advance to the end */
  1038.         ep = --sp;
  1039.         while (*ep++)
  1040.             ;
  1041.         /* null terminate the string one out */
  1042.         *(ep + 1) = 0;
  1043.         /* copy backwards */
  1044.         while(ep-- > sp)
  1045.             *(ep + 1) = *ep;
  1046.  
  1047.         /* and advance sp past the new % */
  1048.         sp += 2;                    
  1049.     }
  1050. }
  1051.  
  1052. PASCAL NEAR freewhile(wp)    /* free a list of while block pointers */
  1053.  
  1054. WHBLOCK *wp;    /* head of structure to free */
  1055.  
  1056. {
  1057.     if (wp != NULL)
  1058.     {
  1059.         freewhile(wp->w_next);
  1060.         free((char *) wp);
  1061.     }
  1062. }
  1063.  
  1064. PASCAL NEAR execfile(f, n)    /* execute a series of commands in a file */
  1065.  
  1066. int f, n;    /* default flag and numeric arg to pass on to file */
  1067.  
  1068. {
  1069.     register int status;    /* return status of name query */
  1070.     char fname[NSTRING];    /* name of file to execute */
  1071.     char *fspec;        /* full file spec */
  1072. #if WINDOW_MSWIN
  1073.         /* special case: we want filenamedlg to refrain from stuffing a
  1074.        full pathname so that flook() can be put to use a few lines
  1075.        down the road... */
  1076.     if ((status = filenamedlg(TEXT129, fname, NSTRING -1, FALSE)) != TRUE)
  1077. #else
  1078.     if ((status = mlreply(TEXT129, fname, NSTRING -1)) != TRUE)
  1079. #endif
  1080. /*                            "File to execute: " */
  1081.         return(status);
  1082.  
  1083.     /* look up the path for the file */
  1084.     fspec = flook(fname, TRUE);
  1085.  
  1086.     /* if it isn't around */
  1087.     if (fspec == NULL) {
  1088.  
  1089.         /* try to default the extension */
  1090.         if (sindex(fname, ".") == 0) {
  1091.             strcat(fname, ".cmd");
  1092.             fspec = flook(fname, TRUE);
  1093.             if (fspec != NULL)
  1094.                 goto exec1;
  1095.         }
  1096.  
  1097.         /* complain if we are interactive */
  1098.         if (clexec == FALSE)
  1099.             mlwrite(TEXT214, fname);
  1100. /*                    "%%No such file as %s" */
  1101.         return(FALSE);
  1102.     }
  1103.  
  1104. exec1:    /* otherwise, execute it */
  1105.     while (n-- > 0)
  1106.         if ((status=dofile(fspec)) != TRUE)
  1107.             return(status);
  1108.  
  1109.     return(TRUE);
  1110. }
  1111.  
  1112. /*    dofile:    yank a file into a buffer and execute it
  1113.         if there are no errors, delete the buffer on exit */
  1114.  
  1115. PASCAL NEAR dofile(fname)
  1116.  
  1117. char *fname;    /* file name to execute */
  1118.  
  1119. {
  1120.     register BUFFER *bp;    /* buffer to place file to exeute */
  1121.     register BUFFER *cb;    /* temp to hold current buf while we read */
  1122.     register int status;    /* results of various calls */
  1123.     char bname[NBUFN];    /* name of buffer */
  1124.  
  1125.     makename(bname, fname);        /* derive the name of the buffer */
  1126.     unqname(bname);            /* make sure we don't stomp things */
  1127.     if ((bp = bfind(bname, TRUE, 0)) == NULL) /* get the needed buffer */
  1128.         return(FALSE);
  1129.  
  1130.     bp->b_mode = MDVIEW;    /* mark the buffer as read only */
  1131.     cb = curbp;        /* save the old buffer */
  1132.     curbp = bp;        /* make this one current */
  1133.     /* and try to read in the file to execute */
  1134.     if ((status = readin(fname, FALSE)) != TRUE) {
  1135.         curbp = cb;    /* restore the current buffer */
  1136.         return(status);
  1137.     }
  1138.  
  1139.     /* go execute it! */
  1140.     curbp = cb;        /* restore the current buffer */
  1141.     if ((status = dobuf(bp)) != TRUE)
  1142.         return(status);
  1143.  
  1144.     /* if not displayed, remove the now unneeded buffer and exit */
  1145.     if (bp->b_nwnd == 0)
  1146.         zotbuf(bp);
  1147.     return(TRUE);
  1148. }
  1149.  
  1150. /*    cbuf:    Execute the contents of a numbered buffer    */
  1151.  
  1152. PASCAL NEAR cbuf(f, n, bufnum)
  1153.  
  1154. int f, n;    /* default flag and numeric arg */
  1155. int bufnum;    /* number of buffer to execute */
  1156.  
  1157. {
  1158.         register BUFFER *bp;        /* ptr to buffer to execute */
  1159.         register int status;        /* status return */
  1160.     static char bufname[] = "[Macro xx]";
  1161.  
  1162.     /* make the buffer name */
  1163.     bufname[7] = '0' + (bufnum / 10);
  1164.     bufname[8] = '0' + (bufnum % 10);
  1165.  
  1166.     /* find the pointer to that buffer */
  1167.         if ((bp=bfind(bufname, FALSE, 0)) == NULL) {
  1168.             mlwrite(TEXT130);
  1169. /*                      "Macro not defined" */
  1170.                 return(FALSE);
  1171.         }
  1172.  
  1173.     /* and now execute it as asked */
  1174.     while (n-- > 0)
  1175.         if ((status = dobuf(bp)) != TRUE)
  1176.             return(status);
  1177.     return(TRUE);
  1178. }
  1179.  
  1180. PASCAL NEAR cbuf1(f, n)
  1181.  
  1182. int f, n;    /* flag and numeric argument */
  1183.  
  1184. {
  1185.     return(cbuf(f, n, 1));
  1186. }
  1187.  
  1188. PASCAL NEAR cbuf2(f, n)
  1189.  
  1190. int f, n;    /* flag and numeric argument */
  1191.  
  1192. {
  1193.     return(cbuf(f, n, 2));
  1194. }
  1195.  
  1196. PASCAL NEAR cbuf3(f, n)
  1197.  
  1198. int f, n;    /* flag and numeric argument */
  1199.  
  1200. {
  1201.     return(cbuf(f, n, 3));
  1202. }
  1203.  
  1204. PASCAL NEAR cbuf4(f, n)
  1205.  
  1206. int f, n;    /* flag and numeric argument */
  1207.  
  1208. {
  1209.     return(cbuf(f, n, 4));
  1210. }
  1211.  
  1212. PASCAL NEAR cbuf5(f, n)
  1213.  
  1214. int f, n;    /* flag and numeric argument */
  1215.  
  1216. {
  1217.     return(cbuf(f, n, 5));
  1218. }
  1219.  
  1220. PASCAL NEAR cbuf6(f, n)
  1221.  
  1222. int f, n;    /* flag and numeric argument */
  1223.  
  1224. {
  1225.     return(cbuf(f, n, 6));
  1226. }
  1227.  
  1228. PASCAL NEAR cbuf7(f, n)
  1229.  
  1230. int f, n;    /* flag and numeric argument */
  1231.  
  1232. {
  1233.     return(cbuf(f, n, 7));
  1234. }
  1235.  
  1236. PASCAL NEAR cbuf8(f, n)
  1237.  
  1238. int f, n;    /* flag and numeric argument */
  1239.  
  1240. {
  1241.     return(cbuf(f, n, 8));
  1242. }
  1243.  
  1244. PASCAL NEAR cbuf9(f, n)
  1245.  
  1246. int f, n;    /* flag and numeric argument */
  1247.  
  1248. {
  1249.     return(cbuf(f, n, 9));
  1250. }
  1251.  
  1252. PASCAL NEAR cbuf10(f, n)
  1253.  
  1254. int f, n;    /* flag and numeric argument */
  1255.  
  1256. {
  1257.     return(cbuf(f, n, 10));
  1258. }
  1259.  
  1260. PASCAL NEAR cbuf11(f, n)
  1261.  
  1262. int f, n;    /* flag and numeric argument */
  1263.  
  1264. {
  1265.     return(cbuf(f, n, 11));
  1266. }
  1267.  
  1268. PASCAL NEAR cbuf12(f, n)
  1269.  
  1270. int f, n;    /* flag and numeric argument */
  1271.  
  1272. {
  1273.     return(cbuf(f, n, 12));
  1274. }
  1275.  
  1276. PASCAL NEAR cbuf13(f, n)
  1277.  
  1278. int f, n;    /* flag and numeric argument */
  1279.  
  1280. {
  1281.     return(cbuf(f, n, 13));
  1282. }
  1283.  
  1284. PASCAL NEAR cbuf14(f, n)
  1285.  
  1286. int f, n;    /* flag and numeric argument */
  1287.  
  1288. {
  1289.     return(cbuf(f, n, 14));
  1290. }
  1291.  
  1292. PASCAL NEAR cbuf15(f, n)
  1293.  
  1294. int f, n;    /* flag and numeric argument */
  1295.  
  1296. {
  1297.     return(cbuf(f, n, 15));
  1298. }
  1299.  
  1300. PASCAL NEAR cbuf16(f, n)
  1301.  
  1302. int f, n;    /* flag and numeric argument */
  1303.  
  1304. {
  1305.     return(cbuf(f, n, 16));
  1306. }
  1307.  
  1308. PASCAL NEAR cbuf17(f, n)
  1309.  
  1310. int f, n;    /* flag and numeric argument */
  1311.  
  1312. {
  1313.     return(cbuf(f, n, 17));
  1314. }
  1315.  
  1316. PASCAL NEAR cbuf18(f, n)
  1317.  
  1318. int f, n;    /* flag and numeric argument */
  1319.  
  1320. {
  1321.     return(cbuf(f, n, 18));
  1322. }
  1323.  
  1324. PASCAL NEAR cbuf19(f, n)
  1325.  
  1326. int f, n;    /* flag and numeric argument */
  1327.  
  1328. {
  1329.     return(cbuf(f, n, 19));
  1330. }
  1331.  
  1332. PASCAL NEAR cbuf20(f, n)
  1333.  
  1334. int f, n;    /* flag and numeric argument */
  1335.  
  1336. {
  1337.     return(cbuf(f, n, 20));
  1338. }
  1339.  
  1340. PASCAL NEAR cbuf21(f, n)
  1341.  
  1342. int f, n;    /* flag and numeric argument */
  1343.  
  1344. {
  1345.     return(cbuf(f, n, 21));
  1346. }
  1347.  
  1348. PASCAL NEAR cbuf22(f, n)
  1349.  
  1350. int f, n;    /* flag and numeric argument */
  1351.  
  1352. {
  1353.     return(cbuf(f, n, 22));
  1354. }
  1355.  
  1356. PASCAL NEAR cbuf23(f, n)
  1357.  
  1358. int f, n;    /* flag and numeric argument */
  1359.  
  1360. {
  1361.     return(cbuf(f, n, 23));
  1362. }
  1363.  
  1364. PASCAL NEAR cbuf24(f, n)
  1365.  
  1366. int f, n;    /* flag and numeric argument */
  1367.  
  1368. {
  1369.     return(cbuf(f, n, 24));
  1370. }
  1371.  
  1372. PASCAL NEAR cbuf25(f, n)
  1373.  
  1374. int f, n;    /* flag and numeric argument */
  1375.  
  1376. {
  1377.     return(cbuf(f, n, 25));
  1378. }
  1379.  
  1380. PASCAL NEAR cbuf26(f, n)
  1381.  
  1382. int f, n;    /* flag and numeric argument */
  1383.  
  1384. {
  1385.     return(cbuf(f, n, 26));
  1386. }
  1387.  
  1388. PASCAL NEAR cbuf27(f, n)
  1389.  
  1390. int f, n;    /* flag and numeric argument */
  1391.  
  1392. {
  1393.     return(cbuf(f, n, 27));
  1394. }
  1395.  
  1396. PASCAL NEAR cbuf28(f, n)
  1397.  
  1398. int f, n;    /* flag and numeric argument */
  1399.  
  1400. {
  1401.     return(cbuf(f, n, 28));
  1402. }
  1403.  
  1404. PASCAL NEAR cbuf29(f, n)
  1405.  
  1406. int f, n;    /* flag and numeric argument */
  1407.  
  1408. {
  1409.     return(cbuf(f, n, 29));
  1410. }
  1411.  
  1412. PASCAL NEAR cbuf30(f, n)
  1413.  
  1414. int f, n;    /* flag and numeric argument */
  1415.  
  1416. {
  1417.     return(cbuf(f, n, 30));
  1418. }
  1419.  
  1420. PASCAL NEAR cbuf31(f, n)
  1421.  
  1422. int f, n;    /* flag and numeric argument */
  1423.  
  1424. {
  1425.     return(cbuf(f, n, 31));
  1426. }
  1427.  
  1428. PASCAL NEAR cbuf32(f, n)
  1429.  
  1430. int f, n;    /* flag and numeric argument */
  1431.  
  1432. {
  1433.     return(cbuf(f, n, 32));
  1434. }
  1435.  
  1436. PASCAL NEAR cbuf33(f, n)
  1437.  
  1438. int f, n;    /* flag and numeric argument */
  1439.  
  1440. {
  1441.     return(cbuf(f, n, 33));
  1442. }
  1443.  
  1444. PASCAL NEAR cbuf34(f, n)
  1445.  
  1446. int f, n;    /* flag and numeric argument */
  1447.  
  1448. {
  1449.     return(cbuf(f, n, 34));
  1450. }
  1451.  
  1452. PASCAL NEAR cbuf35(f, n)
  1453.  
  1454. int f, n;    /* flag and numeric argument */
  1455.  
  1456. {
  1457.     return(cbuf(f, n, 35));
  1458. }
  1459.  
  1460. PASCAL NEAR cbuf36(f, n)
  1461.  
  1462. int f, n;    /* flag and numeric argument */
  1463.  
  1464. {
  1465.     return(cbuf(f, n, 36));
  1466. }
  1467.  
  1468. PASCAL NEAR cbuf37(f, n)
  1469.  
  1470. int f, n;    /* flag and numeric argument */
  1471.  
  1472. {
  1473.     return(cbuf(f, n, 37));
  1474. }
  1475.  
  1476. PASCAL NEAR cbuf38(f, n)
  1477.  
  1478. int f, n;    /* flag and numeric argument */
  1479.  
  1480. {
  1481.     return(cbuf(f, n, 38));
  1482. }
  1483.  
  1484. PASCAL NEAR cbuf39(f, n)
  1485.  
  1486. int f, n;    /* flag and numeric argument */
  1487.  
  1488. {
  1489.     return(cbuf(f, n, 39));
  1490. }
  1491.  
  1492. PASCAL NEAR cbuf40(f, n)
  1493.  
  1494. int f, n;    /* flag and numeric argument */
  1495.  
  1496. {
  1497.     return(cbuf(f, n, 40));
  1498. }
  1499.  
  1500.  
  1501.