private static CreateInstanceMethod GenerateCreateInstanceMethod(ConstructorInfo constructor)
        {
            var           objectType = constructor.DeclaringType;
            DynamicMethod method     = new DynamicMethod(string.Format("CreateInstanceByConstructor_{0}", Guid.NewGuid().ToString("n"))
                                                         , typeof(object)
                                                         , new Type[] { typeof(object[]) }
                                                         , true);

            MethodGenerator g = new MethodGenerator(method);
            //以下代码把数组参数转成,new T(arg0,arg1)的形式
            var result = g.Declare(objectType, "result");
            var objs   = g.Declare <object[]>();

            g.Assign(objs, () =>
            {
                g.LoadParameter(0);
            });

            g.Assign(result, () =>
            {
                g.NewObject(constructor, () =>
                {
                    var index = g.Declare <int>();
                    var prms  = constructor.GetParameters();
                    for (var i = 0; i < prms.Length; i++)
                    {
                        g.Assign(index, () =>
                        {
                            g.Load(i);
                        });

                        g.LoadElement(objs, index);
                        g.Cast(prms[i].ParameterType);
                    }
                });
            });

            g.LoadVariable("result");
            g.Cast(typeof(object));
            g.Return();

            var invoke = method.CreateDelegate(typeof(Func <object[], object>));

            return(new CreateInstanceMethod(invoke));
        }
        private IrisType ProcessArrayAccess(FilePosition fp, Symbol symbol, SymbolLoadMode mode)
        {
            IrisType symbolType = symbol.Type;
            IrisType resultType = IrisType.Invalid;

            if (symbolType != IrisType.Invalid)
            {
                if (!symbolType.IsArray)
                {
                    AddError(fp, string.Format("Symbol '{0}' is not an array, but is being used as an array.", _lexeme));
                }
                else
                {
                    EmitLoadSymbol(symbol, SymbolLoadMode.Dereference);
                    resultType = symbol.Type.GetElementType();
                }
            }

            FilePosition indexerPosition = _lexer.TokenStartPosition;
            IrisType     indexerType     = ParseExpression();

            if (indexerType != IrisType.Integer)
            {
                AddError(indexerPosition, "Expecting integer value as array index.");
            }

            Expect(Token.ChrCloseBracket);

            if (resultType != IrisType.Invalid)
            {
                if (mode == SymbolLoadMode.ElementAddress)
                {
                    MethodGenerator.LoadElementAddress(resultType);
                    resultType = resultType.MakeByRefType();
                }
                else if (mode == SymbolLoadMode.Element)
                {
                    MethodGenerator.LoadElement(resultType);
                }
            }

            return(resultType);
        }