public statement_list CreateStatementList(params statement[] stmts)
{
statement_list res = new statement_list();
foreach (statement x in stmts)
{
res.Add(x);
}
return(res);
}
public static statement_list BuildSimpleAssignList(List <ident> lnames, List <ident> rnames)
{
var sl = new statement_list();
for (int i = 0; i < lnames.Count; i++)
{
sl.Add(new assign(lnames[i], rnames[i]));
}
return(sl);
}
public CapturedVariablesInfo BuildTree(statement_list statementList)
{
return(new CapturedVariablesInfo
{
RootNode = BuildTreeForStatementList(statementList),
IdentsReferences = _identsReferences,
CapturedVarsNodesDictionary = _scopesCapturedVarsNodesDictionary,
ProcedureScope = _procedureScope
});
}
private void get_with_statement(statement_list sl, ICSharpCode.NRefactory.Ast.WithStatement stmt)
{
with_statement with_stmt = new with_statement();
with_stmt.source_context = get_source_context(stmt);
with_stmt.do_with = new expression_list();
with_stmt.do_with.source_context = get_source_context(stmt.Expression);
with_stmt.do_with.expressions.Add(get_expression(stmt.Expression));
with_stmt.what_do = get_statement_list(stmt.Body);
sl.subnodes.Add(with_stmt);
}
public override void visit(statement_list _statement_list)
{
if (is_begin(_statement_list))
{
AddPossibleComments(_statement_list, true, false);
}
foreach (statement stmt in _statement_list.subnodes)
{
stmt.visit(this);
}
}
public override void visit(statement_list _statement_list)
{
executer.visit(_statement_list);
if (_statement_list.subnodes != null)
foreach (dynamic x in _statement_list.subnodes)
if(x != null)
this.visit(x);
if (_statement_list.left_logical_bracket != null)
this.visit((dynamic)_statement_list.left_logical_bracket);
if (_statement_list.right_logical_bracket != null)
this.visit((dynamic)_statement_list.right_logical_bracket);
if (_statement_list.attributes != null)
this.visit((dynamic)_statement_list.attributes);
}
private void get_var_statement(statement_list sl, ICSharpCode.NRefactory.Ast.LocalVariableDeclaration var)
{
foreach (ICSharpCode.NRefactory.Ast.VariableDeclaration vd in var.Variables)
{
var_def_statement vds = new var_def_statement();
vds.source_context = get_source_context(var);
vds.vars_type = get_type_reference(vd.TypeReference);
ident_list idents = new ident_list();
ident name = new ident(vd.Name);
name.source_context = get_source_context(var);
idents.idents.Add(name);
vds.vars = idents;
sl.subnodes.Add(new var_statement(vds));
}
}
public statement_list NewLambdaBody(expression expr_l1, LexLocation loc)
{
var sl = new statement_list();
sl.expr_lambda_body = true;
var id = new ident("result");
var op = new op_type_node(Operators.Assignment);
//_op_type_node.source_context = parsertools.GetTokenSourceContext();
var ass = new assign(id, expr_l1, op.type);
parsertools.create_source_context(ass, id, expr_l1);
sl.subnodes.Add(ass);
sl.source_context = loc;
return(sl);
}
public override void visit(statement_list stmtList)
{
var stl = new statements_list(syntaxTreeVisitor.get_location(stmtList),
syntaxTreeVisitor.get_location_with_check(stmtList.left_logical_bracket),
syntaxTreeVisitor.get_location_with_check(stmtList.right_logical_bracket));
syntaxTreeVisitor.convertion_data_and_alghoritms.statement_list_stack_push(stl);
if (stmtList.subnodes != null)
{
foreach (var stmt in stmtList.subnodes)
{
ProcessNode(stmt);
}
}
syntaxTreeVisitor.convertion_data_and_alghoritms.statement_list_stack.pop();
}
public override void visit(statement_list stmtList)
{
if (stmtList.IsInternal) // просто обойти как продолжение объемлющего statement_list
{
foreach (var stmt in stmtList.subnodes)
{
ProcessNode(stmt);
}
return;
}
var stl = new statements_list(_visitor.get_location(stmtList),
_visitor.get_location_with_check(stmtList.left_logical_bracket),
_visitor.get_location_with_check(stmtList.right_logical_bracket));
_visitor.convertion_data_and_alghoritms.statement_list_stack_push(stl);
var newTreeNode = new CapturedVariablesTreeNodeBlockScope(_currentTreeNode, stl.Scope.ScopeNum, stmtList);
if (_rootNode == null)
{
_rootNode = newTreeNode;
}
if (_currentTreeNode != null)
{
_currentTreeNode.ChildNodes.Add(newTreeNode);
}
_currentTreeNode = newTreeNode;
_scopesCapturedVarsNodesDictionary.Add(stl.Scope.ScopeNum, _currentTreeNode);
foreach (var csi in _pendingCapturedSymbols)
{
_currentTreeNode.VariablesDefinedInScope.Add(csi);
}
_pendingCapturedSymbols.Clear();
if (stmtList.subnodes != null)
{
foreach (var stmt in stmtList.subnodes)
{
ProcessNode(stmt);
}
}
_visitor.convertion_data_and_alghoritms.statement_list_stack.pop();
_currentTreeNode = _currentTreeNode.ParentNode;
}
public void Transform()
{
cas = new case_node(new ident(Consts.State));
curStatList = new statement_list();
case_variant cv = new case_variant(new expression_list(new int32_const(curState)), curStatList);
cas.conditions.variants.Add(cv);
foreach (var st in stl.subnodes)
{
Process(st);
}
stl.subnodes = BaseChangeVisitor.SeqStatements(cas, StatListAfterCase).ToList();
//statement_list res = new statement_list(cas);
res = stl;
}
public override void visit(loop_stmt loop)
{
// тут возможно ошибка более глубокая - в semantic_check_sugared_statement_node(asstup) возможно остаются во вложенных лямбдах другие assign_tuple
var sl = new statement_list();
sl.Add(new semantic_check_sugared_statement_node(typeof(loop_stmt), new List <syntax_tree_node> {
loop.count
}, loop.source_context));
var tname = "#loop_var" + UniqueNumStr();
var fn = new for_node(new ident(tname), new int32_const(1), loop.count, loop.stmt, loop.source_context);
sl.Add(fn);
ReplaceUsingParent(loop, sl);
visit(fn);
}
private static SyntaxTree.program_module InternalCreateProgramModule(statement_list statements, declarations defs)
{
block block = new block();
if (defs != null)
{
block.defs = defs;
}
statements.Add(new SyntaxTree.empty_statement());
statements.left_logical_bracket = new token_info("begin");
statements.right_logical_bracket = new token_info("end");
block.program_code = statements;
program_module res = new program_module();
res.program_block = block;
//res.used_units = create_standard_uses_list();
return(res);
}
/*
* // Scope Level 0
* begin
* var x = value; // Name in Scope Level 0
* // Scope Level 1
* begin
* var x = value; // Name in Scope Level 1 <-- REDEFENITION ERROR, x defined at Level 0
*
* var y = value;
* var y = value2; // Name in Scope Level 1 <-- REDEFINITION ERROR, y defined at Level 1
*
* // Scope Level 2
* begin
* var z = y; // Name in Scope Level 2
* end
* // Scope Level 2
* begin
* var z = value; // Name in Scope Level 2
* end
* end
*
* end
*/
public override void visit(statement_list stlist)
{
++CurrentLevel;
if (BlockNamesStack.Count <= CurrentLevel)
{
// Создаем множество имен для текущего уровня вложенности мини-пространства имен
BlockNamesStack.Add(new HashSet <string>());
}
base.visit(stlist);
//for (var i = 0; i < stlist.list.Count; ++i)
// ProcessNode(stlist.list[i]);
BlockNamesStack.RemoveAt(BlockNamesStack.Count - 1);
--CurrentLevel;
}
public void ReplaceStatement(statement from, IEnumerable <statement> to, Desc d = Desc.DirectDescendants)
{
foreach (var x in to)
{
x.Parent = from.Parent;
}
var sl = from.Parent as statement_list;
if (sl != null)
{
sl.ReplaceInList(from, to);
}
else
{
var l = new statement_list();
l.AddMany(to);
l.source_context = from.source_context;
from.Parent.ReplaceDescendant(from, l, d);
}
}
public override void visit(slice_expr sl)
{
var el = construct_expression_list_for_slice_expr(sl);
if (sl.Parent is assign parent_assign && parent_assign.to == sl)
{
el.Insert(0, parent_assign.from);
var mc = method_call.NewP(
dot_node.NewP(
sl.v,
new ident("SystemSliceAssignment", sl.v.source_context),
sl.v.source_context),
el, sl.source_context);
var systemSliceAssignmentCall = new procedure_call(mc, sl.source_context);
var typeCompatibilityCheck = GetAssignmentTypeCompatibilityCheck(sl, parent_assign.from, mc);
var checkAndDesugaredSliceBlock = new statement_list(typeCompatibilityCheck, systemSliceAssignmentCall);
checkAndDesugaredSliceBlock.source_context = sl.source_context;
ReplaceUsingParent(parent_assign, checkAndDesugaredSliceBlock);
visit(systemSliceAssignmentCall); // обойти заменённое на предмет наличия такого же синтаксического сахара
}
public override void visit(statement_list stlist)
{
++CurrentLevel;
if (BlockNamesStack.Count <= CurrentLevel)
{
// Создаем отображение для имен текущего уровня вложенности мини-пространства имен
BlockNamesStack.Add(new Dictionary <string, string>());
}
//base.visit(stlist);
for (var i = 0; i < stlist.list.Count; ++i)
{
ProcessNode(stlist.list[i]);
}
BlockNamesStack.RemoveAt(BlockNamesStack.Count - 1);
--CurrentLevel;
}
public void ReplaceStatementUsingParent(statement from, IEnumerable <statement> to, Desc d = Desc.DirectDescendants)
{
var fp = from.Parent; // SSM 02.10.18 - запомним, т.к. from.Parent может быть одним из x.Parent
//foreach (var x in to) // Это и так делается по обоим веткам!
// x.Parent = fp;
var sl = fp as statement_list;
if (sl != null)
{
sl.ReplaceInList(from, to);
}
else
{
var l = new statement_list();
l.AddMany(to);
l.source_context = from.source_context;
fp.ReplaceDescendant(from, l, d);
l.Parent = fp; // на всякий случай
}
}
public void ReplaceStatementUsingParent(statement from, IEnumerable <statement> to, Desc d = Desc.DirectDescendants)
{
var fp = from.Parent; // SSM 02.10.18 - запомним, т.к. from.Parent может быть одним из x.Parent
foreach (var x in to)
{
x.Parent = fp;
}
var sl = fp as statement_list;
if (sl != null)
{
sl.ReplaceInList(from, to);
}
else
{
var l = new statement_list();
l.AddMany(to);
l.source_context = from.source_context;
fp.ReplaceDescendant(from, l, d);
}
}
public virtual statement_list GetStatements(object _object)
{
statement_list _statement_list;
if (_object is statement_list)
{
_statement_list = _object as statement_list;
}
else
{
_statement_list = new statement_list();
if (_object is statement)
{
_statement_list.subnodes.Add(_object as statement);
}
else
{
_statement_list.subnodes.Add(new empty_statement());
}
}
return(_statement_list);
}
public override void visit(while_node wn)
{
ProcessNode(wn.statements);
var gt1 = new goto_statement(newLabelName());
var gt2 = new goto_statement(newLabelName());
var gt3 = new goto_statement(newLabelName());
var if0 = new if_node(wn.expr, gt1, null);
var lb3 = new labeled_statement(gt3.label, if0);
var lb1 = new labeled_statement(gt1.label, wn.statements);
var lb2 = new labeled_statement(gt2.label, new empty_statement());
var stl = new statement_list(lb3, gt2, lb1, gt3, lb2);
Replace(wn, stl);
// в declarations ближайшего блока добавить описание labels
block bl = listNodes.FindLast(x => x is block) as block;
var ld = new label_definitions(gt1.label, gt2.label, gt3.label);
bl.defs.Add(ld);
}
/// <summary>
/// Фиктивный блок, представляющий лямбда-выражение. Используется для обхода с целью получения списка захватываемых переменных
/// </summary>
/// <param name="lambdaDef"></param>
/// <returns></returns>
public static block CreateFictiveBlockForLambda(function_lambda_definition lambdaDef)
{
statement_list stmtList = new statement_list();
if (lambdaDef.formal_parameters != null)
{
for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++)
{
stmtList.subnodes.Add(SyntaxTreeNodesConstructor.CreateVarStatementNode(lambdaDef.formal_parameters.params_list[i].idents,
lambdaDef.formal_parameters.params_list[i].vars_type,
null));
}
}
if (lambdaDef.return_type != null)
{
stmtList.subnodes.Add(SyntaxTreeNodesConstructor.CreateVarStatementNode("result", lambdaDef.return_type, null)); // переделать, не сработает, если тип возвращаемого значения не указан
}
stmtList.subnodes.AddRange((lambdaDef.proc_body as statement_list).subnodes);
block resBlock = new block();
resBlock.program_code = stmtList;
return(resBlock);
}
public override void Exit(syntax_tree_node st)
{
var sts = st as statement;
if (sts != null && !(sts is statement_list) && !(sts is case_variant) && !(UpperNode() is statement_list))
{
// Одиночный оператор
var stl = new statement_list(sts, st.source_context);
Replace(sts, stl);
}
var lst = st as labeled_statement;
if (lst != null && !(lst.to_statement is statement_list) && !(lst.to_statement is case_variant))
{
// Одиночный оператор
var stl = new statement_list(sts, st.source_context);
Replace(lst.to_statement, stl);
}
base.Exit(st);
}
public static void Substitute(syntax_tree_visitor _visitor, declarations decls, statement_list _statementList)
{
var tree = new CapturedVariablesTreeBuilder(_visitor).BuildTree(_statementList);
var substs = new CapturedVariablesSubstitutionClassGenerator(tree.RootNode).GenerateSubstitutions();
new CapturedVariablesSubstitutor(tree.IdentsReferences, substs.GeneratedScopeClassesInfo, substs.LambdasToBeAddedAsMethods, substs.SubstitutionsInfo, tree.CapturedVarsNodesDictionary, substs.ConvertingClassNonPublicMembersMapping, _visitor)
.Substitute(_statementList);
if (_visitor.context.converting_block() == block_type.function_block && tree.ProcedureScope != null)
{
if (decls != null && decls.defs != null)
{
foreach (var def in decls.defs.Where(d => d is const_definition ||
d is consts_definitions_list ||
d is variable_definitions))
{
var constDef = def as const_definition;
if (constDef != null)
{
var finder = new FindMainIdentsVisitor();
finder.ProcessNode(constDef.const_value);
foreach (var v in finder.vars)
{
SymbolInfo si = _visitor.context.find_first(v.name);
if (si == null)
{
continue;
}
if (tree.ProcedureScope.VariablesDefinedInScope.Any(var => var.SymbolInfo == si))
{
_visitor.AddError(new UsingCapturedParameterIsNotAllowedInInitializers(_visitor.get_location(v)));
}
}
continue;
}
var constDefList = def as consts_definitions_list;
if (constDefList != null)
{
foreach (var cd in constDefList.const_defs)
{
var finder = new FindMainIdentsVisitor();
finder.ProcessNode(cd.const_value);
foreach (var v in finder.vars)
{
SymbolInfo si = _visitor.context.find_first(v.name);
if (si == null)
{
continue;
}
if (tree.ProcedureScope.VariablesDefinedInScope.Any(var => var.SymbolInfo == si))
{
_visitor.AddError(new UsingCapturedParameterIsNotAllowedInInitializers(_visitor.get_location(v)));
}
}
}
continue;
}
var varDefList = def as variable_definitions;
if (varDefList != null)
{
foreach (var d in varDefList.var_definitions)
{
var finder = new FindMainIdentsVisitor();
finder.ProcessNode(d.inital_value);
foreach (var v in finder.vars)
{
SymbolInfo si = _visitor.context.find_first(v.name);
if (si == null)
{
continue;
}
if (tree.ProcedureScope.VariablesDefinedInScope.Any(var => var.SymbolInfo == si))
{
_visitor.AddError(new UsingCapturedParameterIsNotAllowedInInitializers(_visitor.get_location(v)));
}
}
}
}
}
}
}
}
public ident func_decl_lambda(object lr0, object lr2)
{
statement_list _statement_list = (statement_list)lr2;
expression_list _expression_list = new expression_list();
ident_list _i_l = new ident_list();
formal_parameters _formal_parameters = new formal_parameters();
if (lr0 != null)
{
List <object> ar = (List <object>)lr0;
for (int i = 0; i < ar.Count; i++)
{
if (ar[i] is ident)
{
_i_l.idents.Add((ident)ar[i]);
}
else
{
_i_l.idents.Add(((var_def_statement)ar[i]).vars.idents[0]);
}
}
for (int i = 0; i < _i_l.idents.Count; i++)
{
_expression_list.expressions.Add(_i_l.idents[i]);
}
for (int i = 0; i < ar.Count; i++)
{
ident_list _ident_list = new ident_list();
ident id = _i_l.idents[i];
_ident_list.idents.Add(id);
string name_param = id.name;
typed_parameters _typed_parameters = null;
int k = 0;
{
named_type_reference _named_type_reference = new named_type_reference();
type_definition t_d = new type_definition();
if (ar[i] is ident)
{
ident idtype = new ident("object");
_named_type_reference.names.Add(idtype);
t_d = (type_definition)_named_type_reference;
}
else
{
t_d = ((var_def_statement)ar[i]).vars_type;
}
_typed_parameters = new typed_parameters(_ident_list, t_d, parametr_kind.none, null);
//parsertools.create_source_context(_typed_parameters, _ident_list, t_d);
}
_formal_parameters.params_list.Add(_typed_parameters);
}
}
//////////////////////////
named_type_reference _named_type_reference1 = new named_type_reference();
ident idtype1 = new ident("object");
_named_type_reference1.source_context = idtype1.source_context;
_named_type_reference1.names.Add(idtype1);
/////////////////////////////
lambda_num++;
function_lambda_definition _procedure_definition = new function_lambda_definition();
_procedure_definition.formal_parameters = _formal_parameters;
_procedure_definition.return_type = (type_definition)_named_type_reference1;
_procedure_definition.ident_list = _i_l;
_procedure_definition.proc_body = null;
_procedure_definition.parameters = _expression_list;
_procedure_definition.lambda_name = "__lambda__" + lambda_num;
//new function_lambda_definition(_formal_parameters, (type_definition)_named_type_reference1, _i_l, null, _expression_list, "lambda" + lambda_num);
object rt = _i_l;
_procedure_definition.proc_body = _statement_list;
//////////////////////////////vnutrennie lambda
if (_procedure_definition.defs == null)
{
_procedure_definition.defs = new List <declaration>();
}
while (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] != null)
{
_procedure_definition.defs.Add(lambda((function_lambda_definition)pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1]));
pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1);
}
if (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] == null)
{
pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1);
}
pascalABC_lambda_definitions.Add(_procedure_definition);
///////////////////////////////////////////////
//parsertools.create_source_context(_procedure_definition, _expression_list, rt);
ident _name = new ident(_procedure_definition.lambda_name);
if (lr0 != null)
{
_name.source_context = _i_l.idents[0].source_context;
}
return(_name);
}
/// <summary>
/// Преобразует foreach в for, если коллекция это одномерный массив.
/// </summary>
/// <param name="_foreach_stmt"></param>
/// <param name="in_what"></param>
/// <returns>True - если преобразование удалось, иначе False</returns>
private bool OptimizeForeachInCase1DArray(foreach_stmt _foreach_stmt, expression_node in_what)
{
var is1dimdynarr = false;
var comptn = in_what.type as compiled_type_node;
if (comptn != null && comptn.type_special_kind == type_special_kind.array_kind && comptn.rank == 1)
{
is1dimdynarr = true;
}
if (!is1dimdynarr)
{
var comtn = in_what.type as common_type_node;
if (comtn != null && comtn.internal_type_special_kind == type_special_kind.array_kind &&
comtn.rank == 1)
{
is1dimdynarr = true;
}
}
// SSM 23.08.16 Закомментировал оптимизацию. Не работает с лямбдами. Лямбды обходят старое дерево. А заменить foreach на for на этом этапе пока не получается - не развита инфраструктура
if (is1dimdynarr) // Замена foreach на for для массива
{
// сгенерировать код для for и вызвать соответствующий visit
var arrid = GenIdentName();
//var vdarr = new var_statement(arrid, new semantic_addr_value(in_what)); // semantic_addr_value - перевод в синтаксис для мгновенного вычисления семантического выражения, которое уже вычислено в in_what
var vdarr = new var_statement(arrid, _foreach_stmt.in_what);
var i = GenIdentName();
var x = _foreach_stmt.identifier;
// Возможны 3 случая:
// 1. _foreach_stmt.type_name = null - значит, переменная определена в другом месте
// 2. _foreach_stmt.type_name = no_type_foreach - значит, это for var x in a
// 3. _foreach_stmt.type_name = T - значит, это for var x: T in a
statement vd;
if (_foreach_stmt.type_name == null) // 1.
{
vd = new assign(x, arrid.indexer(i));
}
else if (_foreach_stmt.type_name is no_type_foreach) // 2.
{
vd = new var_statement(x, arrid.indexer(i));
}
else // 3.
{
vd = new var_statement(x, _foreach_stmt.type_name, arrid.indexer(i));
}
// Превратить старое тело в statement_list и добавить к нему в начало x := a[i] или var x := a[i]
var newbody = _foreach_stmt.stmt.ToStatementList();
newbody.AddFirst(vd);
var high = arrid.dot_node("Length").Minus(1);
var fornode = new for_node(i, 0, high, newbody, for_cycle_type.to, null, null, true);
var stl = new statement_list(vdarr, fornode);
// Замена 1 оператора на 1 оператор. Всё хорошо даже если оператор помечен меткой
ReplaceUsingParent(_foreach_stmt, stl);
visit(stl);
//visit(vdarr);
//visit(fornode);
return(true);
}
/// SSM 29.07.16
return(false);
}
public override void visit(PascalABCCompiler.SyntaxTree.for_node _for_node)
{
var loc1 = _visitor.get_location(_for_node.loop_variable);
var loopIdentName = _for_node.loop_variable.name.ToLower();
var nodesToProcess = new List <syntax_tree_node>();
var_definition_node vdn;
var initv = _visitor.convert_strong(_for_node.initial_value);
var tmp = initv;
if (initv is typed_expression)
{
initv = _visitor.convert_typed_expression_to_function_call(initv as typed_expression);
}
if (initv.type == null)
{
initv = tmp;
}
var headStmts = new statements_list(loc1);
_visitor.convertion_data_and_alghoritms.statement_list_stack_push(headStmts);
var newTreeNode = new CapturedVariablesTreeNodeForScope(_currentTreeNode, headStmts.Scope.ScopeNum, _for_node);
if (_currentTreeNode != null)
{
_currentTreeNode.ChildNodes.Add(newTreeNode);
}
_currentTreeNode = newTreeNode;
_scopesCapturedVarsNodesDictionary.Add(headStmts.Scope.ScopeNum, _currentTreeNode);
if (_for_node.type_name == null && !_for_node.create_loop_variable)
{
var dn = _visitor.context.check_name_node_type(loopIdentName, loc1, general_node_type.variable_node);
vdn = (var_definition_node)dn;
nodesToProcess.Add(_for_node.loop_variable);
}
else
{
var tn = _for_node.type_name != null?_visitor.convert_strong(_for_node.type_name) : initv.type;
vdn = _visitor.context.add_var_definition(loopIdentName,
_visitor.get_location(_for_node.loop_variable), tn,
polymorphic_state.ps_common);
_currentTreeNode.VariablesDefinedInScope.Add(new CapturedVariablesTreeNode.CapturedSymbolInfo(_for_node, _visitor.context.find(loopIdentName)));
}
newTreeNode.SymbolInfoLoopVar = _visitor.context.find(loopIdentName);
var fn = new PascalABCCompiler.TreeRealization.for_node(null, null, null, null, null, _visitor.get_location(_for_node));
if (vdn.type == SystemLibrary.bool_type)
{
fn.bool_cycle = true;
}
_visitor.context.cycle_stack.push(fn);
_visitor.context.loop_var_stack.Push(vdn);
nodesToProcess.Add(_for_node.initial_value);
nodesToProcess.Add(_for_node.finish_value);
nodesToProcess.Add(_for_node.increment_value);
foreach (var n in nodesToProcess)
{
ProcessNode(n);
}
if (!(_for_node.statements is statement_list))
{
var stmtList = new statement_list(_for_node.statements, _for_node.statements.source_context);
_for_node.statements = stmtList;
}
ProcessNode(_for_node.statements);
_visitor.context.cycle_stack.pop();
_visitor.context.loop_var_stack.Pop();
_visitor.convertion_data_and_alghoritms.statement_list_stack.pop();
_currentTreeNode = _currentTreeNode.ParentNode;
}
public override void visit(foreach_stmt _foreach_stmt)
{
var loopIdentName = _foreach_stmt.identifier.name.ToLower();
definition_node dn = null;
var_definition_node vdn = null;
var sl2 = new statements_list(_visitor.get_location(_foreach_stmt));
_visitor.convertion_data_and_alghoritms.statement_list_stack_push(sl2);
var newTreeNode = new CapturedVariablesTreeNodeForEachScope(_currentTreeNode, sl2.Scope.ScopeNum, _foreach_stmt);
if (_currentTreeNode != null)
{
_currentTreeNode.ChildNodes.Add(newTreeNode);
}
_currentTreeNode = newTreeNode;
_scopesCapturedVarsNodesDictionary.Add(sl2.Scope.ScopeNum, _currentTreeNode);
var inWhat = _visitor.convert_strong(_foreach_stmt.in_what);
var tmp = inWhat;
if (inWhat is typed_expression)
{
inWhat = _visitor.convert_typed_expression_to_function_call(inWhat as typed_expression);
}
type_node elemType = null;
if (inWhat.type == null)
{
inWhat = tmp;
}
_visitor.FindIEnumerableElementType(/*_foreach_stmt, */ inWhat.type, ref elemType);
if (_foreach_stmt.type_name == null)
{
var loc1 = _visitor.get_location(_foreach_stmt.identifier);
dn = _visitor.context.check_name_node_type(loopIdentName, loc1, general_node_type.variable_node);
vdn = (var_definition_node)dn;
}
else
{
vdn = _visitor.context.add_var_definition(loopIdentName, _visitor.get_location(_foreach_stmt.identifier));
type_node tn;
if (_foreach_stmt.type_name is no_type_foreach)
{
tn = elemType;
}
else
{
tn = _visitor.convert_strong(_foreach_stmt.type_name);
_visitor.check_for_type_allowed(tn, _visitor.get_location(_foreach_stmt.type_name));
}
_visitor.context.close_var_definition_list(tn, null);
_currentTreeNode.VariablesDefinedInScope.Add(new CapturedVariablesTreeNode.CapturedSymbolInfo(_foreach_stmt, _visitor.context.find(loopIdentName)));
}
newTreeNode.SymbolInfoLoopVar = _visitor.context.find(loopIdentName);
if (!(vdn.type is compiled_generic_instance_type_node))
{
_visitor.convertion_data_and_alghoritms.check_convert_type_with_inheritance(vdn.type, elemType, _visitor.get_location(_foreach_stmt.identifier));
}
var fn = new foreach_node(vdn, inWhat, null, _visitor.get_location(_foreach_stmt));
_visitor.context.cycle_stack.push(fn);
_visitor.context.loop_var_stack.Push(vdn);
ProcessNode(_foreach_stmt.in_what);
if (!(_foreach_stmt.stmt is statement_list))
{
var stmtList = new statement_list(_foreach_stmt.stmt, _foreach_stmt.stmt.source_context);
_foreach_stmt.stmt = stmtList;
}
ProcessNode(_foreach_stmt.stmt);
_visitor.context.loop_var_stack.Pop();
_visitor.convertion_data_and_alghoritms.statement_list_stack.pop();
_visitor.context.cycle_stack.pop();
_currentTreeNode = _currentTreeNode.ParentNode;
}
private statement_list ConvertIfNode(if_node ifNode, List <statement> statementsBeforeIf, out statement elseBody)
{
// if e then <then> else <else>
//
// переводим в
//
// begin
// statementsBeforeIf
// if e then begin <then>; goto end_if end;
// end
// <else>
// end_if: empty_statement
// if e then <then>
//
// переводим в
//
// begin
// statementsBeforeIf
// if e then <then>
// end
// Добавляем, чтобы на конвертировать еще раз, если потребуется
processedIfNodes.Add(ifNode);
var statementsBeforeAndIf = new statement_list();
statementsBeforeAndIf.AddMany(statementsBeforeIf);
statementsBeforeAndIf.Add(ifNode);
if (ifNode.else_body == null)
{
elseBody = null;
return(statementsBeforeAndIf);
}
else
{
var result = new statement_list();
result.Add(statementsBeforeAndIf);
var endIfLabel = NewEndIfName();
// добавляем метку
if (!(ifNode.then_body is statement_list))
{
ifNode.then_body = new statement_list(ifNode.then_body, ifNode.then_body.source_context);
ifNode.then_body.Parent = ifNode;
}
var thenBody = ifNode.then_body as statement_list;
thenBody.Add(new goto_statement(endIfLabel));
// добавляем else и метку за ним
result.Add(ifNode.else_body);
result.Add(new labeled_statement(endIfLabel));
// Возвращаем else для обхода, т.к. он уже не входит в if
elseBody = ifNode.else_body;
// удаляем else из if
ifNode.else_body = null;
// Добавляем метку
AddLabel(endIfLabel);
return(result);
}
}
private void AddDefaultCase(statement_list statements)
{
AddDesugaredCaseToResult(statements, _previousIf);
}
public override void visit(statement_list _statement_list)
{
//text="Count: "+_statement_list.subnodes.Count;
get_count(_statement_list.subnodes);
}
public virtual void visit(statement_list _statement_list)
{
}
public virtual void post_do_visit(statement_list _statement_list)
{
}
public override void visit(statement_list _statement_list)
{
DefaultVisit(_statement_list);
pre_do_visit(_statement_list);
for (int i = 0; i < subnodes.Count; i++)
visit(statement_list.subnodes[i]);
visit(statement_list.left_logical_bracket);
visit(statement_list.right_logical_bracket);
post_do_visit(_statement_list);
}
public virtual void visit(statement_list _statement_list)
{
DefaultVisit(_statement_list);
}
