public static var_statement CreateVarStatementNode(string idName, string varTypeName, expression initValue)
{
var id = new ident(idName);
var idlist = new ident_list(id);
var varType = new named_type_reference(varTypeName, null);
var vdef = new var_def_statement(idlist, varType, initValue, definition_attribute.None, false, null);
return(new var_statement(vdef, null));
}
public override void visit(function_lambda_definition lambdaDefinition)
{
if (lambdaDefinition.formal_parameters != null && lambdaDefinition.formal_parameters.params_list != null && lambdaDefinition.formal_parameters.params_list.Count != 0)
{
var varDefsList = new List <statement>();
for (var i = 0; i < lambdaDefinition.formal_parameters.params_list.Count; i++)
{
var varType = lambdaDefinition.formal_parameters.params_list[i].vars_type is lambda_inferred_type?
LambdaHelper.ConvertSemanticTypeToSyntaxType((type_node)((lambda_inferred_type)lambdaDefinition.formal_parameters.params_list[i].vars_type).real_type) :
//new semantic_type_node(((lambda_inferred_type)lambdaDefinition.formal_parameters.params_list[i].vars_type).real_type): // SSM 29/12/18 поменял - пробую - не получилось
lambdaDefinition.formal_parameters.params_list[i].vars_type;
for (var j = 0; j < lambdaDefinition.formal_parameters.params_list[i].idents.idents.Count; j++)
{
var varName = "<>" + lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].name;
SourceContext sc = lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].source_context;
var vds = new var_def_statement(new ident(lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].name, sc), varType, sc);
vds.inital_value = new ident(varName, sc);
lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].name = varName;
varDefsList.Add(new var_statement(vds, sc));
}
}
((statement_list)lambdaDefinition.proc_body).subnodes.InsertRange(0, varDefsList);
}
var procDecl = LambdaHelper.ConvertLambdaNodeToProcDefNode(lambdaDefinition);
_visitor.body_exists = true;
_visitor.hard_node_test_and_visit(procDecl.proc_header);
var newTreeNode = new CapturedVariablesTreeNodeLambdaScope(_currentTreeNode,
lambdaDefinition,
_visitor.context.func_stack.top().scope.ScopeNum, lambdaDefinition);
_currentTreeNode.LambdasDefinedInScope.Add(newTreeNode);
_currentLambdaScopeNodeStack.Push(newTreeNode);
if (_currentTreeNode != null)
{
_currentTreeNode.ChildNodes.Add(newTreeNode);
}
_currentTreeNode = newTreeNode;
_scopesCapturedVarsNodesDictionary.Add(_currentTreeNode.ScopeIndex, _currentTreeNode);
VisitProcParameters(procDecl.proc_header.parameters);
ProcessNode(procDecl.proc_body);
_visitor.context.leave_block();
_visitor.context.remove_lambda_function(procDecl.proc_header.name.meth_name.name, false);
_currentTreeNode = _currentTreeNode.ParentNode;
_currentLambdaScopeNodeStack.Pop();
LambdaHelper.RemoveLambdaInfoFromCompilationContext(_visitor.context, lambdaDefinition);
}
/// <summary>
/// Создать var-выражение
/// </summary>
/// <param name="name">Имя переменной</param>
/// <param name="initialValue">Начальное значение</param>
/// <returns></returns>
public static var_def_statement CreateVarDef(string name, expression initialValue)
{
ident_list list = new ident_list();
list.idents.Add(new ident(name));
var res = new var_def_statement();
res.inital_value = initialValue;
res.vars = list;
return(res);
}
/// <summary>
/// Создать var-выражение с несколькими переменными
/// </summary>
/// <param name="type">Тип переменных</param>
/// <param name="idents">Имена переменных</param>
/// <returns></returns>
public static var_def_statement CreateVarDef(named_type_reference type, params string[] names)
{
var_def_statement res = new var_def_statement();
foreach (string x in names)
{
res.vars.Add(new ident(x));
}
res.vars_type = type;
return(res);
}
public var_def_statement NewVarOrIdentifier(ident identifier, named_type_reference fptype, LexLocation loc)
{
var n_t_r = fptype;
var vds = new var_def_statement();
vds.vars = new ident_list();
vds.vars.idents.Add(identifier);
vds.vars_type = n_t_r;
vds.source_context = loc;
return(vds);
}
public override void visit(var_def_statement _var_def_statement)
{
if (_var_def_statement.is_event)
{
text = "event";
}
if (_var_def_statement.var_attr != definition_attribute.None)
{
text += _var_def_statement.var_attr.ToString();
}
}
public override void visit(var_def_statement vd)
{
var attr = vd.var_attr == definition_attribute.Static ? Attributes.class_attr : 0;
if (vd == null || vd.vars == null || vd.vars.list == null)
{
return;
}
AddSymbols(vd.vars.list, SymKind.var, vd.vars_type, attr);
base.visit(vd);
}
public override void visit(var_def_statement vd)
{
if (vd.inital_value is array_const)
{
throw new SyntaxVisitorError("FUNCTION_WITH_YIELD_CANNOT_CONTAIN_OLDSTYLE_ARRAY_INITIALIZERS", vd.inital_value.source_context);
}
if (vd.inital_value is record_const)
{
throw new SyntaxVisitorError("FUNCTION_WITH_YIELD_CANNOT_CONTAIN_OLDSTYLE_RECORD_INITIALIZERS", vd.inital_value.source_context);
}
}
public override void visit(assign_var_tuple assvartup)
{
var tname = "#temp_var" + UniqueNumStr();
if (assvartup.Parent is declarations ds)
{
var ld = new List <declaration>();
ld.Add(new semantic_check_sugared_statement_node(typeof(assign_var_tuple), new List <syntax_tree_node> {
assvartup.idents, assvartup.expr
}, assvartup.source_context)); // Это нужно для проверок на этапе преобразования в семантику
var vd = new variable_definitions();
var tt1 = new var_def_statement(new ident(tname), assvartup.expr);
vd.Add(tt1);
var nn = assvartup.idents.idents.Count();
for (var i = 0; i < nn; i++)
{
var a = new var_def_statement(assvartup.idents.idents[i],
new dot_node(new ident(tname), new ident("Item" + (i + 1).ToString())),
assvartup.idents.idents[i].source_context);
vd.Add(a);
}
ld.Add(vd);
ReplaceAssignVarTupleUsingParent(assvartup, ld);
visit(assvartup.expr);
return;
}
var sl = new List <statement>();
sl.Add(new semantic_check_sugared_statement_node(typeof(assign_var_tuple), new List <syntax_tree_node> {
assvartup.idents, assvartup.expr
}, assvartup.source_context)); // Это нужно для проверок на этапе преобразования в семантику
var tt = new var_statement(new ident(tname), assvartup.expr); // тут для assvartup.expr внутри повторно вызывается convert_strong, это плохо, но если там лямбда, то иначе - с semantic_addr_value - не работает!!!
sl.Add(tt); // он же помещается в новое синтаксическое дерево
var n = assvartup.idents.idents.Count();
for (var i = 0; i < n; i++)
{
var a = new var_statement(assvartup.idents.idents[i],
new dot_node(new ident(tname), new ident("Item" + (i + 1).ToString())),
assvartup.idents.idents[i].source_context);
sl.Add(a);
}
ReplaceStatementUsingParent(assvartup, sl);
visit(assvartup.expr); // В assvartup.expr могут содержаться лямбды, в которых будут другие assign_var_tuple.
// И вообще другой синтаксический сахар, размещённый в этом визиторе
}
public List <object> ident_list14(object lr1, object lr3)
{
List <object> ar = new List <object>();
//named_type_reference n_t_r = (named_type_reference)lr3;
var_def_statement vds = new var_def_statement();
vds.vars = new ident_list();
vds.vars.idents.Add((ident)lr1);
vds.vars_type = (type_definition)lr3;
ar.Add(vds);
return(ar);
}
public List <object> ident_list13(object lr1, object lr3, object lr5)
{
List <object> ar = (List <object>)lr5;
//named_type_reference n_t_r = (named_type_reference)lr3;
var_def_statement vds = new var_def_statement();
vds.vars = new ident_list();
vds.vars.idents.Add((ident)lr1);
vds.vars_type = (type_definition)lr3;//n_t_r;
ar.Insert(0, vds);
return(ar);
}
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 override void visit(var_def_statement varDefStmt)
{
_visitor.visit(varDefStmt);
foreach (var id in varDefStmt.vars.idents)
{
var si = _visitor.context.find(id.name);
_currentTreeNode.VariablesDefinedInScope.Add(new CapturedVariablesTreeNode.CapturedSymbolInfo(varDefStmt, si));
}
if (varDefStmt.inital_value != null)
{
ProcessNode(varDefStmt.inital_value);
}
}
public override void visit(var_def_statement _var_def_statement)
{
if (_var_def_statement.is_event)
{
AddPossibleComments(_var_def_statement, true, false);
}
_var_def_statement.vars.visit(this);
if (_var_def_statement.vars_type != null)
{
_var_def_statement.vars_type.visit(this);
}
if (_var_def_statement.inital_value != null)
{
_var_def_statement.inital_value.visit(this);
}
}
public override void visit(var_def_statement vd)
{
var attr = vd.var_attr == definition_attribute.Static ? Attributes.class_attr : 0;
if (vd == null || vd.vars == null || vd.vars.list == null)
{
return;
}
var type = vd.vars_type;
var q = vd.vars.list.Select(x => new SymInfoSyntax(x, SymKind.var, type, attr));
if (q.Count() > 0)
{
Current.Symbols.AddRange(q);
}
base.visit(vd);
}
public override void visit(var_def_statement vds)
{
if (vds.Parent is var_statement)
{
InBlockVarDefs += vds.vars.Count;
}
else if (!(vds.Parent is class_members))
{
OutBlockVarDefs += vds.vars.Count;
}
if (vds.vars_type != null && vds.vars_type is string_num_definition)
{
OldStrings += 1;
}
if (vds.vars_type != null && vds.vars_type is array_type at && at.indexers != null && at.indexers.Count > 0 && at.indexers.indexers[0] != null)
{
StaticArrays += 1;
}
if (vds.vars_type != null && vds.vars_type is array_type at1 && at1.indexers == null)
{
DynamicArrays += 1;
}
if (vds.inital_value != null)
{
InitVarInDef++;
}
/*if (vds.inital_value != null)
* {
* if (vds.inital_value is ident id &&
* (id.name.ToLower().StartsWith("readinteger") || id.name.ToLower().StartsWith("readreal") || id.name.ToLower().StartsWith("readstring") ||
* id.name.ToLower().StartsWith("readlninteger") || id.name.ToLower().StartsWith("readlnreal") || id.name.ToLower().StartsWith("readlnstring")))
* ReadFuncCount++;
* }*/
base.visit(vds);
}
private List <declaration> get_field_declaration(ICSharpCode.NRefactory.Ast.FieldDeclaration vd)
{
List <declaration> fields = new List <declaration>();
bool is_static = (vd.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Static) == ICSharpCode.NRefactory.Ast.Modifiers.Static;
foreach (ICSharpCode.NRefactory.Ast.VariableDeclaration vard in vd.Fields)
{
var_def_statement vds = new var_def_statement();
vds.source_context = get_source_context(vd);
vds.vars_type = get_type_reference(vard.TypeReference);
ident_list idents = new ident_list();
ident name = new ident(vard.Name);
name.source_context = vds.source_context;
idents.idents.Add(name);
vds.vars = idents;
if (is_static)
{
vds.var_attr = definition_attribute.Static;
}
fields.Add(vds);
}
return(fields);
}
public override void visit(var_def_statement _var_def_statement)
{
executer.visit(_var_def_statement);
if (_var_def_statement.vars != null)
this.visit((dynamic)_var_def_statement.vars);
if (_var_def_statement.vars_type != null)
this.visit((dynamic)_var_def_statement.vars_type);
if (_var_def_statement.inital_value != null)
this.visit((dynamic)_var_def_statement.inital_value);
if (_var_def_statement.attributes != null)
this.visit((dynamic)_var_def_statement.attributes);
}
public static var_statement CreateVarStatementNode(ident_list idlist, type_definition varType, expression initValue)
{
var vdef = new var_def_statement(idlist, varType, initValue, definition_attribute.None, false, null);
return(new var_statement(vdef, null));
}
public virtual void visit(var_def_statement _var_def_statement)
{
DefaultVisit(_var_def_statement);
}
public virtual void visit(var_def_statement _var_def_statement)
{
}
/*public override void visit(template_type_name ttn) // при определении типа
* {
* Add(ttn);
* AddIdentList(ttn.template_args);
* }*/
public override void visit(var_def_statement vds)
{
AddIdentList(vds.vars);
ProcessNode(vds.vars_type);
}
private void add_module_members(unit_module mod, ICSharpCode.NRefactory.Ast.TypeDeclaration td)
{
foreach (ICSharpCode.NRefactory.Ast.INode node in td.Children)
{
if (node is ICSharpCode.NRefactory.Ast.FieldDeclaration)
{
ICSharpCode.NRefactory.Ast.FieldDeclaration vd = node as ICSharpCode.NRefactory.Ast.FieldDeclaration;
if ((vd.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Dim) == ICSharpCode.NRefactory.Ast.Modifiers.Dim)
{
foreach (ICSharpCode.NRefactory.Ast.VariableDeclaration vard in vd.Fields)
{
var_def_statement vds = new var_def_statement();
vds.source_context = get_source_context(vd);
vds.vars_type = get_type_reference(vard.TypeReference);
ident_list idents = new ident_list();
ident name = new ident(vard.Name);
name.source_context = vds.source_context;
idents.idents.Add(name);
vds.vars = idents;
mod.interface_part.interface_definitions.defs.Add(vds);
}
}
else if ((vd.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Const) == ICSharpCode.NRefactory.Ast.Modifiers.Const)
{
foreach (ICSharpCode.NRefactory.Ast.VariableDeclaration vard in vd.Fields)
{
const_definition tcd = null;
if (vard.TypeReference is ICSharpCode.NRefactory.Ast.TypeReference)
{
tcd = new simple_const_definition();
}
else
{
tcd = new typed_const_definition();
}
tcd.source_context = get_source_context(vd);
if (tcd is typed_const_definition)
{
(tcd as typed_const_definition).const_type = get_type_reference(vard.TypeReference);
}
tcd.const_name = new ident(vard.Name);
tcd.const_name.source_context = tcd.source_context;
tcd.const_value = get_expression(vard.Initializer);
mod.interface_part.interface_definitions.defs.Add(tcd);
}
}
}
else if (node is ICSharpCode.NRefactory.Ast.TypeDeclaration)
{
mod.interface_part.interface_definitions.defs.Add(get_type_declaration(node as ICSharpCode.NRefactory.Ast.TypeDeclaration));
}
else if (node is ICSharpCode.NRefactory.Ast.MethodDeclaration)
{
ICSharpCode.NRefactory.Ast.MethodDeclaration meth = node as ICSharpCode.NRefactory.Ast.MethodDeclaration;
if (!meth.Body.IsNull)
{
mod.interface_part.interface_definitions.defs.Add(get_method_declaration(meth));
}
else
{
mod.interface_part.interface_definitions.defs.Add(get_method_header(meth));
}
}
}
}
public override void visit(var_def_statement varStmt)
{
syntaxTreeVisitor.visit(varStmt);
}
public override void visit(var_def_statement _var_def_statement)
{
prepare_node(_var_def_statement.vars, "vars");
prepare_node(_var_def_statement.vars_type, "vars_type");
prepare_node(_var_def_statement.inital_value, "inital_value");
}
public override void visit(var_def_statement _var_def_statement)
{
connect(_var_def_statement);
}
public override void visit(var_def_statement vds)
{
//ProcessNode(vds.vars_type);
}
public override void visit(var_def_statement defs)
{
indef = true;
ProcessNode(defs.vars); // исключаем типы - просматриваем только имена переменных
indef = false;
}
type_declarations GenClassesForYield(procedure_definition pd, IEnumerable <var_def_statement> fields)
{
var fh = (pd.proc_header as function_header);
if (fh == null)
{
throw new SyntaxError("Only functions can contain yields", "", pd.proc_header.source_context, pd.proc_header);
}
var seqt = fh.return_type as sequence_type;
if (seqt == null)
{
throw new SyntaxError("Functions with yields must return sequences", "", fh.return_type.source_context, fh.return_type);
}
// Теперь на месте функции генерируем класс
// Захваченные переменные
var cm = class_members.Public;
foreach (var m in fields)
{
cm.Add(m);
}
// Параметры функции
List <ident> lid = new List <ident>();
var pars = fh.parameters;
if (pars != null)
{
foreach (var ps in pars.params_list)
{
if (ps.param_kind != parametr_kind.none)
{
throw new SyntaxError("Parameters of functions with yields must not have 'var', 'const' or 'params' modifier", "", pars.source_context, pars);
}
if (ps.inital_value != null)
{
throw new SyntaxError("Parameters of functions with yields must not have initial values", "", pars.source_context, pars);
}
var_def_statement vds = new var_def_statement(ps.idents, ps.vars_type);
cm.Add(vds); // все параметры функции делаем полями класса
lid.AddRange(vds.vars.idents);
}
}
var stels = seqt.elements_type;
// Системные поля и методы для реализации интерфейса IEnumerable
cm.Add(new var_def_statement(Consts.State, "integer"),
new var_def_statement(Consts.Current, stels),
procedure_definition.EmptyDefaultConstructor,
new procedure_definition("Reset"),
new procedure_definition("MoveNext", "boolean", pd.proc_body),
new procedure_definition("get_Current", "object", new assign("Result", Consts.Current)),
new procedure_definition("GetEnumerator", "System.Collections.IEnumerator", new assign("Result", "Self"))
);
var className = newClassName();
var classNameHelper = className + "Helper";
var interfaces = new named_type_reference_list("System.Collections.IEnumerator", "System.Collections.IEnumerable");
var td = new type_declaration(classNameHelper, SyntaxTreeBuilder.BuildClassDefinition(interfaces, cm));
// Изменение тела процедуры
var stl = new statement_list(new var_statement("res", new new_expr(className)));
stl.AddMany(lid.Select(id => new assign(new dot_node("res", id), id)));
stl.Add(new assign("Result", "res"));
pd.proc_body = new block(stl);
// Второй класс
var tpl = new template_param_list(stels);
var IEnumeratorT = new template_type_reference("System.Collections.Generic.IEnumerator", tpl);
var cm1 = class_members.Public.Add(
procedure_definition.EmptyDefaultConstructor,
new procedure_definition(new function_header("get_Current", stels), new assign("Result", Consts.Current)),
new procedure_definition(new function_header("GetEnumerator", IEnumeratorT), new assign("Result", "Self")),
new procedure_definition("Dispose")
);
var interfaces1 = new named_type_reference_list(classNameHelper);
var IEnumerableT = new template_type_reference("System.Collections.Generic.IEnumerable", tpl);
interfaces1.Add(IEnumerableT).Add(IEnumeratorT);
var td1 = new type_declaration(className, SyntaxTreeBuilder.BuildClassDefinition(interfaces1, cm1));
var cct = new type_declarations(td);
cct.Add(td1);
return(cct);
}
public virtual void post_do_visit(var_def_statement _var_def_statement)
{
}
public override void visit(var_def_statement _var_def_statement)
{
DefaultVisit(_var_def_statement);
pre_do_visit(_var_def_statement);
visit(var_def_statement.vars);
visit(var_def_statement.vars_type);
visit(var_def_statement.inital_value);
post_do_visit(_var_def_statement);
}
public virtual void visit(var_def_statement _var_def_statement)
{
}
public virtual void visit(var_def_statement _var_def_statement)
{
DefaultVisit(_var_def_statement);
}
