public static void Test() { string test_dir = GetTestSuiteDir() + @"\formatter_tests"; string[] files = Directory.GetFiles(test_dir + @"\input", "*.pas"); StreamWriter log = new StreamWriter(test_dir + @"\output\log.txt", false, Encoding.GetEncoding(1251)); SyntaxTreeComparer stc = new SyntaxTreeComparer(); foreach (string s in files) { string Text = new StreamReader(s, System.Text.Encoding.GetEncoding(1251)).ReadToEnd(); List <Error> Errors = new List <Error>(); List <CompilerWarning> Warnings = new List <CompilerWarning>(); compilation_unit cu = CodeCompletionController.ParsersController.GetCompilationUnitForFormatter(s, Text, Errors, Warnings); if (Errors.Count == 0) { CodeFormatters.CodeFormatter cf = new CodeFormatters.CodeFormatter(2); Text = cf.FormatTree(Text, cu, 1, 1); StreamWriter sw = new StreamWriter(Path.Combine(test_dir + @"\output", Path.GetFileName(s)), false, Encoding.GetEncoding(1251)); sw.Write(Text); sw.Close(); Errors.Clear(); Warnings.Clear(); compilation_unit cu2 = CodeCompletionController.ParsersController.GetCompilationUnitForFormatter(Path.Combine(test_dir + @"\output", Path.GetFileName(s)), Text, Errors, Warnings); if (Errors.Count > 0) { for (int i = 0; i < Errors.Count; i++) { log.WriteLine(Errors[i].ToString()); } } else { try { stc.Compare(cu, cu2); } catch (Exception ex) { log.WriteLine("SyntaxTreeNotEquals " + s + Environment.NewLine); } } } } files = Directory.GetFiles(test_dir + @"\output", "*.pas"); foreach (string s in files) { string Text = new StreamReader(s, System.Text.Encoding.GetEncoding(1251)).ReadToEnd(); List <Error> Errors = new List <Error>(); List <CompilerWarning> Warnings = new List <CompilerWarning>(); compilation_unit cu = CodeCompletionController.ParsersController.GetCompilationUnitForFormatter(s, Text, Errors, Warnings); CodeFormatters.CodeFormatter cf = new CodeFormatters.CodeFormatter(2); string Text2 = cf.FormatTree(Text, cu, 1, 1); if (Text != Text2) { log.WriteLine("Inavlid formatting of File " + s); } } log.Close(); }
public static Control NewControl(Model model, object o) { IHasCoordinate ihc = (IHasCoordinate)o; TextBox rtb = new TextBox(); rtb.Multiline = true; rtb.ScrollBars = ScrollBars.Both; rtb.WordWrap = false; rtb.HideSelection = false; ILTextView stv = new ILTextView(model, rtb); if (ihc is AST) { AST p = (AST)ihc; while (p.parent != null && p.parent.begin.file == ihc.begin.file && !(p is compilation_unit)) { p = p.parent; } stv.ASTRoot = p; if (stv.ASTRoot is compilation_unit) { compilation_unit c = (compilation_unit)stv.ASTRoot; Tracking tracking = new Tracking(); tracking_ilgen ti = new tracking_ilgen(tracking, c); tracking.tracked = ti; stv.tracking = ti.create(c); stv.Text = stv.tracking.Text; } } rtb.MouseUp += new MouseEventHandler(stv.Select); stv.ObjectChanged(); return(rtb); }
public compilation_unit ParseOnlySyntaxTree(string FileName, string Text) { List <Error> ErrorsList = new List <Error>(); List <CompilerWarning> Warnings = new List <CompilerWarning>(); compilation_unit cu = ParsersControllerGetCompilationUnit(FileName, Text, ErrorsList, Warnings); return(cu); }
void compilation_unit(compilation_unit ast, ArrayList list) { foreach (declaration x in ast.declarations) { declaration(x, list); } ast.declarations = Sort(list); }
public ReferenceFinder1(expression expr, ScopeSyntax scope, compilation_unit cu, string new_val) { this.expr = expr; this.cu = cu; global = scope; current = cu; this.new_val = new_val; }
internal compilation_unit ParsersControllerGetCompilationUnitSpecial(string FileName, string Text, List <Error> ErrorsList, List <CompilerWarning> Warnings) { string ext = Path.GetExtension(FileName); Parser = ParsersController.selectParser(ext.ToLower()); parsers[ext] = Parser; compilation_unit cu = null; cu = ParsersController.GetCompilationUnitSpecial(FileName, Text, ErrorsList, Warnings); //ParsersController.GetExpression("test.pas","a+b",new List<PascalABCCompiler.Errors.Error>()); return(cu); }
virtual public void compilation_unit(compilation_unit ast, int indent) { foreach (using_directive u in ast.using_directives) { visit(u, indent); } EmitattributeSectionList(ast.attributes, indent); foreach (declaration d in ast.declarations) { WriteLine(""); visit(d, indent); } }
public void CompileImplementation(PascalSharp.Internal.TreeConverter.TreeRealization.common_unit_node SemanticUnit, compilation_unit SyntaxUnit, PascalSharp.Internal.TreeConverter.TreeRealization.unit_node_list UsedUnits, List <Error> ErrorsList, List <CompilerWarning> WarningsList, SyntaxError parser_error, System.Collections.Hashtable bad_nodes, using_namespace_list interface_namespaces, using_namespace_list imlementation_namespaces, Dictionary <syntax_tree_node, string> docs, bool debug, bool debugging) { //if (ErrorsList.Count>0) throw ErrorsList[0]; stv.parser_error = parser_error; stv.bad_nodes_in_syntax_tree = bad_nodes; stv.referenced_units = UsedUnits; stv.using_list.clear(); stv.using_list.AddRange(interface_namespaces); stv.interface_using_list.AddRange(interface_namespaces); stv.using_list.AddRange(imlementation_namespaces); stv.ErrorsList = ErrorsList; stv.WarningsList = WarningsList; stv.SymbolTable.CaseSensitive = SemanticRules.SymbolTableCaseSensitive; if (docs != null) { stv.docs = docs; } stv.debug = debug; stv.debugging = debugging; SystemLibrary.syn_visitor = stv; SetSemanticRules(SyntaxUnit); unit_module umod = SyntaxUnit as unit_module; if (umod == null) { throw new PascalSharp.Internal.TreeConverter.CompilerInternalError("Program has not implementation part"); } //TODO: Переделать, чтобы Сашин код работал с common_unit_node. stv.compiled_unit = (PascalSharp.Internal.TreeConverter.TreeRealization.common_unit_node)SemanticUnit; stv.current_document = new document(SyntaxUnit.file_name); foreach (compiler_directive cd in umod.compiler_directives) { cd.visit(stv); } stv.visit_implementation(umod); //stv.visit(SyntaxUnit); //return stv.compiled_unit; }
private static List <Position> FindPositions(string expr, string name, string fileName, int line, int column, string new_val) { string text = File.ReadAllText(fileName); PascalABCNewLanguageParser parser = new PascalABCNewLanguageParser(); compilation_unit cu = parser.BuildTreeInNormalMode(fileName, text) as compilation_unit; expression e = parser.BuildTreeInExprMode(fileName, expr) as expression; var cv = CollectLightSymInfoVisitor.New; cv.ProcessNode(cu); var rf1 = new ReferenceFinder1(e, cv.Root, cu, new_val); rf1.FindPositions(name, line, column, cu); return(rf1.Positions); }
public Dictionary <syntax_tree_node, string[]> Bind(compilation_unit cu, string Text) { this.Text = Text; string[] lines = Text.Split('\n'); line_lens = new int[lines.Length]; for (int i = 0; i < lines.Length; i++) { if (i > 0) { line_lens[i] = lines[i].Length + line_lens[i - 1] + 1; } else { line_lens[i] = lines[i].Length + 1; } } cu.visit(this); return(comment_table); }
private ScopeSyntax FindDefInUnit(string unitName) { string dir = Path.GetDirectoryName(global.Pos.file_name); string fname = $"{dir}{Path.DirectorySeparatorChar}{unitName}.pas"; if (!File.Exists(fname)) { return(null); } string fcontent = File.ReadAllText(fname); PascalABCNewLanguageParser parser = new PascalABCNewLanguageParser(); compilation_unit cu = parser.BuildTreeInNormalMode(fname, fcontent) as compilation_unit; var cv = CollectLightSymInfoVisitor.New; cv.ProcessNode(cu); ScopeSyntax d = null; var dn = expr as dot_node; if (dn != null) { GotoIdentByLocation(name, line, column, this.cu); d = FindDef(current, name, cv.Root, unitName); } else if (cv.Root.Symbols.Any(s => s.Id.name == name)) { d = cv.Root; } if (d is TypeScopeSyntax && !(d.Symbols.First(s => s.Id.name == name) .Attr.HasFlag(Attributes.public_attr))) { d = null; } return(d); }
void SetSemanticRules(compilation_unit SyntaxUnit) { SemanticRules.ClassBaseType = SystemLibrary.object_type; SemanticRules.StructBaseType = SystemLibrary.value_type; switch (SyntaxUnit.Language) { case LanguageId.PascalABCNET: SemanticRules.AddResultVariable = true; SemanticRules.NullBasedStrings = false; SemanticRules.FastStrings = false; SemanticRules.InitStringAsEmptyString = true; SemanticRules.UseDivisionAssignmentOperatorsForIntegerTypes = false; SemanticRules.ManyVariablesOneInitializator = false; SemanticRules.OrderIndependedMethodNames = true; SemanticRules.OrderIndependedFunctionNames = false; SemanticRules.OrderIndependedTypeNames = false; SemanticRules.EnableExitProcedure = true; SemanticRules.StrongPointersTypeCheckForDotNet = true; SemanticRules.AllowChangeLoopVariable = false; SemanticRules.AllowGlobalVisibilityForPABCDll = true; break; case LanguageId.C: SemanticRules.AddResultVariable = false; SemanticRules.NullBasedStrings = true; SemanticRules.InitStringAsEmptyString = false; SemanticRules.UseDivisionAssignmentOperatorsForIntegerTypes = true; SemanticRules.ManyVariablesOneInitializator = false; SemanticRules.OrderIndependedMethodNames = false; SemanticRules.OrderIndependedFunctionNames = false; SemanticRules.OrderIndependedTypeNames = false; SemanticRules.EnableExitProcedure = false; SemanticRules.StrongPointersTypeCheckForDotNet = false; SemanticRules.AllowGlobalVisibilityForPABCDll = false; break; } }
public DomConverter Compile(string FileName, string Text) { this.Text = Text; this.FileName = FileName; List <Error> ErrorsList = new List <Error>(); List <CompilerWarning> Warnings = new List <CompilerWarning>(); compilation_unit cu = null; string ext = Path.GetExtension(FileName); try { cu = ParsersControllerGetCompilationUnit(FileName, Text, ErrorsList, Warnings); ErrorsList.Clear(); documentation_comment_list dt = ParsersController.Compile(System.IO.Path.ChangeExtension(FileName, get_doctagsParserExtension(ext)), Text /*+")))));end."*/, ErrorsList, Warnings, ParseMode.Normal) as documentation_comment_list; DocumentationConstructor docconst = new DocumentationConstructor(); if (cu != null) { docs = docconst.Construct(cu, dt); } } catch (Exception e) { #if DEBUG File.AppendAllText("log.txt", e.Message + Environment.NewLine + e.StackTrace + Environment.NewLine); #endif } DomConverter dconv = new DomConverter(this); if (cu != null) { NetHelper.reset(); dconv.ConvertToDom(cu); } else { ErrorsList.Clear(); Warnings.Clear(); try { //cu = ParsersController.GetComilationUnit(FileName, Text+")))));end.",comp.CompilerOptions.ParserSearchPatchs,ErrorsList); //cu = ParsersControllerGetComilationUnit(FileName, get_temp_text(Text), ErrorsList, true); string tmp = ParsersHelper.GetModifiedProgramm(Text); if (tmp != null) { cu = ParsersControllerGetCompilationUnitSpecial(FileName, tmp, ErrorsList, Warnings); } if (comp_modules[FileName] == null) { if (cu == null) { cu = get_fictive_unit(Text, FileName); } } ErrorsList.Clear(); documentation_comment_list dt = ParsersController.Compile(System.IO.Path.ChangeExtension(FileName, get_doctagsParserExtension(ext)), Text + ")))));end.", ErrorsList, Warnings, ParseMode.Normal) as documentation_comment_list; DocumentationConstructor docconst = new DocumentationConstructor(); if (cu != null) { docs = docconst.Construct(cu, dt); } } catch (Exception e) { #if DEBUG File.AppendAllText("log.txt", e.Message + Environment.NewLine + e.StackTrace + Environment.NewLine); #endif } if (cu != null) { NetHelper.reset(); dconv.ConvertToDom(cu); } } if (docs != null) { docs.Clear(); } //if (dconv.is_compiled) comp_modules[FileName]=dconv; return(dconv); //ConvertToDom(cu); }
public override void visit(compilation_unit _compilation_unit) { }
public virtual void visit(compilation_unit _compilation_unit) { DefaultVisit(_compilation_unit); }
public virtual void post_do_visit(compilation_unit _compilation_unit) { }
public override void visit(compilation_unit _compilation_unit) { DefaultVisit(_compilation_unit); pre_do_visit(_compilation_unit); for (int i = 0; i < compiler_directives.Count; i++) visit(compilation_unit.compiler_directives[i]); post_do_visit(_compilation_unit); }
public override void visit(compilation_unit _compilation_unit) { prepare_collection(_compilation_unit.compiler_directives, "compiler_directives"); }
public tracking_ilgen(Tracking w, compilation_unit c) : base(w, c) { tracking = w; }
public virtual void visit(compilation_unit _compilation_unit) { }
public override void visit(compilation_unit _compilation_unit) { executer.visit(_compilation_unit); if (_compilation_unit.compiler_directives != null) foreach (dynamic x in _compilation_unit.compiler_directives) if(x != null) this.visit(x); }
public DomConverter CompileAllIfNeed(string FileName, bool parse_only_interface = false) { this.FileName = FileName; this.Text = comp.GetSourceFileText(FileName); string ext = Path.GetExtension(FileName); List <Error> ErrorsList = new List <Error>(); List <CompilerWarning> Warnings = new List <CompilerWarning>(); compilation_unit cu = null; if (Text != null) { cu = ParsersController.GetCompilationUnit(FileName, Text, ErrorsList, Warnings); } Parser = ParsersController.selectParser(Path.GetExtension(FileName).ToLower()); ErrorsList.Clear(); Warnings.Clear(); documentation_comment_list dt = ParsersController.Compile(System.IO.Path.ChangeExtension(FileName, get_doctagsParserExtension(ext)), Text, ErrorsList, Warnings, ParseMode.Normal) as documentation_comment_list; DocumentationConstructor docconst = new DocumentationConstructor(); if (cu != null) { docs = docconst.Construct(cu, dt); } DomConverter dconv = new DomConverter(this); dconv.visitor.parse_only_interface = parse_only_interface; if (XmlDoc.LookupLocalizedXmlDocForUnitWithSources(FileName, CodeCompletionController.currentLanguageISO) != null) { dconv.visitor.add_doc_from_text = false; } if (cu != null) { dconv.ConvertToDom(cu); } else { ErrorsList.Clear(); Warnings.Clear(); //cu = ParsersControllerGetComilationUnit(FileName, Text, ErrorsList, true); if (comp_modules[FileName] == null) { string tmp = ParsersHelper.GetModifiedProgramm(Text); if (tmp != null) { cu = ParsersControllerGetCompilationUnitSpecial(FileName, tmp, ErrorsList, Warnings); ErrorsList.Clear(); } if (cu == null) { cu = get_fictive_unit(Text, FileName); } } ErrorsList.Clear(); Warnings.Clear(); dt = ParsersController.Compile(System.IO.Path.ChangeExtension(FileName, get_doctagsParserExtension(ext)), Text, ErrorsList, Warnings, ParseMode.Normal) as documentation_comment_list; if (cu != null) { docs = docconst.Construct(cu, dt); } if (XmlDoc.LookupLocalizedXmlDocForUnitWithSources(FileName, CodeCompletionController.currentLanguageISO) != null) { dconv.visitor.add_doc_from_text = false; } if (cu != null) { dconv.ConvertToDom(cu); } } if (dconv.is_compiled) { comp_modules[FileName] = dconv; } if (docs != null) { docs.Clear(); } //comp_modules[FileName] = dconv; // GC.Collect(); return(dconv); }
public override void visit(compilation_unit _compilation_unit) { throw new NotImplementedException(); }
//TODO: Исправить коллекцию модулей. public PascalSharp.Internal.TreeConverter.TreeRealization.common_unit_node CompileInterface(compilation_unit SyntaxUnit, PascalSharp.Internal.TreeConverter.TreeRealization.unit_node_list UsedUnits, List <Error> ErrorsList, List <CompilerWarning> WarningsList, SyntaxError parser_error, System.Collections.Hashtable bad_nodes, using_namespace_list namespaces, Dictionary <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 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.syn_visitor = stv; SetSemanticRules(SyntaxUnit); foreach (var 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 PascalSharp.Internal.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 Tracking create(compilation_unit c) { this.compilation_unit(c); return(tracking); }
public virtual void compilation_unit(compilation_unit ast) { declarationList(ast.declarations); }