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); }