Example #1
0
        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));
        }
Example #2
0
        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);
        }
Example #3
0
 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);
        }
Example #7
0
        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);
        }
Example #8
0
        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);
        }
Example #9
0
 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);
 }
Example #10
0
        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));
                }
            }
        }
Example #11
0
 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
 }
Example #12
0
        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);
        }
Example #13
0
 public virtual void visit(formal_parameters _formal_parameters)
 {
     DefaultVisit(_formal_parameters);
 }
Example #14
0
		public virtual void post_do_visit(formal_parameters _formal_parameters)
		{
		}
Example #15
0
		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);
		}
Example #16
0
		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));
 }
Example #19
0
		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);
		}
Example #20
0
 public override void visit(formal_parameters _formal_parametres)
 {
     prepare_collection(_formal_parametres.params_list, "parameters");
 }
Example #21
0
        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));
        }
		public virtual void visit(formal_parameters _formal_parameters)
		{
			DefaultVisit(_formal_parameters);
		}
Example #23
0
 public virtual void visit(formal_parameters _formal_parameters)
 {
 }
Example #24
0
        /// <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));
 }
Example #27
0
 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);
        }
Example #30
0
 // 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));
 }