C++ FunctionNode类代码示例

 virtual void evaluate( const FunctionNode& function ) {
     return;
     return;
     switch (function.getType()) {
         case FunctionNode::FT_MOVE :
         {
             //suma
             //                    int result = 0;
             //                    for (int i = 0; i < arity - 1; ++i) {
             //                        result += arguments[i]->getValue();
             //                    }
             //                    arguments[arity - 1]->setValue(result);
             //                    std::cout << function.toString() << std::endl;
             break;
         }
         case FunctionNode::FT_SWAP :
         {
             //resta
             //                    int result = 0;
             //                    for (int i = 0; i < arity - 1; ++i) {
             //                        result -= arguments[i]->getValue();
             //                    }
             //                    arguments[arity - 1]->setValue(result);
             break;
         }
         default: DEBUGM(TO_STRING(function.getType()));
             assert(0);
     }
 }

void ShaderCodeGenerator::writeFunction(const DoutSocket *socket)
{
    QString output;
    initVar(socket);
    output.append(newline());
    output.append(getVariable(socket));
    output.append(" = ");
    FunctionNode *fnode = (FunctionNode*)socket->getNode();
    output.append(fnode->getFunctionName());
    output.append("(");
    for(const DinSocket *nsocket : fnode->getInSockets())
    {
        if(nsocket->getToken())
        {
            output.append("\"");
            output.append(nsocket->getName());
            output.append("\", ");
        }
        output.append(writeVarName(nsocket));
        gotoNextNode(nsocket);
        if(!fnode->getInSockets().endsWith(const_cast<DinSocket*>(nsocket)))
            output.append(", ");
    }

    output.append(");");
    addToCode(output);
}

void AstPrinterVisitor::visitBlockNode(BlockNode* node) {
    if (!isMainScope(node->scope())) {
        _output << "{" << endl;
    }

    Scope::VarIterator varIt(node->scope());
    while(varIt.hasNext()) {
        AstVar* var = varIt.next();
        printVarType(var->type());
        _output << " " << var->name();
        printSemicolon();
    }

    Scope::FunctionIterator funcIt(node->scope());
    while(funcIt.hasNext()) {
        FunctionNode* func = funcIt.next()->node();
        func->visit(this);
    }

    for (uint32_t i = 0; i < node->nodes(); ++i) {
        node->nodeAt(i)->visit(this);
        if (!(node->nodeAt(i)->isIfNode()
              || node->nodeAt(i)->isWhileNode()
              || node->nodeAt(i)->isForNode()
              || node->nodeAt(i)->isReturnNode()
              || node->nodeAt(i)->isBlockNode())) {
            printSemicolon();
        }
    }
    if (!isMainScope(node->scope())) {
        _output << "}" << endl;
    }
}

void QsCodeParser::setQuickDoc(Node *quickNode,
                               const Doc& doc,
                               const QStringList& qtParams,
                               const QStringList& quickParams)
{
    QRegExp quickifyCommand("\\\\" + COMMAND_QUICKIFY + "([^\n]*)(?:\n|$)");

    if (quickNode->type() == Node::Function) {
	FunctionNode *quickFunc = (FunctionNode *) quickNode;
	quickFunc->setOverload(false);
    }

    if (doc.metaCommandsUsed().contains(COMMAND_QUICKIFY)) {
	QString source = doc.source();
	int pos = source.indexOf(quickifyCommand);
	if (pos != -1) {
	    QString quickifiedSource = quickNode->doc().source();
	    if (!qtParams.isEmpty() && qtParams != quickParams)
		renameParameters(quickifiedSource, doc, qtParams,
				  quickParams);
	    applyReplacementList(quickifiedSource, doc);

	    do {
		QString extract = quickifiedSource;
		QString arg = quickifyCommand.cap(1).simplified();
		if (!arg.isEmpty()) {
		    if (arg.startsWith("/") && arg.endsWith("/") &&
			 arg.length() > 2) {
			QString pattern = arg.mid(1, arg.length() - 2);
			extractRegExp(QRegExp(pattern), extract, doc);
		    }
                    else {
			extractTarget(arg, extract, doc);
		    }
		}
		source.replace(pos, quickifyCommand.matchedLength(), extract);
		pos += extract.length();
	    } while ((pos = source.indexOf(quickifyCommand, pos)) != -1);

	    QRegExp quickcodeRegExp(
		    "\\\\" + COMMAND_QUICKCODE + "(.*)\\\\" +
		    COMMAND_ENDQUICKCODE);
	    quickcodeRegExp.setMinimal(true);
	    source.replace(quickcodeRegExp, "");
	}

	Doc quickDoc(doc.location(),
                     doc.location(),
                     source,
                     (CppCodeParser::topicCommands() + topicCommands() +
                      CppCodeParser::otherMetaCommands()) << COMMAND_REPLACE);
	quickNode->setDoc(quickDoc, true);
	processOtherMetaCommands(quickDoc, quickNode);
    }
    else {
	quickNode->setDoc(doc, true);
	processOtherMetaCommands(doc, quickNode);
    }
}

