Esempio n. 1
0
void test_proc(TokenStream &ts)
{
	using namespace Tokens;
	Token t;
	t = ts.get();
	switch (t.kind)
	{
	case create:
		makeCharacter();
		break;
	default:
		cout << "No command" << endl;
		return;
	}
}
Esempio n. 2
0
std::stack<std::unique_ptr<Token> > exprTree::getStack(TokenStream &ts) {
	std::stack<std::unique_ptr<Token> > reverse;

	while(!ts.empty()) {
		std::unique_ptr<Token> t = ts.get();

		reverse.push(std::move(t));
	}

	
	std::stack<std::unique_ptr<Token> > returnStack;
	while (!reverse.empty()) {
		returnStack.push(std::move(reverse.top()));
		reverse.pop();
	}

	return returnStack;
}
Esempio n. 3
0
std::stack<std::unique_ptr<Token> > exprTree::inToPost(TokenStream &ts) {
	/* This will take your lousy stream of infix tokens and turn it into
	 * a glorious stack of tokens in postfix notation
	 *
	 * It is created in such a way the the begginning of the equation lies at the bottom of the stack
	 * so the stack is reversed at the end */
	std::stack<std::unique_ptr<Token> > postEqn;	// Reverse
	std::stack<std::unique_ptr<Token> > workingStack;

	while (!ts.empty()) {
		std::unique_ptr<Token> t = ts.get();

		if (t->kind == operand) {
			postEqn.push(std::move(t));
		} else if (t->kind == bracket) {
			auto temp = static_cast<Bracket*>(t.release());
			auto b = std::unique_ptr<Bracket>(temp);

			if (b->typ == '(') {
				workingStack.push(std::move(b));
			} else {
				// Closed bracket
				bool matched = false;	// Used for error checking
				while(!workingStack.empty()) {
					if (workingStack.top()->kind == bracket) {
						// It must be open becuse closed don't go on this stack
						workingStack.pop();	// We discard that open bracket
						matched = true;
						break;
					} else { // a little redundant beause if true it returns anyway
						// Add operand to the eqn
						postEqn.push(std::move(workingStack.top()));
						workingStack.pop();
					}
				}

				if (!matched) {
					std::cerr << "Unequal brackets!!" << std::endl;
				}
			}
		} else if (t->kind == oprtor) {
			auto temp = static_cast<Oprtor*>(t.release());
			auto o = std::unique_ptr<Oprtor>(temp);

			while(!workingStack.empty() &&
					workingStack.top()->kind != bracket &&
					(static_cast<Oprtor*>(workingStack.top().get()))->precedence >= o->precedence) {

				postEqn.push(std::move(workingStack.top()));
				workingStack.pop();
			}

			workingStack.push(std::move(o));
		}
	}

	while(!workingStack.empty()) {
		postEqn.push(std::move(workingStack.top()));
		workingStack.pop();
	}

	// This is where it's reversed to we can actually use it
	std::stack<std::unique_ptr<Token> > returnStack;
	while (!postEqn.empty()) {
		returnStack.push(std::move(postEqn.top()));
		postEqn.pop();
	}

	return returnStack;
}