C++ RefAST类代码示例

void BinaryCompArithOpAST::renameAttrRef(const SchemaMapString* schemaMap) {
	RefAST childAST = getFirstChild();
	assert (childAST);
	(RefBasicAST(childAST))->renameAttrRef(schemaMap);

	if (childAST->getNextSibling()) {
		(RefBasicAST(childAST->getNextSibling()))->renameAttrRef(schemaMap);
	}
}

int main(int argc, char *argv[])
{
    if (argc < 1)
        return 0;

    ANTLR_USING_NAMESPACE(std);
    ANTLR_USING_NAMESPACE(antlr);
    ANTLR_USING_NAMESPACE(Asm);

    char *filename = argv[1];

    if (!filename)
        exit(1);

    try {
        ifstream input(filename);
        AsmLexer lexer(input);
        TokenBuffer buffer(lexer);
        AsmParser parser(buffer);

        ASTFactory ast_factory;
        parser.initializeASTFactory(ast_factory);
        parser.setASTFactory(&ast_factory);

        parser.asmFile();
        RefAST a = parser.getAST();

        AsmTreeParser tree_parser;
        tree_parser.init(false, false, false);
        tree_parser.initializeASTFactory(ast_factory);
        tree_parser.setASTFactory(&ast_factory);

        tree_parser.asmFile(a);
#if 0
        cout << "List:" << endl;
        cout << a->toStringList() << endl;
        cout << "Tree:" << endl;
        cout << a->toStringTree() << endl;
#endif
    } catch (ANTLRException& e) {
        cerr << "exception: " << e.getMessage() << endl;
        return 2;
    } catch (exception& e) {
        cerr << "exception: " << e.what() << endl;
        return 3;
    }
    return 0;
}

void TreeParser::matchNot(RefAST t, int ttype)
{
	//ANTLR_USE_NAMESPACE(std)cout << "match(" << ttype << "); cursor is " << t.toString() << ANTLR_USE_NAMESPACE(std)endl;
	if ( !t || t==ASTNULL || t->getType()==ttype ) {
		throw MismatchedTokenException();
	}
}

// Expected BitSet / not BitSet
MismatchedTokenException::MismatchedTokenException(
	const char* const* tokenNames_,
	const int numTokens_,
	RefAST node_,
	BitSet set_,
	bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
  , token(0)
  , node(node_)
  , tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
  , mismatchType(matchNot ? NOT_SET : SET)
  , set(set_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

/** Create a new empty AST node; if the user did not specify
 *  an AST node type, then create a default one: CommonAST.
 */
RefAST ASTFactory::create()
{
	RefAST node = nodeFactories[0]->second();
	node->setType(Token::INVALID_TYPE);
	return node;
}

/**Make sure current lookahead symbol matches the given set
 * Throw an exception upon mismatch, which is caught by either the
 * error handler or by the syntactic predicate.
 */
void TreeParser::match(RefAST t, const BitSet& b)
{
	if ( !t || t==ASTNULL || !b.member(t->getType()) ) {
		throw MismatchedTokenException();
	}
}

RefAST ASTFactory::create(int type)
{
    RefAST t = create();
    t->initialize(type,"");
    return t;
}

/** Create a new empty AST node; if the user did not specify
 *  an AST node type, then create a default one: CommonAST.
 */
RefAST ASTFactory::create()
{
    RefAST node = nodeFactory(); //new CommonASTNode();
    node->setType(Token::INVALID_TYPE);
    return node;
}

void TreeParser::matchNot(RefAST t, int ttype)
{
	if ( !t || t == ASTNULL || t->getType() == ttype )
		throw MismatchedTokenException( getTokenNames(), getNumTokens(),
												  t, ttype, true );
}

/** Make sure current lookahead symbol matches the given set
 * Throw an exception upon mismatch, which is caught by either the
 * error handler or by the syntactic predicate.
 */
void TreeParser::match(RefAST t, const BitSet& b)
{
	if ( !t || t==ASTNULL || !b.member(t->getType()) )
		throw MismatchedTokenException( getTokenNames(), getNumTokens(),
												  t, b, false );
}

	virtual void match(RefAST t, int ttype)
	{
		if (!t || t == ASTNULL || t->getType() != ttype )
			throw MismatchedTokenException( getTokenNames(), getNumTokens(),
													  t, ttype, false );
	}

		while( t->right )
		{
			t = t->right;
			n++;
		}
		return n;
	}
	return n;
}

void BaseAST::doWorkForFindAll(
		ANTLR_USE_NAMESPACE(std)vector<RefAST>& v,
		RefAST target,bool partialMatch)
{
	// Start walking sibling lists, looking for matches.
	for (RefAST sibling=this;
			sibling;
			sibling=sibling->getNextSibling())
	{
		if ( (partialMatch && sibling->equalsTreePartial(target)) ||
				(!partialMatch && sibling->equalsTree(target)) ) {
			v.push_back(sibling);
		}
		// regardless of match or not, check any children for matches
		if ( sibling->getFirstChild() ) {
			RefBaseAST(sibling->getFirstChild())->doWorkForFindAll(v, target, partialMatch);
		}
	}
}

/** Is t an exact structural and equals() match of this tree.  The

void CommonAST::initialize(RefAST t)
{
    setType(t->getType());
    setText(t->getText());
}