void
XmlRenderer::renderNode(const FunctionNode& node)
{
  displayOpenTag("function");
  displayNodeList("params", node.params());
  displayType("rettype", node.retType());
  displayNode("body", node.body().get());
  displayCloseTag("function");
}

DetectRecursion::ErrorCode DetectRecursion::detectRecursion()
{
    FunctionNode* main = findFunctionByName("main(");
    if (main == NULL)
        return kErrorMissingMain;
    if (main->detectRecursion())
        return kErrorRecursion;
    return kErrorNone;
}

bool QsCodeParser::makeFunctionNode(const QString& synopsis,
				     QStringList *parentPathPtr,
				     FunctionNode **funcPtr)
{
    QRegExp funcRegExp(
	    "\\s*([A-Za-z0-9_]+)\\.([A-Za-z0-9_]+)\\s*\\((" +
            balancedParens +
	    ")\\)(?:\\s*:\\s*([A-Za-z0-9_]+))?\\s*");
    QRegExp paramRegExp(
	    "\\s*(\\[)?\\s*(?:([A-Za-z0-9_]+)\\s*:\\s*)?"
	    "([A-Za-z0-9_]+|\\.\\.\\.)\\s*(\\[)?[\\s\\]]*");

    if (!funcRegExp.exactMatch(synopsis))
	return false;

    ClassNode *classe = (ClassNode*)
        qsTre->findNode(QStringList(funcRegExp.cap(1)),Node::Class);
    if (classe == 0)
	return false;

    FunctionNode *clone = new FunctionNode(0, funcRegExp.cap(2));
    bool optional = false;

    QString paramStr = funcRegExp.cap(3);
    QStringList params = paramStr.split(",");
    QStringList::ConstIterator p = params.begin();
    while (p != params.end()) {
	if (paramRegExp.exactMatch(*p)) {
	    if (!paramRegExp.cap(1).isEmpty())
		optional = true;
	    clone->addParameter(Parameter(paramRegExp.cap(3),
                                          "",
                                          paramRegExp.cap(2),
                                          optional ? "undefined" : ""));
	    if (!paramRegExp.cap(4).isEmpty())
		optional = true;
	}
        else {
	    delete clone;
	    return false;
	}
	++p;
    }
    QString returnType = funcRegExp.cap(4);
    if (!returnType.isEmpty())
	clone->setReturnType(returnType);
    if (parentPathPtr != 0)
	*parentPathPtr = QStringList() << classe->name();
    if (funcPtr != 0) {
	*funcPtr = clone;
    }
    else {
	delete clone;
    }
    return true;
}

  void visitMethodDecl(MethodDecl *node) override {
    JsonObject *obj = new (pool_) JsonObject();
    obj->add(atom_name_, toJson(node->name()));
    startDoc(obj, "method", node->name(), node->loc());

    FunctionNode *fun = node->method();
    obj->add(atom_returnType_, toJson(fun->signature()->returnType()));
    obj->add(atom_parameters_, toJson(fun->signature()->parameters()));
    methods_->add(obj);
  }

// Join two commands together
Node* Expression::joinCommands(Node* node1, Node* node2)
{
	FunctionNode* leaf = new FunctionNode(Functions::Joiner);
	nodes_.own(leaf);
	leaf->setParent(this);
	if (node1 != NULL) leaf->addArgument(node1);
	if (node2 != NULL) leaf->addArgument(node2);
	msg.print(Messenger::Verbose, "Joined command nodes %p and %p (joiner node is %p)\n", node1, node2, leaf);
	return leaf;
}

void
NameResolver::LeaveMethodDecl(MethodDecl *decl)
{
  FunctionNode *fun = decl->method();
  if (!fun)
    return;

  // Now that we've parsed the function, check if we were able to resolve its
  // signature.
  if (!fun->signature()->isResolved())
    tr_.addPending(decl);
}

/*!
    Visits public member declarations, such as signals and properties.
    These only include custom signals and properties.
*/
bool QmlDocVisitor::visit(QDeclarativeJS::AST::UiPublicMember *member)
{
    switch (member->type) {
    case QDeclarativeJS::AST::UiPublicMember::Signal:
    {
        if (current->type() == Node::Fake) {
            QmlClassNode *qmlClass = static_cast<QmlClassNode *>(current);
            if (qmlClass) {

                QString name = member->name->asString();
                FunctionNode *qmlSignal = new FunctionNode(Node::QmlSignal, current, name, false);

                QList<Parameter> parameters;
                for (QDeclarativeJS::AST::UiParameterList *it = member->parameters; it; it = it->next) {
                    if (it->type && it->name)
                        parameters.append(Parameter(it->type->asString(), "", it->name->asString()));
                }

                qmlSignal->setParameters(parameters);
                applyDocumentation(member->firstSourceLocation(), qmlSignal);
            }
        }
        break;
    }
    case QDeclarativeJS::AST::UiPublicMember::Property:
    {
        QString type = member->memberType->asString();
        QString name = member->name->asString();

        if (current->type() == Node::Fake) {
            QmlClassNode *qmlClass = static_cast<QmlClassNode *>(current);
            if (qmlClass) {

                QString name = member->name->asString();
                QmlPropGroupNode *qmlPropGroup = new QmlPropGroupNode(qmlClass, name, false);
                if (member->isDefaultMember)
                    qmlPropGroup->setDefault();
                QmlPropertyNode *qmlPropNode = new QmlPropertyNode(qmlPropGroup, name, type, false);
                qmlPropNode->setWritable(!member->isReadonlyMember);
                applyDocumentation(member->firstSourceLocation(), qmlPropNode);
            }
        }
        break;
    }
    default:
        return false;
    }

    //current->doc = precedingComment(member->firstSourceLocation().begin());
    return true;
}

