1519 lines
37 KiB
C
1519 lines
37 KiB
C
/*++
|
|
|
|
Copyright (c) 1988-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
cenv.c
|
|
|
|
Abstract:
|
|
|
|
Environment variable support
|
|
|
|
--*/
|
|
|
|
#include "cmd.h"
|
|
|
|
struct envdata CmdEnv ; // Holds info to manipulate Cmd's environment
|
|
struct envdata * penvOrig; // original environment setup used with eStart
|
|
|
|
extern TCHAR PathStr[], PromptStr[] ;
|
|
extern TCHAR AppendStr[]; /* @@ */
|
|
|
|
extern CHAR InternalError[] ;
|
|
extern TCHAR Fmt16[], Fmt17[], EnvErr[] ;
|
|
extern TCHAR SetArithStr[] ;
|
|
extern TCHAR SetPromptStr[] ;
|
|
extern unsigned flgwd ;
|
|
extern TCHAR CdStr[] ;
|
|
extern TCHAR DatStr[] ;
|
|
extern TCHAR TimStr[] ;
|
|
extern TCHAR ErrStr[] ;
|
|
extern TCHAR CmdExtVerStr[] ;
|
|
|
|
extern unsigned LastRetCode;
|
|
extern BOOL CtrlCSeen;
|
|
extern UINT CurrentCP;
|
|
extern BOOLEAN PromptValid;
|
|
|
|
extern int glBatType; // to distinguish OS/2 vs DOS errorlevel behavior depending on a script file name
|
|
|
|
int SetArithWork(TCHAR *tas);
|
|
|
|
|
|
unsigned
|
|
SetLastRetCodeIfError(
|
|
unsigned RetCode
|
|
)
|
|
{
|
|
if (RetCode != 0) {
|
|
LastRetCode = RetCode;
|
|
}
|
|
|
|
return RetCode;
|
|
}
|
|
|
|
/*** ePath - Begin the execution of a Path Command
|
|
*
|
|
* Purpose:
|
|
* If the command has no argument display the current value of the PATH
|
|
* environment variable. Otherwise, change the value of the Path
|
|
* environment variable to the argument.
|
|
*
|
|
* int ePath(struct cmdnode *n)
|
|
*
|
|
* Args:
|
|
* n - the parse tree node containing the path command
|
|
*
|
|
* Returns:
|
|
* If changing the PATH variable, whatever SetEnvVar() returns.
|
|
* SUCCESS, otherwise.
|
|
*
|
|
*/
|
|
|
|
int ePath(n)
|
|
struct cmdnode *n ;
|
|
{
|
|
if (glBatType != CMD_TYPE) {
|
|
// if set command is executed from .bat file OR entered at command prompt
|
|
return( SetLastRetCodeIfError(PathWork( n, 1 )));
|
|
}
|
|
else {
|
|
return( LastRetCode = PathWork( n, 1 ) );
|
|
}
|
|
|
|
}
|
|
|
|
/*** eAppend - Entry point for Append routine
|
|
*
|
|
* Purpose:
|
|
* to call Append and pass it a pointer to the command line
|
|
* arguments
|
|
*
|
|
* Args:
|
|
* a pointer to the command node structure
|
|
*
|
|
*/
|
|
|
|
int eAppend(n)
|
|
struct cmdnode *n ;
|
|
{
|
|
|
|
if (glBatType != CMD_TYPE) {
|
|
// if set command is executed from .bat file OR entered at command prompt
|
|
return( SetLastRetCodeIfError(PathWork( n, 0 )));
|
|
}
|
|
else {
|
|
return( LastRetCode = PathWork( n, 0 ) );
|
|
}
|
|
|
|
}
|
|
|
|
int PathWork(n, flag)
|
|
struct cmdnode *n ;
|
|
int flag; /* 0 = AppendStr, 1 = PathStr */
|
|
{
|
|
TCHAR *tas ; /* Tokenized argument string */
|
|
TCHAR c ;
|
|
|
|
/* M014 - If the only argument is a single ";", then we have to set
|
|
* a NULL path.
|
|
*/
|
|
if ( n->argptr ) {
|
|
c = *(EatWS(n->argptr, NULL)) ;
|
|
} else {
|
|
c = NULLC;
|
|
}
|
|
|
|
if ((!c || c == NLN) && /* If args are all whitespace */
|
|
mystrchr(n->argptr, TEXT(';'))) {
|
|
|
|
return(SetEnvVar(flag ? PathStr : AppendStr, TEXT(""), &CmdEnv)) ;
|
|
|
|
} else {
|
|
|
|
tas = TokStr(n->argptr, TEXT(";"), TS_WSPACE | TS_NWSPACE) ;
|
|
|
|
if (*tas)
|
|
{
|
|
return(SetEnvVar(flag ? PathStr : AppendStr, tas, &CmdEnv)) ;
|
|
}
|
|
|
|
cmd_printf(Fmt16, flag ? PathStr : AppendStr,
|
|
GetEnvVar(flag ? PathStr : AppendStr), &CmdEnv) ;
|
|
}
|
|
return(SUCCESS) ;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*** ePrompt - begin the execution of the Prompt command
|
|
*
|
|
* Purpose:
|
|
* To modifiy the Prompt environment variable.
|
|
*
|
|
* int ePrompt(struct cmdnode *n)
|
|
*
|
|
* Args:
|
|
* n - the parse tree node containing the prompt command
|
|
*
|
|
* Returns:
|
|
* Whatever SetEnvVar() returns.
|
|
*
|
|
*/
|
|
|
|
int ePrompt(n)
|
|
struct cmdnode *n ;
|
|
{
|
|
if (glBatType != CMD_TYPE) {
|
|
// if set command is executed from .bat file OR entered at command prompt
|
|
return(SetLastRetCodeIfError(SetEnvVar(PromptStr, TokStr(n->argptr, NULL, TS_WSPACE), &CmdEnv))) ;
|
|
}
|
|
else {
|
|
return(LastRetCode = SetEnvVar(PromptStr, TokStr(n->argptr, NULL, TS_WSPACE), &CmdEnv) ) ;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*** eSet - execute a Set command
|
|
*
|
|
* Purpose:
|
|
* To set/modify an environment or to display the current environment
|
|
* contents.
|
|
*
|
|
* int eSet(struct cmdnode *n)
|
|
*
|
|
* Args:
|
|
* n - the parse tree node containing the set command
|
|
*
|
|
* Returns:
|
|
* If setting and the command is syntactically correct, whatever SetEnvVar()
|
|
* returns. Otherwise, FAILURE.
|
|
*
|
|
* If displaying, SUCCESS is always returned.
|
|
*
|
|
*/
|
|
|
|
int eSet(n)
|
|
struct cmdnode *n ;
|
|
{
|
|
if (glBatType != CMD_TYPE) {
|
|
// if set command is executed from .bat file OR entered at command prompt
|
|
return( SetLastRetCodeIfError(SetWork( n )));
|
|
}
|
|
else {
|
|
return( LastRetCode = SetWork( n ) );
|
|
}
|
|
}
|
|
|
|
/*** SetPromptUser - set environment variable to value entered by user.
|
|
*
|
|
* Purpose:
|
|
* Set environment variable to value entered by user.
|
|
*
|
|
* int SetPromptUser(TCHAR *tas)
|
|
*
|
|
* Args:
|
|
* tas - pointer to null terminated string of the form:
|
|
*
|
|
* VARNAME=promptString
|
|
*
|
|
* Returns:
|
|
* If valid expression, return SUCCESS otherwise FAILURE.
|
|
*
|
|
*/
|
|
|
|
int SetPromptUser(TCHAR *tas)
|
|
{
|
|
TCHAR *wptr;
|
|
TCHAR *tptr;
|
|
ULONG dwOutputModeOld;
|
|
ULONG dwOutputModeCur;
|
|
ULONG dwInputModeOld;
|
|
ULONG dwInputModeCur;
|
|
BOOLEAN fOutputModeSet = FALSE;
|
|
BOOLEAN fInputModeSet = FALSE;
|
|
HANDLE hndStdOut = NULL;
|
|
HANDLE hndStdIn = NULL;
|
|
DWORD cch;
|
|
TCHAR szValueBuffer[ 1024 ];
|
|
|
|
//
|
|
// Find first non-blank argument.
|
|
//
|
|
if (tas != NULL)
|
|
while (*tas && *tas <= SPACE)
|
|
tas += 1;
|
|
|
|
|
|
// If no input, declare an error
|
|
//
|
|
if (!tas || !*tas) {
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE) ;
|
|
}
|
|
|
|
//
|
|
// See if first argument is quoted. If so, strip off
|
|
// leading quote, spaces and trailing quote.
|
|
//
|
|
if (*tas == QUOTE) {
|
|
tas += 1;
|
|
while (*tas && *tas <= SPACE)
|
|
tas += 1;
|
|
tptr = _tcsrchr(tas, QUOTE);
|
|
if (tptr)
|
|
*tptr = NULLC;
|
|
}
|
|
|
|
//
|
|
// Find the equal sign in the argument.
|
|
//
|
|
wptr = _tcschr(tas, EQ);
|
|
|
|
//
|
|
// If no equal sign, error.
|
|
//
|
|
if (!wptr) {
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE) ;
|
|
}
|
|
|
|
//
|
|
// Found the equal sign, so left of equal sign is variable name
|
|
// and right of equal sign is prompt string. Dont allow user to set
|
|
// a variable name that begins with an equal sign, since those
|
|
// are reserved for drive current directories.
|
|
//
|
|
*wptr++ = NULLC;
|
|
|
|
//
|
|
// See if second argument is quoted. If so, strip off
|
|
// leading quote, spaces and trailing quote.
|
|
//
|
|
if (*wptr == QUOTE) {
|
|
wptr += 1;
|
|
while (*wptr && *wptr <= SPACE)
|
|
wptr += 1;
|
|
tptr = _tcsrchr(wptr, QUOTE);
|
|
if (tptr)
|
|
*tptr = NULLC;
|
|
}
|
|
|
|
if (*wptr == EQ) {
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE) ;
|
|
}
|
|
|
|
hndStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (GetConsoleMode( hndStdOut, &dwOutputModeOld) ) {
|
|
|
|
// make sure CRLF is processed correctly
|
|
|
|
dwOutputModeCur = dwOutputModeOld | ENABLE_PROCESSED_OUTPUT;
|
|
fOutputModeSet = TRUE;
|
|
SetConsoleMode(hndStdOut,dwOutputModeCur);
|
|
GetLastError();
|
|
}
|
|
|
|
hndStdIn = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (GetConsoleMode( hndStdIn, &dwInputModeOld) ) {
|
|
|
|
// make sure input is processed correctly
|
|
|
|
dwInputModeCur = dwInputModeOld | ENABLE_LINE_INPUT |
|
|
ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT;
|
|
fInputModeSet = TRUE;
|
|
SetConsoleMode(hndStdIn,dwInputModeCur);
|
|
GetLastError();
|
|
}
|
|
|
|
//
|
|
// Loop till the user enters a value for the variable.
|
|
//
|
|
|
|
while (TRUE) {
|
|
PutStdOut(MSG_LITERAL_TEXT, ONEARG, wptr );
|
|
szValueBuffer[0] = NULLC;
|
|
if (ReadBufFromInput( GetStdHandle(STD_INPUT_HANDLE),
|
|
szValueBuffer,
|
|
sizeof(szValueBuffer)/sizeof(TCHAR),
|
|
&cch
|
|
) != 0 &&
|
|
cch != 0
|
|
) {
|
|
//
|
|
// Strip off any trailing CRLF
|
|
//
|
|
while (cch > 0 && szValueBuffer[cch-1] < SPACE)
|
|
cch -= 1;
|
|
|
|
break;
|
|
}
|
|
else {
|
|
cch = 0;
|
|
break;
|
|
}
|
|
|
|
if (!FileIsDevice(STDIN) || !(flgwd & 1))
|
|
cmd_printf(CrLf) ;
|
|
}
|
|
|
|
if (fOutputModeSet) {
|
|
SetConsoleMode( hndStdOut, dwOutputModeOld );
|
|
}
|
|
if (fInputModeSet) {
|
|
SetConsoleMode( hndStdIn, dwInputModeOld );
|
|
}
|
|
|
|
if (cch) {
|
|
szValueBuffer[cch] = NULLC;
|
|
return(SetEnvVar(tas, szValueBuffer, &CmdEnv)) ;
|
|
} else {
|
|
return(FAILURE);
|
|
}
|
|
}
|
|
|
|
|
|
int SetWork(n)
|
|
struct cmdnode *n ;
|
|
{
|
|
TCHAR *tas ; /* Tokenized argument string */
|
|
TCHAR *wptr ; /* Work pointer */
|
|
int i ; /* Work variable */
|
|
|
|
//
|
|
// If extensions are enabled, things are different
|
|
//
|
|
if (fEnableExtensions) {
|
|
tas = n->argptr;
|
|
//
|
|
// Find first non-blank argument.
|
|
//
|
|
if (tas != NULL)
|
|
while (*tas && *tas <= SPACE)
|
|
tas += 1;
|
|
|
|
//
|
|
// No arguments, same as old behavior. Display current
|
|
// set of environment variables.
|
|
//
|
|
if (!tas || !*tas)
|
|
return(DisplayEnv()) ;
|
|
|
|
//
|
|
// See if /A switch given. If so, let arithmetic
|
|
// expression evaluator do the work.
|
|
//
|
|
if (!_tcsnicmp(tas, SetArithStr, 2))
|
|
return SetArithWork(tas+2);
|
|
|
|
//
|
|
// See if /P switch given. If so, prompt user for value
|
|
//
|
|
if (!_tcsnicmp(tas, SetPromptStr, 2))
|
|
return SetPromptUser(tas+2);
|
|
|
|
//
|
|
// See if first argument is quoted. If so, strip off
|
|
// leading quote, spaces and trailing quote.
|
|
//
|
|
if (*tas == QUOTE) {
|
|
tas += 1;
|
|
while (*tas && *tas <= SPACE)
|
|
tas += 1;
|
|
wptr = _tcsrchr(tas, QUOTE);
|
|
if (wptr)
|
|
*wptr = NULLC;
|
|
}
|
|
|
|
//
|
|
// Dont allow user to set a variable name that begins with
|
|
// an equal sign, since those are reserved for drive current
|
|
// directories. This check will also detect missing variable
|
|
// name, e.g.
|
|
//
|
|
// set %LOG%=c:\tmp\log.txt
|
|
//
|
|
// if LOG is not defined is an invalid statement.
|
|
//
|
|
if (*tas == EQ) {
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE) ;
|
|
}
|
|
|
|
//
|
|
// Find the equal sign in the argument.
|
|
//
|
|
wptr = _tcschr(tas, EQ);
|
|
|
|
//
|
|
// If no equal sign, then assume argument is variable name
|
|
// and user wants to see its value. Display it.
|
|
//
|
|
if (!wptr)
|
|
return DisplayEnvVariable(tas);
|
|
|
|
//
|
|
// Found the equal sign, so left of equal sign is variable name
|
|
// and right of equal sign is value.
|
|
//
|
|
*wptr++ = NULLC;
|
|
return(SetEnvVar(tas, wptr, &CmdEnv)) ;
|
|
}
|
|
|
|
tas = TokStr(n->argptr, ONEQSTR, TS_WSPACE|TS_SDTOKENS) ;
|
|
if (!*tas)
|
|
return(DisplayEnv()) ;
|
|
|
|
else {
|
|
for (wptr = tas, i = 0 ; *wptr ; wptr += mystrlen(wptr)+1, i++)
|
|
;
|
|
/* If too many parameters were given, the second parameter */
|
|
/* wasn't an equal sign, or they didn't specify a string */
|
|
/* return an error message. */
|
|
if ( i > 3 || *(wptr = tas+mystrlen(tas)+1) != EQ ||
|
|
!mystrlen(mystrcpy(tas, StripQuotes(tas))) ) {
|
|
/* M013 */ PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE) ;
|
|
|
|
} else {
|
|
return(SetEnvVar(tas, wptr+2, &CmdEnv)) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*** DisplayEnvVariable - display a specific variable from the environment
|
|
*
|
|
* Purpose:
|
|
* To display a specific variable from the current environment.
|
|
*
|
|
* int DisplayEnvVariable( tas )
|
|
*
|
|
* Returns:
|
|
* SUCCESS if all goes well
|
|
* FAILURE if it runs out of memory or cannot lock the env. segment
|
|
*/
|
|
|
|
int DisplayEnvVariable(tas)
|
|
TCHAR *tas;
|
|
{
|
|
TCHAR *envptr ;
|
|
TCHAR *vstr ;
|
|
unsigned size ;
|
|
UINT PrefixLength;
|
|
int rc;
|
|
|
|
//
|
|
// Get environment. If there's none, we're done.
|
|
//
|
|
|
|
envptr = GetEnvironmentStrings();
|
|
if (envptr == (TCHAR *)NULL) {
|
|
fprintf ( stderr, InternalError , "Null environment" ) ;
|
|
return ( FAILURE ) ;
|
|
}
|
|
|
|
//
|
|
// Isolate the prefix to match against.
|
|
//
|
|
|
|
tas = EatWS(tas, NULL);
|
|
if ((vstr = mystrrchr(tas, SPACE)) != NULL) {
|
|
*vstr = NULLC;
|
|
}
|
|
|
|
PrefixLength = mystrlen(tas);
|
|
|
|
//
|
|
// Walk through the environment looking for prefixes that match.
|
|
//
|
|
|
|
rc = FAILURE;
|
|
while ((size = mystrlen(envptr)) > 0) {
|
|
|
|
//
|
|
// Stop soon if we see ^C
|
|
//
|
|
|
|
if (CtrlCSeen) {
|
|
return(FAILURE);
|
|
}
|
|
|
|
//
|
|
// If the prefix is long enough, then terminate the string and
|
|
// look for a prefix match. If we match, restore the string
|
|
// and display it
|
|
//
|
|
|
|
if (size >= PrefixLength) {
|
|
TCHAR SavedChar = envptr[PrefixLength];
|
|
envptr[PrefixLength] = NULLC;
|
|
if (!lstrcmpi( envptr, tas )) {
|
|
envptr[PrefixLength] = SavedChar;
|
|
cmd_printf(Fmt17, envptr );
|
|
rc = SUCCESS;
|
|
} else {
|
|
envptr[PrefixLength] = SavedChar;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Advance to the next string
|
|
//
|
|
|
|
envptr += size+1 ;
|
|
}
|
|
|
|
if (rc != SUCCESS) {
|
|
PutStdErr(MSG_ENV_VAR_NOT_FOUND, ONEARG, tas);
|
|
}
|
|
|
|
return(rc) ;
|
|
}
|
|
|
|
|
|
/*** MyGetEnvVar - get a pointer to the value of an environment variable
|
|
*
|
|
* Purpose:
|
|
* Return a pointer to the value of the specified environment variable.
|
|
*
|
|
* If the variable is not found, return NULL.
|
|
*
|
|
* TCHAR *MyGetEnvVar(TCHAR *varname)
|
|
*
|
|
* Args:
|
|
* varname - the name of the variable to search for
|
|
*
|
|
* Returns:
|
|
* See above.
|
|
*
|
|
* Side Effects:
|
|
* Returned value points to within the environment block itself, so is
|
|
* not valid after a set environment variable operations is perform.
|
|
*/
|
|
|
|
|
|
const TCHAR *
|
|
MyGetEnvVarPtr(TCHAR *varname)
|
|
{
|
|
TCHAR *envptr ; /* Ptr to environment */
|
|
TCHAR *vstr ;
|
|
unsigned size ; /* Length of current env string */
|
|
unsigned n ;
|
|
|
|
if (varname == NULL) {
|
|
return ( NULL ) ;
|
|
}
|
|
|
|
envptr = GetEnvironmentStrings();
|
|
if (envptr == (TCHAR *)NULL) {
|
|
return ( NULL ) ;
|
|
}
|
|
|
|
varname = EatWS(varname, NULL);
|
|
if ((vstr = mystrrchr(varname, SPACE)) != NULL)
|
|
*vstr = NULLC;
|
|
|
|
n = mystrlen(varname);
|
|
while ((size = mystrlen(envptr)) > 0) { /* M015 */
|
|
if (CtrlCSeen) {
|
|
return(NULL);
|
|
}
|
|
if (!_tcsnicmp(varname, envptr, n) && envptr[n] == TEXT( '=' )) {
|
|
return envptr+n+1;
|
|
}
|
|
|
|
envptr += size+1 ;
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
/*** DisplayEnv - display the environment
|
|
*
|
|
* Purpose:
|
|
* To display the current contents of the environment.
|
|
*
|
|
* int DisplayEnv()
|
|
*
|
|
* Returns:
|
|
* SUCCESS if all goes well
|
|
* FAILURE if it runs out of memory or cannot lock the env. segment
|
|
*/
|
|
|
|
int DisplayEnv()
|
|
{
|
|
TCHAR *envptr ; /* Ptr to environment */
|
|
unsigned size ; /* Length of current env string */
|
|
|
|
envptr = GetEnvironmentStrings();
|
|
if (envptr == (TCHAR *)NULL) {
|
|
fprintf ( stderr, InternalError , "Null environment" ) ;
|
|
return( FAILURE ) ;
|
|
}
|
|
|
|
while ((size = mystrlen(envptr)) > 0) { /* M015 */
|
|
if (CtrlCSeen) {
|
|
return(FAILURE);
|
|
}
|
|
#if !DBG
|
|
// Dont show current directory variables in retail product
|
|
if (*envptr != EQ)
|
|
#endif // DBG
|
|
cmd_printf(Fmt17, envptr) ; /* M005 */
|
|
envptr += size+1 ;
|
|
}
|
|
|
|
return(SUCCESS) ;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*** SetEnvVar - controls adding/changing an environment variable
|
|
*
|
|
* Purpose:
|
|
* Add/replace an environment variable. Grow it if necessary.
|
|
*
|
|
* int SetEnvVar(TCHAR *varname, TCHAR *varvalue, struct envdata *env)
|
|
*
|
|
* Args:
|
|
* varname - name of the variable being added/replaced
|
|
* varvalue - value of the variable being added/replaced
|
|
* env - environment info structure being used
|
|
*
|
|
* Returns:
|
|
* SUCCESS if the variable could be added/replaced.
|
|
* FAILURE otherwise.
|
|
*
|
|
*/
|
|
|
|
int SetEnvVar(varname, varvalue, env)
|
|
TCHAR *varname ;
|
|
TCHAR *varvalue ;
|
|
struct envdata *env ;
|
|
{
|
|
int retvalue;
|
|
|
|
PromptValid = FALSE; // Force it to be recalculated
|
|
|
|
DBG_UNREFERENCED_PARAMETER( env );
|
|
if (!_tcslen(varvalue)) {
|
|
varvalue = NULL; // null to remove from env
|
|
}
|
|
retvalue = SetEnvironmentVariable(varname, varvalue);
|
|
if (CmdEnv.handle != GetEnvironmentStrings()) {
|
|
MEMORY_BASIC_INFORMATION MemoryInfo;
|
|
|
|
CmdEnv.handle = GetEnvironmentStrings();
|
|
CmdEnv.cursize = GetEnvCb(CmdEnv.handle);
|
|
if (VirtualQuery( CmdEnv.handle, &MemoryInfo, sizeof( MemoryInfo ) ) == sizeof( MemoryInfo )) {
|
|
CmdEnv.maxsize = (UINT)MemoryInfo.RegionSize;
|
|
}
|
|
else {
|
|
CmdEnv.maxsize = CmdEnv.cursize;
|
|
}
|
|
}
|
|
else {
|
|
CmdEnv.cursize = GetEnvCb(CmdEnv.handle);
|
|
}
|
|
|
|
return !retvalue;
|
|
}
|
|
|
|
/*** GetEnvVar - get the value of an environment variable
|
|
*
|
|
* Purpose:
|
|
* Return a string containing the value of the specified environment
|
|
* variable. The string value has been placed into a static buffer
|
|
* that is valid until the next GetEnvVar call.
|
|
*
|
|
* If the variable is not found, return NULL.
|
|
*
|
|
* TCHAR *GetEnvVar(TCHAR *varname)
|
|
*
|
|
* Args:
|
|
* varname - the name of the variable to search for
|
|
*
|
|
* Returns:
|
|
* See above.
|
|
*
|
|
*/
|
|
|
|
|
|
TCHAR GetEnvVarBuffer[LBUFLEN];
|
|
|
|
PTCHAR GetEnvVar(varname)
|
|
PTCHAR varname ;
|
|
{
|
|
GetEnvVarBuffer[0] = TEXT( '\0' );
|
|
|
|
if (GetEnvironmentVariable(varname, GetEnvVarBuffer, sizeof(GetEnvVarBuffer) / sizeof(TCHAR))) {
|
|
return(GetEnvVarBuffer);
|
|
}
|
|
else
|
|
if (fEnableExtensions) {
|
|
if (!_tcsicmp(varname, CdStr)) {
|
|
GetDir(GetEnvVarBuffer, GD_DEFAULT) ;
|
|
return GetEnvVarBuffer;
|
|
}
|
|
else
|
|
if (!_tcsicmp(varname, ErrStr)) {
|
|
_stprintf( GetEnvVarBuffer, TEXT("%d"), LastRetCode );
|
|
return GetEnvVarBuffer;
|
|
}
|
|
else
|
|
if (!_tcsicmp(varname, CmdExtVerStr)) {
|
|
_stprintf( GetEnvVarBuffer, TEXT("%d"), CMDEXTVERSION );
|
|
return GetEnvVarBuffer;
|
|
}
|
|
else
|
|
if (!_tcsicmp(varname, TEXT("CMDCMDLINE"))) {
|
|
return GetCommandLine();
|
|
}
|
|
else
|
|
if (!_tcsicmp(varname, DatStr)) {
|
|
GetEnvVarBuffer[ PrintDate(NULL, PD_DATE, GetEnvVarBuffer, LBUFLEN) ] = NULLC;
|
|
return GetEnvVarBuffer;
|
|
}
|
|
if( !_tcsicmp(varname, TimStr)) {
|
|
GetEnvVarBuffer[ PrintTime(NULL, PT_TIME, GetEnvVarBuffer, LBUFLEN) ] = NULLC;
|
|
return GetEnvVarBuffer;
|
|
}
|
|
if( !_tcsicmp(varname, TEXT("RANDOM"))) {
|
|
_stprintf( GetEnvVarBuffer, TEXT("%d"), rand() );
|
|
return GetEnvVarBuffer;
|
|
}
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
/*** CopyEnv - make a copy of the current environment
|
|
*
|
|
* Purpose:
|
|
* Make a copy of CmdEnv and put the new handle into the newly
|
|
* created envdata structure. This routine is only called by
|
|
* eSetlocal and init.
|
|
*
|
|
* struct envdata *CopyEnv()
|
|
*
|
|
* Returns:
|
|
* A pointer to the environment information structure.
|
|
* Returns NULL if unable to allocate enough memory
|
|
*
|
|
* Notes:
|
|
* - M001 - This function was disabled, now reenabled.
|
|
* - The current environment is copied as a snapshot of how it looked
|
|
* before SETLOCAL was executed.
|
|
* - M008 - This function's copy code was moved to new function MoveEnv.
|
|
*
|
|
*/
|
|
|
|
struct envdata *CopyEnv()
|
|
{
|
|
struct envdata *cce ; /* New env info structure */
|
|
|
|
cce = (struct envdata *) HeapAlloc( GetProcessHeap( ), HEAP_ZERO_MEMORY, sizeof( *cce ));
|
|
if (cce == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
cce->cursize = CmdEnv.cursize ;
|
|
cce->maxsize = CmdEnv.maxsize ;
|
|
cce->handle = VirtualAlloc( NULL,
|
|
cce->maxsize,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
);
|
|
if (cce->handle == NULL) {
|
|
HeapFree( GetProcessHeap( ), 0, cce );
|
|
PutStdErr( MSG_OUT_OF_ENVIRON_SPACE, NOARGS );
|
|
return NULL;
|
|
}
|
|
|
|
if (!MoveEnv( cce->handle, CmdEnv.handle, GetEnvCb( CmdEnv.handle ))) {
|
|
VirtualFree( cce->handle, 0, MEM_RELEASE );
|
|
HeapFree( GetProcessHeap( ), 0, cce );
|
|
return NULL;
|
|
}
|
|
|
|
return cce;
|
|
}
|
|
|
|
|
|
/*** ResetEnv - restore the environment
|
|
*
|
|
* Purpose:
|
|
* Restore the environment to the way it was before the execution of
|
|
* the SETLOCAL command. This function only called by eEndlocal.
|
|
*
|
|
* ResetEnv(struct envdata *env)
|
|
*
|
|
* Args:
|
|
* env - structure containing handle, size and max dimensions of an
|
|
* environment.
|
|
*
|
|
* Notes:
|
|
* - M001 - This function was disabled, but has been reenabled.
|
|
* - M001 - This function used to test for OLD/NEW style batch files
|
|
* and delete the copy or the original environment as
|
|
* appropriate. It now always deletes the original.
|
|
* - M014 - Note that the modified local environment will never be
|
|
* shrunk, so we can assume it will hold the old one.
|
|
*
|
|
*/
|
|
|
|
void ResetEnv( struct envdata *env)
|
|
{
|
|
ULONG cursize;
|
|
|
|
cursize = GetEnvCb( env->handle );
|
|
if (MoveEnv( CmdEnv.handle, env->handle, cursize )) {
|
|
CmdEnv.cursize = cursize ;
|
|
}
|
|
|
|
VirtualFree( env->handle, 0, MEM_RELEASE );
|
|
HeapFree( GetProcessHeap( ), 0, env );
|
|
}
|
|
|
|
|
|
|
|
|
|
/*** MoveEnv - Move the contents of the environment (M008 - New function)
|
|
*
|
|
* Purpose:
|
|
* Used by CopyEnv, this function moves the existing
|
|
* environment contents to the new location.
|
|
*
|
|
* MoveEnv(unsigned thndl, unsigned shndl, unsigned cnt)
|
|
*
|
|
* Args:
|
|
* thndl - Handle of target environment
|
|
* shndl - Handle of source environment
|
|
* cnt - byte count to move
|
|
*
|
|
* Returns:
|
|
* TRUE if no errors
|
|
* FALSE otherwise
|
|
*
|
|
*/
|
|
|
|
MoveEnv(tenvptr, senvptr, cnt)
|
|
TCHAR *senvptr ; /* Ptr into source env seg */
|
|
TCHAR *tenvptr ; /* Ptr into target env seg */
|
|
ULONG cnt ;
|
|
{
|
|
if ((tenvptr == NULL) ||
|
|
(senvptr == NULL)) {
|
|
fprintf(stderr, InternalError, "Null environment") ;
|
|
return(FALSE) ;
|
|
}
|
|
memcpy(tenvptr, senvptr, cnt) ; /* M015 */
|
|
return(TRUE) ;
|
|
}
|
|
|
|
|
|
ULONG
|
|
GetEnvCb( TCHAR *penv ) {
|
|
|
|
ULONG cb = 0;
|
|
|
|
if (penv == NULL) {
|
|
return (0);
|
|
}
|
|
|
|
while ( (*penv) || (*(penv+1))) {
|
|
cb++;
|
|
penv++;
|
|
}
|
|
return (cb+2) * sizeof(TCHAR);
|
|
|
|
}
|
|
|
|
//
|
|
// expr -> assign [, assign]* ,
|
|
//
|
|
// assign -> orlogexpr |
|
|
// VAR ASSIGNOP assign <op>=
|
|
//
|
|
// orlogexpr -> xorlogexpr [| xorlogexpr]* |
|
|
//
|
|
// xorlogexpr -> andlogexpr [^ andlogexpr]* ^
|
|
//
|
|
// andlogexpr -> shiftexpr [& shiftexpr]* &
|
|
//
|
|
// shiftexpr -> addexpr [SHIFTOP addexpr]* <<, >>
|
|
//
|
|
// addexpr -> multexpr [ADDOP multexpr]* +, -
|
|
//
|
|
// multexpr -> unaryexpr [MULOP unaryexpr]* *, /, %
|
|
//
|
|
// unaryexpr -> ( expr ) | ()
|
|
// UNARYOP unaryexpr +, -, !, ~
|
|
//
|
|
|
|
TCHAR szOps[] = TEXT("<>+-*/%()|^&=,");
|
|
TCHAR szUnaryOps[] = TEXT("+-~!");
|
|
|
|
typedef struct {
|
|
PTCHAR Token;
|
|
LONG Value;
|
|
DWORD Error;
|
|
} PARSESTATE, *PPARSESTATE;
|
|
|
|
VOID
|
|
APerformUnaryOperation( PPARSESTATE State, TCHAR Op, LONG Value )
|
|
{
|
|
switch (Op) {
|
|
case TEXT( '+' ):
|
|
State->Value = Value;
|
|
break;
|
|
case TEXT( '-' ):
|
|
State->Value = -Value;
|
|
break;
|
|
case TEXT( '~' ):
|
|
State->Value = ~Value;
|
|
break;
|
|
case TEXT( '!' ):
|
|
State->Value = !Value;
|
|
break;
|
|
default:
|
|
printf( "APerformUnaryOperation: '%c'\n", Op);
|
|
break;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
APerformArithmeticOperation( PPARSESTATE State, TCHAR Op, LONG Left, LONG Right )
|
|
{
|
|
switch (Op) {
|
|
case TEXT( '<' ):
|
|
State->Value = (Right >= 8 * sizeof( Left << Right))
|
|
? 0
|
|
: (Left << Right);
|
|
break;
|
|
case TEXT( '>' ):
|
|
State->Value = (Right >= 8 * sizeof( Left >> Right ))
|
|
? (Left < 0 ? -1 : 0)
|
|
: (Left >> Right);
|
|
break;
|
|
case TEXT( '+' ):
|
|
State->Value = Left + Right;
|
|
break;
|
|
case TEXT( '-' ):
|
|
State->Value = Left - Right;
|
|
break;
|
|
case TEXT( '*' ):
|
|
State->Value = Left * Right;
|
|
break;
|
|
case TEXT( '/' ):
|
|
if (Right == 0) {
|
|
State->Error = MSG_SET_A_DIVIDE_BY_ZERO;
|
|
} else {
|
|
State->Value = Left / Right;
|
|
}
|
|
break;
|
|
case TEXT( '%' ):
|
|
if (Right == 0) {
|
|
State->Error = MSG_SET_A_DIVIDE_BY_ZERO;
|
|
} else {
|
|
State->Value = Left % Right;
|
|
}
|
|
break;
|
|
case TEXT( '|' ):
|
|
State->Value = Left | Right;
|
|
break;
|
|
case TEXT( '^' ):
|
|
State->Value = Left ^ Right;
|
|
break;
|
|
case TEXT( '&' ):
|
|
State->Value = Left & Right;
|
|
break;
|
|
case TEXT( '=' ):
|
|
State->Value = Right;
|
|
break;
|
|
default:
|
|
printf( "APerformArithmeticOperation: '%c'\n", Op);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Return the numeric value of an environment variable (or 0)
|
|
//
|
|
|
|
LONG
|
|
AGetValue( PTCHAR Start, PTCHAR End )
|
|
{
|
|
TCHAR c = *End;
|
|
const TCHAR *Value;
|
|
PTCHAR Dummy;
|
|
|
|
*End = NULLC;
|
|
|
|
Value = MyGetEnvVarPtr( Start );
|
|
*End = c;
|
|
|
|
if (Value == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
return _tcstol( Value, &Dummy, 0);
|
|
}
|
|
|
|
DWORD
|
|
ASetValue( PTCHAR Start, PTCHAR End, LONG Value )
|
|
{
|
|
TCHAR Result[32];
|
|
TCHAR c = *End;
|
|
DWORD Return = SUCCESS;
|
|
|
|
*End = NULLC;
|
|
|
|
_sntprintf( Result, 32, TEXT("%d"), Value ) ;
|
|
|
|
if (SetEnvVar( Start, Result, &CmdEnv ) != SUCCESS) {
|
|
Return = GetLastError();
|
|
}
|
|
|
|
*End = c;
|
|
return Return;
|
|
}
|
|
|
|
|
|
//
|
|
// Forward decls
|
|
//
|
|
PARSESTATE AParseAddExpr( PARSESTATE State );
|
|
PARSESTATE AParseAndLogExpr( PARSESTATE State );
|
|
PARSESTATE AParseAssign( PARSESTATE State );
|
|
PARSESTATE AParseExpr( PARSESTATE State );
|
|
PARSESTATE AParseMultExpr( PARSESTATE State );
|
|
PARSESTATE AParseOrLogExpr( PARSESTATE State );
|
|
PARSESTATE AParseShiftExpr( PARSESTATE State );
|
|
PARSESTATE AParseUnaryExpr( PARSESTATE State );
|
|
PARSESTATE AParseXorLogExpr( PARSESTATE State );
|
|
|
|
//
|
|
// Skip whitespace and return next character
|
|
//
|
|
|
|
BOOL ASkipWhiteSpace( PPARSESTATE State )
|
|
{
|
|
while (*State->Token != NULLC && *State->Token <= SPACE) {
|
|
State->Token++;
|
|
}
|
|
|
|
return *State->Token != NULLC;
|
|
}
|
|
|
|
TCHAR ANextChar( PPARSESTATE State )
|
|
{
|
|
ASkipWhiteSpace( State );
|
|
return *State->Token;
|
|
}
|
|
|
|
BOOL AParseVariable( PPARSESTATE State, PTCHAR *FirstChar, PTCHAR *EndOfName )
|
|
{
|
|
TCHAR c = ANextChar( State );
|
|
|
|
//
|
|
// Next char is a digit or operator, can't be a variable
|
|
//
|
|
|
|
if (c == NULLC
|
|
|| _istdigit( c )
|
|
|| _tcschr( szOps, c ) != NULL
|
|
|| _tcschr( szUnaryOps, c ) != NULL) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
*FirstChar = State->Token;
|
|
|
|
//
|
|
// find end of variable
|
|
//
|
|
|
|
while (*State->Token &&
|
|
*State->Token > SPACE &&
|
|
!_tcschr( szUnaryOps, *State->Token ) &&
|
|
!_tcschr( szOps, *State->Token ) ) {
|
|
State->Token += 1;
|
|
}
|
|
|
|
*EndOfName = State->Token;
|
|
return TRUE;
|
|
}
|
|
|
|
// expr -> assign [, assign]*
|
|
PARSESTATE AParseExpr( PARSESTATE State )
|
|
{
|
|
State = AParseAssign( State );
|
|
|
|
while (State.Error == SUCCESS) {
|
|
|
|
if (ANextChar( &State ) != TEXT( ',' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseAssign( State );
|
|
|
|
}
|
|
|
|
return State;
|
|
}
|
|
|
|
// assign -> VAR ASSIGNOP assign |
|
|
// orlogexpr
|
|
PARSESTATE AParseAssign( PARSESTATE State )
|
|
{
|
|
TCHAR c = ANextChar( &State );
|
|
PARSESTATE SavedState;
|
|
|
|
SavedState = State;
|
|
|
|
if (c == NULLC) {
|
|
State.Error = MSG_SET_A_MISSING_OPERAND;
|
|
return State;
|
|
}
|
|
|
|
//
|
|
// See if we have VAR ASSIGNOP
|
|
//
|
|
|
|
do {
|
|
PTCHAR FirstChar;
|
|
PTCHAR EndOfName;
|
|
TCHAR OpChar;
|
|
LONG OldValue;
|
|
|
|
//
|
|
// Parse off variable
|
|
//
|
|
|
|
if (!AParseVariable( &State, &FirstChar, &EndOfName )) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Look for <op>=
|
|
//
|
|
|
|
OpChar = ANextChar( &State );
|
|
|
|
if (OpChar == NULLC) {
|
|
break;
|
|
}
|
|
|
|
if (OpChar != TEXT( '=' )) {
|
|
if (_tcschr( szOps, OpChar ) == NULL) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
if (OpChar == TEXT( '<' ) || OpChar == TEXT( '>')) {
|
|
if (ANextChar( &State ) != OpChar) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
}
|
|
|
|
}
|
|
|
|
if (ANextChar( &State ) != TEXT( '=' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
//
|
|
// OpChar is the sort of operation to apply before assignment
|
|
// State has been advance to, hopefully, another assign. Parse it
|
|
// and see where we get
|
|
//
|
|
|
|
State = AParseAssign( State );
|
|
if (State.Error != SUCCESS) {
|
|
return State;
|
|
}
|
|
|
|
OldValue = AGetValue( FirstChar, EndOfName );
|
|
|
|
//
|
|
// Perform the operation and the assignment
|
|
//
|
|
|
|
APerformArithmeticOperation( &State, OpChar, OldValue, State.Value );
|
|
if (State.Error != SUCCESS) {
|
|
return State;
|
|
}
|
|
|
|
State.Error = ASetValue( FirstChar, EndOfName, State.Value );
|
|
|
|
return State;
|
|
} while ( FALSE );
|
|
|
|
//
|
|
// Must be orlogexpr. Go back and parse over
|
|
//
|
|
|
|
return AParseOrLogExpr( SavedState );
|
|
}
|
|
|
|
// orlogexpr -> xorlogexpr [| xorlogexpr]* |
|
|
PARSESTATE
|
|
AParseOrLogExpr( PARSESTATE State )
|
|
{
|
|
State = AParseXorLogExpr( State );
|
|
while (State.Error == SUCCESS) {
|
|
TCHAR Op = ANextChar( &State );
|
|
LONG Value = State.Value;
|
|
|
|
if (Op != TEXT( '|' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseXorLogExpr( State );
|
|
APerformArithmeticOperation( &State, Op, Value, State.Value );
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// xorlogexpr -> andlogexpr [^ andlogexpr]* ^
|
|
PARSESTATE
|
|
AParseXorLogExpr( PARSESTATE State )
|
|
{
|
|
State = AParseAndLogExpr( State );
|
|
while (State.Error == SUCCESS) {
|
|
TCHAR Op = ANextChar( &State );
|
|
LONG Value = State.Value;
|
|
|
|
if (Op != TEXT( '^' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseAndLogExpr( State );
|
|
APerformArithmeticOperation( &State, Op, Value, State.Value );
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// andlogexpr -> shiftexpr [& shiftexpr]* &
|
|
PARSESTATE
|
|
AParseAndLogExpr( PARSESTATE State )
|
|
{
|
|
State = AParseShiftExpr( State );
|
|
while (State.Error == SUCCESS) {
|
|
TCHAR Op = ANextChar( &State );
|
|
LONG Value = State.Value;
|
|
|
|
if (Op != TEXT( '&' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseShiftExpr( State );
|
|
APerformArithmeticOperation( &State, Op, Value, State.Value );
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// shiftexpr -> addexpr [SHIFTOP addexpr]* <<, >>
|
|
PARSESTATE
|
|
AParseShiftExpr( PARSESTATE State )
|
|
{
|
|
State = AParseAddExpr( State );
|
|
while (State.Error == SUCCESS) {
|
|
TCHAR Op = ANextChar( &State );
|
|
LONG Value = State.Value;
|
|
|
|
if (Op != TEXT( '<' ) && Op != TEXT( '>' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
if (Op != ANextChar( &State )) {
|
|
State.Error = MSG_SET_A_MISSING_OPERATOR;
|
|
return State;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseAddExpr( State );
|
|
APerformArithmeticOperation( &State, Op, Value, State.Value );
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// addexpr -> multexpr [ADDOP multexpr]* +, -
|
|
PARSESTATE
|
|
AParseAddExpr( PARSESTATE State )
|
|
{
|
|
State = AParseMultExpr( State );
|
|
while (State.Error == SUCCESS) {
|
|
TCHAR Op = ANextChar( &State );
|
|
LONG Value = State.Value;
|
|
|
|
if (Op != TEXT( '+' ) && Op != TEXT( '-' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseMultExpr( State );
|
|
APerformArithmeticOperation( &State, Op, Value, State.Value );
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// multexpr -> unaryexpr [MULOP unaryexpr]* *, /, %
|
|
PARSESTATE
|
|
AParseMultExpr( PARSESTATE State )
|
|
{
|
|
State = AParseUnaryExpr( State );
|
|
while (State.Error == SUCCESS) {
|
|
TCHAR Op = ANextChar( &State );
|
|
LONG Value = State.Value;
|
|
|
|
if (Op != TEXT( '*' ) && Op != TEXT( '/' ) && Op != TEXT( '%' )) {
|
|
break;
|
|
}
|
|
State.Token++;
|
|
|
|
State = AParseUnaryExpr( State );
|
|
APerformArithmeticOperation( &State, Op, Value, State.Value );
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// unaryexpr -> UNARYOP unaryexpr +, -, !, ~
|
|
// ( expr ) | ()
|
|
// NUMBER
|
|
// LITERAL
|
|
PARSESTATE
|
|
AParseUnaryExpr( PARSESTATE State )
|
|
{
|
|
TCHAR c = ANextChar( &State );
|
|
PTCHAR FirstChar;
|
|
PTCHAR EndOfName;
|
|
|
|
if (c == NULLC) {
|
|
State.Error = MSG_SET_A_MISSING_OPERAND;
|
|
return State;
|
|
}
|
|
|
|
// ( expr )
|
|
if (c == TEXT( '(' )) {
|
|
State.Token++;
|
|
State = AParseExpr( State );
|
|
if (State.Error != SUCCESS) {
|
|
return State;
|
|
}
|
|
c = ANextChar( &State );
|
|
if (c != TEXT( ')' )) {
|
|
State.Error = MSG_SET_A_MISMATCHED_PARENS;
|
|
} else {
|
|
State.Token++;
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// UNARYOP unaryexpr
|
|
if (_tcschr( szUnaryOps, c ) != NULL) {
|
|
State.Token++;
|
|
State = AParseUnaryExpr( State );
|
|
if (State.Error != SUCCESS) {
|
|
return State;
|
|
}
|
|
APerformUnaryOperation( &State, c, State.Value );
|
|
return State;
|
|
}
|
|
|
|
// NUMBER
|
|
if (_istdigit(c)) {
|
|
State.Value = _tcstoul( State.Token, &State.Token, 0 );
|
|
if (State.Value == ULONG_MAX && errno == ERANGE) {
|
|
State.Error = MSG_SET_NUMBER_TOO_LARGE;
|
|
} else if (_istdigit( *State.Token ) || _istalpha( *State.Token )) {
|
|
State.Error = MSG_SET_A_INVALID_NUMBER;
|
|
}
|
|
return State;
|
|
}
|
|
|
|
// Must be literal
|
|
|
|
if (!AParseVariable( &State, &FirstChar, &EndOfName )) {
|
|
State.Error = MSG_SET_A_MISSING_OPERAND;
|
|
return State;
|
|
}
|
|
|
|
State.Value = AGetValue( FirstChar, EndOfName );
|
|
return State;
|
|
}
|
|
|
|
/*** SetArithWork - set environment variable to value of arithmetic expression
|
|
*
|
|
* Purpose:
|
|
* Set environment variable to value of arithmetic expression
|
|
*
|
|
* int SetArithWork(TCHAR *tas)
|
|
*
|
|
* Args:
|
|
* tas - pointer to null terminated string of the form:
|
|
*
|
|
* VARNAME=expression
|
|
*
|
|
* Returns:
|
|
* If valid expression, return SUCCESS otherwise FAILURE.
|
|
*
|
|
*/
|
|
|
|
int SetArithWork(TCHAR *tas)
|
|
{
|
|
PARSESTATE State;
|
|
|
|
//
|
|
// If no input, declare an error
|
|
//
|
|
if (!tas || !*tas) {
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE) ;
|
|
}
|
|
|
|
//
|
|
// Set up for parsing
|
|
//
|
|
|
|
State.Token = StripQuotes( tas );
|
|
State.Value = 0;
|
|
State.Error = SUCCESS;
|
|
|
|
State = AParseExpr( State );
|
|
if (State.Error == SUCCESS && ANextChar( &State ) != NULLC) {
|
|
State.Error = MSG_SET_A_MISSING_OPERATOR;
|
|
}
|
|
|
|
if (State.Error != SUCCESS) {
|
|
PutStdErr( State.Error, NOARGS );
|
|
//printf( "%ws\n", tas );
|
|
//printf( "%*s\n", State.Token - tas + 1, "^" );
|
|
|
|
} else if (!CurrentBatchFile) {
|
|
cmd_printf( TEXT("%d"), State.Value ) ;
|
|
}
|
|
|
|
return State.Error;
|
|
}
|