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

void SlotVisitor::drain(){    StackStats::probe();    ASSERT(m_isInParallelMode);   #if ENABLE(PARALLEL_GC)    if (Options::numberOfGCMarkers() > 1) {        while (!m_stack.isEmpty()) {            m_stack.refill();            for (unsigned countdown = Options::minimumNumberOfScansBetweenRebalance(); m_stack.canRemoveLast() && countdown--;)                visitChildren(*this, m_stack.removeLast());            donateKnownParallel();        }                mergeOpaqueRootsIfNecessary();        return;    }#endif        while (!m_stack.isEmpty()) {        m_stack.refill();        while (m_stack.canRemoveLast())            visitChildren(*this, m_stack.removeLast());    }}

void QSGNodeVisitor::visitNode(QSGNode *n){    switch (n->type()) {    case QSGNode::TransformNodeType: {        QSGTransformNode *t = static_cast<QSGTransformNode *>(n);        enterTransformNode(t);        visitChildren(t);        leaveTransformNode(t);        break; }    case QSGNode::GeometryNodeType: {        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(n);        enterGeometryNode(g);        visitChildren(g);        leaveGeometryNode(g);        break; }    case QSGNode::ClipNodeType: {        QSGClipNode *c = static_cast<QSGClipNode *>(n);        enterClipNode(c);        visitChildren(c);        leaveClipNode(c);        break; }    case QSGNode::OpacityNodeType: {        QSGOpacityNode *o = static_cast<QSGOpacityNode *>(n);        enterOpacityNode(o);        visitChildren(o);        leaveOpacityNode(o);        break; }    default:        visitChildren(n);        break;    }}

void QSGNodeUpdater::visitNode(QSGNode *n){#ifdef QSG_UPDATER_DEBUG    qDebug() << "enter:" << n;#endif    if (!n->dirtyFlags() && !m_force_update)        return;    if (n->isSubtreeBlocked())        return;    bool forceUpdate = n->dirtyFlags() & (QSGNode::DirtyNodeAdded | QSGNode::DirtyForceUpdate);    if (forceUpdate)        ++m_force_update;    switch (n->type()) {    case QSGNode::TransformNodeType: {        QSGTransformNode *t = static_cast<QSGTransformNode *>(n);        enterTransformNode(t);        visitChildren(t);        leaveTransformNode(t);        break; }    case QSGNode::GeometryNodeType: {        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(n);        enterGeometryNode(g);        visitChildren(g);        leaveGeometryNode(g);        break; }    case QSGNode::ClipNodeType: {        QSGClipNode *c = static_cast<QSGClipNode *>(n);        enterClipNode(c);        visitChildren(c);        leaveClipNode(c);        break; }    case QSGNode::OpacityNodeType: {        QSGOpacityNode *o = static_cast<QSGOpacityNode *>(n);        enterOpacityNode(o);        visitChildren(o);        leaveOpacityNode(o);        break; }    default:        visitChildren(n);        break;    }    if (forceUpdate)        --m_force_update;    n->clearDirty();}

void MarkStack::drain(){#if !ASSERT_DISABLED    ASSERT(!m_isDraining);    m_isDraining = true;#endif    while (!m_markSets.isEmpty() || !m_values.isEmpty()) {        while (!m_markSets.isEmpty() && m_values.size() < 50) {            ASSERT(!m_markSets.isEmpty());            MarkSet& current = m_markSets.last();            ASSERT(current.m_values);            JSValue* end = current.m_end;            ASSERT(current.m_values);            ASSERT(current.m_values != end);        findNextUnmarkedNullValue:            ASSERT(current.m_values != end);            JSValue value = *current.m_values;            current.m_values++;            JSCell* cell;            if (!value || !value.isCell() || Heap::testAndSetMarked(cell = value.asCell())) {                if (current.m_values == end) {                    m_markSets.removeLast();                    continue;                }                goto findNextUnmarkedNullValue;            }            if (cell->structure()->typeInfo().type() < CompoundType) {                cell->JSCell::visitChildren(*this);                if (current.m_values == end) {                    m_markSets.removeLast();                    continue;                }                goto findNextUnmarkedNullValue;            }            if (current.m_values == end)                m_markSets.removeLast();            visitChildren(cell);        }        while (!m_values.isEmpty())            visitChildren(m_values.removeLast());    }#if !ASSERT_DISABLED    m_isDraining = false;#endif}

void cpt::semantics::PFTypeValidator::processBinaryArithmeticExpression(cdk::node::expression::BinaryExpression * const node, int lvl) {	visitChildren(node, lvl);	// Check for invalid types in expression	// FIXME: this is too long, better negate this...	if((node->left()->type()->name() == ExpressionType::TYPE_STRING)	|| (node->right()->type()->name() == ExpressionType::TYPE_STRING)	|| (node->left()->type()->name() == ExpressionType::TYPE_VOID)	|| (node->right()->type()->name() == ExpressionType::TYPE_VOID)	|| (node->left()->type()->name() == ExpressionType::TYPE_POINTER)	|| (node->right()->type()->name() == ExpressionType::TYPE_POINTER)	|| (node->left()->type()->name() == ExpressionType::TYPE_ERROR)	|| (node->right()->type()->name() == ExpressionType::TYPE_ERROR)) {		node->type(new ExpressionType(0, ExpressionType::TYPE_ERROR));	}	// If an operand is of type double, the binary expression is of type double	if((node->left()->type()->name() == ExpressionType::TYPE_DOUBLE)	|| (node->right()->type()->name() == ExpressionType::TYPE_DOUBLE)) {		node->type(new ExpressionType(8, ExpressionType::TYPE_DOUBLE));	}	// Otherwise, they are both integers, and the binary expression has type integer as well	else {		node->type(new ExpressionType(4, ExpressionType::TYPE_INT));	}}

void CqParseTreeViz::Visit(IqParseNodeGatherConstruct& node){	setNodeProperty(node, "label", "GATHER");	setNodeProperty(node, "fillcolor", blockConstructColor);	setNodeProperty(node, "shape", "Msquare");	visitChildren(node);}

void index_std(){    std::cout << "index_std=======================================================/n";    clang::index index;        std::vector<std::string> args = {"CC", "/home/nicholas/dev/cxxide/ex/stdlib-c++03.cpp"};    args.push_back("-I/usr/include/clang/3.0/include/");    auto& tu = index.parse_translation_unit(args);    std::cout << "parsed: " << tu.spelling() << "/n";        {        auto cursor = tu.get_cursor();                unsigned depth = 1;        std::function<CXChildVisitResult(const clang::cursor& cur, const clang::cursor& parent)> visitor = [&depth, &visitor](clang::cursor cur, clang::cursor parent) -> CXChildVisitResult        {            if(!cur.isUnexposed())            {                std::cout << std::string(depth, ' ') << cur.location() << " " << clang::to_string(cur.kind()) << " " << cur.spelling() << "/n";            }                        ++depth;            cur.visitChildren(visitor);            --depth;                        return CXChildVisit_Continue;        };        cursor.visitChildren(visitor);    }    std::cout << "index_std=======================================================/n";}

void SymbolCheckVisitor::visit(ASTFunction& ast){   ScopedScope scope(mScopeStack);   ScopedValue<ASTFunction*> scopedfunction(&mpFunction, &ast, mpFunction);   ASSERT_PTR(mpFunction);   visitChildren(ast); // <-- arguments   if ( ast.isConstructor() && ast.getName() != mpClass->getName() )   {      error(E0005, UTEXT("Function ") + ast.getName() + UTEXT(" must have a return type (or equal class name as constructor)."), ast);   }   if ( ast.hasBody() )   {      if ( ast.getModifiers().isAbstract() )      {         error(E0006, UTEXT("Abstract function ") + ast.getName() + UTEXT(" should not have a body."), ast);      }      else      {         checkReturn(ast);         ast.getBody().accept(*this);      }   }   else if ( !ast.getModifiers().isAbstract() && !ast.getModifiers().isPureNative() )   {      error(E0007, UTEXT("Function ") + ast.getName() + UTEXT(" requires a body."), ast);   }   mCurrentType.clear();}

void SymbolCheckVisitor::visit(ASTUnary& ast){   visitChildren(ast);   checkOperator(ast, ast.getPre());   checkOperator(ast, ast.getPost());}

void CallTranslator::VisitStmt(const clang::Stmt *s) {    // Insert braces around all if and for statement bodies    if (const clang::CallExpr *call = clang::dyn_cast<clang::CallExpr>(s)) {        const clang::FunctionDecl *callee = call->getDirectCallee();        if (callee) {            std::string callee_name = callee->getNameAsString();            assert(callee_name.size() > 0);            std::string replace_with;            if (curr_func_is_quick == YES &&                    is_quick_transformed(callee_name)) {                replace_with = callee_name + "_quick";            } else if (curr_func_is_npm == YES) {                if (ignorable->find(callee_name) != ignorable->end()) {                    /*                     * Skip this function, we know it is an externally defined                     * function that won't create a checkpoint.                     */                } else if (is_npm_transformed(callee_name)) {                    /*                     * There is a local NPM version of this function defined in                     * the same compilation unit. We can simply reference it                     * directly.                     */                    replace_with = callee_name + "_npm";                } else {                    /*                     * We need to reference an externally defined NPM function                     * through a function pointer.                     */                    std::string varname = get_external_func_name(                            callee_name);                    replace_with = ("(*" + varname + ")");                }            }            if (replace_with.size() > 0) {                std::stringstream ss;                ss << replace_with << "(";                for (int i = 0; i < call->getNumArgs(); i++) {                    if (i != 0) ss << ", ";                    ss << to_string(call->getArg(i));                }                ss << ")";                rewriter->ReplaceText(clang::SourceRange(                            call->getLocStart(), call->getLocEnd()),                        ss.str());            }        }    }    visitChildren(s);}

void visitIfExists(CDGNode * node, CDGNode * nodes[], int size) {  int i;  for (i = 0; i < size; i++) {    if (getID(node) == getID(nodes[i])) {      visitChildren(node, getOutcome(nodes[i]));      return;    }  }  return;}

void SlotVisitor::drain(){    ASSERT(m_isInParallelMode);       while (!m_stack.isEmpty()) {        m_stack.refill();        for (unsigned countdown = Options::minimumNumberOfScansBetweenRebalance(); m_stack.canRemoveLast() && countdown--;)            visitChildren(m_stack.removeLast());        donateKnownParallel();    }        mergeOpaqueRootsIfNecessary();}

void DOMWriter::visitElement(Element * node){  out << '<' << node->getNodeName();  visitNamedNodeMap(node->getAttributes());  if (node->hasChildNodes()) {    out << '>';    visitChildren(node->getChildNodes());    out << '<' << '/' << node->getNodeName() << '>';  }  else {    out << '/' << '>';  }}

void SlotVisitor::drain(MonotonicTime timeout){    ASSERT(m_isInParallelMode);       while ((!m_collectorStack.isEmpty() || !m_mutatorStack.isEmpty()) && !hasElapsed(timeout)) {        if (!m_collectorStack.isEmpty()) {            m_collectorStack.refill();            m_isVisitingMutatorStack = false;            for (unsigned countdown = Options::minimumNumberOfScansBetweenRebalance(); m_collectorStack.canRemoveLast() && countdown--;)                visitChildren(m_collectorStack.removeLast());        } else if (!m_mutatorStack.isEmpty()) {            m_mutatorStack.refill();            // We know for sure that we are visiting objects because of the barrier, not because of            // marking. Marking will visit an object exactly once. The barrier will visit it            // possibly many times, and always after it was already marked.            m_isVisitingMutatorStack = true;            for (unsigned countdown = Options::minimumNumberOfScansBetweenRebalance(); m_mutatorStack.canRemoveLast() && countdown--;)                visitChildren(m_mutatorStack.removeLast());        }        donateKnownParallel();    }        mergeOpaqueRootsIfNecessary();}

bool TreeModel::romoveChildren(const QModelIndex &index){    bool success = true;    QList<qint64> ids;    visitChildren(index, ids);    foreach( qint64 id, ids)    {        bool ret = m_queryItem->removeRecord(id);        if( !ret )        {            success = false;            break;        }    }