public void write_closure_substituting_node(closure_substituting_node _closure_substituting_node)
{
write_ident(_closure_substituting_node);
if (_closure_substituting_node.substitution == null)
{
bw.Write((byte)0);
}
else
{
bw.Write((byte)1);
_closure_substituting_node.substitution.visit(this);
}
}
public void visit(closure_substituting_node _closure_substituting_node)
{
bw.Write((Int16)198);
write_closure_substituting_node(_closure_substituting_node);
}
/* Этот код мешает. Может, его убрать?
public override void visit(SyntaxTree.function_lambda_definition _function_lambda_definition)
{
SyntaxTree.procedure_definition _func_def = new PascalABCCompiler.SyntaxTree.procedure_definition();
SyntaxTree.method_name _method_name = new SyntaxTree.method_name(null, new SyntaxTree.ident("$a"), null);
SyntaxTree.function_header _function_header = new SyntaxTree.function_header();
object rt = new object();
_function_header.name = _method_name;
SyntaxTree.formal_parameters fps=new PascalABCCompiler.SyntaxTree.formal_parameters();
for (int i = 0; i < _function_lambda_definition.formal_parameters.params_list.Count; i++)
{
SyntaxTree.ident_list _ident_list = new SyntaxTree.ident_list();
SyntaxTree.ident id =_function_lambda_definition.formal_parameters.params_list[i].idents.idents[0];
_ident_list.idents.Add(id);
SyntaxTree.named_type_reference _named_type_reference1 = new SyntaxTree.named_type_reference();
SyntaxTree.ident idtype1 = new SyntaxTree.ident("datatype");
_named_type_reference1.names.Add(idtype1);
SyntaxTree.typed_parameters _typed_parametres = new SyntaxTree.typed_parameters(_ident_list, (SyntaxTree.type_definition)_named_type_reference1, SyntaxTree.parametr_kind.none, null);
fps.params_list.Add(_typed_parametres);
}
_function_header.parameters = fps;
fps.visit(this);
SyntaxTree.named_type_reference _named_type_reference = new SyntaxTree.named_type_reference();
SyntaxTree.ident idtype = new SyntaxTree.ident("datatype");
_named_type_reference.source_context = idtype.source_context;
_named_type_reference.names.Add(idtype);
rt = _named_type_reference;
_function_header.return_type = (SyntaxTree.type_definition)_named_type_reference;
_function_header.of_object = false;
_function_header.class_keyword = false;
SyntaxTree.block _block = new SyntaxTree.block(null, null);
SyntaxTree.statement_list sl = new SyntaxTree.statement_list();
sl.subnodes.Add(_function_lambda_definition.proc_body);
_block.program_code = sl;
_func_def.proc_header = _function_header;
_func_def.proc_body = (SyntaxTree.proc_block)_block;
_func_def.visit(this);
expressions_list el = new expressions_list();
foreach (SyntaxTree.expression en in _function_lambda_definition.parameters.expressions)
{
el.AddElement(convert_strong(en));
}
function_node fn = find_function("$a", get_location(_function_header), el);*/
///////////////////////////////////////////////////////////////////////////
/*hard_node_test_and_visit(_function_lambda_definition.formal_parameters);
hard_node_test_and_visit(_function_lambda_definition.proc_body);
CheckToEmbeddedStatementCannotBeADeclaration(_function_lambda_definition.proc_body);
statement_node body = convert_strong(_function_lambda_definition.proc_body);
//context.leave_code_block();
type_node tp = convert_strong(_function_lambda_definition.return_type);
parameter_list pl = new parameter_list();
for (int i = 0; i < _function_lambda_definition.formal_parameters.params_list.Count; i++)
{
common_parameter cp = new common_parameter(_function_lambda_definition.formal_parameters.params_list[i].idents.idents[0].name,
SemanticTree.parameter_type.value, null,
concrete_parameter_type.cpt_none, get_location(_function_lambda_definition.formal_parameters.params_list[i].idents.idents[0]));
pl.AddElement(cp);
}
function_lambda_node fln = new function_lambda_node(pl, tp, body);
fln.type = tp;
//fln.function = fn;
return_value(fln);*/
//lroman//
/*LambdaHelper.captureCheck = true; //захват пока не делаем
var block = LambdaHelper.CreateFictiveBlockForLambda(_function_lambda_definition);
context.create_lambda();
hard_node_test_and_visit(block.program_code);
context.remove_lambda();
LambdaHelper.captureCheck = false;*/
//if (LambdaHelper.capturedVariables.Count == 0)
// SSM - 15.1.2014
//public void proba_after_visit_function_lambda_definition(SyntaxTree.function_lambda_definition _function_lambda_definition, SyntaxTree.procedure_definition pd)
//{
// var fvisbody = new FindMainIdentsVisitor();
// fvisbody.ProcessNode(_function_lambda_definition.proc_body);
// var fvisparams = new FindMainIdentsVisitor();
// fvisparams.ProcessNode(_function_lambda_definition.formal_parameters);
// var fvislocaldefs = new FindLocalDefsVisitor();
// fvislocaldefs.ProcessNode(_function_lambda_definition.proc_body);
// fvislocaldefs.vars.Add("result");
// var candidates = fvisbody.vars.Except(fvisparams.vars, StringComparer.OrdinalIgnoreCase).Except(fvislocaldefs.vars, StringComparer.OrdinalIgnoreCase).ToArray();
// List<SyntaxTree.ident> li = new List<SyntaxTree.ident>();
// List<SyntaxTree.type_definition> lt = new List<SyntaxTree.type_definition>();
// SymbolInfo si;
// foreach (var x in candidates)
// {
// si = context.find(x);
// var tp = si.sym_info.GetType();
// if (tp == typeof(TreeRealization.local_block_variable) || tp == typeof(TreeRealization.local_variable))
// {
// var id = new SyntaxTree.ident(x);
// li.Add(id);
// var typ = ident_value_reciving(id).type;
// lt.Add(SyntaxTreeBuilder.BuildSemanticType(typ));
// // Попытаемся определить их типы
// }
// else if (tp == typeof(TreeRealization.class_field))
// {
// // Поля класса тоже захватываем!
// var id = new SyntaxTree.ident(x);
// li.Add(id);
// var typ = ident_value_reciving(id).type;
// lt.Add(SyntaxTreeBuilder.BuildSemanticType(typ));
// }
// else if (tp == typeof(TreeRealization.common_parameter))
// {
// // И параметры метода/подпрограммы тоже захватываем!
// var id = new SyntaxTree.ident(x);
// li.Add(id);
// var typ = ident_value_reciving(id).type;
// lt.Add(SyntaxTreeBuilder.BuildSemanticType(typ));
// }
// }
// var UNS = UniqueNumStr();
// var LambdaClassName = "#LambdaClassName" + UNS;
// //if (li.Count > 0)
// {
// contextChanger.SaveContextAndUpToGlobalLevel();
// var bt = SyntaxTreeBuilder.BuildClassWithOneMethod(LambdaClassName, li, lt, pd);
// visit(bt); // добавили класс __A в раздел описаний
// contextChanger.RestoreCurrentContext();
// }
// /* другая версия кода внизу
// * var ttp = new SyntaxTree.named_type_reference("__A", null);
// type_node semttp = convert_strong(ttp);
// common_function_node topfun = context.func_stack.top();
// local_variable lv = new local_variable("a1", semttp, topfun, null);
// topfun.var_definition_nodes_list.AddElement(lv);
// context.CurrentScope.AddSymbol("a1", new SymbolInfo(lv));*/
// // теперь сформируем семантический узел вида a1 := new __A()
// var ttp = new SyntaxTree.named_type_reference(LambdaClassName, null);
// type_node semttp = convert_strong(ttp);
// var LambdaVarName = "#LambdaVarName" + UNS;
// context.add_var_definition(LambdaVarName, null, semttp, SemanticTree.polymorphic_state.ps_common); // добавление описания локальной переменной. Все такие описания в .NET-коде делаются перед любыми операторами
// SyntaxTree.expression_list el = new SyntaxTree.expression_list();
// for (int i = 0; i < li.Count; i++)
// el.Add(li[i]);
// var nex = new SyntaxTree.new_expr(ttp, el, null);
// var ass = new SyntaxTree.assign(LambdaVarName, nex);
// var sass = convert_strong(ass);
// // теперь добавим этот узел в конец самого верхнего statement_list текущей функции
// var sf = convertion_data_and_alghoritms.statement_list_stack.first();
// sf.statements.AddElement(sass);
// var dn = new SyntaxTree.dot_node(new SyntaxTree.ident(LambdaVarName), pd.proc_header.name.meth_name);
// visit(dn);
//}
public override void visit(closure_substituting_node _closure_substituting_node)
{
visit(_closure_substituting_node.substitution);
}
private void SubstituteInNode(syntax_tree_node currentNode, syntax_tree_node nodeWhereSubstitute)
{
var identSubnodesIndexes = Enumerable
.Range(0, nodeWhereSubstitute.subnodes_count)
.Where(index => nodeWhereSubstitute[index] is ident)
.ToList();
if (nodeWhereSubstitute is for_node) //нужно исключить переменную цикла, так как она оброабатывается отдельно в SubstituteForLoopVariables
{
var fn = (for_node) nodeWhereSubstitute;
var indexWithLoopIdent = identSubnodesIndexes.First(ind =>
{
var id = nodeWhereSubstitute[ind] as ident;
if (id == null)
{
return false;
}
return id == fn.loop_variable;
});
identSubnodesIndexes.Remove(indexWithLoopIdent);
}
if (nodeWhereSubstitute is foreach_stmt) //нужно исключить переменную цикла, так как она оброабатывается отдельно в SubstituteForEachLoopVariables
{
var fn = (foreach_stmt)nodeWhereSubstitute;
var indexWithLoopIdent = identSubnodesIndexes.First(ind =>
{
var id = nodeWhereSubstitute[ind] as ident;
if (id == null)
{
return false;
}
return id == fn.identifier;
});
identSubnodesIndexes.Remove(indexWithLoopIdent);
}
if (identSubnodesIndexes.Count == 0)
{
return;
}
var keys = _substitutionsInfo
.Keys
.Where(k => k.IsPartialKeyEquals(currentNode))
.Where(k => _identsReferences.ContainsKey(k));
foreach (var key in keys)
{
var subst = _substitutionsInfo[key];
foreach (var id in _identsReferences[key])
{
for (var i = 0; i < identSubnodesIndexes.Count; i++)
{
if (nodeWhereSubstitute[identSubnodesIndexes[i]] == id)
{
nodeWhereSubstitute[identSubnodesIndexes[i]] = new closure_substituting_node(subst);
}
}
}
}
}
public void read_closure_substituting_node(closure_substituting_node _closure_substituting_node)
{
read_ident(_closure_substituting_node);
_closure_substituting_node.substitution = _read_node() as dot_node;
}
public void visit(closure_substituting_node _closure_substituting_node)
{
read_closure_substituting_node(_closure_substituting_node);
}