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


/* entry point for internal commands
 * matches internal commands and executes them
 * returns -1 or exit code if processed
 * returns -2 if command unrecognized */
 
#include <i86.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "doserr.h"
#include "env.h"
#include "helpers.h"
 
struct cmd_funcparam {
  int argc;                 /* number of arguments */
  const char *argv[256];    /* pointers to each argument */
  unsigned short env_seg;   /* segment of environment block */
  unsigned short argoffset; /* offset of cmdline where first argument starts */
  const char far *cmdline;  /* original cmdline (terminated by \r) */
  char BUFFER[1024];        /* a buffer for whatever is needed */
};
 
#include "cmd/_notimpl.c"
#include "cmd/cd.c"
#include "cmd/dir.c"
#include "cmd/exit.c"
#include "cmd/path.c"
#include "cmd/prompt.c"
#include "cmd/set.c"
#include "cmd/ver.c"
#include "cmd/type.c"
 
#include "cmd.h"
 
 
struct CMD_ID {
  const char *cmd;
  int (*func_ptr)(struct cmd_funcparam *); /* pointer to handling function */
};
 
const struct CMD_ID INTERNAL_CMDS[] = {
  {"BREAK",   cmd_notimpl},
  {"CD",      cmd_cd},
  {"CHCP",    cmd_notimpl},
  {"CHDIR",   cmd_cd},
  {"CLS",     cmd_notimpl},
  {"COPY",    cmd_notimpl},
  {"CTTY",    cmd_notimpl},
  {"DATE",    cmd_notimpl},
  {"DEL",     cmd_notimpl},
  {"DIR",     cmd_dir},
  {"ECHO",    cmd_notimpl},
  {"ERASE",   cmd_notimpl},
  {"EXIT",    cmd_exit},
  {"LH",      cmd_notimpl},
  {"LOADHIGH",cmd_notimpl},
  {"MD",      cmd_notimpl},
  {"MKDIR",   cmd_notimpl},
  {"PAUSE",   cmd_notimpl},
  {"PATH",    cmd_path},
  {"PROMPT",  cmd_prompt},
  {"RD",      cmd_notimpl},
  {"REN",     cmd_notimpl},
  {"RENAME",  cmd_notimpl},
  {"RMDIR",   cmd_notimpl},
  {"SET",     cmd_set},
  {"TIME",    cmd_notimpl},
  {"TYPE",    cmd_type},
  {"VER",     cmd_ver},
  {"VERIFY",  cmd_notimpl},
  {"VOL",     cmd_notimpl},
  {NULL,      NULL}
};
 
 
/* NULL if cmdline is not matching an internal command, otherwise returns a
 * pointer to a CMD_ID struct */
static const struct CMD_ID *cmd_match(const char far *cmdline, unsigned short *argoffset) {
  unsigned short i;
  char buff[10];
 
  /* copy command to buffer, until space, NULL, tab, return, dot, slash or backslash */
  for (i = 0; i < 9; i++) {
    if (cmdline[i] == ' ') break;
    if (cmdline[i] == 0) break;
    if (cmdline[i] == '\t') break;
    if (cmdline[i] == '\r') break;
    if (cmdline[i] == '.') break;
    if (cmdline[i] == '/') break;
    if (cmdline[i] == '\\') break;
    buff[i] = cmdline[i];
  }
  buff[i] = 0;
 
  /* advance to nearest non-space to find where arguments start */
  while (cmdline[i] == ' ') i++;
  *argoffset = i;
 
  /* try matching an internal command */
  for (i = 0; INTERNAL_CMDS[i].cmd != NULL; i++) {
    /*printf("imatch(%s,%s)\r\n", buff, INTERNAL_CMDS[i].cmd); */
    if (imatch(buff, INTERNAL_CMDS[i].cmd)) {
      /*printf("match cmd i=%u (buff=%s)\r\n", i, buff);*/
      return(&(INTERNAL_CMDS[i]));
    }
  }
 
  return(NULL); /* command is not recognized as internal */
}
 
 
/* explodes a command into an array of arguments where last arg is NULL
 * returns number of args */
unsigned short cmd_explode(char *buff, const char far *s, char const **argvlist) {
  int si = 0, argc = 0, i = 0;
  for (;;) {
    /* skip to next non-space character */
    while (s[si] == ' ') si++;
    /* end of string? */
    if (s[si] == 0) break;
    /* set argv ptr */
    argvlist[argc++] = buff + i;
    /* find next space while copying arg to local buffer */
    do {
      buff[i++] = s[si++];
    } while (s[si] != ' ' && s[si] != 0 && s[si] != '/');
    buff[i++] = 0;
    /* is this end of string? */
    if (s[si] == 0) break;
  }
  argvlist[argc] = NULL;
  return(argc);
}
 
 
int cmd_process(unsigned short env_seg, const char far *cmdline, char *BUFFER) {
  const struct CMD_ID *cmdptr;
  unsigned short argoffset;
  struct cmd_funcparam *p = (void *)BUFFER;
 
  /* special case: is this a drive change? (like "E:") */
  if ((cmdline[0] != 0) && (cmdline[1] == ':') && ((cmdline[2] == ' ') || (cmdline[2] == 0))) {
    if (((cmdline[0] >= 'a') && (cmdline[0] <= 'z')) || ((cmdline[0] >= 'A') && (cmdline[0] <= 'Z'))) {
      unsigned char drive = cmdline[0];
      unsigned char curdrive = 0;
      if (drive >= 'a') {
        drive -= 'a';
      } else {
        drive -= 'A';
      }
      _asm {
        push ax
        push dx
        mov ah, 0x0e     /* DOS 1+ - SELECT DEFAULT DRIVE */
        mov dl, drive    /* DL = new default drive (00h = A:, 01h = B:, etc) */
        int 0x21
        mov ah, 0x19     /* DOS 1+ - GET CURRENT DRIVE */
        int 0x21
        mov curdrive, al /* cur drive (0=A, 1=B, etc) */
        pop dx
        pop ax
      }
      if (curdrive != drive) puts(doserr(0x0f));
      return(-1);
    }
  }
 
  /* try matching an internal command */
  cmdptr = cmd_match(cmdline, &argoffset);
  if (cmdptr == NULL) return(-2); /* command is not recognized as internal */
 
  /* printf("recognized internal command: '%s', tail of command at offset %u\r\n", cmdptr->cmd, argoffset); */
 
  /* prepare function parameters and feed it to the cmd handling function */
  p->argc = cmd_explode(BUFFER + sizeof(*p), cmdline + argoffset, p->argv);
  p->env_seg = env_seg;
  p->argoffset = argoffset;
  p->cmdline = cmdline;
 
  return((cmdptr->func_ptr)(p));
}
 

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

Subversion Repositories SvarDOS

(root)/svarcom/trunk/cmd.c @ 1141 – Rev 380 → 382