Пример #1
0
    void ExprParser::close()
    {
        while (getOperator()!='(')
            pop();

        popOperator();
    }
Пример #2
0
ParseStatus Parser::popDelimiter(TokenValue t) {
  // Apply all pending operators until we hit the matching paren.
  while (op_stack.back() != t) {
    popOperator();
  }

  // Remove the matching paren from the operator stack.
  op_stack.pop();
  return PARSE_OK;
}
Пример #3
0
    void ExprParser::pop()
    {
        char op = getOperator();

        switch (op)
        {
            case 'm':

                Generator::negate (mCode, getOperandType());
                popOperator();
                break;

            case '+':

                Generator::add (mCode, getOperandType (1), getOperandType());
                popOperator();
                replaceBinaryOperands();
                break;

            case '-':

                Generator::sub (mCode, getOperandType (1), getOperandType());
                popOperator();
                replaceBinaryOperands();
                break;

            case '*':

                Generator::mul (mCode, getOperandType (1), getOperandType());
                popOperator();
                replaceBinaryOperands();
                break;

            case '/':

                Generator::div (mCode, getOperandType (1), getOperandType());
                popOperator();
                replaceBinaryOperands();
                break;

            case 'e':
            case 'n':
            case 'l':
            case 'L':
            case 'g':
            case 'G':

                Generator::compare (mCode, op, getOperandType (1), getOperandType());
                popOperator();
                popOperand();
                popOperand();
                mOperands.push_back ('l');
                break;

            default:

                throw std::logic_error ("unknown operator");
        }
    }
Пример #4
0
ParseStatus Parser::pushOperator(Token& t) {
  assert(t.isOperator());

  // check priority
  while(!op_stack.empty() &&
        (getPriority(op_stack.back()) >= getPriority(t))) {
    popOperator();
  }

  op_stack.push(t);

  return PARSE_OK;
}
Пример #5
0
void ExprEvaluator::E() {
  P();

  tokenizer.nextToken();

  while(tokenizer.isBinary()) {
    pushOperator(binary(tokenizer.nextToken()));
    tokenizer.consumeToken();

    P();
    tokenizer.nextToken();
  }
  while(operators.back() != oper::SANTINEL)
    popOperator();  
}
Пример #6
0
void convertToPostfix(char *str){
	/* o1: Holds the precedence of the new operator
	 * o2: Holds the precendence of the topmost operator on the stack
	 * ptoken: The pointer to the start of each string delimited by commas
	 * stringToAdd:  Houses a single character so strcat() can add singular characters
	 * aCopy: A copy of the given string used to read from as we are modifying the original string
	 */
	int o1, o2;
	char *ptoken, stringToAdd[] = "0", aCopy[100];

	/* Copy the given string to a second string to be read from */
	strcpy(aCopy, str);

	/* Set the first element of the given string to NULL, effectively erasing the string from the point of view of strcat() */
	*str = '\0';

	/* Cycle through each group of characters delimited by a whitespace */
	for(ptoken = strtok(aCopy," "); ptoken != NULL; ptoken = strtok(NULL, " ")){



		/* If the character is a bracket or operator, then run this code */
		if(isOperator(*ptoken) && strlen(ptoken) == 1){

			/* Code to figure out precedences of operators */
			if(*ptoken == '*' || *ptoken == '/') o1 = 3;
			else if(*ptoken == '^') o1 = 4;
			else if(*ptoken == '+' || *ptoken == '-' ) o1 = 2;

			if(seeOperator() == '*' || seeOperator() == '/') o2 = 3;
			else if(seeOperator() == '^') o2 = 4;
			else if(seeOperator() == '+' || seeOperator() == '-' ) o2 = 2;
			else o2 = 0;

			/* If the operator stack isn't empty, and the precedence of the new operator is less than or equal to the top operator
			 * in the stack, then pop the top operator in to the post-fix string, and push the new operator in to the stack.
			 */
			if(emptyOperator() != 1 && o1 <= o2){
				*stringToAdd = popOperator();
				strcat(str," ");
				strcat(str,stringToAdd);
				pushOperator(*ptoken);
			}
			/* Otherwise, if it's empty or the new operator has greater precedence, push to the operator stack */
			else{
				pushOperator(*ptoken);
			}
		}



		/* If the character is a left bracket, push it into the operator stack */
		else if(*ptoken == '('){
			pushOperator(*ptoken);
		}

		/* If the character is a right bracket, pop operators off until you reach a left bracket, then pop off the left bracket without
		 * adding it to the string
		 */
		else if(*ptoken == ')'){
			while(seeOperator() != '('){
				*stringToAdd = popOperator();
				strcat(str," ");
				strcat(str, stringToAdd);
			}
			popOperator();
		}

		/* Otherwise(i.e. the string is a operand), just catenate the operand to the end of the string */
		else{
			strcat(str, " ");
			strcat(str, ptoken);
		}
	}



	/* Check if the operator stack is empty, if it isn't, add the top most operator to the end of the string, repeat until
	 * stack is empty.
	 * If the character is a bracket, then just pop it and don't add to the string.
	 */
	while(emptyOperator() == FALSE){
		if(seeOperator() == '(' || seeOperator() == ')') popOperator();
		else{
			*stringToAdd = popOperator();
			strcat(str," ");
			strcat(str, stringToAdd);
		}

	}

}
Пример #7
0
void ExprEvaluator::pushOperator(oper o) {
  while(isHigherPriority(operators.back(), o))
    popOperator();
  operators.push_back(o);
}
Пример #8
0
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;
}
Пример #9
0
ParseStatus Parser::emitEval() {
  while(op_stack.size()) {
    popOperator();
  }
  return PARSE_OK;
}