void CodeMarker::insert(FastSection &fastSection, Node *node, SynopsisStyle style, Status status)
{
    bool inheritedMember = (!node->relates() &&
			    (node->parent() != (const InnerNode *)fastSection.innerNode));
    bool irrelevant = false;

    if (node->access() == Node::Private) {
	irrelevant = true;
    } else if (node->type() == Node::Function) {
	FunctionNode *func = (FunctionNode *) node;
	irrelevant = (inheritedMember
		      && (func->metaness() == FunctionNode::Ctor ||
			  func->metaness() == FunctionNode::Dtor));
    } else if (node->type() == Node::Class || node->type() == Node::Enum
		    || node->type() == Node::Typedef) {
	irrelevant = (inheritedMember && style != SeparateList);
        if (!irrelevant && style == Detailed && node->type() == Node::Typedef) {
            const TypedefNode* typedeffe = static_cast<const TypedefNode*>(node);
            if (typedeffe->associatedEnum())
                irrelevant = true;
        }
    }

    if (!irrelevant) {
        if (status == Compat) {
            irrelevant = (node->status() != Node::Compat);
	} else if (status == Obsolete) {
            irrelevant = (node->status() != Node::Obsolete);
	} else {
            irrelevant = (node->status() == Node::Compat ||
                          node->status() == Node::Obsolete);
	}
    }

    if (!irrelevant) {
	if (!inheritedMember || style == SeparateList) {
	    QString key = sortName(node);
            if (!fastSection.memberMap.contains(key))
		fastSection.memberMap.insert(key, node);
	} else {
	    if (node->parent()->type() == Node::Class) {
		if (fastSection.inherited.isEmpty()
                    || fastSection.inherited.last().first != node->parent()) {
		    QPair<ClassNode *, int> p((ClassNode *)node->parent(), 0);
		    fastSection.inherited.append(p);
		}
		fastSection.inherited.last().second++;
	    }
	}
    }
}

void CDisassembler::ParseProgram(Program *prog)
{
	prog->EntryAddr = EntryAddr;

	int functioni;
	for( functioni = 1; functioni < FunctionList.GetNumEntries(); functioni++ )
	{
		int section = FunctionList[functioni].Section;
		uint64_t func_start_offset = FunctionList[functioni].Start;
		uint64_t func_end_offset = FunctionList[functioni].End;
		uint64_t section_addr = Sections[section].SectionAddress;

		if((Sections[section].Type & 0xFF) == 1)
		{
			FunctionNode func;
			func.StartAddress = section_addr + func_start_offset;
			func.EndAddress = section_addr + func_end_offset;

			vector<Instruction> insns;
			uint64_t start_addr, end_addr;
			SetFunctionDescriptor(func.StartAddress);
			while( GetBlockInFunction( &insns, &start_addr, &end_addr ) != -1 )
			{
				if(insns.size() == 0)
					fprintf(stderr, "[error] can't get block assembly\n");

				BlockNode node;
				node.Init( insns, start_addr, end_addr );
				func.Insert( node );
				insns.clear();
			}
			//flow_graph1.PrintAllPath();

			prog->Insert(func);
		}
	}

	uint32_t sym_num = Symbols.GetNumEntries();
	for(int i = 0; i < sym_num; i++)
	{
		if(Symbols[i].Name)
		{
			int section = Symbols[i].Section;
			uint64_t section_addr = Sections[section].SectionAddress;
			uint64_t sym_addr = section_addr + Symbols[i].Offset;
			const char *sym_name = Symbols.GetName(i);
			if(sym_name[0] != '?')
				prog->AddSymbol(sym_addr, sym_name);
		}
	}
}

    Status* translate(const string& program, Code* *code) {
        Parser parser;
        Status* status = parser.parseProgram(program);

        if(status->isError()) {
            return status;
        }

        AstPrinterVisitor visitor(std::cout);
        
        FunctionNode* root = parser.top()->node();
        root->body()->visit(&visitor);

        return Status::Ok();
    }       

void BytecodeGenerator::visitFunDefs(BlockNode* node) {
    deque<uint16_t> funIds;
    Scope::FunctionIterator it1(node->scope());
    while(it1.hasNext()) {
        uint16_t id = _state.createBcFun(it1.next());
        funIds.push_back(id);
    }
    Scope::FunctionIterator it2(node->scope());
    while(it2.hasNext()) {
        _state.pushFun(funIds.front());
        funIds.pop_front();
        FunctionNode* funNode = it2.next()->node();
        processFunArgs(funNode);
        funNode->visit(this);
        _state.popFun();
    }
}