WebSVN – SvarDOS – Diff – /svarcom/trunk/command.c


/* This file is part of the SvarCOM project and is published under the terms
 * of the MIT license.
 *
 * Copyright (C) 2021-2024 Mateusz Viste
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#include <i86.h>
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "svarlang.lib/svarlang.h"
 
#include "cmd.h"
#include "env.h"
#include "helpers.h"
#include "redir.h"
#include "rmodinit.h"
#include "sayonara.h"
 
#include "rmodcore.h" /* rmod binary inside a BUFFER array */
 
/* this version byte is used to tag RMOD so I can easily make sure that
 * the RMOD struct I find in memory is one that I know. Should the version
 * mismatch, then it would likely mean that SvarCOM has been upgraded and
 * RMOD should not be accessed as its structure might no longer be in sync
 * with what I think it is.
 *          *** INCREMENT THIS AT EACH NEW SVARCOM RELEASE! ***
 *            (or at least whenever RMOD's struct is changed)            */
#define BYTE_VERSION 5
 
 
struct config {
  unsigned char flags; /* command.com flags, as defined in rmodinit.h */
  char *execcmd;
  unsigned short envsiz;
};
 
/* max length of the cmdline storage (bytes) - includes also max length of
 * line loaded from a BAT file (no more than 255 bytes!) */
#define CMDLINE_MAXLEN 255
 
 
/* sets guard values at a few places in memory for later detection of
 * overflows via memguard_check() */
static void memguard_set(char *cmdlinebuf) {
  BUFFER[sizeof(BUFFER) - 1] = 0xC7;
  cmdlinebuf[CMDLINE_MAXLEN] = 0xC7;
}
 
 
/* checks for valguards at specific memory locations, returns 0 on success */
static int memguard_check(unsigned short rmodseg, char *cmdlinebuf) {
  /* check RMOD signature (would be overwritten in case of stack overflow */
  static char msg[] = "!! MEMORY CORRUPTION ## DETECTED !!";
  unsigned short far *rmodsig = MK_FP(rmodseg, 0x100 + 6);
  unsigned char far *rmod = MK_FP(rmodseg, 0);
 
  if (*rmodsig != 0x2019) {
    msg[22] = '1';
    goto FAIL;
  }
 
  /* check last BUFFER byte */
  if (BUFFER[sizeof(BUFFER) - 1] != 0xC7) {
    msg[22] = '2';
    goto FAIL;
  }
 
  /* check last cmdlinebuf byte */
  if (cmdlinebuf[CMDLINE_MAXLEN] != 0xC7) {
    msg[22] = '3';
    goto FAIL;
  }
 
  /* check rmod exec buf */
  if (rmod[RMOD_OFFSET_EXECPROG + 127] != 0) {
    msg[22] = '4';
    goto FAIL;
  }
 
  /* check rmod exec stdin buf */
  if (rmod[RMOD_OFFSET_STDINFILE + 127] != 0) {
    msg[22] = '5';
    goto FAIL;
  }
 
  /* check rmod exec stdout buf */
  if (rmod[RMOD_OFFSET_STDOUTFILE + 127] != 0) {
    msg[22] = '6';
    goto FAIL;
  }
 
  /* else all good */
  return(0);
 
  /* error handling */
  FAIL:
  outputnl(msg);
  return(1);
}
 
 
/* parses command line the hard way (directly from PSP) */
static void parse_argv(struct config *cfg) {
  unsigned char *cmdlinelen = (void *)0x80;
  char *cmdline = (void *)0x81;
 
  /* The arg tail at [81h] needs some care when being processed.
   *
   * Its length should be provided in [80h], but it is not always exact:
   * https://github.com/SvarDOS/bugz/issues/67
   *
   * The tail string itself is usually terminated by a CR character. But
   * sometimes it might be terminated by a nul. Or by nothing at all.
   *
   * The cautious approach is therefore to read the tail up until the length
   * mentionned at [80h] or to first CR or nul, whichever comes first.
   */
 
  memset(cfg, 0, sizeof(*cfg));
 
  /* Make sure that the advertised cmdline length is no more than 126 bytes
   * because the PSP ends at [0xff] and there ought to be at least 1 byte of
   * room for the CR-terminator.
   * According to Matthias Paul cmdlines longer than 126 (and even longer than
   * 127) might happen with some buggy implementations. */
  if (*cmdlinelen > 126) *cmdlinelen = 126;
 
  /* trim out any trailing CR garbage (see the issue 67 mentioned above) */
  while ((*cmdlinelen > 0) && (cmdline[*cmdlinelen - 1] == '\r')) (*cmdlinelen)--;
 
  /* normalize the cmd so it is nul-terminated - this is expected later in a
   * few places in the codeflow, among others in run_as_external() */
  cmdline[*cmdlinelen] = 0;
 
  /* process the parameters given to COMMAND.COM */
  while (*cmdline != 0) {
 
    /* skip over any leading spaces */
    if (*cmdline == ' ') {
      cmdline++;
      continue;
    }
 
    if (*cmdline != '/') {
      nls_output(0,6); /* "Invalid parameter" */
      output(": ");
      outputnl(cmdline);
      goto SKIP_TO_NEXT_ARG;
    }
 
    /* got a slash */
    cmdline++;  /* skip the slash */
    switch (*cmdline) {
      case 'c': /* /C = execute command and quit */
      case 'C':
        cfg->flags |= FLAG_EXEC_AND_QUIT;
        /* FALLTHRU */
      case 'k': /* /K = execute command and keep running */
      case 'K':
        cmdline++;
        cfg->execcmd = cmdline;
        return; /* further arguments are for the executed program, not for me */
 
      case 'y': /* /Y = execute batch file step-by-step (with /P, /K or /C) */
      case 'Y':
        cfg->flags |= FLAG_STEPBYSTEP;
        break;
 
      case 'd': /* /D = skip autoexec.bat processing */
      case 'D':
        cfg->flags |= FLAG_SKIP_AUTOEXEC;
        break;
 
      case 'e': /* preset the initial size of the environment block */
      case 'E':
        cmdline++;
        if (*cmdline == ':') cmdline++; /* could be /E:size */
        atous(&(cfg->envsiz), cmdline);
        if (cfg->envsiz < 64) cfg->envsiz = 0;
        break;
 
      case 'p': /* permanent shell (can't exit + run autoexec.bat) */
      case 'P':
        cfg->flags |= FLAG_PERMANENT;
        break;
 
      case '?':
        nls_outputnl(1,0); /* "Starts the SvarCOM command interpreter" */
        outputnl("");
        nls_outputnl(1,1); /* "COMMAND /E:nnn [/[C|K] [/P] [/D] command]" */
        outputnl("");
        nls_outputnl(1,2); /* "/D      Skip AUTOEXEC.BAT processing (makes sense only with /P)" */
        nls_outputnl(1,3); /* "/E:nnn  Sets the environment size to nnn bytes" */
        nls_outputnl(1,4); /* "/P      Makes the new command interpreter permanent and run AUTOEXEC.BAT" */
        nls_outputnl(1,5); /* "/C      Executes the specified command and returns" */
        nls_outputnl(1,6); /* "/K      Executes the specified command and continues running" */
        nls_outputnl(1,7); /* "/Y      Executes the batch program step by step" */
        exit(1);
        break;
 
      default:
        nls_output(0,2); /* invalid switch */
        output(": /");
        outputnl(cmdline);
        break;
    }
 
    /* move to next argument or quit processing if end of cmdline */
    SKIP_TO_NEXT_ARG:
    while ((*cmdline != 0) && (*cmdline != ' ') && (*cmdline != '/')) cmdline++;
  }
}
 
 
/* builds the prompt string and displays it. buff is filled with a zero-terminated copy of the prompt. */
static void build_and_display_prompt(char *buff, unsigned short envseg) {
  char *s = buff;
  /* locate the prompt variable or use the default pattern */
  const char far *fmt = env_lookup_val(envseg, "PROMPT");
  if ((fmt == NULL) || (*fmt == 0)) fmt = "$p$g"; /* fallback to default if empty */
  /* build the prompt string based on pattern */
  for (; *fmt != 0; fmt++) {
    if (*fmt != '$') {
      *s = *fmt;
      s++;
      continue;
    }
    /* escape code ($P, etc) */
    fmt++;
    switch (*fmt) {
      case 'Q':  /* $Q = = (equal sign) */
      case 'q':
        *s = '=';
        s++;
        break;
      case '$':  /* $$ = $ (dollar sign) */
        *s = '$';
        s++;
        break;
      case 'T':  /* $t = current time */
      case 't':
        s += sprintf(s, "00:00"); /* TODO */
        break;
      case 'D':  /* $D = current date */
      case 'd':
        s += sprintf(s, "1985-07-29"); /* TODO */
        break;
      case 'P':  /* $P = current drive and path */
      case 'p':
        _asm {
          mov ah, 0x19    /* DOS 1+ - GET CURRENT DRIVE */
          int 0x21
          mov bx, s
          mov [bx], al  /* AL = drive (00 = A:, 01 = B:, etc */
        }
        *s += 'A';
        s++;
        *s = ':';
        s++;
        *s = '\\';
        s++;
        _asm {
          mov ah, 0x47    /* DOS 2+ - CWD - GET CURRENT DIRECTORY */
          xor dl,dl       /* DL = drive number (00h = default, 01h = A:, etc) */
          mov si, s       /* DS:SI -> 64-byte buffer for ASCIZ pathname */
          int 0x21
          jc DONE         /* leave path empty on error */
          /* move s ptr forward to end (0-termintor) of pathname */
          NEXTBYTE:
          mov si, s
          cmp byte ptr [si], 0
          je DONE
          inc s
          jmp NEXTBYTE
          DONE:
        }
        break;
      case 'V':  /* $V = DOS version number */
      case 'v':
        s += sprintf(s, "VER"); /* TODO */
        break;
      case 'N':  /* $N = current drive */
      case 'n':
        _asm {
          mov ah, 0x19    /* DOS 1+ - GET CURRENT DRIVE */
          int 0x21
          mov bx, s
          mov [bx], al  /* AL = drive (00 = A:, 01 = B:, etc */
        }
        *s += 'A';
        s++;
        break;
      case 'G':  /* $G = > (greater-than sign) */
      case 'g':
        *s = '>';
        s++;
        break;
      case 'L':  /* $L = < (less-than sign) */
      case 'l':
        *s = '<';
        s++;
        break;
      case 'B':  /* $B = | (pipe) */
      case 'b':
        *s = '|';
        s++;
        break;
      case 'H':  /* $H = backspace (erases previous character) */
      case 'h':
        *s = '\b';
        s++;
        break;
      case 'E':  /* $E = Escape code (ASCII 27) */
      case 'e':
        *s = 27;
        s++;
        break;
      case '_':  /* $_ = CR+LF */
        *s = '\r';
        s++;
        *s = '\n';
        s++;
        break;
    }
  }
  *s = 0;
  output(buff);
}
 
 
static void dos_fname2fcb(char far *fcb, const char near *cmd);
#pragma aux dos_fname2fcb = \
 
 
 
 
 
 
 
 
 
 
"mov ax, 0x2900"   /* DOS 1+ - parse filename into FCB (DS:SI=fname, ES:DI=FCB) */ \
 
 
 
