| 0,0 → 1,301 |
|---|
| /* This file is part of the SvarCOM project and is published under the terms |
| * of the MIT license. |
| * |
| * Copyright (C) 2021-2022 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, it matches internal commands and |
| * executes them. |
| * |
| * returns one of the following values: |
| * CMD_OK command executed successfully |
| * CMD_FAIL command ended in error |
| * CMD_CHANGED command-line has been modified (used by IF) |
| * CMD_CHANGED_BY_CALL command-line has been modified by CALL |
| * CMD_NOTFOUND command unrecognized |
| */ |
| |
| #include <i86.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "svarlang.lib/svarlang.h" |
| |
| #include "env.h" |
| #include "helpers.h" |
| #include "redir.h" |
| #include "rmodinit.h" |
| #include "sayonara.h" |
| |
| #include "cmd.h" |
| |
| |
| struct cmd_funcparam { |
| int argc; /* number of arguments */ |
| const char *argv[128]; /* pointers to each argument */ |
| char argvbuf[256]; /* buffer that hold data pointed out by argv[] */ |
| unsigned short env_seg; /* segment of environment block */ |
| struct rmod_props far *rmod; /* rmod settings */ |
| unsigned short argoffset; /* offset of cmdline where first argument starts */ |
| const char *cmdline; /* original cmdline (terminated by a NULL) */ |
| unsigned short BUFFERSZ; /* avail space in BUFFER */ |
| char BUFFER[1]; /* a buffer for whatever is needed (must be last) */ |
| }; |
| |
| /* 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/break.c" |
| #include "cmd/call.c" |
| #include "cmd/cd.c" |
| #include "cmd/chcp.c" |
| #include "cmd/cls.c" |
| #include "cmd/copy.c" |
| #include "cmd/ctty.c" |
| #include "cmd/date.c" |
| #include "cmd/del.c" |
| #include "cmd/for.c" |
| #include "cmd/goto.c" |
| #include "cmd/if.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/loadhigh.c" |
| #include "cmd/ln.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/shift.c" |
| #include "cmd/time.c" |
| #include "cmd/truename.c" |
| #include "cmd/type.c" |
| #include "cmd/ver.c" |
| #include "cmd/verify.c" |
| |
| |
| struct CMD_ID { |
| const char *cmd; |
| enum cmd_result (*func_ptr)(struct cmd_funcparam *); /* pointer to handling function */ |
| }; |
| |
| const struct CMD_ID INTERNAL_CMDS[] = { |
| {"BREAK", cmd_break}, |
| {"CALL", cmd_call}, |
| {"CD", cmd_cd}, |
| {"CHCP", cmd_chcp}, |
| {"CHDIR", cmd_cd}, |
| {"CLS", cmd_cls}, |
| {"COPY", cmd_copy}, |
| {"CTTY", cmd_ctty}, |
| {"DATE", cmd_date}, |
| {"DEL", cmd_del}, |
| {"DIR", cmd_dir}, |
| {"ECHO", cmd_echo}, |
| {"ERASE", cmd_del}, |
| {"EXIT", cmd_exit}, |
| {"FOR", cmd_for}, |
| {"GOTO", cmd_goto}, |
| {"IF", cmd_if}, |
| {"LH", cmd_loadhigh}, |
| {"LN", cmd_ln}, |
| {"LOADHIGH",cmd_loadhigh}, |
| {"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}, |
| {"SHIFT", cmd_shift}, |
| {"TIME", cmd_time}, |
| {"TRUENAME",cmd_truename}, |
| {"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 *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. |
| * if argvlist is not NULL, it will be filled with pointers that point to buff |
| * locations. buff is filled with all the arguments, each argument being |
| * zero-separated. buff is terminated with an empty argument to mark the end |
| * of arguments. |
| * 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 */ |
| if (argvlist) argvlist[argc] = buff + i; |
| argc++; |
| /* 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; |
| } |
| buff[i] = 0; /* terminate with one extra zero to tell "this is the end of list" */ |
| if (argvlist) argvlist[argc] = NULL; |
| return(argc); |
| } |
| |
| |
| enum cmd_result cmd_process(struct rmod_props far *rmod, unsigned short env_seg, const char *cmdline, void *BUFFER, unsigned short BUFFERSZ, const struct redir_data *redir, unsigned char delstdin) { |
| const struct CMD_ID *cmdptr; |
| unsigned short argoffset; |
| enum cmd_result cmdres; |
| struct cmd_funcparam *p = (void *)BUFFER; |
| p->BUFFERSZ = BUFFERSZ - sizeof(*p); |
| |
| /* 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) return(CMD_OK); |
| nls_outputnl_doserr(0x0f); |
| return(CMD_FAIL); |
| } |
| } |
| |
| /* try matching an internal command */ |
| cmdptr = cmd_match(cmdline, &argoffset); |
| if (cmdptr == NULL) return(CMD_NOTFOUND); /* command is not recognized as internal */ |
| |
| /* printf("recognized internal command: '%s', tail of command at offset %u\r\n", cmdptr->cmd, argoffset); */ |
| |
| /* apply redirections (if any) */ |
| if (redir_apply(redir) != 0) return(CMD_FAIL); |
| |
| /* prepare function parameters and feed it to the cmd handling function */ |
| p->argc = cmd_explode(p->argvbuf, cmdline + argoffset, p->argv); |
| p->env_seg = env_seg; |
| p->rmod = rmod; |
| p->argoffset = argoffset; |
| p->cmdline = cmdline; |
| |
| cmdres = (cmdptr->func_ptr)(p); |
| |
| /* cancel redirections */ |
| redir_revert(); |
| |
| /* delete stdin temporary file */ |
| if (delstdin) { |
| const char *fname = redir->stdinfile; |
| unsigned short doserr = 0; |
| _asm { |
| push ax |
| push dx |
| mov ah, 0x41 /* delete a file */ |
| mov dx, fname /* DS:DX - filename to delete */ |
| int 0x21 |
| jnc DONE |
| mov doserr, ax |
| DONE: |
| pop dx |
| pop ax |
| } |
| if (doserr) { |
| output(fname); |
| output(": "); |
| nls_outputnl_doserr(doserr); |
| } |
| } |
| |
| return(cmdres); |
| } |