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 virtual void visit(compilation_unit _compilation_unit)
{
DefaultVisit(_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();
}
public virtual void visit(compilation_unit _compilation_unit)
{
}
//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);
}