"int 0x21" \
 
parm [es di] [si] \
 
 
 
 
modify [ax si]
 
 
 
 
/* parses cmdtail and fills fcb1 and fcb2 with first and second arguments,
 * respectively. an FCB is 12 bytes long:
 * drive (0=default, 1=A, 2=B, etc)
 * fname (8 chars, blank-padded)
 * fext (3 chars, blank-padded) */
static void cmdtail_to_fcb(char far *fcb1, char far *fcb2, const char *cmdtail) {
 
  /* skip any leading spaces */
  while (*cmdtail == ' ') cmdtail++;
 
  /* convert first arg */
  dos_fname2fcb(fcb1, cmdtail);
 
  /* skip to next arg */
  while ((*cmdtail != ' ') && (*cmdtail != 0)) cmdtail++;
  while (*cmdtail == ' ') cmdtail++;
 
  /* convert second arg */
  dos_fname2fcb(fcb2, cmdtail);
}
 
 
/* a few internal flags */
#define DELETE_STDIN_FILE 1
#define CALL_FLAG         2
#define LOADHIGH_FLAG     4
 
static void run_as_external(char *buff, const char *cmdline, unsigned short envseg, struct rmod_props far *rmod, struct redir_data *redir, unsigned char flags) {
  char *cmdfile = buff + 512;
  const char far *pathptr;
  int lookup;
  unsigned short i;
  const char *ext;
  char *cmd = buff + 1024;
  const char *cmdtail;
  char far *rmod_execprog = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPROG);
  char far *rmod_cmdtail = MK_FP(rmod->rmodseg, 0x81);
  _Packed struct {
    unsigned short envseg;
    unsigned long cmdtail;
    unsigned long fcb1;
    unsigned long fcb2;
  } far *ExecParam = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPARAM);
 
  /* find cmd and cmdtail */
  i = 0;
  cmdtail = cmdline;
  while (*cmdtail == ' ') cmdtail++; /* skip any leading spaces */
  while ((*cmdtail != ' ') && (*cmdtail != '/') && (*cmdtail != '+') && (*cmdtail != 0)) {
    cmd[i++] = *cmdtail;
    cmdtail++;
  }
  cmd[i] = 0;
 
  /* is this a command in curdir? */
  lookup = lookup_cmd(cmdfile, cmd, NULL, &ext);
  if (lookup == 0) {
    /* printf("FOUND LOCAL EXEC FILE: '%s'\r\n", cmdfile); */
    goto RUNCMDFILE;
  } else if (lookup == -2) {
    /* puts("NOT FOUND"); */
    return;
  }
 
  /* try matching something in PATH */
  pathptr = env_lookup_val(envseg, "PATH");
 
  /* try each path in %PATH% */
  while (pathptr) {
    for (i = 0;; i++) {
      buff[i] = *pathptr;
      if ((buff[i] == 0) || (buff[i] == ';')) break;
      pathptr++;
    }
    buff[i] = 0;
    lookup = lookup_cmd(cmdfile, cmd, buff, &ext);
    if (lookup == 0) goto RUNCMDFILE;
    if (lookup == -2) return;
    if (*pathptr == ';') {
      pathptr++;
    } else {
      break;
    }
  }
 
  /* last chance: is it an executable link? (trim extension from cmd first) */
  for (i = 0; (cmd[i] != 0) && (cmd[i] != '.') && (i < 9); i++) buff[128 + i] = cmd[i];
  buff[128 + i] = 0;
  if ((i < 9) && (link_computefname(buff, buff + 128, envseg) == 0)) {
    /* try opening the link file (if it exists) and read it into buff */
    i = 0;
    _asm {
      push ax
      push bx
      push cx
      push dx
 
      mov ax, 0x3d00  /* DOS 2+ - OPEN EXISTING FILE, READ-ONLY */
      mov dx, buff    /* file name */
      int 0x21
      jc ERR_FOPEN
      /* file handle in AX, read from file now */
      mov bx, ax      /* file handle */
      mov ah, 0x3f    /* Read from file via handle bx */
      mov cx, 128     /* up to 128 bytes */
      /* mov dx, buff */ /* dest buffer (already set) */
      int 0x21        /* read up to 256 bytes from file and write to buff */
      jc ERR_READ
      mov i, ax
      ERR_READ:
      mov ah, 0x3e    /* close file handle in BX */
      int 0x21
      ERR_FOPEN:
 
      pop dx
      pop cx
      pop bx
      pop ax
    }
 
    /* did I read anything? */
    if (i != 0) {
      buff[i] = 0;
      /* trim buff at first \n or \r, just in case someone fiddled with the
       * link file using a text editor */
      for (i = 0; (buff[i] != 0) && (buff[i] != '\r') && (buff[i] != '\n'); i++);
      buff[i] = 0;
      /* lookup check */
      if (buff[0] != 0) {
        lookup = lookup_cmd(cmdfile, cmd, buff, &ext);
        if (lookup == 0) goto RUNCMDFILE;
      }
    }
  }
 
  /* all failed (ie. executable file not found) */
  return;
 
  RUNCMDFILE:
 
  /* special handling of batch files */
  if ((ext != NULL) && (imatch(ext, "bat"))) {
    struct batctx far *newbat;
 
    /* remember the echo flag (in case bat file disables echo, only when starting first bat) */
    if (rmod->bat == NULL) {
      rmod->flags &= ~FLAG_ECHO_BEFORE_BAT;
      if (rmod->flags & FLAG_ECHOFLAG) rmod->flags |= FLAG_ECHO_BEFORE_BAT;
    }
 
    /* if bat is not called via a CALL, then free the bat-context linked list */
    if ((flags & CALL_FLAG) == 0) rmod_free_bat_llist(rmod);
 
    /* allocate a new bat context */
    newbat = rmod_fcalloc(sizeof(struct batctx), rmod->rmodseg, "SVBATCTX");
    if (newbat == NULL) {
      nls_outputnl_doserr(8); /* insufficient memory */
      return;
    }
 
    /* fill the newly allocated batctx structure */
    _fstrcpy(newbat->fname, cmdfile); /* truename of the BAT file */
    newbat->flags = flags & FLAG_STEPBYSTEP;
    /* explode args of the bat file and store them in rmod buff */
    cmd_explode(buff, cmdline, NULL);
    _fmemcpy(newbat->argv, buff, sizeof(newbat->argv));
 
    /* push the new bat to the top of rmod's linked list */
    newbat->parent = rmod->bat;
    rmod->bat = newbat;
 
    return;
  }
 
  /* copy full filename to execute, along with redirected files (if any) */
  _fstrcpy(rmod_execprog, cmdfile);
 
  /* copy stdin file if a redirection is needed */
  if (redir->stdinfile) {
    char far *farptr = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDINFILE);
    char far *delstdin = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDIN_DEL);
    _fstrcpy(farptr, redir->stdinfile);
    if (flags & DELETE_STDIN_FILE) {
      *delstdin = redir->stdinfile[0];
    } else {
      *delstdin = 0;
    }
  }
 
  /* same for stdout file */
  if (redir->stdoutfile) {
    char far *farptr = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDOUTFILE);
    unsigned short far *farptr16 = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDOUTAPP);
    _fstrcpy(farptr, redir->stdoutfile);
    /* openflag */
    *farptr16 = redir->stdout_openflag;
  }
 
  /* copy cmdtail to rmod's PSP and compute its len */
  for (i = 0; cmdtail[i] != 0; i++) rmod_cmdtail[i] = cmdtail[i];
  rmod_cmdtail[i] = '\r';
  rmod_cmdtail[-1] = i;
 
  /* set up rmod to execute the command */
 
  /* loadhigh? */
  if (flags & LOADHIGH_FLAG) {
    unsigned char far *farptr = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXEC_LH);
    *farptr = 1;
  }
 
  ExecParam->envseg = envseg;
  ExecParam->cmdtail = (unsigned long)MK_FP(rmod->rmodseg, 0x80); /* farptr, must be in PSP format (lenbyte args \r) */
  /* far pointers to unopened FCB entries (stored in RMOD's own PSP) */
  {
    char far *farptr;
    /* prep the unopened FCBs */
    farptr = MK_FP(rmod->rmodseg, 0x5C);
    _fmemset(farptr, 0, 36); /* first FCB is 16 bytes long, second is 20 bytes long */
    cmdtail_to_fcb(farptr, farptr + 16, cmdtail);
    /* set (far) pointers in the ExecParam block */
    ExecParam->fcb1 = (unsigned long)MK_FP(rmod->rmodseg, 0x5C);
    ExecParam->fcb2 = (unsigned long)MK_FP(rmod->rmodseg, 0x6C);
  }
  exit(0); /* let rmod do the job now */
}
 
 
static void set_comspec_to_self(unsigned short envseg) {
  unsigned short *psp_envseg = (void *)(0x2c); /* pointer to my env segment field in the PSP */
  char far *myenv = MK_FP(*psp_envseg, 0);
  unsigned short varcount;
  char buff[256] = "COMSPEC=";
  char *buffptr = buff + 8;
  /* who am i? look into my own environment, at the end of it should be my EXEPATH string */
  while (*myenv != 0) {
    /* consume a NULL-terminated string */
    while (*myenv != 0) myenv++;
    /* move to next string */
    myenv++;
  }
  /* get next word, if 1 then EXEPATH follows */
  myenv++;
  varcount = *myenv;
  myenv++;
  varcount |= (*myenv << 8);
  myenv++;
  if (varcount != 1) return; /* NO EXEPATH FOUND */
  while (*myenv != 0) {
    *buffptr = *myenv;
    buffptr++;
    myenv++;
  }
  *buffptr = 0;
  /* printf("EXEPATH: '%s'\r\n", buff); */
  env_setvar(envseg, buff);
}
 
 
/* wait for user input */
static void cmdline_getinput(unsigned short inpseg, unsigned short inpoff);
 
