/*
* execute a series of commands in a file
*
* int f, n; default flag and numeric arg to pass on to file
*/
int execfile(int f, int n)
{
int status; /* return status of name query */
char *fname; /* name of file to execute */
char *fspec; /* full file spec */
fname = alloca(NSTRING * sizeof(char));
if ((status =
mlreply("File to execute: ", fname, NSTRING - 1)) != TRUE)
return status;
#if 1
/* look up the path for the file */
fspec = flook(fname, FALSE); /* used to by TRUE, P.K. */
/* if it isn't around */
if (fspec == NULL)
return FALSE;
#endif
/* otherwise, execute it */
while (n-- > 0)
if ((status = dofile(fspec)) != TRUE)
return status;
return TRUE;
}
execprog( char *cmd)
{
char args[NSTRING]; /* args passed to program */
char *sp;
char failName[NFILEN];
char prog[NSTRING]; /* name of program */
USHORT i;
PRESULTCODES results;
/*
* Parse the command name from the command line and copy it
* into the prog and args arrays.
*/
i = 0;
while (cmd[i] && (cmd[i] != ' ') && (cmd[i] != '\t')) {
prog[i] = args[i] = cmd[i];
i++;
}
prog[i] = args[i] = 0; /* terminate with a null */
/* skip whitespace and copy the args */
while (cmd[i] && ((cmd[i] == ' ') || (cmd[i] == '\t')))
i++;
while (cmd[i]) {
args[i] = cmd[i];
i++;
}
args[i] = args[i + 1] = 0; /* terminate with 2 nulls */
/* look up the program on the path, trying various extentions */
if ((sp = flook(prog, TRUE)) == NULL)
if ((sp = flook(strcat(prog, ".exe"), TRUE)) == NULL) {
strcpy(&prog[strlen(prog)-4], ".com");
if ((sp = flook(prog, TRUE)) == NULL)
return(FALSE);
}
strcpy(prog, sp);
/*
* Execute the program synchronously. We wait for child
* to return.
*/
return (0 == DosExecPgm( failName, NFILEN, EXEC_SYNC,
args, 0, results, prog));
}
execprog( char *cmd)
{
char args[NSTRING]; /* args passed to program */
char *sp;
char prog[NSTRING]; /* name of program */
USHORT i;
/*
* Parse the command name from the command line and copy it
* into the prog and args arrays.
*/
i = 0;
while (cmd[i] && (cmd[i] != ' ') && (cmd[i] != '\t')) {
prog[i] = args[i] = cmd[i];
i++;
}
prog[i] = args[i] = 0; /* terminate with a null */
/* skip whitespace and copy the args */
while (cmd[i] && ((cmd[i] == ' ') || (cmd[i] == '\t')))
i++;
while (cmd[i]) {
args[i] = cmd[i];
i++;
}
args[i] = args[i + 1] = 0; /* terminate with 2 nulls */
/* look up the program on the path, trying various extentions */
if ((sp = flook(prog, TRUE)) == NULL)
if ((sp = flook(strcat(prog, ".exe"), TRUE)) == NULL) {
return(FALSE);
}
strcpy(prog, sp);
/*
* Execute the program synchronously. We wait for child
* to return.
*/
return (0 == spawnl(P_WAIT, prog, args, NULL));
}
/*
* Evaluate a function.
*
* @fname: name of function to evaluate.
*/
char *gtfun(char *fname)
{
int fnum; /* index to function to eval */
int status; /* return status */
char *tsp; /* temporary string pointer */
char arg1[NSTRING]; /* value of first argument */
char arg2[NSTRING]; /* value of second argument */
char arg3[NSTRING]; /* value of third argument */
static char result[2 * NSTRING]; /* string result */
/* look the function up in the function table */
fname[3] = 0; /* only first 3 chars significant */
mklower(fname); /* and let it be upper or lower case */
for (fnum = 0; fnum < ARRAY_SIZE(funcs); fnum++)
if (strcmp(fname, funcs[fnum].f_name) == 0)
break;
/* return errorm on a bad reference */
if (fnum == ARRAY_SIZE(funcs))
return errorm;
/* if needed, retrieve the first argument */
if (funcs[fnum].f_type >= MONAMIC) {
if ((status = macarg(arg1)) != TRUE)
return errorm;
/* if needed, retrieve the second argument */
if (funcs[fnum].f_type >= DYNAMIC) {
if ((status = macarg(arg2)) != TRUE)
return errorm;
/* if needed, retrieve the third argument */
if (funcs[fnum].f_type >= TRINAMIC)
if ((status = macarg(arg3)) != TRUE)
return errorm;
}
}
/* and now evaluate it! */
switch (fnum) {
case UFADD:
return itoa(atoi(arg1) + atoi(arg2));
case UFSUB:
return itoa(atoi(arg1) - atoi(arg2));
case UFTIMES:
return itoa(atoi(arg1) * atoi(arg2));
case UFDIV:
return itoa(atoi(arg1) / atoi(arg2));
case UFMOD:
return itoa(atoi(arg1) % atoi(arg2));
case UFNEG:
return itoa(-atoi(arg1));
case UFCAT:
strcpy(result, arg1);
return strcat(result, arg2);
case UFLEFT:
return strncpy(result, arg1, atoi(arg2));
case UFRIGHT:
return (strcpy(result,
&arg1[(strlen(arg1) - atoi(arg2))]));
case UFMID:
return (strncpy(result, &arg1[atoi(arg2) - 1],
atoi(arg3)));
case UFNOT:
return ltos(stol(arg1) == FALSE);
case UFEQUAL:
return ltos(atoi(arg1) == atoi(arg2));
case UFLESS:
return ltos(atoi(arg1) < atoi(arg2));
case UFGREATER:
return ltos(atoi(arg1) > atoi(arg2));
case UFSEQUAL:
return ltos(strcmp(arg1, arg2) == 0);
case UFSLESS:
return ltos(strcmp(arg1, arg2) < 0);
case UFSGREAT:
return ltos(strcmp(arg1, arg2) > 0);
case UFIND:
return strcpy(result, getval(arg1));
case UFAND:
return ltos(stol(arg1) && stol(arg2));
case UFOR:
return ltos(stol(arg1) || stol(arg2));
case UFLENGTH:
return itoa(strlen(arg1));
case UFUPPER:
return mkupper(arg1);
case UFLOWER:
return mklower(arg1);
case UFTRUTH:
return ltos(atoi(arg1) == 42);
case UFASCII:
return itoa((int) arg1[0]);
case UFCHR:
result[0] = atoi(arg1);
result[1] = 0;
return result;
case UFGTKEY:
result[0] = tgetc();
result[1] = 0;
return result;
case UFRND:
return itoa((ernd() % abs(atoi(arg1))) + 1);
case UFABS:
return itoa(abs(atoi(arg1)));
case UFSINDEX:
return itoa(sindex(arg1, arg2));
case UFENV:
#if ENVFUNC
tsp = getenv(arg1);
return tsp == NULL ? "" : tsp;
#else
return "";
#endif
case UFBIND:
return transbind(arg1);
case UFEXIST:
return ltos(fexist(arg1));
case UFFIND:
tsp = flook(arg1, TRUE);
return tsp == NULL ? "" : tsp;
case UFBAND:
return itoa(atoi(arg1) & atoi(arg2));
case UFBOR:
return itoa(atoi(arg1) | atoi(arg2));
case UFBXOR:
return itoa(atoi(arg1) ^ atoi(arg2));
case UFBNOT:
return itoa(~atoi(arg1));
case UFXLATE:
return xlat(arg1, arg2, arg3);
}
exit(-11); /* never should get here */
}
/*
* EXECPROG:
* A function to execute a named program
* with arguments
*
* char *cmd; Incoming command line to execute
*/
int execprog(char *cmd)
{
char *sp; /* temporary string pointer */
char f1[38]; /* FCB1 area (not initialized */
char f2[38]; /* FCB2 area (not initialized */
char prog[NSTRING]; /* program filespec */
char tail[NSTRING]; /* command tail with length byte */
union REGS regs; /* parameters for dos call */
struct SREGS segreg; /* segment registers for dis call */
struct pblock { /* EXEC parameter block */
short envptr; /* 2 byte pointer to environment string */
char *cline; /* 4 byte pointer to command line */
char *fcb1; /* 4 byte pointer to FCB at PSP+5Ch */
char *fcb2; /* 4 byte pointer to FCB at PSP+6Ch */
} pblock;
char *flook();
/* parse the command name from the command line */
sp = prog;
while (*cmd && (*cmd != ' ') && (*cmd != '\t'))
*sp++ = *cmd++;
*sp = 0;
/* and parse out the command tail */
while (*cmd && ((*cmd == ' ') || (*cmd == '\t')))
++cmd;
*tail = (char) (strlen(cmd)); /* record the byte length */
xstrcpy(&tail[1], cmd);
strcat(&tail[1], "\r");
/* look up the program on the path trying various extentions */
if ((sp = flook(prog, TRUE)) == NULL)
if ((sp = flook(strcat(prog, ".exe"), TRUE)) == NULL) {
xstrcpy(&prog[strlen(prog) - 4], ".com");
if ((sp = flook(prog, TRUE)) == NULL)
return FALSE;
}
xstrcpy(prog, sp);
/* get a pointer to this PSPs environment segment number */
segread(&segreg);
/* set up the EXEC parameter block */
pblock.envptr = 0; /* make the child inherit the parents env */
pblock.fcb1 = f1; /* point to a blank FCB */
pblock.fcb2 = f2; /* point to a blank FCB */
pblock.cline = tail; /* parameter line pointer */
/* and make the call */
regs.h.ah = 0x4b; /* EXEC Load or Execute a Program */
regs.h.al = 0x00; /* load end execute function subcode */
segreg.ds = ((unsigned long) (prog) >> 16); /* program name ptr */
regs.x.dx = (unsigned int) (prog);
segreg.es = ((unsigned long) (&pblock) >> 16); /* set up param block ptr */
regs.x.bx = (unsigned int) (&pblock);
#if TURBO | MSC
intdosx(®s, ®s, &segreg);
if (regs.x.cflag == 0) {
regs.h.ah = 0x4d; /* get child process return code */
intdos(®s, ®s); /* go do it */
rval = regs.x.ax; /* save child's return code */
} else
#if MSC
rval = -1;
#else
rval = -_doserrno; /* failed child call */
#endif
#endif
return (rval < 0) ? FALSE : TRUE;
}
