int cmd_arg(char *param)
{
char **argv;
int argc, opts;
unsigned to_del, base, shiftlevel;
if((argv = scanCmdline(param, 0, 0, &argc, &opts)) == 0)
return 1;
/* Because no option was passed into scanCmdline() no
option can have been processed */
assert(opts == 0);
shiftlevel = base = to_del = 0; /* for argc == 0 */
if(argc == 0
|| argc == 3 && is_num(argv[0], &base) && is_num(argv[1], &to_del)
&& is_num(argv[2], &shiftlevel) && base <= to_del) {
ctxtPopTo(CTXT_TAG_ARG, to_del);
gflag_shiftlevel = shiftlevel;
gflag_base_shiftlevel = base;
freep(argv);
return 0;
}
error_syntax(0);
freep(argv);
return 1;
}
int mk_rd_dir(char *param, int (*func) (const char *), char *fctname)
#endif
{ char **argv;
int argc, opts;
int rv;
assert(func);
if((argv = scanCmdline(param, 0, 0, &argc, &opts)) == 0)
return 1;
if(argc != 1) {
error_syntax(0);
rv = 1;
} else {
cutBackslash(argv[0]);
dprintf(("%s: '%s'\n", fctname, argv[0]));
#ifdef FEATURE_LONG_FILENAMES
if((rv = lfn_mrc_dir( getshortfilename( argv[0] ), lfnfunc )) != 0)
#else
if((rv = func(argv[0])) != 0)
#endif
error_dirfct_failed(fctname, argv[0]);
}
freep(argv);
return rv;
}
/* check the current token, error if not the expected one */
void CurSymExpect(tokid_t expected_tok)
{
init_module();
if (sym.tok != expected_tok)
error_syntax();
}
int cmd_set(char *param)
{ char *value;
if(leadOptions(¶m, opt_set, 0) != E_None)
return 1;
switch(breakVarAssign(ctxtEnvironment, param, &value)) {
case 1: /* no equal sign */
error_syntax(0);
return 1;
case 0: /* displayed */
return 0;
#ifdef DEBUG
case 2: break;
default:
dprintf(("[SET: Invalid response from breakVarAssign()]\n"));
return 1;
#endif
}
/* If the value is just blanks, it means to delete the value;
but otherwise even leading and trailing spaces must be kept */
if(is_empty(value))
value = 0;
return chgEnvCase(optC, param, value);
}
int cmd_set(char *param)
{ char *value;
char *promptBuf = 0;
int ret;
optC = promptUser = 0;
if(leadOptions(¶m, opt_set, 0) != E_None)
return 1;
switch(breakVarAssign(ctxtEnvironment, param, &value)) {
case 1: /* no equal sign */
error_syntax(0);
return 1;
case 0: /* displayed */
return 0;
#ifdef DEBUG
case 2: break;
default:
dprintf(("[SET: Invalid response from breakVarAssign()]\n"));
return 1;
#endif
}
if(promptUser) { /* -> Display the value, then read and assign */
assert(value);
fputs(value, stdout);
promptBuf = malloc(promptBuffer);
if(!promptBuf) {
error_out_of_memory();
return E_NoMem;
}
fgets(promptBuf, promptBuffer, stdin);
if(cbreak) {
free(promptBuf);
return E_CBreak;
}
value = strchr(promptBuf, '\0');
while(--value >= promptBuf && (*value == '\n' || *value == '\r'));
value[1] = '\0'; /* strip trailing newlines */
value = promptBuf;
}
/* If the value is just blanks, it means to delete the value;
but otherwise even leading and trailing spaces must be kept */
if(is_empty(value))
value = 0;
ret = chgEnvCase(optC, param, value);
free(promptBuf);
return ret;
}
INT cmd_if (LPTSTR param)
{
TRACE ("cmd_if: (\'%s\')\n", debugstr_aw(param));
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_IF_HELP1);
return 0;
}
error_syntax(param);
return 1;
}
/*-----------------------------------------------------------------------------
* parse the given assembly file, return FALSE if failed
*----------------------------------------------------------------------------*/
static void parseline(ParseCtx *ctx)
{
int start_num_errors;
next_PC(); /* update assembler program counter */
EOL = FALSE; /* reset END OF LINE flag */
start_num_errors = get_num_errors();
scan_expect_opcode();
GetSym();
if (get_num_errors() != start_num_errors) /* detect errors in GetSym() */
Skipline();
else if (!parse_statement(ctx))
{
if (get_num_errors() == start_num_errors) /* no error output yet */
error_syntax();
Skipline();
}
list_end_line(); /* Write current source line to list file */
}
/* save the current scanner context and parse the given expression */
struct Expr *parse_expr(char *expr_text)
{
Expr *expr;
int num_errors;
save_scan_state();
{
src_push();
{
SetTemporaryLine(expr_text);
num_errors = get_num_errors();
EOL = FALSE;
scan_expect_operands();
GetSym();
expr = expr_parse(); /* may output error */
if (sym.tok != TK_END && num_errors == get_num_errors())
error_syntax();
}
src_pop();
}
restore_scan_state();
return expr;
}
int cd_dir(char *param, int cdd, const char * const fctname)
{ char **argv, *dir;
int argc, opts;
int rv, freeDir;
if((argv = scanCmdline(param, 0, 0, &argc, &opts)) == 0)
return 1;
freeDir = 0;
rv = 1;
/* if doing a CD and no parameters given, print out current directory */
if(argc == 0) {
if((dir = cwd(0)) != 0) {
puts(dir);
freeDir = 1;
goto okRet;
}
goto errRet;
} else if(argc != 1) {
error_syntax(0);
goto errRet;
}
else {
assert(argv[0]);
#ifdef FEATURE_CDD_FNAME
/* if path refers to an existing file and not directory, ignore filename portion */
if (cdd && (dfnstat(argv[0]) & DFN_FILE))
{
dir = strrchr(argv[0], '\\');
if (dir == NULL)
{
dir = argv[0];
if (dir[1] == ':') dir[2]='\0'; /* change drive only, no path */
else goto okRet; /* no drive, no path, so exit early */
}
else /* includes a path or refers to root dir */
{
*(dir+1) = '\0';
}
}
#endif
dir = strchr(argv[0], '\0');
/* take off trailing \ if any, but ONLY if dir is not the root dir */
while(dir > &argv[0][1] && *--dir == '\\' && dir[-1] != ':')
*dir = '\0';
dir = argv[0];
#ifdef FEATURE_LAST_DIR
if(strcmp(dir, "-") == 0) {
assert(!freeDir);
/* change to last directory */
lastDirGet(&dir);
freeDir = 1;
}
lastDirSet();
if(!dir) /* "CD -" without a CD before at all */
goto okRet;
#endif
if(*dir && dir[1] == ':') {
if(cdd) {
if(changeDrive(*dir) != 0)
goto errRet;
if(!dir[2]) /* only change drive */
goto okRet;
} else if(!dir[2]) { /* Real CHDIR displays CWD of
specified drive */
assert(freeDir == 0);
if((dir = cwd(*dir)) != 0) {
puts(dir);
freeDir = 1;
goto okRet;
}
goto errRet;
}
}
dprintf(("%s: '%s'\n", fctname, dir));
if(chdir(dir) != 0) {
error_dirfct_failed(fctname, dir);
goto errRet;
}
}
okRet:
rv = 0;
errRet:
freep(argv);
if(freeDir)
free(dir);
return rv;
}
static void docommand(char *line)
{
/*
* look through the internal commands and determine whether or not this
* command is one of them. If it is, call the command. If not, call
* execute to run it as an external program.
*
* line - the command line of the program to run
*/
char *cp;
char *rest; /* pointer to the rest of the command line */
struct CMD *cmdptr = 0;
#ifdef FEATURE_INSTALLABLE_COMMANDS
/* Duplicate the command line into such buffer in order to
allow Installable Commands to alter the command line.
*line cannot be modified as pipes would be destroyed. */
/* Place both buffers immediately following each other in
order to make sure the contents of args can be appended
to com without any buffer overflow checks.
*2 -> one buffer for com and one for args
+2 -> max length byte of com + cur length of com
+3 -> max length byte of args + cur length of args + additional '\0'
*/
char *buf = malloc(2+2*BUFFER_SIZE_MUX_AE+2+1);
#define args (buf + 2)
#define ARGS_BUFFER_SIZE (2 + BUFFER_SIZE_MUX_AE + 3)
#define com (buf + ARGS_BUFFER_SIZE)
#define BUFFER_SIZE BUFFER_SIZE_MUX_AE
#else
char *com = malloc(MAX_INTERNAL_COMMAND_SIZE);
#define args line
#define buf com
#define BUFFER_SIZE MAX_INTERNAL_COMMAND_SIZE
#endif
assert(line);
if(!buf) {
error_out_of_memory();
return;
}
/* delete leading spaces, but keep trailing whitespaces */
line = ltrimcl(line);
#ifdef FEATURE_INSTALLABLE_COMMANDS
#if BUFFER_SIZE < MAX_INTERNAL_COMMAND_SIZE
if(strlen(line) > BUFFER_SIZE) {
error_line_too_long();
goto errRet;
}
#endif
strcpy(args, line);
#endif
if (*(rest = args)) /* Anything to do ? */
{
cp = com;
/* Copy over 1st word as upper case */
/* Internal commands are constructed out of non-delimiter
characters; ? had been parsed already */
while(*rest && is_fnchar(*rest) && !strchr(QUOTE_STR, *rest))
*cp++ = toupper(*rest++);
if(*rest && strchr(QUOTE_STR, *rest))
/* If the first word is quoted, it is no internal command */
cp = com; /* invalidate it */
*cp = '\0'; /* Terminate first word */
if(*com) {
#ifdef FEATURE_INSTALLABLE_COMMANDS
int tryMUXAE;
for(tryMUXAE = MUX_AE_MAX_REPEAT_CALL; tryMUXAE > 0; --tryMUXAE) {
/* Check for installed COMMAND extension */
switch(runExtension(com, args)) {
case 1: /* OK, done */
goto errRet;
case 0: /* no extension */
tryMUXAE = 0;
}
/* reset the argument pointer */
rest = &args[(unsigned char)com[-1]];
dprintf( ("[Command on return of Installable Commands check: >%s]\n", com) );
#ifndef NDEBUG
dprintf( ("[Command line: >") );
for(cp = args; cp < rest; ++cp)
dprintf( ("%c", *cp) );
dprintf( ("|%s]\n", rest) );
#endif /* !defined(NDEBUG) */
#endif
/* Scan internal command table */
for (cmdptr = internalCommands
; cmdptr->name && strcmp(com, cmdptr->name) != 0
; cmdptr++);
if(cmdptr && cmdptr->name) { /* internal command found */
#ifdef FEATURE_INSTALLABLE_COMMANDS
cp = realloc(buf, ARGS_BUFFER_SIZE);
#ifndef NDEBUG
if(cp != buf) {
dprintf( ("[INTERNAL error: realloc() returned wrong result]") );
buf = cp;
}
#endif
#else
free(buf); buf = 0; /* no further useage of this buffer */
#endif
switch(cmdptr->flags & (CMD_SPECIAL_ALL | CMD_SPECIAL_DIR)) {
case CMD_SPECIAL_ALL: /* pass everything into command */
break;
case CMD_SPECIAL_DIR: /* pass '\\' & '.' too */
if(*rest == '\\' || *rest == '.' || *rest == ':') break;
default: /* pass '/', ignore ',', ';' & '=' */
if(!*rest || *rest == '/') break;
if(isargdelim(*rest)) {
rest = ltrimcl(rest);
break;
}
/* else syntax error */
error_syntax(0);
goto errRet;
}
currCmdHelpScreen = cmdptr->help_id;
/* JPP this will print help for any command */
if(memcmp(ltrimcl(rest), "/?", 2) == 0) {
displayString(currCmdHelpScreen);
} else {
dprintf(("CMD '%s' : '%s'\n", cmdptr->name, rest));
cmdptr->func(rest);
}
goto errRet;
}
#ifdef FEATURE_INSTALLABLE_COMMANDS
}
#endif
}
free(buf); buf = 0; /* no longer used */
/* no internal command --> spawn an external one */
cp = unquote(line, rest = skip_word(line));
if(!cp) {
error_out_of_memory();
goto errRet;
}
execute(cp, rest);
free(cp);
}
#undef com
#undef args
#undef BUFFER_SIZE
#undef ARGS_BUFFER_SIZE
errRet:
free(buf);
}
INT cmd_move (LPTSTR param)
{
LPTSTR *arg;
INT argc, i, nFiles;
LPTSTR pszDest;
TCHAR szDestPath[MAX_PATH];
TCHAR szFullDestPath[MAX_PATH];
TCHAR szSrcDirPath[MAX_PATH];
TCHAR szSrcPath[MAX_PATH];
TCHAR szFullSrcPath[MAX_PATH];
DWORD dwFlags = 0;
INT nOverwrite = 0;
WIN32_FIND_DATA findBuffer;
HANDLE hFile;
/* used only when source and destination directories are on different volume*/
HANDLE hDestFile;
WIN32_FIND_DATA findDestBuffer;
TCHAR szMoveDest[MAX_PATH];
TCHAR szMoveSrc[MAX_PATH];
LPTSTR pszDestDirPointer;
LPTSTR pszSrcDirPointer;
INT nDirLevel = 0;
LPTSTR pszFile;
BOOL OnlyOneFile;
BOOL FoundFile;
BOOL MoveStatus;
DWORD dwMoveFlags = 0;
DWORD dwMoveStatusFlags = 0;
if (!_tcsncmp (param, _T("/?"), 2))
{
#if 0
ConOutPuts (_T("Moves files and renames files and directories.\n\n"
"To move one or more files:\n"
"MOVE [/N][/Y|/-Y][drive:][path]filename1[,...] destination\n"
"\n"
"To rename a directory:\n"
"MOVE [/N][/Y|/-Y][drive:][path]dirname1 dirname2\n"
"\n"
" [drive:][path]filename1 Specifies the location and name of the file\n"
" or files you want to move.\n"
" /N Nothing. Don everthing but move files or direcories.\n"
" /Y\n"
" /-Y\n"
"..."));
#else
ConOutResPaging(TRUE,STRING_MOVE_HELP2);
#endif
return 0;
}
nErrorLevel = 0;
arg = splitspace(param, &argc);
/* read options */
for (i = 0; i < argc; i++)
{
if (!_tcsicmp(arg[i], _T("/N")))
dwFlags |= MOVE_NOTHING;
else if (!_tcsicmp(arg[i], _T("/Y")))
dwFlags |= MOVE_OVER_YES;
else if (!_tcsicmp(arg[i], _T("/-Y")))
dwFlags |= MOVE_OVER_NO;
else
break;
}
nFiles = argc - i;
if (nFiles < 1)
{
/* there must be at least one pathspec */
error_req_param_missing();
freep(arg);
return 1;
}
if (nFiles > 2)
{
/* there are more than two pathspecs */
error_too_many_parameters(param);
freep(arg);
return 1;
}
/* If no destination is given, default to current directory */
pszDest = (nFiles == 1) ? _T(".") : arg[i + 1];
/* check for wildcards in source and destination */
if (_tcschr(pszDest, _T('*')) != NULL || _tcschr(pszDest, _T('?')) != NULL)
{
/* '*'/'?' in dest, this doesnt happen. give folder name instead*/
error_invalid_parameter_format(pszDest);
freep(arg);
return 1;
}
if (_tcschr(arg[i], _T('*')) != NULL || _tcschr(arg[i], _T('?')) != NULL)
{
dwMoveStatusFlags |= MOVE_SOURCE_HAS_WILD;
}
/* get destination */
GetFullPathName (pszDest, MAX_PATH, szDestPath, NULL);
TRACE ("Destination: %s\n", debugstr_aw(szDestPath));
/* get source folder */
GetFullPathName(arg[i], MAX_PATH, szSrcDirPath, &pszFile);
if (pszFile != NULL)
*pszFile = _T('\0');
TRACE ("Source Folder: %s\n", debugstr_aw(szSrcDirPath));
hFile = FindFirstFile (arg[i], &findBuffer);
if (hFile == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), arg[i]);
freep (arg);
return 1;
}
/* check for special cases "." and ".." and if found skip them */
FoundFile = TRUE;
while(FoundFile &&
(_tcscmp(findBuffer.cFileName,_T(".")) == 0 ||
_tcscmp(findBuffer.cFileName,_T("..")) == 0))
FoundFile = FindNextFile (hFile, &findBuffer);
if (!FoundFile)
{
/* what? we don't have anything to move? */
error_file_not_found();
FindClose(hFile);
freep(arg);
return 1;
}
OnlyOneFile = TRUE;
/* check if there can be found files as files have first priority */
if (findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
dwMoveStatusFlags |= MOVE_SOURCE_IS_DIR;
else
dwMoveStatusFlags |= MOVE_SOURCE_IS_FILE;
while(OnlyOneFile && FindNextFile(hFile,&findBuffer))
{
if (!(findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
ConOutPrintf(_T(""));
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE) OnlyOneFile = FALSE;
else
{ /* this has been done this way so that we don't disturb other settings if they have been set before this */
dwMoveStatusFlags |= MOVE_SOURCE_IS_FILE;
dwMoveStatusFlags &= ~MOVE_SOURCE_IS_DIR;
}
}
}
FindClose(hFile);
TRACE ("Do we have only one file: %s\n", OnlyOneFile ? "TRUE" : "FALSE");
/* we have to start again to be sure we don't miss any files or folders*/
hFile = FindFirstFile (arg[i], &findBuffer);
if (hFile == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), arg[i]);
freep (arg);
return 1;
}
/* check for special cases "." and ".." and if found skip them */
FoundFile = TRUE;
while(FoundFile &&
(_tcscmp(findBuffer.cFileName,_T(".")) == 0 ||
_tcscmp(findBuffer.cFileName,_T("..")) == 0))
FoundFile = FindNextFile (hFile, &findBuffer);
if (!FoundFile)
{
/* huh? somebody removed files and/or folders which were there */
error_file_not_found();
FindClose(hFile);
freep(arg);
return 1;
}
/* check if source and destination paths are on different volumes */
if (szSrcDirPath[0] != szDestPath[0])
dwMoveStatusFlags |= MOVE_PATHS_ON_DIF_VOL;
/* move it */
do
{
TRACE ("Found file/directory: %s\n", debugstr_aw(findBuffer.cFileName));
nOverwrite = 1;
dwMoveFlags = 0;
dwMoveStatusFlags &= ~MOVE_DEST_IS_FILE &
~MOVE_DEST_IS_DIR &
~MOVE_SRC_CURRENT_IS_DIR &
~MOVE_DEST_EXISTS;
_tcscpy(szFullSrcPath,szSrcDirPath);
if(szFullSrcPath[_tcslen(szFullSrcPath) - 1] != _T('\\'))
_tcscat (szFullSrcPath, _T("\\"));
_tcscat(szFullSrcPath,findBuffer.cFileName);
_tcscpy(szSrcPath, szFullSrcPath);
if (IsExistingDirectory(szSrcPath))
{
/* source is directory */
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE)
{
dwMoveStatusFlags |= MOVE_SRC_CURRENT_IS_DIR; /* source is file but at the current round we found a directory */
continue;
}
TRACE ("Source is dir: %s\n", debugstr_aw(szSrcPath));
dwMoveFlags = MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
/* if source is file we don't need to do anything special */
if (IsExistingDirectory(szDestPath))
{
/* destination is existing directory */
TRACE ("Destination is directory: %s\n", debugstr_aw(szDestPath));
dwMoveStatusFlags |= MOVE_DEST_IS_DIR;
/*build the dest string(accounts for *)*/
_tcscpy (szFullDestPath, szDestPath);
/*check to see if there is an ending slash, if not add one*/
if(szFullDestPath[_tcslen(szFullDestPath) - 1] != _T('\\'))
_tcscat (szFullDestPath, _T("\\"));
_tcscat (szFullDestPath, findBuffer.cFileName);
if (IsExistingFile(szFullDestPath) || IsExistingDirectory(szFullDestPath))
dwMoveStatusFlags |= MOVE_DEST_EXISTS;
dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
if (IsExistingFile(szDestPath))
{
/* destination is a file */
TRACE ("Destination is file: %s\n", debugstr_aw(szDestPath));
dwMoveStatusFlags |= MOVE_DEST_IS_FILE | MOVE_DEST_EXISTS;
_tcscpy (szFullDestPath, szDestPath);
dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
TRACE ("Move Status Flags: 0x%X\n",dwMoveStatusFlags);
if (dwMoveStatusFlags & MOVE_SOURCE_IS_DIR &&
dwMoveStatusFlags & MOVE_DEST_IS_DIR &&
dwMoveStatusFlags & MOVE_SOURCE_HAS_WILD)
{
/* We are not allowed to have existing source and destination dir when there is wildcard in source */
error_syntax(NULL);
FindClose(hFile);
freep(arg);
return 1;
}
if (!(dwMoveStatusFlags & (MOVE_DEST_IS_FILE | MOVE_DEST_IS_DIR)))
{
/* destination doesn't exist */
_tcscpy (szFullDestPath, szDestPath);
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE) dwMoveStatusFlags |= MOVE_DEST_IS_FILE;
if (dwMoveStatusFlags & MOVE_SOURCE_IS_DIR) dwMoveStatusFlags |= MOVE_DEST_IS_DIR;
dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE &&
dwMoveStatusFlags & MOVE_DEST_IS_FILE &&
!OnlyOneFile)
{
/*source has many files but there is only one destination file*/
error_invalid_parameter_format(pszDest);
FindClose(hFile);
freep (arg);
return 1;
}
/*checks to make sure user wanted/wants the override*/
if((dwFlags & MOVE_OVER_NO) &&
(dwMoveStatusFlags & MOVE_DEST_EXISTS))
continue;
if(!(dwFlags & MOVE_OVER_YES) &&
(dwMoveStatusFlags & MOVE_DEST_EXISTS))
nOverwrite = MoveOverwrite (szFullDestPath);
if (nOverwrite == PROMPT_NO || nOverwrite == PROMPT_BREAK)
continue;
if (nOverwrite == PROMPT_ALL)
dwFlags |= MOVE_OVER_YES;
ConOutPrintf (_T("%s => %s "), szSrcPath, szFullDestPath);
/* are we really supposed to do something */
if (dwFlags & MOVE_NOTHING)
continue;
/*move the file*/
if (!(dwMoveStatusFlags & MOVE_SOURCE_IS_DIR &&
dwMoveStatusFlags & MOVE_PATHS_ON_DIF_VOL))
/* we aren't moving source folder to different drive */
MoveStatus = MoveFileEx (szSrcPath, szFullDestPath, dwMoveFlags);
else
{ /* we are moving source folder to different drive */
_tcscpy(szMoveDest, szFullDestPath);
_tcscpy(szMoveSrc, szSrcPath);
DeleteFile(szMoveDest);
MoveStatus = CreateDirectory(szMoveDest, NULL); /* we use default security settings */
if (MoveStatus)
{
_tcscat(szMoveDest,_T("\\"));
_tcscat(szMoveSrc,_T("\\"));
nDirLevel = 0;
pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
_tcscpy(pszSrcDirPointer,_T("*.*"));
hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
if (hDestFile == INVALID_HANDLE_VALUE)
MoveStatus = FALSE;
else
{
BOOL FirstTime = TRUE;
FoundFile = TRUE;
MoveStatus = FALSE;
while(FoundFile)
{
if (FirstTime)
FirstTime = FALSE;
else
FoundFile = FindNextFile (hDestFile, &findDestBuffer);
if (!FoundFile)
{ /* Nothing to do in this folder so we stop working on it */
FindClose(hDestFile);
(pszSrcDirPointer)--;
(pszDestDirPointer)--;
_tcscpy(pszSrcDirPointer,_T(""));
_tcscpy(pszDestDirPointer,_T(""));
if (nDirLevel > 0)
{
TCHAR szTempPath[MAX_PATH];
INT nDiff;
FoundFile = TRUE; /* we need to continue our seek for files */
nDirLevel--;
RemoveDirectory(szMoveSrc);
GetDirectory(szMoveSrc,szTempPath,0);
nDiff = _tcslen(szMoveSrc) - _tcslen(szTempPath);
pszSrcDirPointer = pszSrcDirPointer - nDiff;
_tcscpy(pszSrcDirPointer,_T(""));
GetDirectory(szMoveDest,szTempPath,0);
nDiff = _tcslen(szMoveDest) - _tcslen(szTempPath);
pszDestDirPointer = pszDestDirPointer - nDiff;
_tcscpy(pszDestDirPointer,_T(""));
if(szMoveSrc[_tcslen(szMoveSrc) - 1] != _T('\\'))
_tcscat (szMoveSrc, _T("\\"));
if(szMoveDest[_tcslen(szMoveDest) - 1] != _T('\\'))
_tcscat (szMoveDest, _T("\\"));
pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
_tcscpy(pszSrcDirPointer,_T("*.*"));
hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
if (hDestFile == INVALID_HANDLE_VALUE)
continue;
FirstTime = TRUE;
}
else
{
MoveStatus = TRUE; /* we moved everything so lets tell user about it */
RemoveDirectory(szMoveSrc);
}
continue;
}
/* if we find "." or ".." we'll skip them */
if (_tcscmp(findDestBuffer.cFileName,_T(".")) == 0 ||
_tcscmp(findDestBuffer.cFileName,_T("..")) == 0)
continue;
_tcscpy(pszSrcDirPointer, findDestBuffer.cFileName);
_tcscpy(pszDestDirPointer, findDestBuffer.cFileName);
if (IsExistingFile(szMoveSrc))
{
FoundFile = CopyFile(szMoveSrc, szMoveDest, FALSE);
if (!FoundFile) continue;
DeleteFile(szMoveSrc);
}
else
{
FindClose(hDestFile);
CreateDirectory(szMoveDest, NULL);
_tcscat(szMoveDest,_T("\\"));
_tcscat(szMoveSrc,_T("\\"));
nDirLevel++;
pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
_tcscpy(pszSrcDirPointer,_T("*.*"));
hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
if (hDestFile == INVALID_HANDLE_VALUE)
{
FoundFile = FALSE;
continue;
}
FirstTime = TRUE;
}
}
}
}
}
if (MoveStatus)
ConOutResPrintf(STRING_MOVE_ERROR1);
else
ConOutResPrintf(STRING_MOVE_ERROR2);
}
while ((!OnlyOneFile || dwMoveStatusFlags & MOVE_SRC_CURRENT_IS_DIR ) &&
!(dwMoveStatusFlags & MOVE_SOURCE_IS_DIR) &&
FindNextFile (hFile, &findBuffer));
FindClose (hFile);
freep (arg);
return 0;
}
static void docommand(char *line)
{
/*
* look through the internal commands and determine whether or not this
* command is one of them. If it is, call the command. If not, call
* execute to run it as an external program.
*
* line - the command line of the program to run
*/
#ifdef FEATURE_INSTALLABLE_COMMANDS
/* Duplicate the command line into such buffer in order to
allow Installable Commands to alter the command line.
*line cannot be modified as pipes would be destroyed. */
/* Place both buffers immediately following each other in
order to make sure the contents of args can be appended
to com without any buffer overflow checks.
*2 -> one buffer for com and one for args
+2 -> max length byte of com + cur length of com
+3 -> max length byte of args + cur length of args + additional '\0'
*/
char buf[2*BUFFER_SIZE_MUX_AE+3+1];
#define com (buf + 1)
#define args (buf + 1 + BUFFER_SIZE_MUX_AE + 2)
#define BUFFER_SIZE BUFFER_SIZE_MUX_AE
#else
char com[MAX_INTERNAL_COMMAND_SIZE];
#define BUFFER_SIZE MAX_INTERNAL_COMMAND_SIZE
#endif
char *cp;
char *rest; /* pointer to the rest of the command line */
struct CMD *cmdptr;
assert(line);
/* delete leading & trailing whitespaces */
line = trim(line);
#ifdef FEATURE_INSTALLABLE_COMMANDS
#if BUFFER_SIZE < MAX_INTERNAL_COMMAND_SIZE
if(strlen(line) > BUFFER_SIZE) {
error_line_too_long();
return;
}
#endif
line = strcpy(args, line);
#endif
if (*(rest = line)) /* Anything to do ? */
{
cp = com;
/* Copy over 1st word as lower case */
/* Internal commands are constructed out of non-delimiter
characters; ? had been parsed already */
while(*rest && !is_delim(*rest) && !strchr(QUOTE_STR, *rest))
*cp++ = toupper(*rest++);
if(*rest && strchr(QUOTE_STR, *rest))
/* If the first word is quoted, it is no internal command */
cp = com; /* invalidate it */
*cp = '\0'; /* Terminate first word */
if(*com) {
#ifdef FEATURE_INSTALLABLE_COMMANDS
/* Check for installed COMMAND extension */
if(runExtension(com, args))
return; /* OK, executed! */
dprintf( ("[Command on return of Installable Commands check: >%s<]\n", com) );
#endif
/* Scan internal command table */
for (cmdptr = cmds; cmdptr->name && strcmp(com, cmdptr->name) != 0
; cmdptr++);
}
if(*com && cmdptr->name) { /* internal command found */
switch(cmdptr->flags & (CMD_SPECIAL_ALL | CMD_SPECIAL_DIR)) {
case CMD_SPECIAL_ALL: /* pass everything into command */
break;
case CMD_SPECIAL_DIR: /* pass '\\' & '.' too */
if(*rest == '\\' || *rest == '.') break;
default: /* pass '/', ignore ',', ';' & '=' */
if(*rest == '/') break;
if(!*rest || isspace(*rest)) { /* normal delimiter */
rest = ltrim(rest);
break;
}
if(strchr(",;=", *rest)) {
rest = ltrim(rest + 1);
break;
}
/* else syntax error */
error_syntax(NULL);
return;
}
/* JPP this will print help for any command */
if (strstr(rest, "/?"))
{
displayString(cmdptr->help_id);
}
else
{
dprintf(("CMD '%s' : '%s'\n", com, rest));
cmdptr->func(rest);
}
} else {
#ifdef FEATURE_INSTALLABLE_COMMANDS
if(*com) { /* external command */
/* Installable Commands are allowed to change both:
"com" and "args". Therefore, we may need to
reconstruct the external command line */
/* Because com and *rest are located within the very same
buffer and rest is definitely terminated with '\0',
the followinf memmove() operation is fully robust
against buffer overflows */
memmove(com + strlen(com), rest, strlen(rest) + 1);
/* Unsave, but probably more efficient operation:
strcat(com, rest);
-- 2000/12/10 ska*/
line = com;
}
#endif
/* no internal command --> spawn an external one */
cp = unquote(line, rest = skip_word(line));
if(!cp) {
error_out_of_memory();
return;
}
execute(cp, ltrim(rest));
free(cp);
}
}
#undef line
#undef com
#undef args
#undef BUFFER_SIZE
}
static void docommand(char *line)
{
/*
* look through the internal commands and determine whether or not this
* command is one of them. If it is, call the command. If not, call
* execute to run it as an external program.
*
* line - the command line of the program to run
*/
char *com; /* the first word in the command */
char *cp;
char *rest; /* pointer to the rest of the command line */
struct CMD *cmdptr;
assert(line);
/* delete leading & trailing whitespaces */
line = rest = trim(line);
if (*rest) /* Anything to do ? */
{
if ((cp = com = malloc(strlen(line) + 1)) == NULL)
{
error_out_of_memory();
return;
}
/* Copy over 1st word as lower case */
/* Internal commands are constructed out of alphabetic
characters; ? had been parsed already */
while (isalpha(*rest))
*cp++ = tolower(*rest++);
if(*rest && (!is_delim(*rest) || strchr(QUOTE_STR, *rest)))
/* If the first word is quoted, it is no internal command */
cp = com; /* invalidate it */
*cp = '\0'; /* Terminate first word */
/* Scan internal command table */
if(*com)
for (cmdptr = cmds; cmdptr->name && strcmp(com, cmdptr->name) != 0
; cmdptr++);
if(*com && cmdptr->name) { /* internal command found */
free(com); /* free()'ed during call */
switch(cmdptr->flags & (CMD_SPECIAL_ALL | CMD_SPECIAL_DIR)) {
case CMD_SPECIAL_ALL: /* pass everything into command */
break;
case CMD_SPECIAL_DIR: /* pass '\\' too */
if(*rest == '\\') break;
default: /* pass '/', ignore ',', ';' & '=' */
if(*rest == '/') break;
if(!*rest || isspace(*rest)) { /* normal delimiter */
rest = ltrim(rest);
break;
}
if(strchr(",;=", *rest)) {
rest = ltrim(rest + 1);
break;
}
/* else syntax error */
error_syntax(NULL);
return;
}
/* JPP this will print help for any command */
if (strstr(rest, "/?"))
{
displayString(cmdptr->help_id);
}
else
{
dprintf(("CMD '%s' : '%s'\n", com, rest));
cmdptr->func(rest);
}
} else {
/* no internal command --> spawn an external one */
free(com);
com = unquote(line, rest = skip_word(line));
if(!com) {
error_out_of_memory();
return;
}
execute(com, ltrim(rest));
free(com);
}
}
}
INT ExecuteIf(PARSED_COMMAND *Cmd)
{
INT result = FALSE; /* when set cause 'then' clause to be executed */
LPTSTR param;
LPTSTR Left = NULL, Right;
if (Cmd->If.LeftArg)
{
Left = DoDelayedExpansion(Cmd->If.LeftArg);
if (!Left)
return 1;
}
Right = DoDelayedExpansion(Cmd->If.RightArg);
if (!Right)
{
cmd_free(Left);
return 1;
}
if (Cmd->If.Operator == IF_CMDEXTVERSION)
{
/* IF CMDEXTVERSION n: check if Command Extensions version
* is greater or equal to n */
DWORD n = _tcstoul(Right, ¶m, 10);
if (*param != _T('\0'))
{
error_syntax(Right);
cmd_free(Right);
return 1;
}
result = (2 >= n);
}
else if (Cmd->If.Operator == IF_DEFINED)
{
/* IF DEFINED var: check if environment variable exists */
result = (GetEnvVarOrSpecial(Right) != NULL);
}
else if (Cmd->If.Operator == IF_ERRORLEVEL)
{
/* IF ERRORLEVEL n: check if last exit code is greater or equal to n */
INT n = _tcstol(Right, ¶m, 10);
if (*param != _T('\0'))
{
error_syntax(Right);
cmd_free(Right);
return 1;
}
result = (nErrorLevel >= n);
}
else if (Cmd->If.Operator == IF_EXIST)
{
BOOL IsDir;
INT Size;
WIN32_FIND_DATA f;
HANDLE hFind;
/* IF EXIST filename: check if file exists (wildcards allowed) */
StripQuotes(Right);
Size = _tcslen(Right);
IsDir = (Right[Size - 1] == '\\');
if (IsDir)
Right[Size - 1] = 0;
hFind = FindFirstFile(Right, &f);
if (hFind != INVALID_HANDLE_VALUE)
{
if (IsDir)
{
result = ((f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
}
else
{
result = TRUE;
}
FindClose(hFind);
}
if (IsDir)
Right[Size - 1] = '\\';
}
else
{
/* Do case-insensitive string comparisons if /I specified */
INT (*StringCmp)(LPCTSTR, LPCTSTR) =
(Cmd->If.Flags & IFFLAG_IGNORECASE) ? _tcsicmp : _tcscmp;
if (Cmd->If.Operator == IF_STRINGEQ)
{
/* IF str1 == str2 */
result = StringCmp(Left, Right) == 0;
}
else
{
result = GenericCmp(StringCmp, Left, Right);
switch (Cmd->If.Operator)
{
case IF_EQU: result = (result == 0); break;
case IF_NEQ: result = (result != 0); break;
case IF_LSS: result = (result < 0); break;
case IF_LEQ: result = (result <= 0); break;
case IF_GTR: result = (result > 0); break;
case IF_GEQ: result = (result >= 0); break;
}
}
}
cmd_free(Left);
cmd_free(Right);
if (result ^ ((Cmd->If.Flags & IFFLAG_NEGATE) != 0))
{
/* full condition was true, do the command */
return ExecuteCommand(Cmd->Subcommands);
}
else
{
/* full condition was false, do the "else" command if there is one */
if (Cmd->Subcommands->Next)
return ExecuteCommand(Cmd->Subcommands->Next);
return 0;
}
}
int grabComFilename(const int warn, const char far * const fnam)
{
char *buf;
size_t len;
int rc;
dprintf( ("[INIT: grabComFilename(%s)]\n", fnam) );
if(!fnam)
return 4;
/* Copy the filename into the local heap */
len = _fstrlen(fnam);
if(len >= INT_MAX || len < 1) {
/* no filename specified */
if(warn)
error_syntax(0);
return 4;
}
if((buf = malloc(len + 1)) == 0) {
if(warn) error_out_of_memory();
return 4;
}
_fmemcpy((char far*)buf, fnam, len);
buf[len] = '\0';
if (buf[1] != ':' || buf[2] != '\\')
{ char *p;
/* expand the string for the user */
p = abspath(buf, warn);
free(buf);
if((buf = p) == 0)
return 4;
if(warn)
error_init_fully_qualified(buf);
len = strlen(buf);
}
while(buf[len - 1] == '\\')
--len;
buf[len] = 0;
if(dfnstat(buf) & DFN_DIRECTORY) {
/* The user specified a directory, try if we can find the
COMMAND.COM with the standard name in there */
char *p;
if((p = realloc(buf, len + sizeof(COM_NAME) + 1)) == 0) {
if(warn) error_out_of_memory();
free(buf);
return 4;
}
buf = p;
strcpy(&buf[len], "\\" COM_NAME);
}
if(0 != (rc = validResFile(buf))) {
if(warn) switch(rc) {
default:
#ifdef NDEBUG
assert(0);
#endif
case 1:
error_open_file(buf);
break;
case 2:
error_fcom_is_device(buf);
break;
case 3:
error_fcom_invalid(buf);
break;
}
free(buf);
return rc;
}
free(ComPath); /* Save the found file */
ComPath = buf;
dprintf(("[INIT: new resource file name: %s]\n", ComPath));
isSwapFile = 0;
buf = dfnfilename(ComPath);
assert(buf);
if((buf = strchr(buf, '.')) != 0
&& stricmp(buf, ".swp") == 0) {
dprintf(("[INIT: VSpawn file found: %s]\n", ComPath));
memcpy(++buf, "COM", 3);
isSwapFile = buf - ComPath;
}
return 0;
}
int cmd_if(char *param)
{
#define X_EXEC 1
char *pp;
int x_flag = 0; /* when set cause 'then' clause to be exec'ed */
int negate = 0; /* NOT keyword present */
int ignore_case = 0; /* /I option, case insensitive compare */
/* First check if param exists */
assert(param);
/* check for options, note non-options must be treated as part of comparision */
if (matchtok(param, "/I")||matchtok(param, "/i"))
ignore_case++;
/* next check if param string begins with word 'not' */
if(matchtok(param, "not"))
negate = X_EXEC; /* Remember 'NOT' */
/* Check for 'exist' form */
if(matchtok(param, "exist")) {
struct dos_ffblk f;
isr olderrhandler;
if(!*param) {
/* syntax error */
error_if_exist();
return 0;
}
pp = skip_word(param);
*pp++ = '\0';
/* don't show abort/retry/fail if no disk in drive */
get_isr(0x24, olderrhandler);
#ifdef XMS_SWAP
set_isrfct(0x24, autofail_err_handler); /* always fails */
#else
set_isrfct(0x24, dummy_criter_handler); /* always fails */
#endif
if(dos_findfirst(param, &f, FA_NORMAL|FA_ARCH|FA_SYSTEM|FA_RDONLY|FA_HIDDEN) == 0)
x_flag = X_EXEC;
dos_findclose(&f);
/* restore critical error handler */
set_isrfct(0x24, olderrhandler);
}
/* Check for 'errorlevel' form */
else if(matchtok(param, "errorlevel")) {
int n = 0;
#if 0
if(!isdigit(*param)) {
error_if_errorlevel();
return 0;
}
pp = param;
do n = n * 10 + (*pp - '0');
while (isdigit(*++pp));
if(*pp && !isargdelim(*pp)) {
error_if_errorlevel_number();
return 0;
}
#else
/* Add this COMMAND bug as someone tries to use:
IF ERRORLEVEL H<upper-case_letter>
-or-
IF ERRORLEVEL x<lower-case_letter>
to match the errorlevel against drive letters.
NOT supported by 4dos or WinNT.
HA --> maps to errorlevel 1
xa --> same
HB & xb --> to 2
a.s.o.
*/
if(!*param) {
error_if_errorlevel();
return 0;
}
pp = param;
do n = n * 10 + (*pp - '0');
while(*++pp && !isargdelim(*pp));
n &= 255;
dprintf( ("IF: checking for ERRORLEVEL >= %u\n", n) );
#endif
if(errorlevel >= n)
x_flag = X_EXEC;
}
/* Check that '==' is present, syntax error if not */
else {
size_t len;
char *r; /* right operand */
pp = skipqword(param, "==");
if(*pp != '=' || pp[1] != '=') {
error_syntax(0);
return 0;
}
*pp = '\0'; /* param[] points to the left operand */
/* skip over the '==' and subsquent spaces and
assign the end of the right operator to pp */
pp = skipqword(r = ltrimcl(pp + 2), 0);
/* now: param := beginning of the left operand
r := beginning of the right operand
pp := end of right operand
*/
rtrimcl(param); /* ensure that spurious whitespaces are ignored */
len = strlen(param);
/* check if strings differ */
if ( ((pp - r) == len) &&
((ignore_case && strnicmp(param, r, len) == 0) ||
(memcmp(param, r, len) == 0)) )
x_flag = X_EXEC;
}
if(x_flag ^ negate) /* perform the command */
if(!*(pp = ltrimcl(pp)))
error_if_command();
else
parsecommandline(pp, FALSE);
return 0;
}
int cmd_set(char *param)
{ char *value;
char *promptBuf = 0, tempcmd[255];
int ret;
optC = promptUser = upCaseValue = optExecute = 0;
if(leadOptions(¶m, opt_set, 0) != E_None)
return 1;
switch(breakVarAssign(ctxtEnvironment, param, &value)) {
case 1: /* no equal sign */
#ifdef FEATURE_CMD_SET_PRINT
if( ( value = getEnv( param ) ) != NULL ) printf( "%s\n", value );
else {
error_env_var_not_found( param );
return( 1 );
}
return( 0 );
#else
error_syntax(0);
return 1;
#endif
case 0: /* displayed */
return 0;
#ifdef DEBUG
case 2: break;
default:
dprintf(("[SET: Invalid response from breakVarAssign()]\n"));
return 1;
#endif
}
if(promptUser) { /* -> Display the value, then read and assign */
assert(value);
fputs(value, stdout);
promptBuf = malloc(promptBuffer);
if(!promptBuf) {
error_out_of_memory();
return E_NoMem;
}
fgets(promptBuf, promptBuffer, stdin);
if(cbreak) {
free(promptBuf);
return E_CBreak;
}
value = strchr(promptBuf, '\0');
while(--value >= promptBuf && (*value == '\n' || *value == '\r'));
value[1] = '\0'; /* strip trailing newlines */
value = promptBuf;
}
if (optExecute) {
char *tempfile = tmpfn();
FILE *fhandle;
if (!tempfile) return (1);
sprintf (tempcmd, "%s>%s", value, tempfile);
parsecommandline (tempcmd, TRUE);
fhandle = fopen (tempfile, "r");
if (!fhandle) {
unlink (tempfile);
free (tempfile);
return (1);
}
fgets (tempcmd, 255, fhandle);
value = strchr(tempcmd, '\n');
if (value) *value = '\0';
value = tempcmd;
fclose (fhandle);
unlink (tempfile);
free (tempfile);
}
/* If the value is just blanks, it means to delete the value;
but otherwise even leading and trailing spaces must be kept */
if(is_empty(value))
value = 0;
if (upCaseValue) StrUpr(value); /* set value as upper case, eg for if testing */
ret = chgEnvCase(optC, param, value);
free(promptBuf);
return ret;
}
/*
* Grab the filename of COMMAND.COM
*
* If warn != 0, warnings can be issued; otherwise this functions
* is silent.
*/
void grabComFilename(int warn, char far *fnam)
{
char *buf;
size_t len;
assert(fnam);
/* Copy the filename into the local heap */
len = _fstrlen(fnam);
if(len >= INT_MAX || len < 1) {
/* no filename specified */
if(warn)
error_syntax(NULL);
return;
}
if((buf = malloc(len + 1)) == NULL) {
if(warn) error_out_of_memory();
return ;
}
_fmemcpy((char far*)buf, fnam, len);
buf[len] = '\0';
if (buf[1] != ':' || buf[2] != '\\')
{ char *p;
/* expand the string for the user */
p = dfnexpand(buf, NULL);
free(buf);
if((buf = p) == NULL) {
if(warn) error_out_of_memory();
return;
}
if(warn)
error_init_fully_qualified(buf);
}
if(dfnstat(buf) & DFN_DIRECTORY) {
/* The user specified a directory, try if we can find the
COMMAND.COM with the standard name in there */
char *p;
if((p = realloc(buf, len + sizeof(COM_NAME) + 1)) == NULL) {
if(warn) error_out_of_memory();
free(buf);
return;
}
buf = p;
strcpy(&buf[len], "\\" COM_NAME);
}
if(!(dfnstat(buf) & DFN_FILE)) {
/* not found */
if(warn) error_open_file(buf);
free(buf);
return;
}
free(ComPath); /* Save the found file */
ComPath = buf;
}
void parser_push(const context_t *ctx, const line_t *line) {
position_t *pos = line->position;
// is the first block already set?
if (p->blk == NULL) {
p->blk = block_init(NULL, pos);
}
statement_t *stmt = new_statement(ctx);
const operation_t *op = NULL;
const char *name = NULL;
label_t *label = NULL;
// allow the tokenizer to fold comma into ",x" etc addressing mode tokens
int allow_index = 0;
// tokenize the line
pstate_t state = P_INIT;
tokenizer_t *tok = tokenizer_init(line->line);
while (tokenizer_next(tok, allow_index)) {
switch(state) {
case P_OP:
if (tok->type == T_TOKEN && tok->vals.op == OP_COLON) {
// accept after label
// continue to next
stmt->type = S_LABEQPC;
statement_push(stmt);
stmt = new_statement(ctx);
state = P_INIT;
break;
}
if (tok->type == T_TOKEN && tok->vals.op == OP_ASSIGN) {
// after label, that's a label value definition
stmt->type = S_LABDEF;
// next define the label from param
state = P_PARAM;
break;
}
// fall-through!
case P_INIT:
switch(tok->type) {
case T_NAME:
name = mem_alloc_strn(tok->line + tok->ptr, tok->len);
op = operation_find(name);
if (op != NULL) {
// check if the operation is compatible with the current CPU
if (0 == (ctx->cpu->isa & op->isa)) {
// TODO: config for either no message or error
warn_operation_not_for_cpu(pos, name, ctx->cpu->name);
op = NULL;
}
}
if (op == NULL) {
// label
// TODO: redefinition?
label = label_init(ctx, name, pos);
if (state == P_OP) {
// we already had a label
stmt->type = S_LABEQPC;
statement_push(stmt);
stmt = new_statement(ctx);
}
stmt->label = label;
// expect operation next (but accept labels too)
state = P_OP;
} else {
// operation
stmt->op = op;
state = P_PARAM;
}
break;
default:
// syntax error
error_syntax(pos);
goto end;
break;
}
break;
case P_PARAM:
// parse parameters
arith_parse(tok, allow_index, &stmt->param);
break;
default:
error_syntax(pos);
goto end;
break;
};
}
statement_push(stmt);
end:
tokenizer_free(tok);
}