#pragma aux cmdline_getinput = \
"push ds" \
/* set up buffered input to inpseg:inpoff */ \
"push ax" \
"pop ds" \
\
/* is DOSKEY support present? (INT 2Fh, AX=4800h, returns non-zero in AL if present) */ \
"mov ax, 0x4800" \
"int 0x2f" \
 
 
 
 
 
 
 
\
/* execute either DOS input or DOSKEY */ \
"test al, al" /* al=0 if no DOSKEY present */ \
"jnz DOSKEY" \
\
/* buffered string input */ \
"mov ah, 0x0a" \
"int 0x21" \
"jmp short DONE" \
\
"DOSKEY:" \
"mov ax, 0x4810" \
"int 0x2f" \
\
"DONE:" \
/* terminate command with a CR/LF */ \
"mov ah, 0x02" /* display character in dl */ \
"mov dl, 0x0d" \
"int 0x21" \
"mov dl, 0x0a" \
"int 0x21" \
 
"pop ds" \
parm [ax] [dx] \
 
 
modify [ax dl]
 
 
 
 
/* fetches a line from batch file and write it to buff (NULL-terminated),
 * increments rmod counter and returns 0 on success. */
static int getbatcmd(char *buff, unsigned char buffmaxlen, struct rmod_props far *rmod) {
  unsigned short i;
  unsigned short batname_seg = FP_SEG(rmod->bat->fname);
  unsigned short batname_off = FP_OFF(rmod->bat->fname);
  unsigned short filepos_cx = rmod->bat->nextline >> 16;
  unsigned short filepos_dx = rmod->bat->nextline & 0xffff;
  unsigned char blen = 0;
  unsigned short errv = 0;
 
  /* open file, jump to offset filpos, and read data into buff.
   * result in blen (unchanged if EOF or failure). */
  _asm {
    push ax
    push bx
    push cx
    push dx
 
    /* open file (read-only) */
    mov bx, 0xffff        /* preset BX to 0xffff to detect error conditions */
    mov dx, batname_off
    mov ax, batname_seg
    push ds     /* save DS */
    mov ds, ax
    mov ax, 0x3d00
    int 0x21    /* handle in ax on success */
    pop ds      /* restore DS */
    jc ERR
    mov bx, ax  /* save handle to bx */
 
    /* jump to file offset CX:DX */
    mov ax, 0x4200
    mov cx, filepos_cx
    mov dx, filepos_dx
    int 0x21  /* CF clear on success, DX:AX set to cur pos */
    jc ERR
 
    /* read the line into buff */
    mov ah, 0x3f
    xor ch, ch
    mov cl, buffmaxlen
    mov dx, buff
    int 0x21 /* CF clear on success, AX=number of bytes read */
    jc ERR
    mov blen, al
    jmp CLOSEANDQUIT
 
    ERR:
    mov errv, ax
 
    CLOSEANDQUIT:
    /* close file (if bx contains a handle) */
    cmp bx, 0xffff
    je DONE
    mov ah, 0x3e
    int 0x21
 
    DONE:
    pop dx
    pop cx
    pop bx
    pop ax
  }
 
  /* printf("blen=%u filepos_cx=%u filepos_dx=%u\r\n", blen, filepos_cx, filepos_dx); */
 
  if (errv != 0) nls_outputnl_doserr(errv);
 
  /* on EOF - abort processing the bat file */
  if (blen == 0) goto OOPS;
 
  /* find nearest \n to inc batch offset and replace \r by NULL terminator
   * I support all CR/LF, CR- and LF-terminated batch files */
  for (i = 0; i < blen; i++) {
    if ((buff[i] == '\r') || (buff[i] == '\n')) {
      if ((buff[i] == '\r') && ((i+1) < blen) && (buff[i+1] == '\n')) rmod->bat->nextline += 1;
      break;
    }
  }
  buff[i] = 0;
  rmod->bat->nextline += i + 1;
 
  return(0);
 
  OOPS:
  rmod->bat->fname[0] = 0;
  rmod->bat->nextline = 0;
  return(-1);
}
 
 
/* replaces %-variables in a BAT line with resolved values:
 * %PATH%       -> replaced by the contend of the PATH env variable
 * %UNDEFINED%  -> undefined variables are replaced by nothing ("")
 * %NOTCLOSED   -> NOTCLOSED
 * %1           -> first argument of the batch file (or nothing if no arg) */
static void batpercrepl(char *res, unsigned short ressz, const char *line, const struct rmod_props far *rmod, unsigned short envseg) {
  unsigned short lastperc = 0xffff;
  unsigned short reslen = 0;
 
  if (ressz == 0) return;
  ressz--; /* reserve one byte for the NULL terminator */
 
  for (; (reslen < ressz) && (*line != 0); line++) {
    /* if not a percent, I don't care */
    if (*line != '%') {
      res[reslen++] = *line;
      continue;
    }
 
    /* *** perc char handling *** */
 
    /* closing perc? */
    if (lastperc != 0xffff) {
      /* %% is '%' */
      if (lastperc == reslen) {
        res[reslen++] = '%';
      } else {   /* otherwise variable name */
        const char far *ptr;
        res[reslen] = 0;
        reslen = lastperc;
        nls_strtoup(res + reslen); /* turn varname uppercase before lookup */
        ptr = env_lookup_val(envseg, res + reslen);
        if (ptr != NULL) {
          while ((*ptr != 0) && (reslen < ressz)) {
            res[reslen++] = *ptr;
            ptr++;
          }
        }
      }
      lastperc = 0xffff;
      continue;
    }
 
    /* digit? (bat arg) */
    if ((line[1] >= '0') && (line[1] <= '9')) {
      unsigned short argid = line[1] - '0';
      unsigned short i;
      const char far *argv = "";
      if ((rmod != NULL) && (rmod->bat != NULL)) argv = rmod->bat->argv;
 
      /* locate the proper arg */
      for (i = 0; i != argid; i++) {
        /* if string is 0, then end of list reached */
        if (*argv == 0) break;
        /* jump to next arg */
        while (*argv != 0) argv++;
        argv++;
      }
 
      /* copy the arg to result */
      for (i = 0; (argv[i] != 0) && (reslen < ressz); i++) {
        res[reslen++] = argv[i];
      }
      line++;  /* skip the digit */
      continue;
    }
 
    /* opening perc */
    lastperc = reslen;
 
  }
 
  res[reslen] = 0;
}
 
 
/* process the ongoing forloop, returns 0 on success, non-zero otherwise (no
   more things to process) */
