自学教程：C++ AST类代码示例

bool QueryEvaluator::evaluatePTClause(TNode * PT_node, 										vector<int> row, 										vector<vector<int>> * new_rows, 										ResultTable * temp_result) {	TNode * stmt_node = PT_node->getChildAtIndex(0);	string stmt_name = stmt_node->getValue();	Symbol stmt_type = SyntaxHelper::getSymbolType(table.getType(stmt_name));	int stmt_index=row[0]; // get stmt_index from row	if (stmt_index==-1) {		// retrieve a list of values of stmt_type from PKB		vector<int> stmt_indexes = getAllPKBValues(stmt_name);		for (size_t i=0; i<stmt_indexes.size(); i++) {			//save back stmt_indexes[i] to row			row[0] = stmt_indexes[i];			//recursive call to update new_rows			vector<vector<int>> rows;			bool isSatisfied = evaluatePTClause(PT_node, row, &rows, temp_result);			if (isSatisfied) {				for (size_t j=0; j<rows.size(); j++) {					new_rows->push_back(rows[j]);				}			}		}	} else {		// from here is hell of logic		// get ASTNode of this Stmt		TNode * root = PKB::getASTRoot();		AST tree; tree.setRoot(root);		TNode * ast_node = tree.findNodeOfStmt(stmt_index);			// handle first argument node		TNode * arg1_node = stmt_node->getChildAtIndex(0);		if (!evaluatePTArgNode(arg1_node, ast_node, ARG1, row, new_rows)) 			return false; 		switch(stmt_type) {		case Assign:			{				TNode * expr_node = stmt_node->getChildAtIndex(1);				if (!evaluateExprNode(expr_node, ast_node)) return false;				return true;			}		case While:			{				break;			}		case If:			{				break;			}		default:			break;		}	}	if (!new_rows->empty()) return true;	return false;}

/// Read-Eval-Print-Loopstatic void repl(CEnv& cenv, ExecutionEngine* engine){	while (1) {		std::cout << "> ";		std::cout.flush();		SExp exp = readExpression(std::cin);		try {			AST* ast = parseExpression(exp);			if (ast->evaluatable()) {				ASTPrototype* proto = new ASTPrototype(false, "", vector<string>());				ASTFunction*  func  = new ASTFunction(proto, ast);				Function*     code  = func->Funcgen(cenv);				void*         fp    = engine->getPointerToFunction(code);				double (*f)() = (double (*)())fp;				std::cout << f() << endl;			} else {				Value* code = ast->Codegen(cenv); 				std::cout << "Generated code:" << endl;				code->dump();			}		} catch (SyntaxError e) {			std::cerr << "Syntax error: " << e.what() << endl;		}	}}

int __etest(const char *program){	FILE *f = fopen("/tmp/tmp", "w");	if (f == NULL) {		//fprintf(stderr, "open fail %s (%s)/n", strerror(errno), argv[1]);		exit(-1);	}	fwrite(program, 1, strlen(program), f);	fclose(f);	SCParser parser;	AST *ast = parser.parse("/tmp/tmp");	assert(ast);	DBG("%s", ast->toString().c_str());	DBG("/n");	DBG("%s", ast->toSource().c_str());	TypeCheck typeCheck;	ast->accept(&typeCheck);	DBG("%s/n", SymbolTable.toString().c_str());	int err = typeCheck.getLastError();	return err;}

void DepGenerator::analyse(const AST& ast) {    const string& modName = ast.getModuleName();    const string& fileName = ast.getFileName();    ModInfo* info = getInfo(modName);    info->addFile(fileName, ast);}

int main() {		AST *ast = new ASTree();	ast->ShowTree();	//ast.GetCurrentElement()}

AST*ASTHelper::retrieveMethodAST( IPosition<SourceToken>& p ){	AST* ast = this->ast.copySubtree( p );	ast->storeIndent();		return ast;}

void testFile(const char *file){	SCParser parser;	AST *ast = parser.parse(file);	if (ast) {		DBG("%s", ast->toString().c_str());		DBG("/n");		DBG("%s", ast->toSource().c_str());	}}

int main (){  AST* id = new ID_NODE("may_var");  AST* val = new VAL_NODE(5.5);  AST* opr = new OPR_NODE('+', id, val);  opr->process();  return 0;}

	void MittenSource::onNode(AST &a, ASTBuilder &b, ErrorHandler &e, StructureParser &p)	{		MittenErrorHandler &meh = dynamic_cast<MittenErrorHandler &>(e);		if (a.isBranch() && a.name().compare("line") == 0)		{			cout << "LINE: " << a.display() << "/n";			if (a.size() == 2)			{				if (a[0].isLeaf() && a[0].leaf().value().compare("include") == 0)				{					if (a[1].isBranch())					{						if (a[1].size() == 1)						{							if (a[1][0].size() == 1)							{								if (a[1][0][0].isLeaf())								{									Token inc = a[1][0][0].leaf();									if (inc.tag() == SymbolTag)										cout << "INCLUDE MODULE '" << inc.value() << "'/n";									else if (inc.tag() == StringLiteralTag)										cout << "INCLUDE FILE '" << inc.value() << "'/n";									else										meh.includeRequiresModuleOrFileName(a[0].leaf());								}								else								{									meh.includeRequiresModuleOrFileName(a[0].leaf());								}							}							else							{								meh.includeRequiresOneArgument(a[0].leaf());							}						}						else						{							meh.includeRequiresOneArgument(a[0].leaf());						}					}					else					{						meh.includeRequiresArgumentList(a[0].leaf());					}				}			}		}	}

int Calculator::eval(string expr, bool flag) {  Parser* parser = new Parser(new istringstream(expr), flag);      AST* tree = parser->parse();      int result = tree->evaluate();      delete tree;      delete parser;      return result;}

void testFile(const char *file){	SCParser parser;	AST *ast = parser.parse(file);	if (ast) {		DBG("%s", ast->toString().c_str());		DBG("/n");		DBG("%s", ast->toSource().c_str());	}	TypeCheck typeCheck;	ast->accept(&typeCheck);	//int err = typeCheck.getLastError();}

size_t CFG::_varcnt_(void) {	size_t cnt = 0;	for (ssize_t i = 0; i < this->length(); ++i) {		AST *child = (AST *)this->child(i);		switch(child->type()) {			case AST_ASSIGN:				if (0 != child->length() && 0 == child->child(0)->length()) {					cnt ++;				}				break;			case AST_FUNC:				if (0 != child->length() && 0 != child->child(0)->length()) {					cnt += child->child(0)->child(0)->length();				}				break;			default:				_D(LOG_DEBUG, "Need NOT count on %s", child->data().c_str());				break;		}	}	cnt += (NULL == this->nextCFG(true)  ? 0 : this->nextCFG(true)->_varcnt_());	cnt += (NULL == this->nextCFG(false) ? 0 : this->nextCFG(false)->_varcnt_());	return cnt;}

void scopeOfNode( AST* ast, QStringList& scope ){    if( !ast )        return;    if( ast->parent() )        scopeOfNode( ast->parent(), scope );    QString s;    switch( ast->nodeType() )    {    case NodeType_ClassSpecifier:        if( ((ClassSpecifierAST*)ast)->name() ){            s = ((ClassSpecifierAST*)ast)->name()->text();            s = s.isEmpty() ? QString::fromLatin1("<unnamed>") : s;            scope.push_back( s );        }        break;    case NodeType_Namespace:    {        AST* namespaceName = ((NamespaceAST*)ast)->namespaceName();        s = namespaceName ? namespaceName->text() : QString::fromLatin1("<unnamed>");        scope.push_back( s );    }    break;    case NodeType_FunctionDefinition:    {        FunctionDefinitionAST* funDef = static_cast<FunctionDefinitionAST*>( ast );        DeclaratorAST* d = funDef->initDeclarator()->declarator();        // hotfix for bug #68726        if ( !d->declaratorId() )            break;        QList<ClassOrNamespaceNameAST*> l = d->declaratorId()->classOrNamespaceNameList();        for( int i = 0; i < l.size(); ++i ) {            AST* name = l.at(i)->name();            scope.push_back( name->text() );        }    }    break;    default:        break;    }}

int main(){    Parser parser;    parser.parse();    AST ast = parser.ast();    if (ast.printErrors(std::cerr))        return -1;    int code = SymbolResolver::resolve(ast, std::cerr);    if (code)        return code;    PrintVisitor::print(std::cerr, ast);    PrintCode::print(std::cout, ast, true);}

C2Sema::C2Sema(SourceManager& sm_, DiagnosticsEngine& Diags_, AST& ast_, clang::Preprocessor& PP_)    : SourceMgr(sm_)    , Diags(Diags_)    , typeContext(ast_.getTypeContext())    , ast(ast_)    , PP(PP_){}

bool C2Builder::checkModuleImports(ParseHelper& helper, Component* component, Module* module, ImportsQueue& queue, const LibInfo* lib) {    if (!module->isLoaded()) {        assert(lib);        if (options.verbose) log(COL_VERBOSE, "parsing (%s) %s", component->getName().c_str(), lib->c2file.c_str());        if (!helper.parse(*component, module, lib->c2file, (options.printAST0 && options.printASTLib))) {            return false;        }    }    if (options.verbose) log(COL_VERBOSE, "checking imports for module (%s) %s", component->getName().c_str(), module->getName().c_str());    bool ok = true;    const AstList& files = module->getFiles();    for (unsigned a=0; a<files.size(); a++) {        AST* ast = files[a];        for (unsigned u=1; u<ast->numImports(); u++) {  // NOTE: first import is module decl            ImportDecl* D = ast->getImport(u);            const std::string& targetModuleName = D->getModuleName();            // handle c2 pseudo-module            if (targetModuleName == "c2") {                createC2Module();                D->setModule(c2Mod);                continue;            }            const LibInfo* target = libLoader.findModuleLib(targetModuleName);            if (!target) {                helper.Diags.Report(D->getLocation(), clang::diag::err_unknown_module) << targetModuleName;                ok = false;                continue;            }            D->setModule(target->module);            if (target->component != component) {                // check that imports are in directly dependent component (no indirect component)                if (!component->hasDep(target->component)) {                    helper.Diags.Report(D->getLocation(), clang::diag::err_indirect_component)                            << component->getName() << target->component->getName() << targetModuleName;                    ok = false;                    continue;                }            }            if (target->module->isLoaded()) continue;            queue.push_back(targetModuleName);        }    }    return ok;}

QList<CppQuickFixOperation::Ptr> CompleteSwitchCaseStatement::match(    const QSharedPointer<const CppEditor::Internal::CppQuickFixAssistInterface> &interface){    const QList<AST *> &path = interface->path();    if (path.isEmpty())        return noResult(); // nothing to do    // look for switch statement    for (int depth = path.size() - 1; depth >= 0; --depth) {        AST *ast = path.at(depth);        SwitchStatementAST *switchStatement = ast->asSwitchStatement();        if (switchStatement) {            if (!interface->isCursorOn(switchStatement->switch_token) || !switchStatement->statement)                return noResult();            CompoundStatementAST *compoundStatement = switchStatement->statement->asCompoundStatement();            if (!compoundStatement) // we ignore pathologic case "switch (t) case A: ;"                return noResult();            // look if the condition's type is an enum            if (Enum *e = conditionEnum(interface, switchStatement)) {                // check the possible enum values                QStringList values;                Overview prettyPrint;                for (unsigned i = 0; i < e->memberCount(); ++i) {                    if (Declaration *decl = e->memberAt(i)->asDeclaration()) {                        values << prettyPrint(LookupContext::fullyQualifiedName(decl));                    }                }                // Get the used values                Block *block = switchStatement->symbol;                CaseStatementCollector caseValues(interface->semanticInfo().doc, interface->snapshot(),                                                  interface->semanticInfo().doc->scopeAt(block->line(), block->column()));                QStringList usedValues = caseValues(switchStatement);                // save the values that would be added                foreach (const QString &usedValue, usedValues)                    values.removeAll(usedValue);                if (values.isEmpty())                    return noResult();                else                    return singleResult(new Operation(interface, depth, compoundStatement, values));            }            return noResult();        }    }

PKB Parser::parseSource( string source ) {		trim(source);	addNewLineString(source);		list<std::pair<int, string>> sourceCodeList;	buildSourceCodeList(source, sourceCodeList);		processSourceCodeList(sourceCodeList);	cout << "end of everything before ast." << endl;	AST ast = AST();	ast.acceptStatements(sourceCodeList);	pkb.setAST(ast);	return pkb;}

Value* ASTIf::Codegen(CEnv& cenv){	Value* condV = _cond->Codegen(cenv);	// Convert condition to a bool by comparing equal to 0.0.	condV = cenv.builder.CreateFCmpONE(			condV, ConstantFP::get(APFloat(0.0)), "ifcond");	Function* parent = cenv.builder.GetInsertBlock()->getParent();	// Create blocks for the then and else cases.	// Insert the 'then' block at the end of the function.	BasicBlock* thenBB = BasicBlock::Create("then", parent);	BasicBlock* elseBB = BasicBlock::Create("else");	BasicBlock* mergeBB = BasicBlock::Create("ifcont");	cenv.builder.CreateCondBr(condV, thenBB, elseBB);	// Emit then value.	cenv.builder.SetInsertPoint(thenBB);	Value* thenV = _then->Codegen(cenv);	cenv.builder.CreateBr(mergeBB);	// Codegen of 'Then' can change the current block, update thenBB	thenBB = cenv.builder.GetInsertBlock();	// Emit else block.	parent->getBasicBlockList().push_back(elseBB);	cenv.builder.SetInsertPoint(elseBB);	Value* elseV = _else->Codegen(cenv);	cenv.builder.CreateBr(mergeBB);	// Codegen of 'Else' can change the current block, update elseBB	elseBB = cenv.builder.GetInsertBlock();	// Emit merge block.	parent->getBasicBlockList().push_back(mergeBB);	cenv.builder.SetInsertPoint(mergeBB);	PHINode* pn = cenv.builder.CreatePHI(Type::DoubleTy, "iftmp");	pn->addIncoming(thenV, thenBB);	pn->addIncoming(elseV, elseBB);	return pn;}

void ParserTest::testMultipleProcedures(){	Parser p;	std::string src;	src =	"procedure main{/n"			"	a = a + 2;}/n"			"procedure text1{/n"			"	b = a * (2 + c);/n"			"	c = c - 2;}"			"procedure text2{/n"			"	while a{/n"			"		d = d - 2;}/n"			"	e = e + 1;/n"			"	if a then {/n"			"		h = h * (a * b);/n"			"		b = b + 1;}/n"			"	else{/n"			"		c = b;/n"			"		while z{/n"			"			abc = xyz;/n"			"			abc1 = xyz2 * xyz + h - y;}/n"			"		a=abc1*2;}}";				p.setSource(src);	CPPUNIT_ASSERT_EQUAL(1, p.startParse());	PKB *pkb = p.getPKB();		// AST Test	AST *ast = pkb->getRootAST();	CPPUNIT_ASSERT(pkb->getType(ast->getRightSibling()) == PROCEDURE);	CPPUNIT_ASSERT(pkb->getType(ast->getRightSibling()->getRightSibling()) == PROCEDURE);	CPPUNIT_ASSERT(pkb->getType(ast->getRightSibling()->getRightSibling()->getFirstDescendant()->getFirstDescendant()) == WHILE);	// Parent Test to ensure insertion is correct.	CPPUNIT_ASSERT(!pkb->isParent(1, 9));	CPPUNIT_ASSERT(pkb->isParent(4, 5));	// Follow Test	CPPUNIT_ASSERT(!pkb->isFollows(1, 2));	CPPUNIT_ASSERT(!pkb->isFollows(3, 4));	CPPUNIT_ASSERT(pkb->isFollows(4, 6));}

CodeGen hex(AST &ast){	CodeGen cg;	cg.generate(ast.get_root());	cg.back_patch();	cg.fill();	// cg.print_hex();	// cg.print_tables();	return cg;}

void ASTTest::testAcrossMethods() {	AST* asd = (AST::getInstance());	CPPUNIT_ASSERT(asd->contains("Alice"));	CPPUNIT_ASSERT(asd->contains("Bob"));	ProcNode* pget = asd->getProcNode("Bob");	CPPUNIT_ASSERT(NULL != pget);	string expname = "Bob";	CPPUNIT_ASSERT_EQUAL(expname, pget->getName());	//CPPUNIT_ASSERT_EQUAL(pn, pget);	StmtLstNode* sget = pget->getStmtLstNode();	//CPPUNIT_ASSERT_EQUAL(sln, sget);	string sname = "then";	CPPUNIT_ASSERT_EQUAL(sname, sget->getName());	return;}

void ASTTest::testInstances() {	CPPUNIT_ASSERT(dynamic_cast<AST*>(ast));	AST* asd = AST::getInstance();	AST* qwe = AST::getInstance();	CPPUNIT_ASSERT(asd->contains("Alice"));	CPPUNIT_ASSERT(qwe->contains("Alice"));	ProcNode* pn = new ProcNode("Bob");	StmtLstNode* sln = new StmtLstNode("then");	pn->linkStmtLstNode(sln);	asd->addProcNode(pn);	ProcNode* pget = asd->getProcNode("Bob");	CPPUNIT_ASSERT(NULL != pget);	string expname = "Bob";	CPPUNIT_ASSERT_EQUAL(expname, pget->getName());	CPPUNIT_ASSERT_EQUAL(pn, pget);	StmtLstNode* sget = pget->getStmtLstNode();	CPPUNIT_ASSERT_EQUAL(sln, sget);	string sname = "then";	CPPUNIT_ASSERT_EQUAL(sname, sget->getName());	return;}

void P::parse_action(ASTBase **_root,int *_retsignal ){  zzRULE;  int _signal=NoSignal;  *_retsignal = NoSignal;  loop_clause_nest_level = 0;  *_root = new AST(TOK_STATEMENTS);  tracein("action");  while ( 1 )    {      statement( _root, &_signal );      _signal = NoSignal;      if ( LA(1) == Eof ) break;    }  ASTBase::tmake( NULL, (*_root)->bottom(), (new AST(Eof)) , NULL);  if ( dumpflag && (*_root) )    {		((AST *)(*_root))->dumpTree("/nAST tree", ascii_buffer);		printf("--------------------------------------------------/n");		if (relocflag)        {          printf("Relocatable ASTs:/n");          AST *look = ttr->getItemHead();          while (look)            {              look->dumpNode("  ");              look = look->getItemNext();            }          printf("--------------------------------------------------/n");        }    }  traceout("action");  return;}

AST* Parser::parse_case_branch(void) {	AST* res = new AST();	res->kind = AST_CASE_BRANCH;	// Patron	AST* pattern = parse_expression();	if (!is_pattern(pattern)) {		cerr << "Error en el case:" << endl;		pattern->show(cerr, 1);		cerr << endl;		cerr << "no es un patron." << endl;		exit(1);	}	res->children.push_back(pattern);	assert_type(TOK_FAT_ARROW);	_tokenizer.next();	// Resultado	res->children.push_back(parse_expression());		return res;}

// parent is either a FunctionDefinitionAST or a SimpleDeclarationAST// line and column are 1-basedstatic bool findDeclOrDef(const Document::Ptr &doc, int line, int column,                          DeclarationAST **parent, DeclaratorAST **decl,                          FunctionDeclaratorAST **funcDecl){    QList<AST *> path = ASTPath(doc)(line, column);    // for function definitions, simply scan for FunctionDefinitionAST not preceded    //    by CompoundStatement/CtorInitializer    // for function declarations, look for SimpleDeclarations with a single Declarator    //    with a FunctionDeclarator postfix    FunctionDefinitionAST *funcDef = 0;    SimpleDeclarationAST *simpleDecl = 0;    *decl = 0;    for (int i = path.size() - 1; i > 0; --i) {        AST *ast = path.at(i);        if (ast->asCompoundStatement() || ast->asCtorInitializer())            break;        if ((funcDef = ast->asFunctionDefinition()) != 0) {            *parent = funcDef;            *decl = funcDef->declarator;            break;        }        if ((simpleDecl = ast->asSimpleDeclaration()) != 0) {            *parent = simpleDecl;            if (!simpleDecl->declarator_list || !simpleDecl->declarator_list->value)                break;            *decl = simpleDecl->declarator_list->value;            break;        }    }    if (!*parent || !*decl)        return false;    if (!(*decl)->postfix_declarator_list || !(*decl)->postfix_declarator_list->value)        return false;    *funcDecl = (*decl)->postfix_declarator_list->value->asFunctionDeclarator();    return *funcDecl;}

void Error::complain(const AST &node, const char *fmt, ...){    char buf[255] = { 0 };    va_list list;    // get compile source file path and name    LocationMgr *locationMgr = getLocationMgr();    string sourcePath = locationMgr->getCompileSourcePath();    string sourceFile = locationMgr->getCompileSourceFile();    int lineno = node.getLocation().getLineno();    va_start(list, fmt);    vsprintf(buf, fmt, list);    std::cout << sourcePath << "/" << sourceFile << ":" << lineno << ":"  <<  buf << std::endl;    va_end(list);}

void TagWriter::analyse(const AST& ast) {    currentFile = getFile(ast.getFileName());    for (unsigned i=0; i<ast.numTypes(); i++) {        TagVisitor visitor(*this, ast.getType(i), SM);        visitor.run();    }    for (unsigned i=0; i<ast.numVars(); i++) {        TagVisitor visitor(*this, ast.getVar(i), SM);        visitor.run();    }    for (unsigned i=0; i<ast.numFunctions(); i++) {        TagVisitor visitor(*this, ast.getFunction(i), SM);        visitor.run();    }    // TODO TypeDecls ArrayValueDecls}

void DepGenerator::writeAST(const AST& ast, StringBuilder& output, unsigned indent) const {    if (showExternals) {        for (unsigned i=0; i<ast.numImports(); i++) {            const ImportDecl* U = ast.getImport(i);            QualType Q = U->getType();            const ModuleType* T = cast<ModuleType>(Q.getTypePtr());            const Module* P = T->getModule();            assert(P);            if (P->isExternal()) addExternal(P);        }    }    for (unsigned i=0; i<ast.numTypes(); i++) {        writeDecl(ast.getType(i), output, indent);    }    for (unsigned i=0; i<ast.numVars(); i++) {       writeDecl(ast.getVar(i), output, indent);    }    for (unsigned i=0; i<ast.numFunctions(); i++) {        writeDecl(ast.getFunction(i), output, indent);    }}