void InfixToPostfix::convert()
{
char Y[50],val;
int l=strlen(X),len=0,pr,pr1;
push('(');
X[l]=')';
for(int i=0;i<=l;i++)
{
if(isalnum(X[i]))
{
Y[len]=X[i];
len++;
}
else if(X[i]=='(')
push(X[i]);
else if(X[i]=='^'||X[i]=='/'||X[i]=='*'||X[i]=='+'||X[i]=='-')
{
pr=checkPrecedence(X[i]);
pr1=checkPrecedence(stack[top]);
while(pr1>pr||pr1==pr)
{
val=pop();
Y[len]=val;
len++;
pr1=checkPrecedence(stack[top]);
}
push(X[i]);
}
else if(X[i]==')')
{
while(stack[top]!='(')
{
val=pop();
Y[len]=val;
len++;
}
pop();
}
}
Y[len]='\0';
cout<<Y;
}
int compareTwoOper(char n)
{
if(checkPrecedence(n) == checkPrecedence(stack[top]) || checkPrecedence(n) < checkPrecedence(stack[top]))
return 0;
if(checkPrecedence(n) > checkPrecedence(stack[top]))
return 1;
}
int main(int argc, char** argv){
/*main expression is one string of all args put together*/
char* mainExpression = getExpressionFromArgs(argc, argv);
/*list of tokens*/
tokenNode *mainList = malloc(sizeof(tokenNode));
/*not useful yet
*TODO: Something with variables*/
int totalVariables = 0;
/*keep iterating i until it reaches a ; in main expression*/
for(int i = 0; mainExpression[i] != ';'; i++){
/*get necesarry tokens from expression*/
if(isalpha(mainExpression[i])){
addTokenToList(mainList, getVariableLexeme(mainExpression, &i));
}
if(isdigit(mainExpression[i] )){
addTokenToList(mainList, getNumericLexeme(mainExpression, &i));
}
if(isOperator(mainExpression[i])){
addTokenToList(mainList, getOperatorLexeme(mainExpression, &i));
}
if(mainExpression[i] == '$'){
addTokenToList(mainList, getSpecialLexeme(mainExpression, &i));
}
}
/*conductor is the iterator to move across the list*/
tokenNode *conductor;
/*tempNode is used for freeing memory*/
tokenNode *tempNode;
/*used to determine if there are anymore
*RELEVANT operators to compute with */
_Bool noMoreOperators = false;
/*check if we have one number left over*/
while(mainList->size > 1){
/*i represents the current order of precedence to be checked,
*in EMDAS order*/
for(int i = 0; i < 3; i++){
/*set/reset conductor back to start of list*/
conductor = mainList;
/*set/reset noMoreOperators so that next loop can continue*/
noMoreOperators = false;
while(!noMoreOperators){
/*default; if the list is traversed and there are no more operators, loop will end
*this was inspired by traditional bubble sort*/
noMoreOperators = true;
/*while not at end of list*/
while(conductor->next != NULL){
/*check if the next token is an operator*/
if(conductor->next->value.type == operator){
/*check if the operator token is the same precedence as the operator we are looking for*/
if(checkPrecedence(conductor->next->value) == i){
/*if so, we have found a RELEVANT operator and noMoreOperators is false*/
noMoreOperators = false;
/*perform necesarry calculation depending on current precedence (i)*/
switch(getOperatorID(conductor->next->value)){
case 0:
/*set conductor value to conductor^conductor->next->next*/
conductor->value = tokenExponentation(conductor->value, conductor->next->next->value);
/*set tempNode to the 3 items down the list (next number)*/
tempNode = conductor->next->next->next;
/*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/
free(conductor->next);
free(conductor->next->next);
/*link conductor with tempNode*/
conductor->next = tempNode;
/*subtract two tokens from mainList*/
mainList->size -= 2;
break;
case 1:
/*set conductor value to conductor*conductor->next->next*/
conductor->value = tokenMultiplication(conductor->value, conductor->next->next->value);
/*set tempNode to the 3 items down the list (next number)*/
tempNode = conductor->next->next->next;
/*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/
free(conductor->next);
free(conductor->next->next);
/*link conductor with tempNode*/
conductor->next = tempNode;
/*subtract two tokens from mainList*/
mainList->size -= 2;
break;
case 2:
/*set conductor value to conductor/conductor->next->next*/
conductor->value = tokenDivision(conductor->value, conductor->next->next->value);
/*set tempNode to the 3 items down the list (next number)*/
tempNode = conductor->next->next->next;
/*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/
free(conductor->next);
free(conductor->next->next);
/*link conductor with tempNode*/
conductor->next = tempNode;
/*subtract two tokens from mainList*/
mainList->size -= 2;
break;
case 3:
/*set conductor value to conductor+conductor->next->next*/
conductor->value = tokenAddition(conductor->value, conductor->next->next->value);
/*set tempNode to the 3 items down the list (next number)*/
tempNode = conductor->next->next->next;
/*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/
free(conductor->next);
free(conductor->next->next);
/*link conductor with tempNode*/
conductor->next = tempNode;
/*subtract two tokens from mainList*/
mainList->size -= 2;
break;
case 4:
/*set conductor value to conductor-conductor->next->next*/
conductor->value = tokenSubtraction(conductor->value, conductor->next->next->value);
/*set tempNode to the 3 items down the list (next number)*/
tempNode = conductor->next->next->next;
/*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/
free(conductor->next);
free(conductor->next->next);
/*link conductor with tempNode*/
conductor->next = tempNode;
/*subtract two tokens from mainList*/
mainList->size -= 2;
break;
default:
/*if current token is not really a token*/
printf(ANSI_COLOR_MAGENTA"Error: Erroneous token: %s\n"ANSI_COLOR_RESET, conductor->next->value.lexeme);
exit(1);
}
/*show your work!*/
for(int j = 0; j < mainList->size; j++){
printf("%s", getTokenFromList(mainList, j).lexeme);
}
printf("\n");
}
}
/*iterate down the list unless at end of list,
unless the current operator is of the desired precedence
this is to avoid skipping operators on accident*/
if(conductor->next != NULL && checkPrecedence(conductor->next->value) != i){
conductor = conductor->next;
}
}
}
}
}
/*print list*/
printf("Answer: %s\n",getTokenFromList(mainList, 0).lexeme);
}
/*
* Prototype: int parseExpression(const std::string&)
* What: This method converts the expression (entered in postfix notation) to prefix notation, Reverse Polish Notation (RPN).
* How to Call: This method is called in the main function in the test file.
ex: Calculator myCalc; std::string myExpression; myCalc.parseExpression(myExpression);
* Pre-Conditions:
- A Calculator object must have been built.
- User must pass in an expression.
* Post-Conditions:
- Expression will be parsed into RPN and stored in the member container: Queue<std::string> output
- Will call the function evaluateExpression() and return an int to either signify a successful calculation, or and error (e.g., division by zero, mismatched parentheses, etc.).
*/
int Calculator::parseExpression(std::string& expression)
{
expression = checkForUnaryMinus(expression);
for (size_t i = 0; i < expression.length(); i++)
{
const std::string token = expression.substr(i, 1);
if (token == " ") // If space, skip iteration and throw it out.
continue;
else if (token == "u")
{
std::string newToken = "-";
i++; // Skip over the u
while (i < expression.length() && !isOperator(expression.substr(i, 1)) && !isParenthesis(expression.substr(i, 1)))
newToken.append(expression.substr(i++, 1));
i--; // For loop will increment i, causing it to skip over operators and such, so decrement i here
output.enqueue(newToken);
}
else if (isOperator(token))
{
if (!operators.empty())
{
std::string op2 = operators.top();
while (isOperator(op2) && ((isLeftAssoc(token) && checkPrecedence(token, op2) == 1) || (checkPrecedence(token, op2) == 0)))
{
output.enqueue(op2);
operators.pop();
if (!operators.empty())
op2 = operators.top();
else
break;
}
}
operators.push(token);
}
else if (isParenthesis(token))
{
if (token == "(")
operators.push(token);
else
{
if (!operators.empty())
{
std::string top = operators.top();
while (top != "(")
{
output.enqueue(top);
operators.pop();
if (operators.empty())
break; // Mismatched Parentheses
top = operators.top();
}
if (!operators.empty()) // You've found the left parenthesis!
operators.pop();
if (top != "(")
return 1; // Mismatched Parentheses
}
}
}
else if (isNumber(token))
{
std::string newToken;
while (i < expression.length() && !isOperator(expression.substr(i, 1)) && !isParenthesis(expression.substr(i, 1)))
newToken.append(expression.substr(i++, 1));
i--; // For loop will increment i, causing it to skip over operators and such, so decrement i here
output.enqueue(newToken);
}
else
return 5; // Invalid character
}
while (!operators.empty())
{
std::string top = operators.top();
if (isParenthesis(top))
return 1; // Mismatched Parentheses
output.enqueue(top);
operators.pop();
}
return (evaluateExpression());
}
int buildTree(command_t commList, int i, int rootListIndex, int* rootList)
{
int maxOperandSize = 100;
int maxOperatorSize = 100;
int operandIndex = 0; // first empty index in operand stack
int operatorIndex = 0; // first empty index in operator stack
//printf("rootListIndex: %d\n", rootListIndex);
int* operatorList = malloc(sizeof(int)*maxOperatorSize);
int* operandList = malloc(sizeof(int)*maxOperandSize);
int returnIndex = -1;
//int i;
//printf("# of commands: %d\n", g_commandListLength);
for(; i < g_commandListLength; i++)
{
// printf("ii: %d\n", i);
//printf("p..operatorIndex: %d\n", operatorIndex);
//printf("p..operandIndex: %d\n", operandIndex);
if(operandIndex == maxOperandSize)
{
maxOperandSize *= 2;
operandList = realloc(operandList, sizeof(int)*maxOperandSize);
}
else if(operatorIndex == maxOperatorSize)
{
maxOperatorSize *= 2;
operatorList = realloc(operatorList, sizeof(int)*maxOperatorSize);
}
else if(commList[i].type == SIMPLE_COMMAND)
{
//printf("simple command\n");
//printf("operandIndex: %d\n", operandIndex);
operandList[operandIndex] = i;
operandIndex++;
// printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
continue;
}
else if(commList[i].type == OPEN_PAREN)
{
// push onto operator stack
operatorList[operatorIndex] = i;
operatorIndex++;
continue;
}
else if(commList[i].type == CLOSED_PAREN)
{
// pop off until reach open paren
int topIndex = operatorList[operatorIndex-1];
enum command_type top = commList[topIndex].type-1;
while(top != OPEN_PAREN)
{
//printf("pop til open paren \n");
popOperator(operatorIndex-1, operandIndex-1, operatorList, operandList, commList);
operandIndex--;
operatorIndex--;
//printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
// print stack for debugging
//printf("topIndex: %d\n", topIndex);
topIndex = operatorList[operatorIndex-1];
top = commList[topIndex].type;
}
//end loop: top = OPEN_PAREN
//printf("end paren popping\n");
int subShellIndex = operatorList[operatorIndex-1];
setSubShell(subShellIndex, operandIndex-1, operandList, commList);
operatorIndex--;
//printCommandList(commList, g_commandListLength);
//printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
continue;
}
else if(commList[i].type == NEW_LINE)
{
returnIndex = i;
if(i+1 == g_commandListLength)
{
// printf("return\n");
returnIndex = -1;
}
break;
}
else if(commList[i].type == IGNORE_COMMAND)
{
continue;
}
/*else if(commList[i].type == SEQUENCE_COMMAND)
{
//printf("i: %d\n", i);
returnIndex = i;
if(i == g_commandListLength-2 && commList[i+1].type == NEW_LINE)
{
returnIndex = -1;
}
break;
}*/
else
{
enum command_type input = commList[i].type;
if(operatorIndex == 0)
{
operatorList[0] = i;
operatorIndex++;
//printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
continue;
}
int topIndex = operatorIndex-1;
enum command_type top = commList[operatorList[topIndex]].type;
/* printf("topIndex: %d\n", topIndex);
printf("top: ");
printCommandType(top);
printf("input: ");
printCommandType(input);*/
while(checkPrecedence(input, top) && operatorIndex > 0)
{
// printf("PRECEDENCE\n");
// printf("stack1:\n");
//printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
popOperator(operatorIndex-1, operandIndex-1, operatorList, operandList, commList);
operandIndex--;
operatorIndex--;
// printf("stack2:\n");
//printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
//printf("op index: %d\n", operatorIndex);
// print stack for debugging
topIndex = operatorList[operatorIndex-1];
top = commList[topIndex].type;
/* printf("in loop topIndex: %d\n", topIndex);
printf("in loop top: ");
printCommandType(top);
printf("in loop input: ");
printCommandType(input);*/
}
operatorList[operatorIndex] = i;
operatorIndex++;
}
}
while(operatorIndex > 0)
{
popOperator(operatorIndex-1, operandIndex-1, operatorList, operandList, commList);
operandIndex--;
operatorIndex--;
// printf("stack3:\n");
// printStack(operatorIndex-1, operandIndex-1, operatorList, operandList);
}
free(operatorList);
free(operandList);
rootList[rootListIndex] = operandList[0];
return returnIndex;
}