public expression_node visit(SyntaxTree.expression expr) { expr.visit(syntax_tree_visitor); /*addressed_expression ad = ret_semantic as addressed_expression; if (ad != null && ad.is_addressed) { if (convertion_data_and_alghoritms.check_for_constant(ad)) ad.is_addressed = false; }*/ //Надеюсь, это сильно не скажется на производительности, хотя в другом случае этот же код просто будет разбросан по всем метдам syntax_tree_visitor-а. base_function_call bfc = ret_semantic as base_function_call; if (bfc != null) { if (bfc.simple_function_node.compile_time_executor != null) { expression_node ex = bfc.simple_function_node.compile_time_executor(bfc.location, bfc.parameters.ToArray()); if (ex != null) { return ex; } } } return ret_semantic as expression_node; }
public void hard_node_test_and_visit(SyntaxTree.syntax_tree_node tn) { #if (DEBUG) // try // { if (tn == null) { throw new CompilerInternalError("This node can not be null"); } #endif convertion_data_and_alghoritms.check_node_parser_error(tn); if (is_direct_type_decl && !(tn is SyntaxTree.ref_type)) is_direct_type_decl = false; tn.visit(this); /*#if (DEBUG) } catch (Exception e) { if (tn != null) throw new Exception("" + tn.source_context.ToString() + System.Environment.NewLine + e.ToString()); else throw e; } #endif*/ }
public void weak_node_test_and_visit(SyntaxTree.syntax_tree_node tn) { if (tn != null) { convertion_data_and_alghoritms.check_node_parser_error(tn); tn.visit(this); } }
//TODO: Исправить коллекцию модулей. public PascalABCCompiler.TreeRealization.common_unit_node CompileInterface(SyntaxTree.compilation_unit SyntaxUnit, PascalABCCompiler.TreeRealization.unit_node_list UsedUnits, List<Errors.Error> ErrorsList, List<Errors.CompilerWarning> WarningsList, PascalABCCompiler.Errors.SyntaxError parser_error, System.Collections.Hashtable bad_nodes, TreeRealization.using_namespace_list namespaces, Dictionary<SyntaxTree.syntax_tree_node,string> docs, bool debug, bool debugging) { //convertion_data_and_alghoritms.__i = 0; stv.parser_error=parser_error; stv.bad_nodes_in_syntax_tree = bad_nodes; stv.referenced_units=UsedUnits; //stv.comp_units=UsedUnits; //stv.visit(SyntaxUnit //stv.interface_using_list = namespaces; stv.using_list.clear(); stv.interface_using_list.clear(); stv.using_list.AddRange(namespaces); stv.current_document = new TreeRealization.document(SyntaxUnit.file_name); stv.ErrorsList = ErrorsList; stv.WarningsList = WarningsList; stv.SymbolTable.CaseSensitive = SemanticRules.SymbolTableCaseSensitive; stv.docs = docs; stv.debug = debug; stv.debugging = debugging; SystemLibrary.SystemLibrary.syn_visitor = stv; SetSemanticRules(SyntaxUnit); foreach (SyntaxTree.compiler_directive cd in SyntaxUnit.compiler_directives) cd.visit(stv); stv.DirectivesToNodesLinks = CompilerDirectivesToSyntaxTreeNodesLinker.BuildLinks(SyntaxUnit, ErrorsList); //MikhailoMMX добавил передачу списка ошибок (02.10.10) SyntaxUnit.visit(stv); /*SyntaxTree.program_module pmod=SyntaxUnit as SyntaxTree.program_module; if (pmod!=null) { stv.visit(pmod); } else { SyntaxTree.unit_module umod=SyntaxUnit as SyntaxTree.unit_module; if (umod==null) { throw new PascalABCCompiler.TreeConverter.CompilerInternalError("Undefined module type (not program and not unit)"); } stv.visit(umod); }*/ //stv.visit(SyntaxUnit); //if (ErrorsList.Count>0) throw ErrorsList[0]; return stv.compiled_unit; }
public addressed_expression visit(SyntaxTree.addressed_value av) { av.visit(syntax_tree_visitor); return ret_semantic as addressed_expression; }
public type_node visit(SyntaxTree.type_definition type_def) { type_def.visit(syntax_tree_visitor); return ret_semantic as type_node; }
public statement_node visit(SyntaxTree.statement st) { st.visit(syntax_tree_visitor); return ret_semantic as statement_node; }
public semantic_node visit(SyntaxTree.syntax_tree_node tn) { tn.visit(syntax_tree_visitor); return ret_semantic; }