Subversion Repositories SvarDOS

Rev

Rev 406 | Rev 408 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
352 mateuszvis 1
/* entry point for internal commands
2
 * matches internal commands and executes them
353 mateuszvis 3
 * returns -1 or exit code if processed
4
 * returns -2 if command unrecognized */
352 mateuszvis 5
 
6
#include <i86.h>
7
#include <stdio.h>
364 mateuszvis 8
#include <stdlib.h>
372 mateuszvis 9
#include <string.h>
352 mateuszvis 10
 
363 mateuszvis 11
#include "doserr.h"
371 mateuszvis 12
#include "env.h"
352 mateuszvis 13
#include "helpers.h"
405 mateuszvis 14
#include "rmodinit.h"
352 mateuszvis 15
 
403 mateuszvis 16
#define BUFFER_SIZE 2048    /* make sure this is not bigger than the static buffer in command.c */
17
 
364 mateuszvis 18
struct cmd_funcparam {
371 mateuszvis 19
  int argc;                 /* number of arguments */
20
  const char *argv[256];    /* pointers to each argument */
21
  unsigned short env_seg;   /* segment of environment block */
405 mateuszvis 22
  unsigned short rmod_seg;  /* segment of the resident module */
371 mateuszvis 23
  unsigned short argoffset; /* offset of cmdline where first argument starts */
405 mateuszvis 24
  const char far *cmdline;  /* original cmdline (terminated by a NULL) */
403 mateuszvis 25
  char BUFFER[BUFFER_SIZE]; /* a buffer for whatever is needed */
364 mateuszvis 26
};
27
 
387 mateuszvis 28
/* scans argv for the presence of a "/?" parameter. returns 1 if found, 0 otherwise */
29
static int cmd_ishlp(const struct cmd_funcparam *p) {
30
  int i;
31
  for (i = 0; i < p->argc; i++) {
32
    if ((p->argv[i][0] == '/') && (p->argv[i][1] == '?')) return(1);
33
  }
34
  return(0);
35
}
36
 
380 mateuszvis 37
#include "cmd/_notimpl.c"
363 mateuszvis 38
#include "cmd/cd.c"
407 mateuszvis 39
#include "cmd/chcp.c"
404 mateuszvis 40
#include "cmd/cls.c"
403 mateuszvis 41
#include "cmd/copy.c"
392 mateuszvis 42
#include "cmd/del.c"
399 mateuszvis 43
#include "cmd/vol.c"     /* must be included before dir.c due to dependency */
368 mateuszvis 44
#include "cmd/dir.c"
405 mateuszvis 45
#include "cmd/echo.c"
364 mateuszvis 46
#include "cmd/exit.c"
385 mateuszvis 47
#include "cmd/mkdir.c"
372 mateuszvis 48
#include "cmd/path.c"
400 mateuszvis 49
#include "cmd/pause.c"
371 mateuszvis 50
#include "cmd/prompt.c"
400 mateuszvis 51
#include "cmd/rem.c"
406 mateuszvis 52
#include "cmd/rename.c"
385 mateuszvis 53
#include "cmd/rmdir.c"
352 mateuszvis 54
#include "cmd/set.c"
399 mateuszvis 55
#include "cmd/type.c"
379 mateuszvis 56
#include "cmd/ver.c"
386 mateuszvis 57
#include "cmd/verify.c"
352 mateuszvis 58
 
59
#include "cmd.h"
60
 
61
 
364 mateuszvis 62
struct CMD_ID {
63
  const char *cmd;
372 mateuszvis 64
  int (*func_ptr)(struct cmd_funcparam *); /* pointer to handling function */
364 mateuszvis 65
};
352 mateuszvis 66
 
364 mateuszvis 67
const struct CMD_ID INTERNAL_CMDS[] = {
380 mateuszvis 68
  {"BREAK",   cmd_notimpl},
364 mateuszvis 69
  {"CD",      cmd_cd},
407 mateuszvis 70
  {"CHCP",    cmd_chcp},
364 mateuszvis 71
  {"CHDIR",   cmd_cd},
404 mateuszvis 72
  {"CLS",     cmd_cls},
403 mateuszvis 73
  {"COPY",    cmd_copy},
380 mateuszvis 74
  {"CTTY",    cmd_notimpl},
75
  {"DATE",    cmd_notimpl},
392 mateuszvis 76
  {"DEL",     cmd_del},
368 mateuszvis 77
  {"DIR",     cmd_dir},
405 mateuszvis 78
  {"ECHO",    cmd_echo},
392 mateuszvis 79
  {"ERASE",   cmd_del},
364 mateuszvis 80
  {"EXIT",    cmd_exit},
380 mateuszvis 81
  {"LH",      cmd_notimpl},
82
  {"LOADHIGH",cmd_notimpl},
385 mateuszvis 83
  {"MD",      cmd_mkdir},
84
  {"MKDIR",   cmd_mkdir},
400 mateuszvis 85
  {"PAUSE",   cmd_pause},
372 mateuszvis 86
  {"PATH",    cmd_path},
371 mateuszvis 87
  {"PROMPT",  cmd_prompt},
385 mateuszvis 88
  {"RD",      cmd_rmdir},
400 mateuszvis 89
  {"REM",     cmd_rem},
406 mateuszvis 90
  {"REN",     cmd_rename},
91
  {"RENAME",  cmd_rename},
385 mateuszvis 92
  {"RMDIR",   cmd_rmdir},
364 mateuszvis 93
  {"SET",     cmd_set},
380 mateuszvis 94
  {"TIME",    cmd_notimpl},
382 mateuszvis 95
  {"TYPE",    cmd_type},
379 mateuszvis 96
  {"VER",     cmd_ver},
386 mateuszvis 97
  {"VERIFY",  cmd_verify},
399 mateuszvis 98
  {"VOL",     cmd_vol},
364 mateuszvis 99
  {NULL,      NULL}
100
};
101
 