static int forloop_process(char *res, struct forctx far *forloop) {
  unsigned short i, t;
  struct DTA *dta = (void *)0x80; /* default DTA at 80h in PSP */
  char *fnameptr = dta->fname;
  char *pathprefix = BUFFER + 256;
 
  *pathprefix = 0;
 
  TRYAGAIN:
 
  /* dta_inited: FindFirst() or FindNext()? */
  if (forloop->dta_inited == 0) {
 
    /* copy next awaiting pattern to BUFFER (and skip all delimiters until
     * next pattern or end of list) */
    t = 0;
    for (i = 0;; i++) {
      BUFFER[i] = forloop->cmd[forloop->nextpat + i];
      /* is this a delimiter? (all delimiters are already normalized to a space here) */
      if (BUFFER[i] == ' ') {
        BUFFER[i] = 0;
        t = 1;
      } else if (BUFFER[i] == 0) {
        /* end of patterns list */
        break;
      } else {
        /* quit if I got a pattern already */
        if (t == 1) break;
      }
    }
 
    if (i == 0) return(-1);
 
    /* remember position of current pattern */
    forloop->curpat = forloop->nextpat;
 
    /* move nextpat forward to next pattern */
    i += forloop->nextpat;
    forloop->nextpat = i;
 
    /* if this is a string and not a pattern, skip all the FindFirst business
     * a file pattern has a wildcard (* or ?), a message doesn't */
    for (i = 0; (BUFFER[i] != 0) && (BUFFER[i] != '?') && (BUFFER[i] != '*'); i++);
    if (BUFFER[i] == 0) {
      fnameptr = BUFFER;
      goto SKIP_DTA;
    }
 
    /* FOR in MSDOS 6 includes hidden and system files, but not directories nor volumes */
    if (findfirst(dta, BUFFER, DOS_ATTR_RO | DOS_ATTR_HID | DOS_ATTR_SYS | DOS_ATTR_ARC) != 0) {
      goto TRYAGAIN;
    }
    forloop->dta_inited = 1;
  } else { /* dta in progress */
 
    /* copy forloop DTA to my local copy */
    _fmemcpy(dta, &(forloop->dta), sizeof(*dta));
 
    /* findnext() call */
    if (findnext(dta) != 0) {
      forloop->dta_inited = 0;
      goto TRYAGAIN;
    }
  }
 
  /* copy updated DTA to rmod */
  _fmemcpy(&(forloop->dta), dta, sizeof(*dta));
 
  /* prefill pathprefix with the prefix (path) of the files */
  {
    short lastbk = -1;
    char far *c = forloop->cmd + forloop->curpat;
    for (i = 0;; i++) {
      pathprefix[i] = c[i];
      if (pathprefix[i] == '\\') lastbk = i;
      if ((pathprefix[i] == ' ') || (pathprefix[i] == 0)) break;
    }
    pathprefix[lastbk+1] = 0;
  }
 
  SKIP_DTA:
 
  /* fill res with command, replacing varname by actual filename */
  /* full filename is to be built with path of curpat and fname from dta */
  t = 0;
  i = 0;
  for (;;) {
    if ((forloop->cmd[forloop->exec + t] == '%') && (forloop->cmd[forloop->exec + t + 1] == forloop->varname)) {
      strcpy(res + i, pathprefix);
      strcat(res + i, fnameptr);
      for (; res[i] != 0; i++);
      t += 2;
    } else {
      res[i] = forloop->cmd[forloop->exec + t];
      t++;
      if (res[i++] == 0) break;
    }
  }
 
  return(0);
}
 
 
int main(void) {
  static struct config cfg;
  static unsigned short far *rmod_envseg;
  static unsigned short far *lastexitcode;
  static struct rmod_props far *rmod;
  static char cmdlinebuf[CMDLINE_MAXLEN + 2]; /* 1 extra byte for 0-terminator and another for memguard */
  static char *cmdline;
  static struct redir_data redirprops;
  static enum cmd_result cmdres;
  static unsigned short i; /* general-purpose variable for short-lived things */
  static unsigned char flags;
 
  rmod = rmod_find(BUFFER_len);
  if (rmod == NULL) {
    /* look at command line parameters (in case env size if set there) */
    parse_argv(&cfg);
    rmod = rmod_install(cfg.envsiz, BUFFER, BUFFER_len);
    if (rmod == NULL) {
      nls_outputnl_err(2,1); /* "FATAL ERROR: rmod_install() failed" */
      return(1);
    }
    /* copy flags to rmod's storage (and enable ECHO) */
    rmod->flags = cfg.flags | FLAG_ECHOFLAG;
    /* printf("rmod installed at %Fp\r\n", rmod); */
    rmod->version = BYTE_VERSION;
  } else {
    /* printf("rmod found at %Fp\r\n", rmod); */
    /* if I was spawned by rmod and FLAG_EXEC_AND_QUIT is set, then I should
     * die asap, because the command has been executed already, so I no longer
     * have a purpose in life */
    if (rmod->flags & FLAG_EXEC_AND_QUIT) sayonara(rmod);
    /* */
    if (rmod->version != BYTE_VERSION) {
      nls_outputnl_err(2,0);
      _asm {
        HALT:
        hlt
        jmp HALT
      }
    }
  }
 
  /* install a few guardvals in memory to detect some cases of overflows */
  memguard_set(cmdlinebuf);
 
  rmod_envseg = MK_FP(rmod->rmodseg, RMOD_OFFSET_ENVSEG);
  lastexitcode = MK_FP(rmod->rmodseg, RMOD_OFFSET_LEXITCODE);
 
  /* make COMSPEC point to myself */
  set_comspec_to_self(*rmod_envseg);
 
  /* on /P check for the presence of AUTOEXEC.BAT and execute it if found,
   * but skip this check if /D was also passed */
  if ((cfg.flags & (FLAG_PERMANENT | FLAG_SKIP_AUTOEXEC)) == FLAG_PERMANENT) {
    if (file_getattr("AUTOEXEC.BAT") >= 0) cfg.execcmd = "AUTOEXEC.BAT";
  }
 
  do {
 
    /* terminate previous command with a CR/LF if ECHO ON (but not during BAT processing) */
    if ((rmod->flags & FLAG_ECHOFLAG) && (rmod->bat == NULL)) outputnl("");
 
    SKIP_NEWLINE:
 
    /* memory check */
    memguard_check(rmod->rmodseg, cmdlinebuf);
 
    /* preset cmdline to point at the dedicated buffer */
    cmdline = cmdlinebuf;
 
    /* (re)load translation strings if needed */
    nls_langreload(BUFFER, *rmod_envseg);
 
    /* am I inside a FOR loop? */
    if (rmod->forloop) {
      if (forloop_process(cmdlinebuf, rmod->forloop) != 0) {
        rmod_ffree(rmod->forloop);
        rmod->forloop = NULL;
      } else {
        /* output prompt and command on screen if echo on and command is not
         * inhibiting it with the @ prefix */
        if (rmod->flags & FLAG_ECHOFLAG) {
          build_and_display_prompt(BUFFER, *rmod_envseg);
          outputnl(cmdline);
        }
        /* jump to command processing */
        goto EXEC_CMDLINE;
      }
    }
 
    /* load awaiting command, if any (used to run piped commands) */
    if (rmod->awaitingcmd[0] != 0) {
      _fstrcpy(cmdline, rmod->awaitingcmd);
      rmod->awaitingcmd[0] = 0;
      flags |= DELETE_STDIN_FILE;
      goto EXEC_CMDLINE;
    } else {
      flags &= ~DELETE_STDIN_FILE;
    }
 
    /* skip user input if I have a command to exec (/C or /K or /P) */
    if (cfg.execcmd != NULL) {
      cmdline = cfg.execcmd;
      cfg.execcmd = NULL;
      /* */
      if (cfg.flags & FLAG_STEPBYSTEP) flags |= FLAG_STEPBYSTEP;
      goto EXEC_CMDLINE;
    }
 
    /* if batch file is being executed -> fetch next line */
    if (rmod->bat != NULL) {
      if (getbatcmd(BUFFER, CMDLINE_MAXLEN, rmod) != 0) { /* end of batch */
        struct batctx far *victim = rmod->bat;
        rmod->bat = rmod->bat->parent;
        rmod_ffree(victim);
        /* end of batch? then restore echo flag as it was before running the (first) bat file */
        if (rmod->bat == NULL) {
          rmod->flags &= ~FLAG_ECHOFLAG;
          if (rmod->flags & FLAG_ECHO_BEFORE_BAT) rmod->flags |= FLAG_ECHOFLAG;
        }
        continue;
      }
      /* %-decoding of variables (%PATH%, %1, %%...), result in cmdline */
      batpercrepl(cmdline, CMDLINE_MAXLEN, BUFFER, rmod, *rmod_envseg);
      /* skip any leading spaces */
      while (*cmdline == ' ') cmdline++;
      /* skip batch labels */
      if (*cmdline == ':') continue;
      /* step-by-step execution? */
      if (rmod->bat->flags & FLAG_STEPBYSTEP) {
        if (*cmdline == 0) continue; /* skip empty lines */
        if (askchoice(cmdline, svarlang_str(0,10)) != 0) continue;
      }
      /* output prompt and command on screen if echo on and command is not
       * inhibiting it with the @ prefix */
      if ((rmod->flags & FLAG_ECHOFLAG) && (cmdline[0] != '@')) {
        build_and_display_prompt(BUFFER, *rmod_envseg);
        outputnl(cmdline);
      }
      /* skip the @ prefix if present, it is no longer useful */
      if (cmdline[0] == '@') cmdline++;
    } else {
      unsigned char far *rmod_inputbuf = MK_FP(rmod->rmodseg, RMOD_OFFSET_INPUTBUF);
      /* invalidate input history if it appears to be damaged (could occur
       * because of a stack overflow, for example if some stack-hungry TSR is
       * being used) */
      if ((rmod_inputbuf[0] != 128) || (rmod_inputbuf[rmod_inputbuf[1] + 2] != '\r') || (rmod_inputbuf[rmod_inputbuf[1] + 3] != 0xCA) || (rmod_inputbuf[rmod_inputbuf[1] + 4] != 0xFE)) {
        rmod_inputbuf[0] = 128;  /* max allowed input length */
        rmod_inputbuf[1] = 0;    /* string len stored in buffer */
        rmod_inputbuf[2] = '\r'; /* string terminator */
        rmod_inputbuf[3] = 0xCA; /* trailing signature */
        rmod_inputbuf[4] = 0xFE; /* trailing signature */
        nls_outputnl_err(2,2); /* "stack overflow detected, command history flushed" */
      }
      /* interactive mode: display prompt (if echo enabled) and wait for user
       * command line */
      if (rmod->flags & FLAG_ECHOFLAG) build_and_display_prompt(BUFFER, *rmod_envseg);
      /* collect user input */
      cmdline_getinput(rmod->rmodseg, RMOD_OFFSET_INPUTBUF);
      /* append stack-overflow detection signature to the end of the input buffer */
      rmod_inputbuf[rmod_inputbuf[1] + 3] = 0xCA; /* trailing signature */
      rmod_inputbuf[rmod_inputbuf[1] + 4] = 0xFE; /* trailing signature */
      /* copy it to local cmdline */
      if (rmod_inputbuf[1] != 0) _fmemcpy(cmdline, rmod_inputbuf + 2, rmod_inputbuf[1]);
      cmdline[rmod_inputbuf[1]] = 0; /* zero-terminate local buff (original is '\r'-terminated) */
    }
 
    /* if nothing entered, loop again (but without appending an extra CR/LF) */
    if (cmdline[0] == 0) goto SKIP_NEWLINE;
 
    /* I jump here when I need to exec an initial command (/C or /K) */
    EXEC_CMDLINE:
 
    /* move pointer forward to skip over any leading spaces */
    while (*cmdline == ' ') cmdline++;
 
    /* sanitize separators into spaces */
    for (i = 0; cmdline[i] != 0; i++) {
      switch (cmdline[i]) {
        case '\t':
          cmdline[i] = ' ';
      }
    }
 
    /* update rmod's ptr to COMSPEC so it is always up to date */
    rmod_updatecomspecptr(rmod->rmodseg, *rmod_envseg);
 
    /* handle redirections (if any) */
    i = redir_parsecmd(&redirprops, cmdline, rmod->awaitingcmd, *rmod_envseg);
    if (i != 0) {
      nls_outputnl_doserr(i);
      rmod->awaitingcmd[0] = 0;
      continue;
    }
 
    /* try matching (and executing) an internal command */
    cmdres = cmd_process(rmod, *rmod_envseg, cmdline, BUFFER, sizeof(BUFFER), &redirprops, flags & DELETE_STDIN_FILE);
    if ((cmdres == CMD_OK) || (cmdres == CMD_FAIL)) {
      /* internal command executed */
    } else if (cmdres == CMD_CHANGED) { /* cmdline changed, needs to be reprocessed */
      goto EXEC_CMDLINE;
    } else if (cmdres == CMD_CHANGED_BY_CALL) { /* cmdline changed *specifically* by CALL */
      /* the distinction is important since it changes the way batch files are processed */
      flags |= CALL_FLAG;
      goto EXEC_CMDLINE;
    } else if (cmdres == CMD_CHANGED_BY_LH) { /* cmdline changed *specifically* by LH */
      flags |= LOADHIGH_FLAG;
      goto EXEC_CMDLINE;
    } else if (cmdres == CMD_NOTFOUND) {
      /* this was not an internal command, try matching an external command */
      run_as_external(BUFFER, cmdline, *rmod_envseg, rmod, &redirprops, flags);
 
      /* is it a newly launched BAT file? */
      if ((rmod->bat != NULL) && (rmod->bat->nextline == 0)) goto SKIP_NEWLINE;
      /* run_as_external() does not return on success, if I am still alive then
       * external command failed to execute */
      nls_outputnl(0,5); /* "Bad command or file name" */
    } else {
      /* I should never ever land here */
      outputnl("INTERNAL ERR: INVALID CMDRES");
    }
 
    /* reset one-time only flags */
    flags &= ~CALL_FLAG;
    flags &= ~FLAG_STEPBYSTEP;
    flags &= ~LOADHIGH_FLAG;
 
    /* repeat unless /C was asked - but always finish running an ongoing batch
     * file (otherwise only first BAT command would be executed with /C) */
  } while (((rmod->flags & FLAG_EXEC_AND_QUIT) == 0) || (rmod->bat != NULL) || (rmod->forloop != NULL));
 
  sayonara(rmod);
  return(0);
}
 

