public override void visit(SyntaxTree.slice_expr sl)
        {
            // Новое
            // Последовательности исключены
            // Преобразуется в вызов a.SystemSlice(situation,from,to,step)
            // situation = 0 - ничего не пропущено
            // situation = 1 - пропущен from
            // situation = 2 - пропущен to
            // situation = 3 - пропущены from и to
            // пропущенность кодируется тем, что в соответствующем поле int.MaxValue

            var semvar = convert_strong(sl.v);
            if (semvar is typed_expression)
                semvar = convert_typed_expression_to_function_call(semvar as typed_expression);

            var semvartype = semvar.type;

            // semvartype должен быть array of T, List<T> или string

            var IsSlicedType = 0; // проверим, является ли semvartype динамическим массивом, списком List или строкой

            var t = ConvertSemanticTypeNodeToNETType(semvartype);

            if (t.IsArray)
                IsSlicedType = 1;
            else if (t == typeof(System.String))
                IsSlicedType = 2;
            else if (t.IsGenericType && t.GetGenericTypeDefinition()==typeof(System.Collections.Generic.List<>))
                IsSlicedType = 3;

            if (IsSlicedType==0)
                AddError(get_location(sl.v), "BAD_SLICE_OBJECT");

            int situation = 0;

            if ((sl.from is int32_const) && (sl.from as int32_const).val==int.MaxValue)
                situation += 1;
            if ((sl.to is int32_const) && (sl.to as int32_const).val == int.MaxValue)
                situation += 2;

            var el = new SyntaxTree.expression_list();
            el.Add(new int32_const(situation));
            el.Add(sl.from);
            el.Add(sl.to);

            if (sl.step != null)
                el.Add(sl.step);

            var mc = new method_call(new dot_node(sl.v, new ident("SystemSlice", sl.v.source_context), sl.v.source_context), el, sl.source_context);
            visit(mc);
        }
 public override void visit(SyntaxTree.function_lambda_call _function_lambda_call)
 {
     SyntaxTree.op_type_node _op_type_node = new SyntaxTree.op_type_node(SyntaxTree.Operators.Assignment);
     for (int i = 0; i < _function_lambda_call.parameters.expressions.Count; i++)
     {
         SyntaxTree.assign _assign = new SyntaxTree.assign(_function_lambda_call.f_lambda_def.parameters.expressions[i] as SyntaxTree.addressed_value, _function_lambda_call.parameters.expressions[i] as SyntaxTree.expression, _op_type_node.type);
         ((SyntaxTree.statement_list)_function_lambda_call.f_lambda_def.proc_body).subnodes.Insert(0, _assign);
         _assign.source_context = _function_lambda_call.source_context;
     }
     SyntaxTree.expression_list el = new SyntaxTree.expression_list();
     for (int i = 0; i < _function_lambda_call.f_lambda_def.formal_parameters.params_list.Count; i++)
         if (i < _function_lambda_call.parameters.expressions.Count)
             el.expressions.Add(_function_lambda_call.parameters.expressions[i]);
         else
         {
             el.expressions.Add(new SyntaxTree.ident(_function_lambda_call.f_lambda_def.formal_parameters.params_list[i].idents.idents[0].name, _function_lambda_call.source_context));
         }
     SyntaxTree.method_call _method_call = new SyntaxTree.method_call(el);
     _method_call.source_context = _function_lambda_call.source_context;
     if (_method_call is SyntaxTree.dereference)
     {
         ((SyntaxTree.dereference)_method_call).dereferencing_value = (SyntaxTree.addressed_value)(new SyntaxTree.ident(_function_lambda_call.f_lambda_def.lambda_name, _function_lambda_call.source_context));
     }
     _method_call.visit(this);
 }
 private SyntaxTree.procedure_call ConvertEventOperationToProcedureCall(SyntaxTree.assign _assign)
 {
     SyntaxTree.ident event_name = _assign.to as SyntaxTree.ident;
     SyntaxTree.dot_node dot = _assign.to as SyntaxTree.dot_node;
     if (dot != null)
         event_name = dot.right as SyntaxTree.ident;
     if (event_name == null)
         AddError(new EventNameExpected(get_location(_assign.to)));
     string format;
     if (_assign.operator_type == PascalABCCompiler.SyntaxTree.Operators.AssignmentSubtraction)
         format = compiler_string_consts.event_remove_method_nameformat;
     else
         format = compiler_string_consts.event_add_method_nameformat;
     SyntaxTree.ident add_name = new SyntaxTree.ident(string.Format(format, event_name.name));
     add_name.source_context = event_name.source_context;
     if (dot != null)
         dot.right = add_name;
     SyntaxTree.expression_list exprlist = new SyntaxTree.expression_list();
     exprlist.expressions.Add(_assign.from);
     exprlist.source_context = _assign.to.source_context;
     SyntaxTree.method_call add_methcall = new SyntaxTree.method_call(exprlist);
     if (dot != null)
         add_methcall.dereferencing_value = dot;
     else
         add_methcall.dereferencing_value = add_name;
     add_methcall.source_context = _assign.source_context;
     SyntaxTree.procedure_call add_proccall = new SyntaxTree.procedure_call(add_methcall);
     add_proccall.source_context = _assign.source_context;
     return add_proccall;
 }
 private SyntaxTree.procedure_call ConvertOperatorToProcedureCall(SyntaxTree.assign _assign)
 {
     SyntaxTree.ident operator_name = new PascalABCCompiler.SyntaxTree.ident(name_reflector.get_name(_assign.operator_type));
     operator_name.source_context = _assign.to.source_context;
     SyntaxTree.dot_node dot = new PascalABCCompiler.SyntaxTree.dot_node(_assign.to, operator_name);
     dot.source_context = _assign.to.source_context;
     SyntaxTree.expression_list exprlist = new SyntaxTree.expression_list();
     exprlist.expressions.Add(_assign.from);
     exprlist.source_context = _assign.to.source_context;
     SyntaxTree.method_call add_methcall = new SyntaxTree.method_call(exprlist);
     add_methcall.dereferencing_value = dot;
     add_methcall.source_context = _assign.source_context;
     SyntaxTree.procedure_call add_proccall = new SyntaxTree.procedure_call(add_methcall);
     add_proccall.source_context = _assign.source_context;
     return add_proccall;
 }
        private void make_attributes_for_declaration(SyntaxTree.unit_module un, common_unit_node cun)
        {
            if (cun.attributes != null)
            {
                Hashtable ht = new Hashtable();
                foreach (SyntaxTree.simple_attribute_list sal in un.attributes.attributes)
                    for (int j = 0; j < sal.attributes.Count; j++)
                    {
                        SyntaxTree.attribute attr = sal.attributes[j];
                        attribute_converted = true;
                        type_node tn = convert_strong(attr.type);
                        bool is_attr = false;
                        type_node tmp = tn;
                        while (tmp.base_type != null && !is_attr)
                        {
                            is_attr = tmp.base_type == SystemLibrary.SystemLibrary.attribute_type;
                            tmp = tmp.base_type;
                        }
                        if (!is_attr)
                            AddError(get_location(attr), "CLASS_{0}_NOT_ATTRIBUTE", tn.name);
                        bool allowMultiple = false;
                        AttributeTargets targets = get_usage_attrs(tn, out allowMultiple);
                        if (ht.Contains(tn) && !allowMultiple)
                        {
                            AddError(get_location(attr), "DUPLICATE_ATTRIBUTE_{0}_APPLICATION", tn.name);
                        }
                        else
                            ht[tn] = tn;
                        SemanticTree.attribute_qualifier_kind qualifier = SemanticTree.attribute_qualifier_kind.none_kind;
                        if (attr.qualifier != null)
                            if (j == 0)
                            {
                                if (string.Compare(attr.qualifier.name, "return", true) == 0)
                                {
                                    if (context.top_function == null)
                                        AddError(get_location(attr), "ATTRIBUTE_APPLICABLE_ONLY_TO_METHOD");
                                    if (context.top_function.return_value_type == null || context.top_function.return_value_type == SystemLibrary.SystemLibrary.void_type)
                                        AddError(get_location(attr), "EXPECTED_RETURN_VALUE_FOR_ATTRIBUTE");
                                    throw new NotSupportedError(get_location(attr.qualifier));
                                    qualifier = SemanticTree.attribute_qualifier_kind.return_kind;
                                }
                                else
                                    throw new NotSupportedError(get_location(attr.qualifier));
                            }
                            else
                                AddError(get_location(attr.qualifier), "ATTRIBUTE_QUALIFIER_MUST_BE_FIRST");
                        check_for_usage_attribute(cun, targets, tn.name, get_location(attr), qualifier);

                        attribute_converted = false;
                        SyntaxTree.expression_list cnstr_args = new SyntaxTree.expression_list();
                        if (attr.arguments != null)
                        {
                            foreach (SyntaxTree.expression e in attr.arguments.expressions)
                            {
                                if (e is SyntaxTree.bin_expr && (e as SyntaxTree.bin_expr).operation_type == SyntaxTree.Operators.Equal
                                    && (e as SyntaxTree.bin_expr).left is SyntaxTree.ident)
                                {
                                    break;
                                }
                                else
                                {
                                    cnstr_args.expressions.Add(e);
                                }
                            }
                        }
                        expressions_list args = new expressions_list();
                        for (int i = 0; i < cnstr_args.expressions.Count; i++)
                        {
                            constant_node cn = convert_strong_to_constant_node(cnstr_args.expressions[i]);
                            check_for_strong_constant(cn, get_location(cnstr_args.expressions[i]));
                            args.AddElement(cn);
                        }

                        base_function_call bfc = create_constructor_call(tn, args, get_location(attr));
                        attribute_node attr_node = new attribute_node(bfc.simple_function_node, tn, get_location(un));
                        foreach (expression_node en in bfc.parameters)
                        {
                            constant_node cn = convert_strong_to_constant_node(en, en.type);
                            check_for_strong_constant(cn, en.location);
                            attr_node.args.Add(cn);
                        }
                        if (attr.arguments != null)
                        {
                            for (int i = cnstr_args.expressions.Count; i < attr.arguments.expressions.Count; i++)
                            {
                                SyntaxTree.expression e = attr.arguments.expressions[i];
                                if (!(e is SyntaxTree.bin_expr && (e as SyntaxTree.bin_expr).operation_type == SyntaxTree.Operators.Equal
                                      && (e as SyntaxTree.bin_expr).left is SyntaxTree.ident))
                                {
                                    AddError(get_location(e), "EXPECTED_ATTRIBUTE_INITIALIZER");
                                }
                                else
                                {
                                    SyntaxTree.ident id = (e as SyntaxTree.bin_expr).left as SyntaxTree.ident;
                                    SymbolInfo si = tn.find(id.name);
                                    definition_node dn = context.check_name_node_type(id.name, si, get_location(id), general_node_type.property_node, general_node_type.variable_node);
                                    type_node mem_tn = null;
                                    if (dn is property_node)
                                    {
                                        property_node pn = dn as property_node;
                                        attr_node.prop_names.Add(pn);
                                        if (pn.set_function == null)
                                            AddError(new ThisPropertyCanNotBeWrited(pn, get_location(id)));
                                        if (pn.set_function.parameters.Count != 1)
                                            AddError(get_location(id), "INDEX_PROPERTY_INITIALIZING_NOT_VALID");
                                        mem_tn = pn.set_function.parameters[0].type;
                                    }
                                    else if (dn is var_definition_node)
                                    {
                                        attr_node.field_names.Add(dn as var_definition_node);
                                        mem_tn = (dn as var_definition_node).type;
                                    }
                                    else
                                    {
                                        throw new CompilerInternalError("Bad general node type for attribute initializer");
                                    }
                                    //SyntaxTree.assign tmp_ass = new SyntaxTree.assign(id,(e as SyntaxTree.bin_expr).right,SyntaxTree.Operators.Assignment);
                                    //tmp_ass.source_context = e.source_context;
                                    //basic_function_call tmp_bfc = convert_strong(tmp_ass) as basic_function_call;
                                    constant_node cn = convert_strong_to_constant_node((e as SyntaxTree.bin_expr).right, mem_tn);
                                    check_for_strong_constant(cn, get_location((e as SyntaxTree.bin_expr).right));
                                    if (dn is property_node)
                                        attr_node.prop_initializers.Add(cn);
                                    else
                                        attr_node.field_initializers.Add(cn);
                                }
                            }
                        }
                        attr_node.qualifier = qualifier;
                        cun.attributes.AddElement(attr_node);
                        if (cun.namespaces.Count > 0)
                            cun.namespaces[0].attributes.AddElement(attr_node);
                    }
            }
        }