C++ ASTNode::joinChild方法代码示例

ASTNode* TestASTMatcher::buildSubTree()
{
	ASTNode* plusNode = new ASTNode("", PLUS, 0);
	ASTNode* minusNode = new ASTNode("", MINUS, 0);
	ASTNode* varNodeB = new ASTNode("b", VARIABLE, 0);
	ASTNode* varNodeC = new ASTNode("c", VARIABLE, 0);
	ASTNode* constantNode = new ASTNode("1", CONSTANT, 0);

	minusNode->joinChild(plusNode);
	plusNode->joinChild(varNodeB);
	varNodeB->joinNext(varNodeC);
	plusNode->joinNext(constantNode);

	return minusNode;
}

ASTNode* TestASTMatcher::buildSubTreeWithDiffValue()
{
	ASTNode* timesNode = new ASTNode("", TIMES, 0);
	ASTNode* divideNode = new ASTNode("", DIVIDE, 0);
	ASTNode* varNodeB = new ASTNode("b", VARIABLE, 0);
	ASTNode* varNodeC = new ASTNode("c", VARIABLE, 0);
	ASTNode* constantNode = new ASTNode("1", CONSTANT, 0);

	divideNode->joinChild(timesNode);
	timesNode->joinChild(varNodeB);
	varNodeB->joinNext(varNodeC);
	timesNode->joinNext(constantNode);

	return timesNode;
}

ASTNode* Parser::ifStmt()
{
	matchKeyword("if");
	ASTNode* ifNode = new ASTNode("", IF, _stmtNum);

	_varTable->addVariable(_token);
	ASTNode* varNode = new ASTNode(_token, VARIABLE, 0);
	matchName();

	matchKeyword("then");
	matchKeyword("{");

	ASTNode* ifStmtListNode = statementList();

	matchKeyword("}");
	matchKeyword("else");
	matchKeyword("{");
	
	ASTNode* elseStmtListNode = statementList();

	matchKeyword("}");

	ifNode->joinChild(varNode);
	varNode->joinNext(ifStmtListNode);
	ifStmtListNode->joinNext(elseStmtListNode);

	return ifNode;
}

ASTNode* Parser::procedure()
{
	matchKeyword("procedure");

	if (_procTable->getIndex(_token) > -1) {
		throw ParseException(_stmtNum, _token, "Duplicate procedure names");
	}

	std::string procedure = _token;

	ASTNode* procNode = new ASTNode(procedure, PROCEDURE, 0);
	matchName();

	matchKeyword("{");
	int fromStmtNum = _stmtNum + 1;

	ASTNode* stmtListNode = statementList();
	
	matchKeyword("}");
	int toStmtNum = _stmtNum;

	_procTable->addProcedure(procedure, fromStmtNum, toStmtNum);

	procNode->joinChild(stmtListNode);

	return procNode;
}

ASTNode* TestASTMatcher::buildTree()
{
	ASTNode* assignNode = new ASTNode("", ASSIGN, 1);
	ASTNode* plusNode = new ASTNode("", PLUS, 0);
	ASTNode* minusNode = new ASTNode("", MINUS, 0);
	ASTNode* varNodeA = new ASTNode("a", VARIABLE, 0);
	ASTNode* varNodeB = new ASTNode("b", VARIABLE, 0);
	ASTNode* varNodeC = new ASTNode("c", VARIABLE, 0);
	ASTNode* constantNode = new ASTNode("1", CONSTANT, 0);

	assignNode->joinChild(varNodeA);
	varNodeA->joinNext(minusNode);
	minusNode->joinChild(plusNode);
	plusNode->joinChild(varNodeB);
	varNodeB->joinNext(varNodeC);
	plusNode->joinNext(constantNode);

	return assignNode;
}

ASTNode* Parser::assignStmt()
{
	_varTable->addVariable(_token);
	ASTNode* varNode = new ASTNode(_token, VARIABLE, 0);
	matchName();

	matchKeyword("=");
	ASTNode* assignNode = new ASTNode("", ASSIGN, _stmtNum);

	ASTNode* expNode = expression();

	matchKeyword(";");

	assignNode->joinChild(varNode);
	varNode->joinNext(expNode);

	return assignNode;
}

ASTNode* Parser::program()
{
	ASTNode* progNode = new ASTNode("Simple", PROGRAM, 0);

	ASTNode* procNode = procedure();

	progNode->joinChild(procNode);

	ASTNode* prevProcNode;

	while (isKeyword("procedure")) {
		prevProcNode = procNode;
		procNode = procedure();

		prevProcNode->joinNext(procNode);
	}

	return progNode;
}

ASTNode* Parser::statementList()
{
	ASTNode* stmtListNode = new ASTNode("", STATEMENT_LIST, 0);

	ASTNode* stmtNode = statement();

	stmtListNode->joinChild(stmtNode);

	ASTNode* prevStmtNode;

	while (!isKeyword("}")) {
		prevStmtNode = stmtNode;
		stmtNode = statement();

		prevStmtNode->joinNext(stmtNode);
	}

	return stmtListNode;
}

ASTNode* Parser::whileStmt()
{
	matchKeyword("while");
	ASTNode* whileNode = new ASTNode("", WHILE, _stmtNum);

	_varTable->addVariable(_token);
	ASTNode* varNode = new ASTNode(_token, VARIABLE, 0);
	matchName();

	matchKeyword("{");

	ASTNode* stmtListNode = statementList();
	
	matchKeyword("}");

	whileNode->joinChild(varNode);
	varNode->joinNext(stmtListNode);

	return whileNode;
}

void ASTExpressionBuilder::buildOperators()
{
	ASTNode* operatorNode;
	ASTNode* leftNode;
	ASTNode* rightNode;

	ASTType type;

	if (_operators.back() == "+") {
		type = PLUS;
	} else if (_operators.back() == "-") {
		type = MINUS;
	} else if (_operators.back() == "*") {
		type = TIMES;
	}else if (_operators.back() == "/") {
		type = DIVIDE;
	}

	operatorNode = new ASTNode("", type, 0);

	if (!_results.empty()) {
		rightNode = _results.back();
		_results.pop_back();
	} else {
		throw ParseException(_token, "Unable to parse expression");
	}

	if (!_results.empty()) {
		leftNode = _results.back();
		_results.pop_back();
	} else {
		throw ParseException(_token, "Unable to parse expression");
	}

	operatorNode->joinChild(leftNode);
	leftNode->joinNext(rightNode);

	_results.push_back(operatorNode);

	_operators.pop_back();
}