/**
* @param expression: A string array
* @return: The root of expression tree
*/
ExpressionTreeNode* build(vector<string> &expression) {
if (expression.empty()) {
return 0;
}
vector<string> prefix;
infixToPrefix(expression, prefix);
int start = 0;
return buildExpressionTree(prefix, start);
}
/*
* Take a command string and break it up into an argc, argv list while
* handling quoting and wildcards. The returned argument list and
* strings are in static memory, and so are overwritten on each call.
* The argument list is ended with a NULL pointer for convenience.
* Returns TRUE if successful, or FALSE on an error with a message
* already output.
*/
BOOL
makeArgs(const char * cmd, int * retArgc, const char *** retArgv)
{
const char * argument;
char * cp;
char * cpOut;
char * newStrings;
const char ** fileTable;
const char ** newArgTable;
int newArgTableSize;
int fileCount;
int len;
int ch;
int quote;
BOOL quotedWildCards;
BOOL unquotedWildCards;
BOOL dollarMode;
static int stringsLength;
static char * strings;
static int argCount;
static int argTableSize;
static const char ** argTable;
/*
* Clear the returned values until we know them.
*/
argCount = 0;
*retArgc = 0;
*retArgv = NULL;
/*
* Copy the command string into a buffer that we can modify,
* reallocating it if necessary.
*/
len = strlen(cmd) + 1;
if (len > stringsLength)
{
newStrings = realloc(strings, len);
if (newStrings == NULL)
{
fprintf(stderr, "Cannot allocate string\n");
return FALSE;
}
strings = newStrings;
stringsLength = len;
}
memcpy(strings, cmd, len);
cp = strings;
/*
* Keep parsing the command string as long as there are any
* arguments left.
*/
while (*cp)
{
/*
* Save the beginning of this argument.
*/
argument = cp;
cpOut = cp;
/*
* Reset quoting and wildcarding for this argument.
*/
quote = '\0';
quotedWildCards = FALSE;
unquotedWildCards = FALSE;
dollarMode = FALSE;
/*
* Loop over the string collecting the next argument while
* looking for quoted strings or quoted characters, and
* remembering whether there are any wildcard characters
* in the argument.
*/
while (*cp)
{
ch = *cp++;
/*
* If we are not in a quote and we see a blank then
* this argument is done.
*/
if (isBlank(ch) && (quote == '\0'))
break;
/*
* If we see a backslash then accept the next
* character no matter what it is.
*/
if (ch == '\\')
{
ch = *cp++;
/*
* Make sure there is a next character.
*/
if (ch == '\0')
{
fprintf(stderr,
"Bad quoted character\n");
return FALSE;
}
/*
* Remember whether the quoted character
* is a wildcard.
*/
if (isWildCard(ch))
quotedWildCards = TRUE;
*cpOut++ = ch;
continue;
}
/*
* If we see one of the wildcard characters then
* remember whether it was seen inside or outside
* of quotes.
*/
if (isWildCard(ch) && !dollarMode)
{
if (quote)
quotedWildCards = TRUE;
else
unquotedWildCards = TRUE;
}
/*
* If we were in a quote and we saw the same quote
* character again then the quote is done.
*/
if (ch == quote)
{
quote = '\0';
continue;
}
/*
* If we weren't in a quote and we see either type
* of quote character, then remember that we are
* now inside of a quote.
*/
if ((quote == '\0') && ((ch == '\'') || (ch == '"')))
{
quote = ch;
continue;
}
/*
* TP1
* If we see a $
*/
if(ch == '$' && !quote)
{
dollarMode = TRUE;
}
/*
* Store the character.
*/
*cpOut++ = ch;
}
/*
* Make sure that quoting is terminated properly.
*/
if (quote)
{
fprintf(stderr, "Unmatched quote character\n");
return FALSE;
}
/*
* Null terminate the argument if it had shrunk, and then
* skip over all blanks to the next argument, nulling them
* out too.
*/
if (cp != cpOut)
*cpOut = '\0';
while (isBlank(*cp))
*cp++ = '\0';
if(dollarMode)
{
if(*(argument+1)=='$'){
char* buff = (char*)malloc(5*sizeof(char));
sprintf(buff,"%d",getpid());
argument=buff;
}else if(*(argument+1)=='['){
char* buff = (char*)malloc((strlen(argument)-3)*sizeof(char));
strncpy(buff,argument+2,strlen(argument)-3);
printf("test %s\n",infixToPrefix(buff));
}else{
argument=getenv(argument+1);
}
}
/*
* If both quoted and unquoted wildcards were used then
* complain since we don't handle them properly.
*/
if (quotedWildCards && unquotedWildCards)
{
fprintf(stderr,
"Cannot use quoted and unquoted wildcards\n");
return FALSE;
}
/*
* Expand the argument into the matching filenames or accept
* it as is depending on whether there were any unquoted
* wildcard characters in it.
*/
if (unquotedWildCards)
{
/*
* Expand the argument into the matching filenames.
*/
fileCount = expandWildCards(argument, &fileTable);
/*
* Return an error if the wildcards failed to match.
*/
if (fileCount < 0)
return FALSE;
if (fileCount == 0)
{
fprintf(stderr, "Wildcard expansion error\n");
return FALSE;
}
}
else
{
/*
* Set up to only store the argument itself.
*/
fileTable = &argument;
fileCount = 1;
}
/*
* Now reallocate the argument table to hold the file name.
*/
if (argCount + fileCount >= argTableSize)
{
newArgTableSize = argCount + fileCount + 1;
newArgTable = (const char **) realloc(argTable,
(sizeof(const char *) * newArgTableSize));
if (newArgTable == NULL)
{
fprintf(stderr, "No memory for arg list\n");
return FALSE;
}
argTable = newArgTable;
argTableSize = newArgTableSize;
}
/*
* Copy the new arguments to the end of the old ones.
*/
memcpy((void *) &argTable[argCount], (const void *) fileTable,
(sizeof(const char **) * fileCount));
/*
* Add to the argument count.
*/
argCount += fileCount;
}
/*
* Null terminate the argument list and return it.
*/
argTable[argCount] = NULL;
*retArgc = argCount;
*retArgv = argTable;
return TRUE;
}
