C++ (Cpp) AstFunction::node示例

示例#1

文件： ASTtoByteCodeTranslator.cpp 项目： nvmd/spbau-mathvm

void ASTtoByteCodeTranslator::createFunMap(Scope* scope){
    Scope::FunctionIterator funIt(scope);

    while(funIt.hasNext()) {
        AstFunction* fun = funIt.next();
        if (fun->node()->body()->nodeAt(0)->isNativeCallNode())
            fun->node()->visit(this);
        else{
        	BytecodeFunction* bcFun = new BytecodeFunction(fun);
        	code->addFunction(bcFun);
        	funMap.insert(std::make_pair(fun, bcFun));
        	funStack.push(bcFun);
        	fun->node()->visit(this);
        	funStack.pop();
        }
    }
}

示例#2

文件： BytecodeGenerationVisitor.cpp 项目： nvmd/spbau-mathvm

void BytecodeGenerationVisitor::visitBlockNode(BlockNode* node) {   // DONE
	Scope* prevScope = currentScope;
	currentScope = node->scope();
	
	Scope::VarIterator varsToSave(currentScope);
	while (varsToSave.hasNext()) {
		AstVar* v = varsToSave.next();
		bytecode->addInsn(insnByUntypedInsn[v->type()][UT_LOADVAR]);
		bytecode->addInt16(getVarId(v));
		locals.push_back(v);
	}
	
	Scope::VarIterator varsToInit(currentScope);
	while (varsToInit.hasNext()) {
		AstVar* v = varsToInit.next();
		bytecode->addInsn(insnByUntypedInsn[v->type()][UT_LOAD0]);
		bytecode->addInsn(insnByUntypedInsn[v->type()][UT_STOREVAR]);
		bytecode->addInt16(getVarId(v));
	}
	
	Scope::FunctionIterator functionsToAdd(node -> scope());
	while (functionsToAdd.hasNext()) {
		AstFunction *astFunction = functionsToAdd.next();
		BytecodeFunction *bytecodeFunction = new BytecodeFunction(astFunction);
		code -> addFunction(bytecodeFunction);
	}
	
	Scope::FunctionIterator functionsToBuild(node -> scope());
	while (functionsToBuild.hasNext()) {
		AstFunction *astFunction = functionsToBuild.next();
		astFunction->node()->visit(this);
	}

	for (unsigned int i = 0; i < (node -> nodes()); i++) {
		node -> nodeAt(i) -> visit(this);
		if (currentType != VT_VOID && !(node->nodeAt(i)->isReturnNode())) {
			bytecode -> addInsn(BC_POP);
		}
	}
	
	Scope::VarIterator varsToRestore(currentScope);
	stack<AstVar*> variables;
	while (varsToRestore.hasNext()) {
		variables.push(varsToRestore.next());
	}
	
	while (!variables.empty()) {
		AstVar* v = variables.top();
		bytecode->addInsn(insnByUntypedInsn[v->type()][UT_STOREVAR]);
		bytecode->addInt16(getVarId(v));
		locals.pop_back();
		variables.pop();
	}
	
	currentScope = prevScope;
	currentType = VT_VOID;
}

示例#3

文件： typechecking.cpp 项目： kamanov/Shared

void TypeChecker::visitFunDefs(BlockNode* node) {
    Scope::FunctionIterator funIt(node->scope());
    while(funIt.hasNext()) {
        AstFunction* fun = funIt.next();
        size_t dbg_cur_size = _funs.size();
        _funs.push(fun);
        fun->node()->visit(this);
        _funs.pop();
        assert(dbg_cur_size == _funs.size());
    }
}

示例#4

文件： bytecode_visitor.cpp 项目： kamanov/Shared

void ByteCodeVisitor::visitBlockNode(mathvm::BlockNode *node) {
    currScope = node->scope();
    for (uint32_t i = 0; i < node->nodes(); ++i) {
        AstNode *n = node->nodeAt(i);
        n->visit(this);
    }
    Scope::FunctionIterator functionIterator(currScope);
    while (functionIterator.hasNext()) {
        AstFunction *astFunction = functionIterator.next();
        visitFunctionNode(astFunction->node());
    }
    currScope = currScope->parent();
}

示例#5

文件： bytecode_gen.cpp 项目： nvmd/spbau-mathvm

void BytecodeGenerator::secondRun(Scope * scope) {
  Scope::FunctionIterator it(scope);
  while (it.hasNext()) {
    AstFunction *func = it.next();
    BytecodeFunction *bcf =
        (BytecodeFunction*) code->functionByName(func->name());
    fBC = bcf->bytecode();
    currentFun = bcf->id();
    returnType = func->returnType();
    func->node()->body()->visit(this);
    bcf->setLocalsNumber(localsCounter[currentFun]);
  }

  for (size_t i = 0; i < scope->childScopeNumber(); ++i) {
    secondRun(scope->childScopeAt(i));
  }
}

示例#6

文件： ast_printer.cpp 项目： kamanov/Shared

    void printScope(Scope * scope) {
        Scope::VarIterator varIt(scope); 

        while(varIt.hasNext()) {
            AstVar* var = varIt.next();

            os << indent();
            os << typeToName(var->type()) << " " << var->name() << ";" << endl;
        }

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

示例#7

文件： typechecker.cpp 项目： nvmd/spbau-mathvm

void TypeCheckerVisitor::visitBlockNode(BlockNode* node) {
	_current_scope = node->scope();
	Scope::FunctionIterator funcIt(_current_scope);
	while (funcIt.hasNext()) {
		AstFunction* func = funcIt.next();
		func->node()->visit(this);
	}
	int nodes_count = node->nodes();
	VarType commonType = VT_VOID;
	for (int i = 0; i != nodes_count; ++i) {
		AstNode* currentNode = node->nodeAt(i);
		currentNode->visit(this);
		bool isBlockNode = currentNode->isForNode() || currentNode->isWhileNode() || currentNode->isIfNode();
		VarType currentNodeType = getNodeType(currentNode);
		bool hasType = currentNodeType != VT_VOID;
		if ((isBlockNode && hasType) || (i == nodes_count - 1)) {
			commonType = getUpperCommonType(commonType, currentNodeType);
		}
	}
	setNodeType(node, commonType);
	_current_scope = node->scope()->parent();
}