public static procedure_definition BuildToStringFuncForAutoClass(List <ident> names) { var pal = new procedure_attributes_list(proc_attribute.attr_override); var fp = new formal_parameters(); var ff = new function_header("ToString", "string", fp, pal); var cleft = new char_const('('); var cright = new char_const(')'); var ccomma = new char_const(','); bin_expr ex = new bin_expr(cleft, cright, Operators.Plus); for (var i = 0; i < names.Count; i++) { var dn = new dot_node(names[i], new ident("ToString")); var asnode = new typecast_node(names[i], new named_type_reference("object"), op_typecast.as_op); var eqnode = new bin_expr(asnode, new nil_const(), Operators.Equal); var expr = new question_colon_expression(eqnode, new string_const("nil"), dn); ex.left = new bin_expr(ex.left, expr, Operators.Plus); if (i < names.Count - 1) { ex.left = new bin_expr(ex.left, ccomma, Operators.Plus); } } var ass = new assign("Result", ex); return(BuildShortProcFuncDefinitionNoSC(ff, ass)); }
public static procedure_definition BuildShortFuncDefinition(formal_parameters fp, procedure_attributes_list att, method_name name, type_definition result, expression ex, SourceContext headsc) { var ff = new function_header(fp, att, name, null, result, headsc); procedure_definition pd = BuildShortProcFuncDefinition(ff, new assign("Result", ex, ex.source_context)); return(pd); }
public override void visit(formal_parameters _formal_parametres) { foreach (typed_parameters tp in _formal_parametres.params_list) { tp.visit(this); } }
public override void visit(formal_parameters fp) { foreach (var pg in fp.params_list) { AddSymbols(pg.idents.idents, SymKind.param, pg.vars_type); } base.visit(fp); }
public override void visit(formal_parameters fp) { foreach (var id in fp.params_list.SelectMany(tp => tp.idents.idents)) { CheckVariableAlreadyDefined(id); UpperBlockNames.Add(id.name); } }
public procedure_definition lambda(function_lambda_definition _function_lambda_definition) { procedure_definition _func_def = new procedure_definition(); method_name _method_name1 = new method_name(null, null, new ident(_function_lambda_definition.lambda_name), null); //parsertools.create_source_context(_method_name1, _method_name1.meth_name, _method_name1.meth_name); function_header _function_header1 = new function_header(); object rt1 = new object(); _function_header1.name = _method_name1; if (_function_header1.name.meth_name is template_type_name) { _function_header1.template_args = (_function_header1.name.meth_name as template_type_name).template_args; ident id = new ident(_function_header1.name.meth_name.name); //parsertools.create_source_context(id, _function_header1.name.meth_name, _function_header1.name.meth_name); _function_header1.name.meth_name = id; } formal_parameters fps = new formal_parameters(); _function_header1.parameters = _function_lambda_definition.formal_parameters;//fps; /*SyntaxTree.named_type_reference _named_type_reference = new SyntaxTree.named_type_reference(); * SyntaxTree.ident idtype = new SyntaxTree.ident("object"); * _named_type_reference.source_context = idtype.source_context; * _named_type_reference.names.Add(idtype); * rt1 = _named_type_reference; * _function_header1.return_type = (SyntaxTree.type_definition)_named_type_reference;*/ _function_header1.return_type = _function_lambda_definition.return_type; _function_header1.of_object = false; _function_header1.class_keyword = false; token_info _token_info = new token_info("function"); //_token_info.source_context = parsertools.GetTokenSourceContext(); //parsertools.create_source_context(_function_header1, _token_info, _token_info); block _block1 = new block(null, null); statement_list sl1 = new statement_list(); sl1.subnodes.Add(_function_lambda_definition.proc_body); _block1.program_code = sl1; _func_def.proc_header = _function_header1; _func_def.proc_body = (proc_block)_block1; if (_function_lambda_definition.defs != null) { if (((block)_func_def.proc_body).defs == null) { ((block)_func_def.proc_body).defs = new declarations(); } for (int l = 0; l < _function_lambda_definition.defs.Count; l++) { ((block)_func_def.proc_body).defs.defs.Add(_function_lambda_definition.defs[l] as procedure_definition); } } _function_lambda_definition.proc_definition = _func_def; //parsertools.create_source_context(_func_def, _function_header1, _function_header1); return(_func_def); }
public static formal_parameters BuildFormalParameters(List <ident> names, List <type_definition> types) { var fp = new formal_parameters(); for (int i = 0; i < names.Count; i++) { fp.Add(new typed_parameters(names[i], types[i])); } return(fp); }
public static formal_parameters BuildFormalVarParameters(List <ident> names, List <type_definition> types) { var fp = new formal_parameters(); for (int i = 0; i < names.Count; i++) { fp.Add(new typed_parameters(new ident_list(names[i]), types[i], parametr_kind.var_parametr, null)); } return(fp); }
public override void visit(formal_parameters fp) { foreach (var pg in fp.params_list) { var type = pg.vars_type; var q = pg.idents.idents.Select(x => new SymInfoSyntax(x, SymKind.param, type)); Current.Symbols.AddRange(q); } base.visit(fp); }
private void VisitProcParameters(formal_parameters procParametres) { if (procParametres == null || procParametres.params_list == null) { return; } foreach (var tp in procParametres.params_list) { foreach (var id in tp.idents.idents) { var si = _visitor.context.find(id.name); _currentTreeNode.VariablesDefinedInScope.Add(new CapturedVariablesTreeNode.CapturedSymbolInfo(tp, si)); } } }
public override void visit(formal_parameters fp) { if (!first_time_visit_function_header) // чтобы в лямбдах не заходить в формальные параметры. Во вложенных тоже не зайдёт { return; } // SSM переименование формальных параметров (нужно если мы их изменяем внутри) ++CurrentLevel; BlockNamesStack.Add(new Dictionary <string, string>()); if (fp != null) { var fpids = fp.params_list.SelectMany(tp => tp.idents.idents); foreach (var v in fpids) { BlockNamesStack[CurrentLevel].Add(v.name, "$fp_" + v.name); } } // DO NOTHING }
private formal_parameters get_parameters(List <ICSharpCode.NRefactory.Ast.ParameterDeclarationExpression> prms) { formal_parameters fp = new formal_parameters(); foreach (ICSharpCode.NRefactory.Ast.ParameterDeclarationExpression prm in prms) { typed_parameters tp = new typed_parameters(); tp.source_context = get_source_context(prm); tp.idents = new ident_list(); tp.idents.idents.Add(new ident(prm.ParameterName)); tp.vars_type = get_type_reference(prm.TypeReference); tp.inital_value = get_expression(prm.DefaultValue); switch (prm.ParamModifier) { case ICSharpCode.NRefactory.Ast.ParameterModifiers.Ref: tp.param_kind = parametr_kind.var_parametr; break; case ICSharpCode.NRefactory.Ast.ParameterModifiers.Params: tp.param_kind = parametr_kind.params_parametr; break; } fp.params_list.Add(tp); } return(fp); }
public virtual void visit(formal_parameters _formal_parameters) { DefaultVisit(_formal_parameters); }
public virtual void post_do_visit(formal_parameters _formal_parameters) { }
public override void visit(formal_parameters _formal_parameters) { DefaultVisit(_formal_parameters); pre_do_visit(_formal_parameters); for (int i = 0; i < params_list.Count; i++) visit(formal_parameters.params_list[i]); post_do_visit(_formal_parameters); }
public virtual void visit(formal_parameters _formal_parameters) { }
public static procedure_definition CreateFunctionDefinitionNode(method_name methName, formal_parameters formalPars, bool ofObject, bool classKeyword, statement procBody, type_definition returnType, SourceContext sc) { procedure_definition procDef = new procedure_definition(); function_header procHeader = new function_header(); procHeader.name = methName; procHeader.source_context = sc; if (procHeader.name.meth_name is template_type_name) { procHeader.template_args = (procHeader.name.meth_name as template_type_name).template_args; ident id = new ident(procHeader.name.meth_name.name); procHeader.name.meth_name = id; } procHeader.parameters = formalPars; procHeader.of_object = ofObject; procHeader.class_keyword = classKeyword; procHeader.return_type = returnType; statement_list stmtList = new statement_list(); stmtList.subnodes.Add(procBody); block bl = new block(null, null); bl.program_code = stmtList; procDef.proc_header = procHeader; procDef.proc_body = (proc_block)bl; return(procDef); }
public static procedure_definition CreateProcedureDefinitionNode(string methName, formal_parameters formalPars, bool classKeyword, statement procBody, SourceContext sc) { return(InternalCreateProcedureDefinitionNode(methName, formalPars, classKeyword, procBody, sc)); }
public override void visit(formal_parameters _formal_parameters) { executer.visit(_formal_parameters); if (_formal_parameters.params_list != null) foreach (dynamic x in _formal_parameters.params_list) if(x != null) this.visit(x); }
public override void visit(formal_parameters _formal_parametres) { prepare_collection(_formal_parametres.params_list, "parameters"); }
public static procedure_definition BuildShortProcDefinition(formal_parameters fp, procedure_attributes_list att, method_name name, statement st, SourceContext headsc) { var ff = new procedure_header(fp, att, name, null, headsc); return(BuildShortProcFuncDefinition(ff, st)); }
/// <summary> /// Вывод типа параметров лямбд и типа возвращаемого значения при присваивании лямбды переменной /// </summary> public static void InferTypesFromVarStmt(type_node leftType, function_lambda_definition lambdaDef, syntax_tree_visitor visitor) { if (lambdaDef == null) { return; } if (leftType != null) { delegate_internal_interface dii_left = (delegate_internal_interface)leftType.get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left == null) { if (leftType != SystemLibrary.SystemLibrary.system_delegate_type) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } else { return; } } int leftTypeParamsNumber = dii_left.parameters.Count; int lambdaDefParamsCount = 0; if (lambdaDef.formal_parameters != null && lambdaDef.formal_parameters.params_list.Count != 0) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { lambdaDefParamsCount += lambdaDef.formal_parameters.params_list[i].idents.idents.Count; } if (lambdaDefParamsCount != leftTypeParamsNumber) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_PARAMETERS_NUMBER"); } bool flag = true; SyntaxTree.formal_parameters lambdaDefParamsTypes = new formal_parameters(); for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { for (int j = 0; j < lambdaDef.formal_parameters.params_list[i].idents.idents.Count; j++) { var param = new SyntaxTree.typed_parameters(); param.idents = new ident_list(); param.idents.Add(lambdaDef.formal_parameters.params_list[i].idents.idents[j]); param.vars_type = lambdaDef.formal_parameters.params_list[i].vars_type; param.source_context = lambdaDef.formal_parameters.source_context; lambdaDefParamsTypes.Add(param); } } for (int i = 0; i < leftTypeParamsNumber && flag; i++) { if (lambdaDefParamsTypes.params_list[i].vars_type is SyntaxTree.lambda_inferred_type) { if ((lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type is lambda_any_type_node) { var curLeftParType = dii_left.parameters[i].type; lambdaDefParamsTypes.params_list[i].vars_type = new SyntaxTree.lambda_inferred_type(); (lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type = curLeftParType; continue; } } var lambdaPar = visitor.convert_strong(lambdaDefParamsTypes.params_list[i].vars_type); if (!convertion_data_and_alghoritms.eq_type_nodes(dii_left.parameters[i].type, lambdaPar)) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } } lambdaDef.formal_parameters = lambdaDefParamsTypes; } if (lambdaDef.return_type != null && lambdaDef.return_type is lambda_inferred_type) { if (dii_left.return_value_type != null) { (lambdaDef.return_type as lambda_inferred_type).real_type = dii_left.return_value_type; } else // SSM 23/07/16 - попытка бороться с var p: Shape->() := a->a.Print() { var b = TryConvertFuncLambdaBodyWithMethodCallToProcLambdaBody(lambdaDef); if (!b) { throw new SimpleSemanticError(visitor.get_location(lambdaDef), "UNABLE_TO_CONVERT_FUNCTIONAL_TYPE_TO_PROCEDURAL_TYPE"); } } } } else { if (lambdaDef.formal_parameters != null) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { if (lambdaDef.formal_parameters.params_list[i].vars_type is lambda_inferred_type) { visitor.AddError(visitor.get_location(lambdaDef), "IMPOSSIBLE_TO_INFER_TYPES_IN_LAMBDA"); } } } } }
/// <summary> /// Вывод типа параметров лямбд и типа возвращаемого значения при присваивании лямбды переменной /// </summary> public static void InferTypesFromVarStmt(type_node leftType, function_lambda_definition lambdaDef, syntax_tree_visitor visitor, Operators op = Operators.Undefined) { if (lambdaDef == null) { return; } if (leftType != null) { delegate_internal_interface dii_left = (delegate_internal_interface)leftType.get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left == null) { if (leftType != SystemLibrary.SystemLibrary.system_delegate_type) { if (op != Operators.Undefined) { var sil = leftType.find_in_type(name_reflector.get_name(op)); if (sil != null && sil.Count > 0) { foreach (SymbolInfo si in sil) { if (si.sym_info is function_node) { function_node fn = si.sym_info as function_node; if (fn.parameters.Count == 2) { dii_left = (delegate_internal_interface)fn.parameters[1].type.get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left != null) { break; } if (fn.parameters[1].type.is_generic_parameter) { compiled_type_node ctn = leftType as compiled_type_node; common_type_node ctn2 = leftType as common_type_node; if (ctn != null && ctn.is_generic_type_instance && fn.parameters[0].type.is_generic_type_instance && ctn.original_generic == fn.parameters[0].type.original_generic) { dii_left = (delegate_internal_interface)ctn.generic_params[0].get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left != null) { break; } } if (ctn2 != null && ctn2.is_generic_type_instance && ctn2.instance_params.Count > 0 && fn.parameters[0].type.is_generic_type_instance && ctn2.original_generic == fn.parameters[0].type.original_generic) { dii_left = (delegate_internal_interface)ctn2.instance_params[0].get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left != null) { break; } } } } } } } } if (dii_left == null) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } } else { return; } } int leftTypeParamsNumber = dii_left.parameters.Count; int lambdaDefParamsCount = 0; if (lambdaDef.formal_parameters != null && lambdaDef.formal_parameters.params_list.Count != 0) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { lambdaDefParamsCount += lambdaDef.formal_parameters.params_list[i].idents.idents.Count; } if (lambdaDefParamsCount != leftTypeParamsNumber) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_PARAMETERS_NUMBER"); } bool flag = true; SyntaxTree.formal_parameters lambdaDefParamsTypes = new formal_parameters(); for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { for (int j = 0; j < lambdaDef.formal_parameters.params_list[i].idents.idents.Count; j++) { var param = new SyntaxTree.typed_parameters(); param.idents = new ident_list(); param.idents.Add(lambdaDef.formal_parameters.params_list[i].idents.idents[j]); param.vars_type = lambdaDef.formal_parameters.params_list[i].vars_type; param.source_context = lambdaDef.formal_parameters.source_context; lambdaDefParamsTypes.Add(param); } } for (int i = 0; i < leftTypeParamsNumber && flag; i++) { if (lambdaDefParamsTypes.params_list[i].vars_type is SyntaxTree.lambda_inferred_type) { if ((lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type is lambda_any_type_node) { var curLeftParType = dii_left.parameters[i].type; lambdaDefParamsTypes.params_list[i].vars_type = new SyntaxTree.lambda_inferred_type(); (lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type = curLeftParType; continue; } } var lambdaPar = visitor.convert_strong(lambdaDefParamsTypes.params_list[i].vars_type); if (!convertion_data_and_alghoritms.eq_type_nodes(dii_left.parameters[i].type, lambdaPar)) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } } lambdaDef.formal_parameters = lambdaDefParamsTypes; } if (lambdaDef.return_type != null && lambdaDef.return_type is lambda_inferred_type) { if (dii_left.return_value_type != null) { (lambdaDef.return_type as lambda_inferred_type).real_type = dii_left.return_value_type; } else // SSM 23/07/16 - попытка бороться с var p: Shape->() := a->a.Print() { // lambdaDef.usedkeyword == 1 // function var b = lambdaDef.usedkeyword == 0 && TryConvertFuncLambdaBodyWithMethodCallToProcLambdaBody(lambdaDef); // пытаться конвертировать только если мы явно не указали, что это функция if (!b) { visitor.AddError(visitor.get_location(lambdaDef), "UNABLE_TO_CONVERT_FUNCTIONAL_TYPE_TO_PROCEDURAL_TYPE"); } } } } else { if (lambdaDef.formal_parameters != null) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { if (lambdaDef.formal_parameters.params_list[i].vars_type is lambda_inferred_type) { visitor.AddError(visitor.get_location(lambdaDef), "IMPOSSIBLE_TO_INFER_TYPES_IN_LAMBDA"); } } } } }
private static procedure_definition InternalCreateFunctionDefinitionNode(string methName, formal_parameters formalPars, bool classKeyword, statement procBody, type_definition returnType, SourceContext sc) { return(PascalABCCompiler.TreeConverter.LambdaHelper.SyntaxTreeNodesConstructor.CreateFunctionDefinitionNode(new method_name(methName), formalPars, false, classKeyword, procBody, returnType, sc)); }
public override void visit(formal_parameters _formal_parametres) { get_count(_formal_parametres.params_list); }
public static procedure_definition CreateFunctionDefinitionNode(string methName, formal_parameters formalPars, bool classKeyword, statement procBody, type_definition returnType) { return(InternalCreateFunctionDefinitionNode(methName, formalPars, classKeyword, procBody, returnType, null)); }
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); }
// From LamdaHelper private procedure_definition InternalCreateProcedureDefinitionNode(string methName, formal_parameters formalPars, bool classKeyword, statement procBody, SourceContext sc) { return(LambdaHelper.SyntaxTreeNodesConstructor.CreateProcedureDefinitionNode(new method_name(methName), formalPars, false, classKeyword, procBody, sc)); }