102
 
103
/* NULL if cmdline is not matching an internal command, otherwise returns a
104
 * pointer to a CMD_ID struct */
105
static const struct CMD_ID *cmd_match(const char far *cmdline, unsigned short *argoffset) {
106
  unsigned short i;
107
  char buff[10];
108
 
109
  /* copy command to buffer, until space, NULL, tab, return, dot, slash or backslash */
110
  for (i = 0; i < 9; i++) {
111
    if (cmdline[i] == ' ') break;
112
    if (cmdline[i] == 0) break;
113
    if (cmdline[i] == '\t') break;
114
    if (cmdline[i] == '\r') break;
115
    if (cmdline[i] == '.') break;
116
    if (cmdline[i] == '/') break;
117
    if (cmdline[i] == '\\') break;
118
    buff[i] = cmdline[i];
119
  }
120
  buff[i] = 0;
121
 
122
  /* advance to nearest non-space to find where arguments start */
123
  while (cmdline[i] == ' ') i++;
124
  *argoffset = i;
125
 
126
  /* try matching an internal command */
127
  for (i = 0; INTERNAL_CMDS[i].cmd != NULL; i++) {
128
    /*printf("imatch(%s,%s)\r\n", buff, INTERNAL_CMDS[i].cmd); */
129
    if (imatch(buff, INTERNAL_CMDS[i].cmd)) {
130
      /*printf("match cmd i=%u (buff=%s)\r\n", i, buff);*/
131
      return(&(INTERNAL_CMDS[i]));
132
    }
133
  }
134
 
135
  return(NULL); /* command is not recognized as internal */
352 mateuszvis 136
}
364 mateuszvis 137
 
138
 
139
/* explodes a command into an array of arguments where last arg is NULL
140
 * returns number of args */
141
unsigned short cmd_explode(char *buff, const char far *s, char const **argvlist) {
142
  int si = 0, argc = 0, i = 0;
143
  for (;;) {
144
    /* skip to next non-space character */
145
    while (s[si] == ' ') si++;
146
    /* end of string? */
147
    if (s[si] == 0) break;
148
    /* set argv ptr */
149
    argvlist[argc++] = buff + i;
403 mateuszvis 150
    /* find next arg delimiter (spc, null, slash or plus) while copying arg to local buffer */
364 mateuszvis 151
    do {
152
      buff[i++] = s[si++];
403 mateuszvis 153
    } while (s[si] != ' ' && s[si] != 0 && s[si] != '/' && s[si] != '+');
364 mateuszvis 154
    buff[i++] = 0;
155
    /* is this end of string? */
156
    if (s[si] == 0) break;
157
  }
158
  argvlist[argc] = NULL;
159
  return(argc);
160
}
161
 
162
 
405 mateuszvis 163
int cmd_process(unsigned short rmod_seg, unsigned short env_seg, const char far *cmdline, char *BUFFER) {
364 mateuszvis 164
  const struct CMD_ID *cmdptr;
165
  unsigned short argoffset;
372 mateuszvis 166
  struct cmd_funcparam *p = (void *)BUFFER;
364 mateuszvis 167
 
365 mateuszvis 168
  /* special case: is this a drive change? (like "E:") */
169
  if ((cmdline[0] != 0) && (cmdline[1] == ':') && ((cmdline[2] == ' ') || (cmdline[2] == 0))) {
170
    if (((cmdline[0] >= 'a') && (cmdline[0] <= 'z')) || ((cmdline[0] >= 'A') && (cmdline[0] <= 'Z'))) {
171
      unsigned char drive = cmdline[0];
172
      unsigned char curdrive = 0;
173
      if (drive >= 'a') {
174
        drive -= 'a';
175
      } else {
176
        drive -= 'A';
177
      }
178
      _asm {
179
        push ax
180
        push dx
181
        mov ah, 0x0e     /* DOS 1+ - SELECT DEFAULT DRIVE */
182
        mov dl, drive    /* DL = new default drive (00h = A:, 01h = B:, etc) */
183
        int 0x21
184
        mov ah, 0x19     /* DOS 1+ - GET CURRENT DRIVE */
185
        int 0x21
186
        mov curdrive, al /* cur drive (0=A, 1=B, etc) */
187
        pop dx
188
        pop ax
189
      }
190
      if (curdrive != drive) puts(doserr(0x0f));
191
      return(-1);
192
    }
193
  }
194
 
195
  /* try matching an internal command */
364 mateuszvis 196
  cmdptr = cmd_match(cmdline, &argoffset);
197
  if (cmdptr == NULL) return(-2); /* command is not recognized as internal */
198
 
199
  /* printf("recognized internal command: '%s', tail of command at offset %u\r\n", cmdptr->cmd, argoffset); */
200
 
201
  /* prepare function parameters and feed it to the cmd handling function */
372 mateuszvis 202
  p->argc = cmd_explode(BUFFER + sizeof(*p), cmdline + argoffset, p->argv);
203
  p->env_seg = env_seg;
405 mateuszvis 204
  p->rmod_seg = rmod_seg;
372 mateuszvis 205
  p->argoffset = argoffset;
206
  p->cmdline = cmdline;
364 mateuszvis 207
 
372 mateuszvis 208
  return((cmdptr->func_ptr)(p));
364 mateuszvis 209
}