public void Replace(syntax_tree_node from, syntax_tree_node to)
{
var upper = UpperNode();
if (upper == null)
{
throw new Exception("У корневого элемента нельзя получить UpperNode");
}
upper.ReplaceDescendant(from, to);
}
public override syntax_tree_node BuildTreeInTypeExprMode(string FileName, string Text)
{
// LineCorrection = -1 не забыть
Text = String.Concat("<<type>>", Environment.NewLine, Text);
localparserhelper = new GPPGParserHelper(Errors, Warnings, FileName);
// localparser.parsertools.LineCorrection = -1;
syntax_tree_node root = localparserhelper.Parse(Text);
return(root as expression);
}
public typecast_node NewAsIsExpr(syntax_tree_node term, op_typecast typecast_op, type_definition simple_or_template_type_reference, LexLocation loc)
{
var naie = new typecast_node((addressed_value)term, simple_or_template_type_reference, typecast_op, loc);
if (!(term is addressed_value))
{
parsertools.errors.Add(new bad_operand_type(parsertools.CurrentFileName, term.source_context, naie));
}
return(naie);
}
public SyntaxError(string Message, string fileName, PascalABCCompiler.SyntaxTree.SourceContext _source_context, PascalABCCompiler.SyntaxTree.syntax_tree_node _bad_node)
: base(Message, fileName)
{
source_context = _source_context;
if (source_context != null && source_context.FileName != null)
{
base.fileName = source_context.FileName;
}
bad_node = _bad_node;
}
public override void Enter(syntax_tree_node st)
{
base.Enter(st);
countNodesVisited++;
// сокращение обходимых узлов. Как сделать фильтр по тем узлам, которые необходимо обходить? Например, все операторы (без выражений и описаний), все описания (без операторов)
if (st is assign || st is var_def_statement || st is procedure_call || st is procedure_header || st is expression)
{
visitNode = false; // фильтр - куда не заходить
}
}
/*public procedure_definition NewProcDecl(procedure_definition proc_decl_noclass, LexLocation loc)
* {
* (proc_decl_noclass.proc_header as procedure_header).class_keyword = true;
* proc_decl_noclass.source_context = loc;
* return proc_decl_noclass;
* }*/
public case_variants NewCaseItem(syntax_tree_node case_item, LexLocation loc)
{
var nci = new case_variants();
if (case_item is case_variant)
{
nci.Add((case_variant)case_item);
}
nci.source_context = loc;
return(nci);
}
public override void DefaultVisit(syntax_tree_node node)
{
if (node is T)
{
foundT = true;
}
else
{
base.DefaultVisit(node);
}
}
public case_variants AddCaseItem(case_variants case_list, syntax_tree_node case_item, LexLocation loc)
{
var nci = case_list;
if (case_item is case_variant)
{
nci.Add((case_variant)case_item);
}
nci.source_context = loc;
return(nci);
}
public ScopeClassDefinition(syntax_tree_node syntaxTreeNode,
type_declaration classDeclaration,
CapturedVariablesTreeNode correspondingTreeNode,
string generatedSubstitutingFieldName = null)
{
CorrespondingSyntaxTreeNode = syntaxTreeNode;
ClassDeclaration = classDeclaration;
_generatedSubstitutingFieldName = generatedSubstitutingFieldName;
CorrespondingTreeNode = correspondingTreeNode;
NestedLambdas = new List <CapturedVariablesTreeNodeLambdaScope>();
}
public override void Enter(syntax_tree_node st)
{
base.Enter(st);
if (!(st is procedure_definition || st is block || st is statement_list ||
st.GetType() == typeof(case_node) || st.GetType() == typeof(for_node) || st.GetType() == typeof(foreach_stmt) ||
st.GetType() == typeof(if_node) ||
st.GetType() == typeof(repeat_node) || st.GetType() == typeof(while_node) ||
st.GetType() == typeof(with_statement) || st is try_stmt || st.GetType() == typeof(lock_stmt)))
{
//visitNode = false;
}
}
public override void Enter(syntax_tree_node st)
{
base.Enter(st);
if (st is procedure_definition || st is class_definition)
{
list.Add(st as declaration);
if (PrintInfo)
{
Console.Write("+: " + st.GetType().Name);
}
}
}
public override void Exit(syntax_tree_node st)
{
if (st is procedure_definition || st is class_definition)
{
if (PrintInfo)
{
Console.WriteLine("-: " + st.GetType().Name);
}
list.RemoveAt(list.Count - 1);
}
base.Exit(st);
}
public syntax_tree_node Convert(syntax_tree_node root)
{
// Прошивание ссылками на Parent nodes. Должно идти первым
// FillParentNodeVisitor расположен в SyntaxTree/tree как базовый визитор, отвечающий за построение дерева
FillParentNodeVisitor.New.ProcessNode(root);
// Выносим выражения с лямбдами из заголовка foreach
StandOutExprWithLambdaInForeachSequenceVisitor.New.ProcessNode(root);
//--- Обработка синтаксически сахарных узлов
// loop
LoopDesugarVisitor.New.ProcessNode(root);
// tuple_node
TupleVisitor.New.ProcessNode(root);
// assign_tuple и assign_var_tuple
AssignTuplesDesugarVisitor.New.ProcessNode(root);
// slice_expr и slice_expr_question
SliceDesugarVisitor.New.ProcessNode(root);
// question_point_desugar_visitor
QuestionPointDesugarVisitor.New.ProcessNode(root);
// double_question_desugar_visitor
DoubleQuestionDesugarVisitor.New.ProcessNode(root);
// Всё, связанное с yield
MarkMethodHasYieldAndCheckSomeErrorsVisitor.New.ProcessNode(root);
ProcessYieldCapturedVarsVisitor.New.ProcessNode(root);
#if DEBUG
/*var cv = CollectLightSymInfoVisitor.New;
* cv.ProcessNode(root);
* cv.Output(@"Light1.txt");*/
/*try
* {
* //root.visit(new SimplePrettyPrinterVisitor(@"d:\\zzz4.txt"));
* }
* catch
* {
*
* }*/
#endif
return(root);
}
public T UpperTo <T>() where T : syntax_tree_node
{
syntax_tree_node upperNode = null;
int up = 1;
do
{
upperNode = UpperNode(up);
++up;
}while ((object)upperNode != null && !(upperNode is T));
return((object)upperNode != null ? upperNode as T : null);
}
public override PascalABCCompiler.SyntaxTree.syntax_tree_node BuildTree(string FileName, string Text, ParseMode ParseMode, List <string> DefinesList = null)
{
syntax_tree_node root = null;
PreBuildTree(FileName);
switch (ParseMode)
{
case ParseMode.Normal:
root = BuildTreeInNormalMode(FileName, Text, DefinesList);
break;
case ParseMode.Expression:
root = BuildTreeInExprMode(FileName, Text);
break;
case ParseMode.TypeAsExpression:
root = BuildTreeInTypeExprMode(FileName, Text);
break;
case ParseMode.Special:
root = BuildTreeInSpecialMode(FileName, Text);
break;
case ParseMode.ForFormatter:
root = BuildTreeInFormatterMode(FileName, Text);
break;
case ParseMode.Statement:
root = BuildTreeInStatementMode(FileName, Text);
break;
default:
break;
}
if (root != null && root is compilation_unit)
{
(root as compilation_unit).file_name = FileName;
(root as compilation_unit).compiler_directives = CompilerDirectives;
if (root is unit_module)
{
if ((root as unit_module).unit_name.HeaderKeyword == UnitHeaderKeyword.Library)
{
(root as compilation_unit).compiler_directives.Add(new compiler_directive(new token_info("apptype"), new token_info("dll")));
}
}
}
return(root);
}
public void visit_yield_helper(syntax_tree_node yn)
{
procedure_definition pd = null;
if (MethodsStack.Count > 0)
{
pd = MethodsStack.Peek();
}
if (pd == null)
{
throw new SyntaxVisitorError("ONLY_FUNCTIONS_CAN_CONTAIN_YIELDS", yn.source_context);
}
var fh = (pd.proc_header as function_header);
if (fh == null)
{
throw new SyntaxVisitorError("ONLY_FUNCTIONS_CAN_CONTAIN_YIELDS", pd.proc_header.source_context);
}
var seqt = fh.return_type as sequence_type;
if (seqt == null)
{
throw new SyntaxVisitorError("YIELD_FUNC_MUST_RETURN_SEQUENCE", fh.source_context);
}
if (seqt.elements_type is procedure_header || seqt.elements_type is function_header)
{
throw new SyntaxVisitorError("YIELD_FUNC_CANNOT_RETURN_SEQUENCE_OF_ANONYMOUS_DELEGATES", fh.source_context);
}
var pars = fh.parameters;
if (pars != null)
{
foreach (var ps in pars.params_list)
{
if (ps.param_kind != parametr_kind.none)
{
throw new SyntaxVisitorError("FUNCTIONS_WITH_YIELDS_CANNOT_CONTAIN_VAR_CONST_PARAMS_MODIFIERS", pars.source_context);
}
if (ps.inital_value != null)
{
throw new SyntaxVisitorError("FUNCTIONS_WITH_YIELDS_CANNOT_CONTAIN_DEFAULT_PARAMETERS", pars.source_context);
}
}
}
HasYields = true;
}
private PatternLocation GetLocation(syntax_tree_node node)
{
var firstStatement = GetAscendant <statement>(node);
switch (firstStatement)
{
case if_node _: return(PatternLocation.IfCondition);
case var_statement _: return(PatternLocation.Assign);
case assign _: return(PatternLocation.Assign);
default: return(PatternLocation.Unknown);
}
}
public compilation_unit GetCompilationUnitForFormatter(string FileName, string Text, List <Error> Errors, List <CompilerWarning> Warnings)
{
syntax_tree_node cu = Compile(FileName, Text, Errors, Warnings, ParseMode.ForFormatter);
if (cu == null)
{
return(null);
}
if (cu is compilation_unit)
{
return(cu as compilation_unit);
}
Errors.Add(new UnexpectedNodeType(FileName, cu.source_context, null));
return(null);
}
public override void Exit(syntax_tree_node st)
{
if (st is procedure_definition)
{
if (mids.vars.Count > 0)
{
d[st as procedure_definition] = new HashSet <string>(mids.vars);
}
var fld = new FindLocalDefsVisitor();
st.visit(fld);
fld.Print();
var t = fld.ids.Intersect(mids.vars); // идентификаторы, захваченные из локального контекста
}
base.Exit(st);
}
public statement GetStatement(string FileName, string Text, List <Error> Errors, List <CompilerWarning> Warnings)
{
syntax_tree_node cu = Compile(FileName, Text, Errors, Warnings, ParseMode.Statement);
if (cu == null)
{
return(null);
}
if (cu is statement)
{
return(cu as statement);
}
Errors.Add(new UnexpectedNodeType(FileName, cu.source_context, null));
return(null);
//throw new Errors.CompilerInternalError("Parsers.Controller.GetComilationUnit", new Exception("bad node type"));
}
public while_node NewWhileStmt(token_info tkWhile, expression expr, token_info opt_tk_do, statement stmt, LexLocation loc)
{
var nws = new while_node(expr, stmt, WhileCycleType.While, loc);
if (opt_tk_do == null)
{
file_position fp = expr.source_context.end_position;
syntax_tree_node err_stn = stmt;
if (err_stn == null)
{
err_stn = expr;
}
parsertools.errors.Add(new PABCNETUnexpectedToken(parsertools.CurrentFileName, StringResources.Get("TKDO"), new SourceContext(fp.line_num, fp.column_num + 1, fp.line_num, fp.column_num + 1, 0, 0), err_stn));
}
return(nws);
}
public override void DefaultVisit(syntax_tree_node n)
{
// Элементы списков - с конца в начало чтобы можно было эти элементы изменять по ходу (удалять/вставлять/заменять один несколькими)
var Сount = n.subnodes_count;
var СountWithoutListElements = n.subnodes_without_list_elements_count;
for (var i = 0; i < СountWithoutListElements; i++)
{
ProcessNode(n[i]);
}
for (var i = Сount - 1; i >= СountWithoutListElements; i--) // в обратном порядке
{
ProcessNode(n[i]);
}
}
public override void Enter(syntax_tree_node st)
{
base.Enter(st);
countNodesVisited++;
if (st is procedure_definition)
{
// пока вложенные процедуры не анализируются, хотя надо
mids.vars.Clear();
}
// сокращение обходимых узлов. Как сделать фильтр по тем узлам, которые необходимо обходить? Например, все операторы (без выражений и описаний), все описания (без операторов)
if (st is assign || st is var_def_statement || st is procedure_call || st is procedure_header || st is expression)
{
visitNode = false;
}
}
public override void visit(index ind)
{
var indexCreation =
new method_call(
new dot_node(
new ident("SystemIndex", ind.source_context),
new ident("Create", ind.source_context),
ind.source_context),
new expression_list(
new List<expression>()
{
ind.index_expr,
new bool_const(ind.inverted, ind.source_context)
},
ind.source_context),
ind.source_context);
syntax_tree_node mc = null;
var possibleIndexer = ind.Parent?.Parent;
if (possibleIndexer != null && possibleIndexer is indexer indexer)
{
// Надо подняться до узла indexer и запомнить индекс, под которым данный index входит
// Идём по Parent - и смотрим, когда Parent = indexer
// Находим у него expressions и ищем, под каким индексом в нем содержится текущий.
// Запоминаем это целое число и передаем его последним параметром в Reverse если expressions.Count > 1
expression_list reverseIndexMethodParams = null;
if (indexer.indexes.expressions.Count == 1)
reverseIndexMethodParams = new expression_list(indexer.dereferencing_value, ind.source_context);
else
{
var i = indexer.indexes.expressions.FindIndex(x => x == ind);
if (i >= 0)
reverseIndexMethodParams = new expression_list(new List<expression> { indexer.dereferencing_value, new int32_const(i) }, ind.source_context);
}
mc = new method_call(
new dot_node(indexCreation, new ident("Reverse", ind.source_context)),
reverseIndexMethodParams,
ind.source_context);
}
else // Это непонятная ветка. Она наступает в частности если индексер не находится на 2 уровня выше, что бывает в случае индекса вида a[1..^1]
{
mc = indexCreation;
}
//var sug = new sugared_expression(ind, mc, ind.source_context);
ReplaceUsingParent(ind, mc);
visit(mc);
}
private T GetAscendant <T>(syntax_tree_node node)
where T : syntax_tree_node
{
var current = node.Parent;
while (current != null)
{
if (current is T res)
{
return(res);
}
current = current.Parent;
}
return(null);
}
public syntax_tree_node Convert(syntax_tree_node root)
{
root.visit(new MarkMethodHasYieldAndCheckSomeErrorsVisitor());
ProcessYieldCapturedVarsVisitor.New.ProcessNode(root);
#if DEBUG
try
{
//root.visit(new SimplePrettyPrinterVisitor(@"d:\\zzz1.txt"));
}
catch
{
}
#endif
return(root);
}
public virtual void Exit(syntax_tree_node st)
{
if (st is statement_list)
{
off -= 2;
Println("end");
}
else if (st is while_node || st is if_node || st is type_declarations || st is variable_definitions || st is case_variant)
{
off -= 2;
}
else if (st is class_definition || st is case_node)
{
off -= 2;
Println("end;");
}
}
public syntax_tree_node BuildTree(string FileName, string Text, ParseMode ParseMode)
{
//if (parser == null)
Reset();
GPPGParser.current_file_name = FileName;
GPPGParser.CompilerDirectives = compilerDirectives;
Scanner scn = new Scanner();
scn.SetSource(Text, 0);
parser.scanner = scn;
bool b = parser.Parse();
if (!b)
{
// if we can't recognize error :( or brain.dll not loaded
Errors.ErrorMsg err = new Errors.ErrorMsg(GPPGParser.current_file_name, new SourceContext(0, 0, 0, 0), "PROGRAM_ERROR");
GPPGParser.errors.Add(err);
}
Errors = GPPGParser.errors;
syntax_tree_node cu = null;
switch (ParseMode)
{
case ParseMode.Normal:
cu = GPPGParser.CompilationUnit;
break;
case ParseMode.Expression:
case ParseMode.Statement:
return(null);
}
if (cu != null && cu is compilation_unit)
{
(cu as compilation_unit).file_name = FileName;
(cu as compilation_unit).compiler_directives = CompilerDirectives;
}
return(cu);
}
public override void Exit(syntax_tree_node st)
{
switch (st)
{
case program_module p:
case procedure_definition pd:
case formal_parameters fp:
case statement_list stl:
case for_node f:
case foreach_stmt fe:
case class_definition cd:
case record_type rt:
case function_lambda_definition fld:
//case repeat_node rep:
case case_node cas:
Current = Current.Parent;
break;
}
}
public override void Enter(syntax_tree_node st)
{
if (d.ContainsKey(st.GetType()))
{
d[st.GetType()] += 1;
}
else
{
d[st.GetType()] = 1;
}
if (st is expression)
{
exprcount++;
}
if (st is statement)
{
statcount++;
}
}
public virtual void visit(syntax_tree_node _syntax_tree_node)
{
}
public virtual void visit(syntax_tree_node _syntax_tree_node)
{
DefaultVisit(_syntax_tree_node);
}
public override void visit(syntax_tree_node _syntax_tree_node)
{
executer.visit(_syntax_tree_node);
}
public override void visit(syntax_tree_node _syntax_tree_node)
{
DefaultVisit(_syntax_tree_node);
pre_do_visit(_syntax_tree_node);
post_do_visit(_syntax_tree_node);
}
public virtual void pre_do_visit(syntax_tree_node _syntax_tree_node)
{
}
public virtual void DefaultVisit(syntax_tree_node n)
{
}
