WebSVN – SvarDOS – Diff – /svarcom/tags/svarcom-2022.0/cmd.c


/* This file is part of the SvarCOM project and is published under the terms
 * of the MIT license.
 *
 * Copyright (C) 2021 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.
 */
 
/* 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"
#include "rmodinit.h"
#include "sayonara.h"
 
#define BUFFER_SIZE 2048    /* make sure this is not bigger than the static buffer in command.c */
 
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 rmod_seg;  /* segment of the resident module */
  unsigned short argoffset; /* offset of cmdline where first argument starts */
  const char far *cmdline;  /* original cmdline (terminated by a NULL) */
  char BUFFER[BUFFER_SIZE]; /* a buffer for whatever is needed */
};
 
/* scans argv for the presence of a "/?" parameter. returns 1 if found, 0 otherwise */
static int cmd_ishlp(const struct cmd_funcparam *p) {
  int i;
  for (i = 0; i < p->argc; i++) {
    if ((p->argv[i][0] == '/') && (p->argv[i][1] == '?')) return(1);
  }
  return(0);
}
 
#include "cmd/_notimpl.c"
#include "cmd/break.c"
#include "cmd/cd.c"
#include "cmd/chcp.c"
#include "cmd/cls.c"
#include "cmd/copy.c"
#include "cmd/date.c"
#include "cmd/del.c"
#include "cmd/vol.c"     /* must be included before dir.c due to dependency */
#include "cmd/dir.c"
#include "cmd/echo.c"
#include "cmd/exit.c"
#include "cmd/mkdir.c"
#include "cmd/path.c"
#include "cmd/pause.c"
#include "cmd/prompt.c"
#include "cmd/rem.c"
#include "cmd/rename.c"
#include "cmd/rmdir.c"
#include "cmd/set.c"
#include "cmd/time.c"
#include "cmd/type.c"
#include "cmd/ver.c"
#include "cmd/verify.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_break},
  {"CD",      cmd_cd},
  {"CHCP",    cmd_chcp},
  {"CHDIR",   cmd_cd},
  {"CLS",     cmd_cls},
  {"COPY",    cmd_copy},
  {"CTTY",    cmd_notimpl},
  {"DATE",    cmd_date},
  {"DEL",     cmd_del},
  {"DIR",     cmd_dir},
  {"ECHO",    cmd_echo},
  {"ERASE",   cmd_del},
  {"EXIT",    cmd_exit},
  {"LH",      cmd_notimpl},
  {"LOADHIGH",cmd_notimpl},
  {"MD",      cmd_mkdir},
  {"MKDIR",   cmd_mkdir},
  {"PAUSE",   cmd_pause},
  {"PATH",    cmd_path},
  {"PROMPT",  cmd_prompt},
  {"RD",      cmd_rmdir},
  {"REM",     cmd_rem},
  {"REN",     cmd_rename},
  {"RENAME",  cmd_rename},
  {"RMDIR",   cmd_rmdir},
  {"SET",     cmd_set},
  {"TIME",    cmd_time},
  {"TYPE",    cmd_type},
  {"VER",     cmd_ver},
  {"VERIFY",  cmd_verify},
  {"VOL",     cmd_vol},
  {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 arg delimiter (spc, null, slash or plus) while copying arg to local buffer */
    do {
      buff[i++] = s[si++];
    } while (s[si] != ' ' && s[si] != 0 && s[si] != '/' && 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 rmod_seg, 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->rmod_seg = rmod_seg;
  p->argoffset = argoffset;
  p->cmdline = cmdline;
 
  return((cmdptr->func_ptr)(p));
}
 

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

Subversion Repositories SvarDOS

(root)/svarcom/tags/svarcom-2022.0/cmd.c @ 1200 – Rev 431 → 448