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); }