自学教程：C++ visitNode函数代码示例

GLSLValue* GLSLVisitor::visitNode(GLSLUnaryExpression* const unary){    if (! unary)        return 0;    GLSLExpression* const operand = unary->getExpression();    if (! operand)        return 0;    GLSLValue* res = 0;    switch (operand->getNodeType())    {        case GLSLNodeTypes::NODE_POSTFIX_EXPRESSION:            res = visitNode(static_cast<GLSLPostfixExpression* const>(operand));            break;        case GLSLNodeTypes::NODE_UNARY_EXPRESSION:            res = visitNode(static_cast<GLSLUnaryExpression*>(operand));            break;    }   // switch    // TODO: to "really" evaluate this expression, check opToken, value and    // apply that operator.    //Token* const opToken = unary->getToken();    return res;}

bool AnnotationVisitor::visit(ParseTreeNode* const node) {    if (node == 0)        return false;    bool res = true;    try {        switch (node->getNodeType()) {            case AnnotationNodeTypes::NODE_ANNOTATION:                visitNode(dynamic_cast<AnnotationNode*>(node));                break;            case AnnotationNodeTypes::NODE_ANNOTATION_TAGS:                visitNode(dynamic_cast<AnnotationTags*>(node));                break;            case AnnotationNodeTypes::NODE_ANNOTATION_TAG_NAME:                visitNode(dynamic_cast<AnnotationTagName*>(node));                break;            case AnnotationNodeTypes::NODE_ANNOTATION_TAG_VALUES:                visitNode(dynamic_cast<AnnotationTagValues*>(node));                break;            default:                res = false;                log_ << "AnnotationVisitor::visit() called for ParseTreeNode!/n";                break;        }   // switch    } catch (std::runtime_error& e) {        log_ << "  Exception: " << e.what() << "/n";        return false;    }    return res;}

void DefaultVisitor::visitStatement(StatementAst *node){    visitNode(node->assignStmt);    visitNode(node->ifStmt);    visitNode(node->blockStmt);    visitNode(node->returnStmt);}

GLSLValue* GLSLVisitor::visitNode(GLSLCondition* const cond){    if (! cond)        return 0;    GLSLTypeSpecifier* const spec = cond->getTypeSpecifier();    IdentifierToken* const id = cond->getIdentifier();    if ((spec) && (id))    {        try {            GLSLVariableSymbol symbol = visitNode(spec);            symbol.setID(id->getValue());            symbol.setIsArray(false);            symbol.setNumArrayElements(0);            activeSymbols_->insertSymbol(new GLSLVariableSymbol(symbol));        } catch (std::runtime_error& e) {            log_ << "  Exeption in GLSLVisitor::visitNode(GLSLCondition*): " << e.what() << "/n";        }    }    // If spec and id where both not NULL, the expression is the initializer    //    // NOTE: initializer is however only an assignemnt expression, not    // an arbitrary expression to be more precise.    return visitNode(cond->getExpression());}

int PreprocessorVisitor::visitNode(LogicalExpression* const n) {    if (LogicalBinaryExpression* const lbex = dynamic_cast<LogicalBinaryExpression* const>(n))        return visitNode(lbex);    else if (DefinedOperator* const defop = dynamic_cast<DefinedOperator* const>(n))        return visitNode(defop);    throw std::runtime_error("unknown logical expression class!");}

int PreprocessorVisitor::visitNode(ArithmeticExpression* const n) {    if (IntConstant* const c = dynamic_cast<IntConstant* const>(n))        return c->getValue();    else if (BinaryExpression* const b = dynamic_cast<BinaryExpression* const>(n))        return visitNode(b);    else if (UnaryExpression* const u = dynamic_cast<UnaryExpression* const>(n))        return visitNode(u);    throw std::runtime_error("error: unknown arithmetic expression class!");}

void CloneTree::visitCons(Model::ConsItem *node){  visitNode(node->mLeft);  Model::Node *left = mTemps.top();  mTemps.pop();  visitNode(node->mRight);  Model::Node *right = mTemps.top();  mTemps.pop();  mTemps.push(KDevPG::cons(left, right));}

    int kthSmallest(TreeNode *pRoot, int k)    {        if (!pRoot)            return 0;        auto ret = 0;        auto iterCount = 0;        std::vector<TreeNode*> nodes;        nodes.push_back(pRoot);        while (!nodes.empty())        {            TreeNode *pNode = nodes.back();            if (pushNodeIfNotNull(&nodes, pNode->left))                continue;            if (visitNode(pNode, &iterCount, k, &ret))                break;            if (pushNodeIfNotNull(&nodes, pNode->right))                continue;            bool found = false;            TreeNode *pChild = pNode;            TreeNode *pParent = nullptr;            while (true)            {                nodes.pop_back();                if (nodes.empty())                    break;                // 遍历完左子树的话，先回溯到父结点，再开始遍历右子树，如果有的话                pParent = nodes.back();                if (pChild == pParent->left)                {                    found = visitNode(pParent, &iterCount, k, &ret);                    if (pushNodeIfNotNull(&nodes, pParent->right))                        break;                }                pChild = pParent;            }            if (found)                break;        }        return ret;    }

voidGraphvizFunction::printGraph(    ItemFactory* aFactory,    const Item& in, std::fstream& os){  // create helper qnames for comparison  Item lNodeQName = aFactory->createQName("", "", "node");  Item lEdgeQName = aFactory->createQName("", "", "edge");  Item lRelQName  = aFactory->createQName("", "", "rel");  // print the graph with all its children  Item lGraphId;  if (!getAttribute(aFactory, "id", in, lGraphId)) {    GraphvizFunction::throwErrorWithQName(aFactory, "IM003", "GXL parse error: edge does not have an 'id' attribute");  }  os << "digraph /"" << lGraphId.getStringValue() << "/" {" << std::endl;  // visit nodes and edges (TODO add rel elements)  Iterator_t lChildren = in.getChildren();  lChildren->open();  Item item;  while (lChildren->next(item)) {    Item lNodeName;    item.getNodeName(lNodeName);    if (lNodeName.getLocalName() == lNodeQName.getLocalName()) {      visitNode(aFactory, item, os);    } else if (lNodeName.getLocalName() == lEdgeQName.getLocalName()) {      visitEdge(aFactory, item, os);    }   }  os << "}" << std::endl;} /* GraphvizFunction::printGraph */

void CodeGenerator::visitAlternative(Model::AlternativeItem *node){  QList<Model::Node*> top_level_nodes;  QStack<Model::Node*> working_list;  working_list.push(node->mRight);  working_list.push(node->mLeft);  while (!working_list.empty())    {      Model::Node *n = working_list.top();      working_list.pop();      if (Model::AlternativeItem *a = nodeCast<Model::AlternativeItem*>(n))        {          working_list.push(a->mRight);          working_list.push(a->mLeft);        }      else        {          top_level_nodes.push_back(n);        }    }  QList<Model::Node*>::iterator it = top_level_nodes.begin();  while (it != top_level_nodes.end())    {      Model::Node *n = *it;      ++it;      Model::ConditionItem *cond = nodeCast<Model::ConditionItem*>(n);      out << "if (";      if (cond)        out << "(";      generateTestCondition(n, out);      if (cond)        out << ") && (" << cond->mCode << ")";      out << ") {" << endl;      visitNode(n);      out << "}";      if (it != top_level_nodes.end())        out << "else ";      else        {          out << "else {" << endl;          if (!mCurrentCatchId)              out << "return false;" << endl;          else              out << "goto __catch_" << mCurrentCatchId << ";";          out << "}" << endl;        }    }}

void CodeGenerator::visitEvolve(Model::EvolveItem *node){  out << "if (";  Model::ConditionItem *cond = nodeCast<Model::ConditionItem*>(node->mItem);  if (cond)    out << "(";  generateTestCondition(node, out);  if (reducesToEpsilon(node->mItem))    {      out << " || ";      generateCondition(globalSystem.follow(node->mSymbol), out);    }  if (cond)    out << ") && (" << cond->mCode << ")";  out << ") {" << endl;  GenerateLocalDeclarations gen_locals(out, mNames);  gen_locals(node->mItem);  out << node->mCode;  visitNode(node->mItem);  if (globalSystem.start.contains(node->mSymbol))    out << "if (Token_EOF != yytoken) { return false; }" << endl;  out << "}" << endl;}

pt_value invokeNative(pt_native *native, pt_node *node) {	extern pt_value UNDEF;	extern pt_value visitNode(pt_node *node);	extern pt_value visitTerminal(pt_node *node);	if(native == NULL || node == NULL) return UNDEF;	switch(native->type) {		case PNT_FUNCTION: {				pt_node *args = node->next;				int idx, count = node->count;				pt_value *values = malloc(sizeof(pt_value) * count);				if(values == NULL) return UNDEF;				values[0] = visitTerminal(node);				for(idx = 1; idx < count; idx++) {					values[idx] = visitNode(args);					if(values[idx].type == PT_UNDEF) {						/* TODO */						free(values);						return UNDEF;					}					args = args->next;				}				return native->u.function(values, count);			}		case PNT_EXTENSION:			return native->u.extension(node, node->count);		default:			/* TODO */			return UNDEF;	}}

static void _inorderTreeWalk(TreeNode * curNode, void (visitNode)(TreeNode * node)) {    if (curNode) {        _inorderTreeWalk(curNode->left, visitNode);        visitNode(curNode);        _inorderTreeWalk(curNode->right, visitNode);    }}

void AnnotationVisitor::visitNode(AnnotationNode* const node) {    if (node == 0)        return;    if (AnnotationTags* const n = dynamic_cast<AnnotationTags* const>(node))        visitNode(n);    else if (AnnotationTagName* const n = dynamic_cast<AnnotationTagName* const>(node))        visitNode(n);    else if (AnnotationTagValues* const n = dynamic_cast<AnnotationTagValues* const>(node)) {        try {            visitNode(n);        } catch (std::runtime_error& e) {            log_ << "  Exception: " << e.what() << "/n";        }    }}

int PreprocessorVisitor::visitNode(UnaryExpression* const n) {    switch (n->getSymbolID()) {        case PreprocessorTerminals::ID_PLUS:            return visitNode(n->getExpression());        case PreprocessorTerminals::ID_DASH:            return (-visitNode(n->getExpression()));        case PreprocessorTerminals::ID_OP_COMPLEMENT:            return (~ visitNode(n->getExpression()));        case PreprocessorTerminals::ID_OP_NOT:            return (! visitNode(n->getExpression()));    }    throw std::runtime_error("unknown unary operator!");}