void TypeInferenceVisitor::visitBinaryOpNode(BinaryOpNode* node) { AstNode* left = node->left(); AstNode* right = node->right(); left->visit(this); right->visit(this); _types[node] = maxType(_types[left], _types[right]); }
void TypeCheckerVisitor::visitBinaryOpNode(BinaryOpNode* node) { AstNode* left = node->left(); AstNode* right = node->right(); left->visit(this); right->visit(this); setNodeType(node, getOperationResultType(node->kind(), left, right)); }
void ByteCodeVisitor::visitCallNode(mathvm::CallNode *node) { unsigned long stackSize = currStack->size(); AstFunction *astFunction = currScope->lookupFunction(node->name(), true); AstFunctionInfo *functionInfo = (AstFunctionInfo *) astFunction->info(); Scope *parameterScope = astFunction->scope(); if (node->parametersNumber() != parameterScope->variablesCount()) { error("parameters number mistmach in calling %s", node->name().c_str()); } vector<VarType> declaredParameters; declaredParameters.reserve(parameterScope->variablesCount()); Scope::VarIterator varIterator(parameterScope); while (varIterator.hasNext()) { declaredParameters.push_back(varIterator.next()->type()); } vector<VarType>::reverse_iterator it = declaredParameters.rbegin(); for (uint32_t i = node->parametersNumber(); i > 0; --i, ++it) { AstNode *n = node->parameterAt(i - 1); n->visit(this); cast(topStack(), (*it)); } insn(BC_CALL); typed(functionInfo->function->id()); if (astFunction->returnType() != VT_VOID) { pushStack(astFunction->returnType()); } }
void Printer::printBlockContents(BlockNode* node) { // functions delcarations Scope::FunctionIterator funIt(node->scope()); while (funIt.hasNext()) { funIt.next()->node()->visit(this); out << '\n'; } // variables declarations Scope::VarIterator varIt(node->scope()); while (varIt.hasNext()) { AstVar* var = varIt.next(); out << typeToName(var->type()) << " " << var->name() << ";\n"; } // nodes for (size_t i = 0; i < node->nodes(); ++i) { AstNode* subNode = node->nodeAt(i); subNode->visit(this); if (!subNode->isIfNode() && !subNode->isWhileNode() && !subNode->isForNode()) { out << ';'; } out << '\n'; } }
virtual void visitBlockNode(BlockNode * node) { if (currentTabNum >= 0) { out<< "{"<< endl; } ++currentTabNum; visitScope(node->scope()); for (size_t i = 0; i < node->nodes(); ++i) { addIndent(); AstNode * currentNode = node->nodeAt(i); currentNode->visit(this); if (currentNode->isCallNode() || currentNode->isLoadNode() || currentNode->isNativeCallNode() || currentNode->isPrintNode() || currentNode->isReturnNode() || currentNode->isStoreNode()) { out<< ";"<< endl; } } --currentTabNum; if (currentTabNum >= 0) { addIndent(); out<< "}"<< endl; } }
void TypeCheckerVisitor::visitStoreNode(StoreNode* node) { AstNode* value = node->value(); value->visit(this); const AstVar* var = node->var(); if (isAssignable(var->type(), getNodeType(value))) { setNodeType(node, var->type()); } else { setErrorMessage(node, "Bad type"); } }
void PrintVisitor::visitPrintNode(PrintNode *node) { cout << "print("; for (uint32_t i = 0; i < node->operands(); i++) { if (i > 0) cout << ", "; AstNode *pNode = node->operandAt(i); pNode->visit(this); } cout << ")"; lastSym = ')'; }
void ast_printer::visitPrintNode( PrintNode* node ) { stream_ << "print("; for (unsigned int i = 0; i < node->operands(); ++i) { if (i > 0) stream_ << ", "; AstNode *pNode = node->operandAt(i); pNode->visit(this); } stream_ << ")"; needSemicolon = true; }
void ASTAnalyzer::printBlock (BlockNode* node) { for (unsigned int i = 0; i < node->nodes(); ++i) { AstNode* innerNode = node->nodeAt(i); innerNode->visit(this); if (!innerNode->isIfNode() && !innerNode->isWhileNode() && !innerNode->isForNode()) { output << ';'; } output << '\n'; } }
void AstPrinter::visitIfNode(IfNode* node) { print ("if ("); node->ifExpr()->visit(this); print(")" ); node->thenBlock()->visit(this); AstNode* elseBlock = node->elseBlock(); if (elseBlock) { print(" else "); elseBlock->visit(this); } }
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(); }
void BytecodeGenerator::visitPrintNode(PrintNode * node) { for (size_t i = 0; i < node->operands(); i++) { AstNode *operand = node->operandAt(i); operand->visit(this); switch (TOSType) { case VT_INT: fBC->addInsn(BC_IPRINT); break; case VT_DOUBLE: fBC->addInsn(BC_DPRINT); break; case VT_STRING: fBC->addInsn(BC_SPRINT); break; default: throw BCGenerationException("Unknown type"); } } }
void insideBlock(BlockNode* node) { variableDeclaration(node->scope()); functionDeclaration(node->scope()); for (uint32_t i = 0; i < node->nodes(); i++) { indent(); AstNode* current = node->nodeAt(i); current->visit(this); if (current->isCallNode() || current->isBinaryOpNode() || current->isUnaryOpNode() || current->isStringLiteralNode() || current->isDoubleLiteralNode() || current->isIntLiteralNode() || current->isLoadNode()) _output << ";"; _output << endl; } }
void TypeCheckerVisitor::visitCallNode(CallNode* node) { uint32_t params_count = node->parametersNumber(); AstFunction* refFunc = _current_scope->lookupFunction(node->name(), true); bool matchesRefedFunction = (refFunc!= NULL) && (refFunc->parametersNumber() == params_count); for (uint32_t i = 0; i < params_count; i++) { AstNode* param = node->parameterAt(i); param->visit(this); if (matchesRefedFunction && !isAssignable(refFunc->parameterType(i), getNodeType(param))) { setErrorMessage(param, "Wrong type parameter"); } } if (matchesRefedFunction) { setNodeType(node, refFunc->returnType()); } else { setNodeType(node, VT_INVALID); } }
void TypeChecker::visitReturnNode(ReturnNode* node) { assert(_funs.size() != 0); VarType expectedRetType = _funs.top()->returnType(); AstNode* retExpr = node->returnExpr(); if(retExpr != 0) { retExpr->visit(this); VarType actualRetType = nodeType(retExpr); if(actualRetType != expectedRetType && !isIntDoublePair(actualRetType, expectedRetType)) { throw ExceptionWithPos(invalidRetExprTypeMsg(expectedRetType, actualRetType), node->position()); } } else if(expectedRetType != VT_VOID) { throw ExceptionWithPos(retExprExpectedMsg(), node->position()); } }
void SourceByASTPrinter::visitBlockNodeWithoutBraces(BlockNode *node){ Scope::VarIterator vIt(node->scope()); while(vIt.hasNext()) { AstVar *var = vIt.next(); cout<<typeToName(var->type())<<" "<< var->name()<< ";"<<endl; } Scope::FunctionIterator fIt(node->scope()); while(fIt.hasNext()) { fIt.next()->node()->visit(this); } int nodesNumber = node->nodes(); for (int i = 0; i < nodesNumber; ++i) { AstNode *nodeAt = node->nodeAt(i); nodeAt->visit(this); if(!nodeAt->isForNode() && !nodeAt->isIfNode() && !nodeAt->isWhileNode()) cout<<";"<<endl; } }
virtual void visitBlockNode(BlockNode *node) { bool topLevel = node->scope()->parent()->parent() == NULL; if (!topLevel) { out << "{" << endl; } printVars(node->scope()); for (uint32_t i = 0; i < node->nodes(); i++) { AstNode *currentNode = node->nodeAt(i); currentNode->visit(this); if (currentNode->isLoadNode() || currentNode->isStoreNode() || currentNode->isReturnNode() || currentNode->isCallNode() || currentNode->isNativeCallNode() || currentNode->isPrintNode()) { out << ";" << endl; } } if (!topLevel) { out << "}" << endl; } }
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(); }
void TypeCheckerVisitor::visitUnaryOpNode(UnaryOpNode* node) { AstNode* operand = node->operand(); operand->visit(this); setNodeType(node, getOperationResultType(node->kind(), operand)); }