Rev 1730	Rev 1797
1	`/* This file is part of the SvarCOM project and is published under the terms`	1	`/* This file is part of the SvarCOM project and is published under the terms`
2	`* of the MIT license.`	2	`* of the MIT license.`
3	`*`	3	`*`
4	`* Copyright (C) 2021-2024 Mateusz Viste`	4	`* Copyright (C) 2021-2024 Mateusz Viste`
5	`*`	5	`*`
6	`* Permission is hereby granted, free of charge, to any person obtaining a`	6	`* Permission is hereby granted, free of charge, to any person obtaining a`
7	`* copy of this software and associated documentation files (the "Software"),`	7	`* copy of this software and associated documentation files (the "Software"),`
8	`* to deal in the Software without restriction, including without limitation`	8	`* to deal in the Software without restriction, including without limitation`
9	`* the rights to use, copy, modify, merge, publish, distribute, sublicense,`	9	`* the rights to use, copy, modify, merge, publish, distribute, sublicense,`
10	`* and/or sell copies of the Software, and to permit persons to whom the`	10	`* and/or sell copies of the Software, and to permit persons to whom the`
11	`* Software is furnished to do so, subject to the following conditions:`	11	`* Software is furnished to do so, subject to the following conditions:`
12	`*`	12	`*`
13	`* The above copyright notice and this permission notice shall be included in`	13	`* The above copyright notice and this permission notice shall be included in`
14	`* all copies or substantial portions of the Software.`	14	`* all copies or substantial portions of the Software.`
15	`*`	15	`*`
16	`* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`	16	`* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`
17	`* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`	17	`* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`
18	`* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`	18	`* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`
19	`* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER`	19	`* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER`
20	`* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING`	20	`* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING`
21	`* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER`	21	`* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER`
22	`* DEALINGS IN THE SOFTWARE.`	22	`* DEALINGS IN THE SOFTWARE.`
23	`*/`	23	`*/`
24		24
25	`#include <i86.h>`	25	`#include <i86.h>`
26	`#include <dos.h>`	26	`#include <dos.h>`
27	`#include <stdio.h>`	27	`#include <stdio.h>`
28	`#include <stdlib.h>`	28	`#include <stdlib.h>`
29	`#include <string.h>`	29	`#include <string.h>`
30		30
31	`#include "svarlang.lib/svarlang.h"`	31	`#include "svarlang.lib/svarlang.h"`
32		32
33	`#include "cmd.h"`	33	`#include "cmd.h"`
34	`#include "env.h"`	34	`#include "env.h"`
35	`#include "helpers.h"`	35	`#include "helpers.h"`
36	`#include "redir.h"`	36	`#include "redir.h"`
37	`#include "rmodinit.h"`	37	`#include "rmodinit.h"`
38	`#include "sayonara.h"`	38	`#include "sayonara.h"`
39		39
40	`#include "rmodcore.h" /* rmod binary inside a BUFFER array */`	40	`#include "rmodcore.h" /* rmod binary inside a BUFFER array */`
41		41
42	`/* this version byte is used to tag RMOD so I can easily make sure that`	42	`/* this version byte is used to tag RMOD so I can easily make sure that`
43	`* the RMOD struct I find in memory is one that I know. Should the version`	43	`* the RMOD struct I find in memory is one that I know. Should the version`
44	`* mismatch, then it would likely mean that SvarCOM has been upgraded and`	44	`* mismatch, then it would likely mean that SvarCOM has been upgraded and`
45	`* RMOD should not be accessed as its structure might no longer be in sync`	45	`* RMOD should not be accessed as its structure might no longer be in sync`
46	`* with what I think it is.`	46	`* with what I think it is.`
47	`* * INCREMENT THIS AT EACH NEW SVARCOM RELEASE! *`	47	`* * INCREMENT THIS AT EACH NEW SVARCOM RELEASE! *`
48	`* (or at least whenever RMOD's struct is changed) */`	48	`* (or at least whenever RMOD's struct is changed) */`
49	`#define BYTE_VERSION 5`	49	`#define BYTE_VERSION 5`
50		50
51		51
52	`struct config {`	52	`struct config {`
53	`unsigned char flags; /* command.com flags, as defined in rmodinit.h */`	53	`unsigned char flags; /* command.com flags, as defined in rmodinit.h */`
54	`char *execcmd;`	54	`char *execcmd;`
55	`unsigned short envsiz;`	55	`unsigned short envsiz;`
56	`};`	56	`};`
57		57
58	`/* max length of the cmdline storage (bytes) - includes also max length of`	58	`/* max length of the cmdline storage (bytes) - includes also max length of`
59	`* line loaded from a BAT file (no more than 255 bytes!) */`	59	`* line loaded from a BAT file (no more than 255 bytes!) */`
60	`#define CMDLINE_MAXLEN 255`	60	`#define CMDLINE_MAXLEN 255`
61		61
62		62
63	`/* sets guard values at a few places in memory for later detection of`	63	`/* sets guard values at a few places in memory for later detection of`
64	`* overflows via memguard_check() */`	64	`* overflows via memguard_check() */`
65	`static void memguard_set(char *cmdlinebuf) {`	65	`static void memguard_set(char *cmdlinebuf) {`
66	`BUFFER[sizeof(BUFFER) - 1] = 0xC7;`	66	`BUFFER[sizeof(BUFFER) - 1] = 0xC7;`
67	`cmdlinebuf[CMDLINE_MAXLEN] = 0xC7;`	67	`cmdlinebuf[CMDLINE_MAXLEN] = 0xC7;`
68	`}`	68	`}`
69		69
70		70
71	`/* checks for valguards at specific memory locations, returns 0 on success */`	71	`/* checks for valguards at specific memory locations, returns 0 on success */`
72	`static int memguard_check(unsigned short rmodseg, char *cmdlinebuf) {`	72	`static int memguard_check(unsigned short rmodseg, char *cmdlinebuf) {`
73	`/* check RMOD signature (would be overwritten in case of stack overflow */`	73	`/* check RMOD signature (would be overwritten in case of stack overflow */`
74	`static char msg[] = "!! MEMORY CORRUPTION ## DETECTED !!";`	74	`static char msg[] = "!! MEMORY CORRUPTION ## DETECTED !!";`
75	`unsigned short far *rmodsig = MK_FP(rmodseg, 0x100 + 6);`	75	`unsigned short far *rmodsig = MK_FP(rmodseg, 0x100 + 6);`
76	`unsigned char far *rmod = MK_FP(rmodseg, 0);`	76	`unsigned char far *rmod = MK_FP(rmodseg, 0);`
77		77
78	`if (*rmodsig != 0x2019) {`	78	`if (*rmodsig != 0x2019) {`
79	`msg[22] = '1';`	79	`msg[22] = '1';`
80	`goto FAIL;`	80	`goto FAIL;`
81	`}`	81	`}`
82		82
83	`/* check last BUFFER byte */`	83	`/* check last BUFFER byte */`
84	`if (BUFFER[sizeof(BUFFER) - 1] != 0xC7) {`	84	`if (BUFFER[sizeof(BUFFER) - 1] != 0xC7) {`
85	`msg[22] = '2';`	85	`msg[22] = '2';`
86	`goto FAIL;`	86	`goto FAIL;`
87	`}`	87	`}`
88		88
89	`/* check last cmdlinebuf byte */`	89	`/* check last cmdlinebuf byte */`
90	`if (cmdlinebuf[CMDLINE_MAXLEN] != 0xC7) {`	90	`if (cmdlinebuf[CMDLINE_MAXLEN] != 0xC7) {`
91	`msg[22] = '3';`	91	`msg[22] = '3';`
92	`goto FAIL;`	92	`goto FAIL;`
93	`}`	93	`}`
94		94
95	`/* check rmod exec buf */`	95	`/* check rmod exec buf */`
96	`if (rmod[RMOD_OFFSET_EXECPROG + 127] != 0) {`	96	`if (rmod[RMOD_OFFSET_EXECPROG + 127] != 0) {`
97	`msg[22] = '4';`	97	`msg[22] = '4';`
98	`goto FAIL;`	98	`goto FAIL;`
99	`}`	99	`}`
100		100
101	`/* check rmod exec stdin buf */`	101	`/* check rmod exec stdin buf */`
102	`if (rmod[RMOD_OFFSET_STDINFILE + 127] != 0) {`	102	`if (rmod[RMOD_OFFSET_STDINFILE + 127] != 0) {`
103	`msg[22] = '5';`	103	`msg[22] = '5';`
104	`goto FAIL;`	104	`goto FAIL;`
105	`}`	105	`}`
106		106
107	`/* check rmod exec stdout buf */`	107	`/* check rmod exec stdout buf */`
108	`if (rmod[RMOD_OFFSET_STDOUTFILE + 127] != 0) {`	108	`if (rmod[RMOD_OFFSET_STDOUTFILE + 127] != 0) {`
109	`msg[22] = '6';`	109	`msg[22] = '6';`
110	`goto FAIL;`	110	`goto FAIL;`
111	`}`	111	`}`
112		112
113	`/* else all good */`	113	`/* else all good */`
114	`return(0);`	114	`return(0);`
115		115
116	`/* error handling */`	116	`/* error handling */`
117	`FAIL:`	117	`FAIL:`
118	`outputnl(msg);`	118	`outputnl(msg);`
119	`return(1);`	119	`return(1);`
120	`}`	120	`}`
121		121
122		122
123	`/* parses command line the hard way (directly from PSP) */`	123	`/* parses command line the hard way (directly from PSP) */`
124	`static void parse_argv(struct config *cfg) {`	124	`static void parse_argv(struct config *cfg) {`
125	`unsigned char cmdlinelen = (void )0x80;`	125	`unsigned char cmdlinelen = (void )0x80;`
126	`char cmdline = (void )0x81;`	126	`char cmdline = (void )0x81;`
127		127
128	`/* The arg tail at [81h] needs some care when being processed.`	128	`/* The arg tail at [81h] needs some care when being processed.`
129	`*`	129	`*`
130	`* Its length should be provided in [80h], but it is not always exact:`	130	`* Its length should be provided in [80h], but it is not always exact:`
131	`* https://github.com/SvarDOS/bugz/issues/67`	131	`* https://github.com/SvarDOS/bugz/issues/67`
132	`*`	132	`*`
133	`* The tail string itself is usually terminated by a CR character. But`	133	`* The tail string itself is usually terminated by a CR character. But`
134	`* sometimes it might be terminated by a nul. Or by nothing at all.`	134	`* sometimes it might be terminated by a nul. Or by nothing at all.`
135	`*`	135	`*`
136	`* The cautious approach is therefore to read the tail up until the length`	136	`* The cautious approach is therefore to read the tail up until the length`
137	`* mentionned at [80h] or to first CR or nul, whichever comes first.`	137	`* mentionned at [80h] or to first CR or nul, whichever comes first.`
138	`*/`	138	`*/`
139		139
140	`memset(cfg, 0, sizeof(*cfg));`	140	`memset(cfg, 0, sizeof(*cfg));`
141		141
142	`/* Make sure that the advertised cmdline length is no more than 126 bytes`	142	`/* Make sure that the advertised cmdline length is no more than 126 bytes`
143	`* because the PSP ends at [0xff] and there ought to be at least 1 byte of`	143	`* because the PSP ends at [0xff] and there ought to be at least 1 byte of`
144	`* room for the CR-terminator.`	144	`* room for the CR-terminator.`
145	`* According to Matthias Paul cmdlines longer than 126 (and even longer than`	145	`* According to Matthias Paul cmdlines longer than 126 (and even longer than`
146	`* 127) might happen with some buggy implementations. */`	146	`* 127) might happen with some buggy implementations. */`
147	`if (cmdlinelen > 126) cmdlinelen = 126;`	147	`if (cmdlinelen > 126) cmdlinelen = 126;`
148		148
149	`/* trim out any trailing CR garbage (see the issue 67 mentioned above) */`	149	`/* trim out any trailing CR garbage (see the issue 67 mentioned above) */`
150	`while ((cmdlinelen > 0) && (cmdline[cmdlinelen - 1] == '\r')) (*cmdlinelen)--;`	150	`while ((cmdlinelen > 0) && (cmdline[cmdlinelen - 1] == '\r')) (*cmdlinelen)--;`
151		151
152	`/* normalize the cmd so it is nul-terminated - this is expected later in a`	152	`/* normalize the cmd so it is nul-terminated - this is expected later in a`
153	`* few places in the codeflow, among others in run_as_external() */`	153	`* few places in the codeflow, among others in run_as_external() */`
154	`cmdline[*cmdlinelen] = 0;`	154	`cmdline[*cmdlinelen] = 0;`
155		155
156	`/* process the parameters given to COMMAND.COM */`	156	`/* process the parameters given to COMMAND.COM */`
157	`while (*cmdline != 0) {`	157	`while (*cmdline != 0) {`
158		158
159	`/* skip over any leading spaces */`	159	`/* skip over any leading spaces */`
160	`if (*cmdline == ' ') {`	160	`if (*cmdline == ' ') {`
161	`cmdline++;`	161	`cmdline++;`
162	`continue;`	162	`continue;`
163	`}`	163	`}`
164		164
165	`if (*cmdline != '/') {`	165	`if (*cmdline != '/') {`
166	`nls_output(0,6); /* "Invalid parameter" */`	166	`nls_output(0,6); /* "Invalid parameter" */`
167	`output(": ");`	167	`output(": ");`
168	`outputnl(cmdline);`	168	`outputnl(cmdline);`
169	`goto SKIP_TO_NEXT_ARG;`	169	`goto SKIP_TO_NEXT_ARG;`
170	`}`	170	`}`
171		171
172	`/* got a slash */`	172	`/* got a slash */`
173	`cmdline++; /* skip the slash */`	173	`cmdline++; /* skip the slash */`
174	`switch (*cmdline) {`	174	`switch (*cmdline) {`
175	`case 'c': /* /C = execute command and quit */`	175	`case 'c': /* /C = execute command and quit */`
176	`case 'C':`	176	`case 'C':`
177	`cfg->flags \|= FLAG_EXEC_AND_QUIT;`	177	`cfg->flags \|= FLAG_EXEC_AND_QUIT;`
178	`/* FALLTHRU */`	178	`/* FALLTHRU */`
179	`case 'k': /* /K = execute command and keep running */`	179	`case 'k': /* /K = execute command and keep running */`
180	`case 'K':`	180	`case 'K':`
181	`cmdline++;`	181	`cmdline++;`
182	`cfg->execcmd = cmdline;`	182	`cfg->execcmd = cmdline;`
183	`return; /* further arguments are for the executed program, not for me */`	183	`return; /* further arguments are for the executed program, not for me */`
184		184
185	`case 'y': /* /Y = execute batch file step-by-step (with /P, /K or /C) */`	185	`case 'y': /* /Y = execute batch file step-by-step (with /P, /K or /C) */`
186	`case 'Y':`	186	`case 'Y':`
187	`cfg->flags \|= FLAG_STEPBYSTEP;`	187	`cfg->flags \|= FLAG_STEPBYSTEP;`
188	`break;`	188	`break;`
189		189
190	`case 'd': /* /D = skip autoexec.bat processing */`	190	`case 'd': /* /D = skip autoexec.bat processing */`
191	`case 'D':`	191	`case 'D':`
192	`cfg->flags \|= FLAG_SKIP_AUTOEXEC;`	192	`cfg->flags \|= FLAG_SKIP_AUTOEXEC;`
193	`break;`	193	`break;`
194		194
195	`case 'e': /* preset the initial size of the environment block */`	195	`case 'e': /* preset the initial size of the environment block */`
196	`case 'E':`	196	`case 'E':`
197	`cmdline++;`	197	`cmdline++;`
198	`if (cmdline == ':') cmdline++; / could be /E:size */`	198	`if (cmdline == ':') cmdline++; / could be /E:size */`
199	`atous(&(cfg->envsiz), cmdline);`	199	`atous(&(cfg->envsiz), cmdline);`
200	`if (cfg->envsiz < 64) cfg->envsiz = 0;`	200	`if (cfg->envsiz < 64) cfg->envsiz = 0;`
201	`break;`	201	`break;`
202		202
203	`case 'p': /* permanent shell (can't exit + run autoexec.bat) */`	203	`case 'p': /* permanent shell (can't exit + run autoexec.bat) */`
204	`case 'P':`	204	`case 'P':`
205	`cfg->flags \|= FLAG_PERMANENT;`	205	`cfg->flags \|= FLAG_PERMANENT;`
206	`break;`	206	`break;`
207		207
208	`case '?':`	208	`case '?':`
209	`nls_outputnl(1,0); /* "Starts the SvarCOM command interpreter" */`	209	`nls_outputnl(1,0); /* "Starts the SvarCOM command interpreter" */`
210	`outputnl("");`	210	`outputnl("");`
211	`nls_outputnl(1,1); /* "COMMAND /E:nnn [/[C\|K] [/P] [/D] command]" */`	211	`nls_outputnl(1,1); /* "COMMAND /E:nnn [/[C\|K] [/P] [/D] command]" */`
212	`outputnl("");`	212	`outputnl("");`
213	`nls_outputnl(1,2); /* "/D Skip AUTOEXEC.BAT processing (makes sense only with /P)" */`	213	`nls_outputnl(1,2); /* "/D Skip AUTOEXEC.BAT processing (makes sense only with /P)" */`
214	`nls_outputnl(1,3); /* "/E:nnn Sets the environment size to nnn bytes" */`	214	`nls_outputnl(1,3); /* "/E:nnn Sets the environment size to nnn bytes" */`
215	`nls_outputnl(1,4); /* "/P Makes the new command interpreter permanent and run AUTOEXEC.BAT" */`	215	`nls_outputnl(1,4); /* "/P Makes the new command interpreter permanent and run AUTOEXEC.BAT" */`
216	`nls_outputnl(1,5); /* "/C Executes the specified command and returns" */`	216	`nls_outputnl(1,5); /* "/C Executes the specified command and returns" */`
217	`nls_outputnl(1,6); /* "/K Executes the specified command and continues running" */`	217	`nls_outputnl(1,6); /* "/K Executes the specified command and continues running" */`
218	`nls_outputnl(1,7); /* "/Y Executes the batch program step by step" */`	218	`nls_outputnl(1,7); /* "/Y Executes the batch program step by step" */`
219	`exit(1);`	219	`exit(1);`
220	`break;`	220	`break;`
221		221
222	`default:`	222	`default:`
223	`nls_output(0,2); /* invalid switch */`	223	`nls_output(0,2); /* invalid switch */`
224	`output(": /");`	224	`output(": /");`
225	`outputnl(cmdline);`	225	`outputnl(cmdline);`
226	`break;`	226	`break;`
227	`}`	227	`}`
228		228
229	`/* move to next argument or quit processing if end of cmdline */`	229	`/* move to next argument or quit processing if end of cmdline */`
230	`SKIP_TO_NEXT_ARG:`	230	`SKIP_TO_NEXT_ARG:`
231	`while ((cmdline != 0) && (cmdline != ' ') && (*cmdline != '/')) cmdline++;`	231	`while ((cmdline != 0) && (cmdline != ' ') && (*cmdline != '/')) cmdline++;`
232	`}`	232	`}`
233	`}`	233	`}`
234		234
235		235
236	`/* builds the prompt string and displays it. buff is filled with a zero-terminated copy of the prompt. */`	236	`/* builds the prompt string and displays it. buff is filled with a zero-terminated copy of the prompt. */`
237	`static void build_and_display_prompt(char *buff, unsigned short envseg) {`	237	`static void build_and_display_prompt(char *buff, unsigned short envseg) {`
238	`char *s = buff;`	238	`char *s = buff;`
239	`/* locate the prompt variable or use the default pattern */`	239	`/* locate the prompt variable or use the default pattern */`
240	`const char far *fmt = env_lookup_val(envseg, "PROMPT");`	240	`const char far *fmt = env_lookup_val(envseg, "PROMPT");`
241	`if ((fmt == NULL) \|\| (fmt == 0)) fmt = "$p$g"; / fallback to default if empty */`	241	`if ((fmt == NULL) \|\| (fmt == 0)) fmt = "$p$g"; / fallback to default if empty */`
242	`/* build the prompt string based on pattern */`	242	`/* build the prompt string based on pattern */`
243	`for (; *fmt != 0; fmt++) {`	243	`for (; *fmt != 0; fmt++) {`
244	`if (*fmt != '$') {`	244	`if (*fmt != '$') {`
245	`s = fmt;`	245	`s = fmt;`
246	`s++;`	246	`s++;`
247	`continue;`	247	`continue;`
248	`}`	248	`}`
249	`/* escape code ($P, etc) */`	249	`/* escape code ($P, etc) */`
250	`fmt++;`	250	`fmt++;`
251	`switch (*fmt) {`	251	`switch (*fmt) {`
252	`case 'Q': /* $Q = = (equal sign) */`	252	`case 'Q': /* $Q = = (equal sign) */`
253	`case 'q':`	253	`case 'q':`
254	`*s = '=';`	254	`*s = '=';`
255	`s++;`	255	`s++;`
256	`break;`	256	`break;`
257	`case '$': /* $$ = $ (dollar sign) */`	257	`case '$': /* $$ = $ (dollar sign) */`
258	`*s = '$';`	258	`*s = '$';`
259	`s++;`	259	`s++;`
260	`break;`	260	`break;`
261	`case 'T': /* $t = current time */`	261	`case 'T': /* $t = current time */`
262	`case 't':`	262	`case 't':`
263	`s += sprintf(s, "00:00"); /* TODO */`	263	`s += sprintf(s, "00:00"); /* TODO */`
264	`break;`	264	`break;`
265	`case 'D': /* $D = current date */`	265	`case 'D': /* $D = current date */`
266	`case 'd':`	266	`case 'd':`
267	`s += sprintf(s, "1985-07-29"); /* TODO */`	267	`s += sprintf(s, "1985-07-29"); /* TODO */`
268	`break;`	268	`break;`
269	`case 'P': /* $P = current drive and path */`	269	`case 'P': /* $P = current drive and path */`
270	`case 'p':`	270	`case 'p':`
271	`_asm {`	271	`_asm {`
272	`mov ah, 0x19 /* DOS 1+ - GET CURRENT DRIVE */`	272	`mov ah, 0x19 /* DOS 1+ - GET CURRENT DRIVE */`
273	`int 0x21`	273	`int 0x21`
274	`mov bx, s`	274	`mov bx, s`
275	`mov [bx], al /* AL = drive (00 = A:, 01 = B:, etc */`	275	`mov [bx], al /* AL = drive (00 = A:, 01 = B:, etc */`
276	`}`	276	`}`
277	`*s += 'A';`	277	`*s += 'A';`
278	`s++;`	278	`s++;`
279	`*s = ':';`	279	`*s = ':';`
280	`s++;`	280	`s++;`
281	`*s = '\\';`	281	`*s = '\\';`
282	`s++;`	282	`s++;`
283	`_asm {`	283	`_asm {`
284	`mov ah, 0x47 /* DOS 2+ - CWD - GET CURRENT DIRECTORY */`	284	`mov ah, 0x47 /* DOS 2+ - CWD - GET CURRENT DIRECTORY */`
285	`xor dl,dl /* DL = drive number (00h = default, 01h = A:, etc) */`	285	`xor dl,dl /* DL = drive number (00h = default, 01h = A:, etc) */`
286	`mov si, s /* DS:SI -> 64-byte buffer for ASCIZ pathname */`	286	`mov si, s /* DS:SI -> 64-byte buffer for ASCIZ pathname */`
287	`int 0x21`	287	`int 0x21`
288	`jc DONE /* leave path empty on error */`	288	`jc DONE /* leave path empty on error */`
289	`/* move s ptr forward to end (0-termintor) of pathname */`	289	`/* move s ptr forward to end (0-termintor) of pathname */`
290	`NEXTBYTE:`	290	`NEXTBYTE:`
291	`mov si, s`	291	`mov si, s`
292	`cmp byte ptr [si], 0`	292	`cmp byte ptr [si], 0`
293	`je DONE`	293	`je DONE`
294	`inc s`	294	`inc s`
295	`jmp NEXTBYTE`	295	`jmp NEXTBYTE`
296	`DONE:`	296	`DONE:`
297	`}`	297	`}`
298	`break;`	298	`break;`
299	`case 'V': /* $V = DOS version number */`	299	`case 'V': /* $V = DOS version number */`
300	`case 'v':`	300	`case 'v':`
301	`s += sprintf(s, "VER"); /* TODO */`	301	`s += sprintf(s, "VER"); /* TODO */`
302	`break;`	302	`break;`
303	`case 'N': /* $N = current drive */`	303	`case 'N': /* $N = current drive */`
304	`case 'n':`	304	`case 'n':`
305	`_asm {`	305	`_asm {`
306	`mov ah, 0x19 /* DOS 1+ - GET CURRENT DRIVE */`	306	`mov ah, 0x19 /* DOS 1+ - GET CURRENT DRIVE */`
307	`int 0x21`	307	`int 0x21`
308	`mov bx, s`	308	`mov bx, s`
309	`mov [bx], al /* AL = drive (00 = A:, 01 = B:, etc */`	309	`mov [bx], al /* AL = drive (00 = A:, 01 = B:, etc */`
310	`}`	310	`}`
311	`*s += 'A';`	311	`*s += 'A';`
312	`s++;`	312	`s++;`
313	`break;`	313	`break;`
314	`case 'G': /* $G = > (greater-than sign) */`	314	`case 'G': /* $G = > (greater-than sign) */`
315	`case 'g':`	315	`case 'g':`
316	`*s = '>';`	316	`*s = '>';`
317	`s++;`	317	`s++;`
318	`break;`	318	`break;`
319	`case 'L': /* $L = < (less-than sign) */`	319	`case 'L': /* $L = < (less-than sign) */`
320	`case 'l':`	320	`case 'l':`
321	`*s = '<';`	321	`*s = '<';`
322	`s++;`	322	`s++;`
323	`break;`	323	`break;`
324	`case 'B': /* $B = \| (pipe) */`	324	`case 'B': /* $B = \| (pipe) */`
325	`case 'b':`	325	`case 'b':`
326	`*s = '\|';`	326	`*s = '\|';`
327	`s++;`	327	`s++;`
328	`break;`	328	`break;`
329	`case 'H': /* $H = backspace (erases previous character) */`	329	`case 'H': /* $H = backspace (erases previous character) */`
330	`case 'h':`	330	`case 'h':`
331	`*s = '\b';`	331	`*s = '\b';`
332	`s++;`	332	`s++;`
333	`break;`	333	`break;`
334	`case 'E': /* $E = Escape code (ASCII 27) */`	334	`case 'E': /* $E = Escape code (ASCII 27) */`
335	`case 'e':`	335	`case 'e':`
336	`*s = 27;`	336	`*s = 27;`
337	`s++;`	337	`s++;`
338	`break;`	338	`break;`
339	`case '_': /* $_ = CR+LF */`	339	`case '_': /* $_ = CR+LF */`
340	`*s = '\r';`	340	`*s = '\r';`
341	`s++;`	341	`s++;`
342	`*s = '\n';`	342	`*s = '\n';`
343	`s++;`	343	`s++;`
344	`break;`	344	`break;`
345	`}`	345	`}`
346	`}`	346	`}`
347	`*s = 0;`	347	`*s = 0;`
348	`output(buff);`	348	`output(buff);`
349	`}`	349	`}`
350		350
351		351
352	`static void dos_fname2fcb(char far fcb, const char cmd) {`	352	`static void dos_fname2fcb(char far fcb, const char near cmd);`
353	`unsigned short fcb_seg, fcb_off;`	353	`#pragma aux dos_fname2fcb = \`
354	`fcb_seg = FP_SEG(fcb);`	-
355	`fcb_off = FP_OFF(fcb);`	-
356	`_asm {`	-
357	`push ax`	-
358	`push bx`	-
359	`push cx`	-
360	`push dx`	-
361	`push es`	-
362	`push si`	-
363		-
364	`mov ax, 0x2900 /* DOS 1+ - parse filename into FCB (DS:SI=fname, ES:DI=FCB) */`	354	`"mov ax, 0x2900" /* DOS 1+ - parse filename into FCB (DS:SI=fname, ES:DI=FCB) */ \`
365	`mov si, cmd`	-
366	`mov es, fcb_seg`	-
367	`mov di, fcb_off`	-
368	`int 0x21`	355	`"int 0x21" \`
369		-
370	`pop si`	356	`parm [es di] [si] \`
371	`pop es`	-
372	`pop dx`	-
373	`pop cx`	-
374	`pop bx`	-
375	`pop ax`	357	`modify [ax si]`
376	`}`	-
377	`}`	-
378		358
379		359
380	`/* parses cmdtail and fills fcb1 and fcb2 with first and second arguments,`	360	`/* parses cmdtail and fills fcb1 and fcb2 with first and second arguments,`
381	`* respectively. an FCB is 12 bytes long:`	361	`* respectively. an FCB is 12 bytes long:`
382	`* drive (0=default, 1=A, 2=B, etc)`	362	`* drive (0=default, 1=A, 2=B, etc)`
383	`* fname (8 chars, blank-padded)`	363	`* fname (8 chars, blank-padded)`
384	`* fext (3 chars, blank-padded) */`	364	`* fext (3 chars, blank-padded) */`
385	`static void cmdtail_to_fcb(char far fcb1, char far fcb2, const char *cmdtail) {`	365	`static void cmdtail_to_fcb(char far fcb1, char far fcb2, const char *cmdtail) {`
386		366
387	`/* skip any leading spaces */`	367	`/* skip any leading spaces */`
388	`while (*cmdtail == ' ') cmdtail++;`	368	`while (*cmdtail == ' ') cmdtail++;`
389		369
390	`/* convert first arg */`	370	`/* convert first arg */`
391	`dos_fname2fcb(fcb1, cmdtail);`	371	`dos_fname2fcb(fcb1, cmdtail);`
392		372
393	`/* skip to next arg */`	373	`/* skip to next arg */`
394	`while ((cmdtail != ' ') && (cmdtail != 0)) cmdtail++;`	374	`while ((cmdtail != ' ') && (cmdtail != 0)) cmdtail++;`
395	`while (*cmdtail == ' ') cmdtail++;`	375	`while (*cmdtail == ' ') cmdtail++;`
396		376
397	`/* convert second arg */`	377	`/* convert second arg */`
398	`dos_fname2fcb(fcb2, cmdtail);`	378	`dos_fname2fcb(fcb2, cmdtail);`
399	`}`	379	`}`
400		380
401		381
402	`/* a few internal flags */`	382	`/* a few internal flags */`
403	`#define DELETE_STDIN_FILE 1`	383	`#define DELETE_STDIN_FILE 1`
404	`#define CALL_FLAG 2`	384	`#define CALL_FLAG 2`
405	`#define LOADHIGH_FLAG 4`	385	`#define LOADHIGH_FLAG 4`
406		386
407	`static void run_as_external(char buff, const char cmdline, unsigned short envseg, struct rmod_props far rmod, struct redir_data redir, unsigned char flags) {`	387	`static void run_as_external(char buff, const char cmdline, unsigned short envseg, struct rmod_props far rmod, struct redir_data redir, unsigned char flags) {`
408	`char *cmdfile = buff + 512;`	388	`char *cmdfile = buff + 512;`
409	`const char far *pathptr;`	389	`const char far *pathptr;`
410	`int lookup;`	390	`int lookup;`
411	`unsigned short i;`	391	`unsigned short i;`
412	`const char *ext;`	392	`const char *ext;`
413	`char *cmd = buff + 1024;`	393	`char *cmd = buff + 1024;`
414	`const char *cmdtail;`	394	`const char *cmdtail;`
415	`char far *rmod_execprog = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPROG);`	395	`char far *rmod_execprog = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPROG);`
416	`char far *rmod_cmdtail = MK_FP(rmod->rmodseg, 0x81);`	396	`char far *rmod_cmdtail = MK_FP(rmod->rmodseg, 0x81);`
417	`_Packed struct {`	397	`_Packed struct {`
418	`unsigned short envseg;`	398	`unsigned short envseg;`
419	`unsigned long cmdtail;`	399	`unsigned long cmdtail;`
420	`unsigned long fcb1;`	400	`unsigned long fcb1;`
421	`unsigned long fcb2;`	401	`unsigned long fcb2;`
422	`} far *ExecParam = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPARAM);`	402	`} far *ExecParam = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPARAM);`
423		403
424	`/* find cmd and cmdtail */`	404	`/* find cmd and cmdtail */`
425	`i = 0;`	405	`i = 0;`
426	`cmdtail = cmdline;`	406	`cmdtail = cmdline;`
427	`while (cmdtail == ' ') cmdtail++; / skip any leading spaces */`	407	`while (cmdtail == ' ') cmdtail++; / skip any leading spaces */`
428	`while ((cmdtail != ' ') && (cmdtail != '/') && (cmdtail != '+') && (cmdtail != 0)) {`	408	`while ((cmdtail != ' ') && (cmdtail != '/') && (cmdtail != '+') && (cmdtail != 0)) {`
429	`cmd[i++] = *cmdtail;`	409	`cmd[i++] = *cmdtail;`
430	`cmdtail++;`	410	`cmdtail++;`
431	`}`	411	`}`
432	`cmd[i] = 0;`	412	`cmd[i] = 0;`
433		413
434	`/* is this a command in curdir? */`	414	`/* is this a command in curdir? */`
435	`lookup = lookup_cmd(cmdfile, cmd, NULL, &ext);`	415	`lookup = lookup_cmd(cmdfile, cmd, NULL, &ext);`
436	`if (lookup == 0) {`	416	`if (lookup == 0) {`
437	`/* printf("FOUND LOCAL EXEC FILE: '%s'\r\n", cmdfile); */`	417	`/* printf("FOUND LOCAL EXEC FILE: '%s'\r\n", cmdfile); */`
438	`goto RUNCMDFILE;`	418	`goto RUNCMDFILE;`
439	`} else if (lookup == -2) {`	419	`} else if (lookup == -2) {`
440	`/* puts("NOT FOUND"); */`	420	`/* puts("NOT FOUND"); */`
441	`return;`	421	`return;`
442	`}`	422	`}`
443		423
444	`/* try matching something in PATH */`	424	`/* try matching something in PATH */`
445	`pathptr = env_lookup_val(envseg, "PATH");`	425	`pathptr = env_lookup_val(envseg, "PATH");`
446		426
447	`/* try each path in %PATH% */`	427	`/* try each path in %PATH% */`
448	`while (pathptr) {`	428	`while (pathptr) {`
449	`for (i = 0;; i++) {`	429	`for (i = 0;; i++) {`
450	`buff[i] = *pathptr;`	430	`buff[i] = *pathptr;`
451	`if ((buff[i] == 0) \|\| (buff[i] == ';')) break;`	431	`if ((buff[i] == 0) \|\| (buff[i] == ';')) break;`
452	`pathptr++;`	432	`pathptr++;`
453	`}`	433	`}`
454	`buff[i] = 0;`	434	`buff[i] = 0;`
455	`lookup = lookup_cmd(cmdfile, cmd, buff, &ext);`	435	`lookup = lookup_cmd(cmdfile, cmd, buff, &ext);`
456	`if (lookup == 0) goto RUNCMDFILE;`	436	`if (lookup == 0) goto RUNCMDFILE;`
457	`if (lookup == -2) return;`	437	`if (lookup == -2) return;`
458	`if (*pathptr == ';') {`	438	`if (*pathptr == ';') {`
459	`pathptr++;`	439	`pathptr++;`
460	`} else {`	440	`} else {`
461	`break;`	441	`break;`
462	`}`	442	`}`
463	`}`	443	`}`
464		444
465	`/* last chance: is it an executable link? (trim extension from cmd first) */`	445	`/* last chance: is it an executable link? (trim extension from cmd first) */`
466	`for (i = 0; (cmd[i] != 0) && (cmd[i] != '.') && (i < 9); i++) buff[128 + i] = cmd[i];`	446	`for (i = 0; (cmd[i] != 0) && (cmd[i] != '.') && (i < 9); i++) buff[128 + i] = cmd[i];`
467	`buff[128 + i] = 0;`	447	`buff[128 + i] = 0;`
468	`if ((i < 9) && (link_computefname(buff, buff + 128, envseg) == 0)) {`	448	`if ((i < 9) && (link_computefname(buff, buff + 128, envseg) == 0)) {`
469	`/* try opening the link file (if it exists) and read it into buff */`	449	`/* try opening the link file (if it exists) and read it into buff */`
470	`i = 0;`	450	`i = 0;`
471	`_asm {`	451	`_asm {`
472	`push ax`	452	`push ax`
473	`push bx`	453	`push bx`
474	`push cx`	454	`push cx`
475	`push dx`	455	`push dx`
476		456
477	`mov ax, 0x3d00 /* DOS 2+ - OPEN EXISTING FILE, READ-ONLY */`	457	`mov ax, 0x3d00 /* DOS 2+ - OPEN EXISTING FILE, READ-ONLY */`
478	`mov dx, buff /* file name */`	458	`mov dx, buff /* file name */`
479	`int 0x21`	459	`int 0x21`
480	`jc ERR_FOPEN`	460	`jc ERR_FOPEN`
481	`/* file handle in AX, read from file now */`	461	`/* file handle in AX, read from file now */`
482	`mov bx, ax /* file handle */`	462	`mov bx, ax /* file handle */`
483	`mov ah, 0x3f /* Read from file via handle bx */`	463	`mov ah, 0x3f /* Read from file via handle bx */`
484	`mov cx, 128 /* up to 128 bytes */`	464	`mov cx, 128 /* up to 128 bytes */`
485	`/* mov dx, buff / / dest buffer (already set) */`	465	`/* mov dx, buff / / dest buffer (already set) */`
486	`int 0x21 /* read up to 256 bytes from file and write to buff */`	466	`int 0x21 /* read up to 256 bytes from file and write to buff */`
487	`jc ERR_READ`	467	`jc ERR_READ`
488	`mov i, ax`	468	`mov i, ax`
489	`ERR_READ:`	469	`ERR_READ:`
490	`mov ah, 0x3e /* close file handle in BX */`	470	`mov ah, 0x3e /* close file handle in BX */`
491	`int 0x21`	471	`int 0x21`
492	`ERR_FOPEN:`	472	`ERR_FOPEN:`
493		473
494	`pop dx`	474	`pop dx`
495	`pop cx`	475	`pop cx`
496	`pop bx`	476	`pop bx`
497	`pop ax`	477	`pop ax`
498	`}`	478	`}`
499		479
500	`/* did I read anything? */`	480	`/* did I read anything? */`

Subversion Repositories SvarDOS

(root)/svarcom/trunk/command.c – Rev 1730 → 1797