Пример #1
0
 public StateContext(string jobId, MethodData methodData)
 {
     if (String.IsNullOrEmpty(jobId)) throw new ArgumentNullException("jobId");
     
     JobId = jobId;
     MethodData = methodData;
 }
Пример #2
0
        private static IEnumerable<MethodData> GetBaseAndImplementedMethodsForMethod(MethodData method)
        {
            var bases = Inheritance.GetBaseMethods(method);
            var implements = Inheritance.GetImplementedMethods(method);

            return Enumerable.Concat(bases, implements);
        }
Пример #3
0
        public void ToCode_given_ConstructorDataWithoutParameters_should_ReturnDefaultConstructorCode()
        {
            //	#	Arrange.
            var sut = new MethodData();
            sut.Comment = new CommentData("Default constructor.");
            sut.IsConstructor = true;
            sut.Scope = Common.VisibilityScope.Public;
            sut.Name = "MyClassName";

            //	#	Act.
            var res = sut.ToCode();

            //	#	Assert.
            Assert.AreEqual(5, res.Count);
            CollectionAssert.AreEqual(
                new[]
                {
                    "/// <summary> Default constructor.",
                    "/// </summary>",
                    "public MyClassName()",
                    "{",
                    "}",
                },
                res.ToList());
        }
Пример #4
0
        public static IEnumerable<MethodData> GetBaseAndImplementedMethods(MethodData method)
        {
            if (!(method.Inner is MethodInfo)) // constructor
                return Enumerable.Empty<MethodData>();

            return Inheritance.GetBaseAndImplementedMethodsForMethod(method);
        }
        /// <summary>
        /// Sets up an errored execute setup.
        /// </summary>
        /// <param name="methodData">The method data.</param>
        /// <returns>A <see cref="Func{T}"/> returning an errored <see cref="Task"/> setup with the <see cref="Exception"/>.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="methodData"/> parameter is <see langword="null"/>.</exception>
        Func<Task> IExecutionSetup.Setup(MethodData methodData)
        {
            if (methodData == null)
                throw new ArgumentNullException("methodData");

            return Execute;
        }
Пример #6
0
        public static string JobType(MethodData methodData)
        {
            if (methodData == null)
            {
                return "Could not find the target method.";
            }

            return methodData.Type.FullName;
        }
Пример #7
0
        public JobAsMethodPerformStrategy(
            MethodData methodData,
            string[] arguments)
        {
            if (methodData == null) throw new ArgumentNullException("methodData");
            if (arguments == null) throw new ArgumentNullException("arguments");

            _methodData = methodData;
            _arguments = arguments;
        }
Пример #8
0
        public void Ctor_CorrectlySets_PropertyValues()
        {
            var type = typeof (TestJob);
            var methodInfo = type.GetMethod("Perform");
            var method = new MethodData(type, methodInfo);

            Assert.Equal(type, method.Type);
            Assert.Equal(methodInfo, method.MethodInfo);
            Assert.False(method.OldFormat);
        }
Пример #9
0
        public static string DisplayMethod(MethodData methodData)
        {
            if (methodData == null)
            {
                return null;
            }

            var separator = methodData.MethodInfo.IsStatic ? "." : "::";
            return String.Format("{0}{1}{2}", methodData.Type.Name, separator, methodData.MethodInfo.Name);
        }
Пример #10
0
        public JobAsClassPerformStrategy(
            MethodData methodData,
            Dictionary<string, string> arguments)
        {
            if (methodData == null) throw new ArgumentNullException("methodData");
            if (arguments == null) throw new ArgumentNullException("arguments");

            _methodData = methodData;
            _arguments = arguments;
        }
        public virtual IEnumerable<JobFilter> GetFilters(MethodData methodData)
        {
            var typeFilters = GetTypeAttributes(methodData)
                .Select(attr => new JobFilter(attr, JobFilterScope.Type, null));

            var methodFilters = GetMethodAttributes(methodData)
                .Select(attr => new JobFilter(attr, JobFilterScope.Method, null));

            return typeFilters.Union(methodFilters).ToList();
        }
Пример #12
0
        public static IEnumerable<MethodData> GetImplementedMethods(MethodData method)
        {
            var type = method.DeclaringType;
            if (type.Inner.IsInterface)
                return Enumerable.Empty<MethodData>();

            return from implementation in type.ImplementedInterfaces
                   from map in implementation.Members.AsEnumerable()
                   where map.Value == method
                   select (MethodData)map.Key;
        }
Пример #13
0
        public ApplyStateContextFacts()
        {
            _methodData = MethodData.FromExpression(() => Console.WriteLine());
            _newStateMock = new Mock<State>();
            _newStateMock.Setup(x => x.Name).Returns(NewState);

            _transaction = new Mock<IWriteOnlyTransaction>();
            
            _filters = new List<IApplyStateFilter>();
            _handlers = new StateHandlerCollection();
        }
        /// <summary>
        /// Sets up a reflected asynchronous <see cref="MethodBase"/> execution.
        /// </summary>
        /// <param name="methodData">The method data.</param>
        /// <returns>A reflected asynchronous <see cref="MethodBase"/> execution.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="methodData"/> parameter is <see langword="null"/>.</exception>
        Func<Task> IExecutionSetup.Setup(MethodData methodData)
        {
            if (methodData == null)
                throw new ArgumentNullException("methodData");

            _methodUnderTest = methodData.MethodUnderTest;
            _parameters = methodData.Parameters;
            _sut = methodData.InstanceUnderTest;

            return Execute;
        }
Пример #15
0
        public static IEnumerable<MethodData> GetBaseMethods(MethodData method)
        {
            var lastBaseMethod = method;
            var baseMethod = method.Base;

            while (lastBaseMethod != baseMethod) {
                yield return baseMethod;

                lastBaseMethod = baseMethod;
                baseMethod = baseMethod.Base;
            }
        }
Пример #16
0
        private void CollectDirectlyUsedBy(MethodData method)
        {
            method.GetReferencedMethods().Cast<IMemberData>().ForEach(this.Collect);
            this.methodsByBases[method].Cast<IMemberData>().ForEach(this.Collect);

            var generic = method.GetGenericDefinition();
            if (generic != null)
                this.Collect(generic);

            var propertyOrEvent = method.DeclaringMember;
            if (propertyOrEvent != null)
                this.Collect(propertyOrEvent);
        }
        public async Task SetupThrowingExecution(
            [Frozen(Matching.DirectBaseType)] ApplicationException expected,
            ErroredExecutionSetup sut,
            MethodData methodData)
        {
            // Act
            Func<Task> execute = ((IExecutionSetup) sut).Setup(methodData);

            // Executing method should not throw but return a faulted task.
            Task task = execute();

            // Assert
            Assert.True(task.IsFaulted);
            ApplicationException actual = await Assert.ThrowsAsync<ApplicationException>(() => task);
            Assert.Same(expected, actual);
        }
Пример #18
0
        public void ToCode_given_ConstructorDataWithBody_should_ReturnProper()
        {
            //	#	Arrange.
            const string ClassName = "Customer";

            var sut = new MethodData
            {
                IsConstructor = true,
                Scope = Common.VisibilityScope.Internal,
                Name = ClassName,
                Parameters = new List<ParameterData>
                {
                    new ParameterData
                    {
                        Name=ClassName,
                        SystemTypeString = ClassName
                    }
                },
                Body = new BodyData
                {
                    Lines= new List<string>
                    {
                        "this.CustomerId = customer.CustomerId;",
                        "this.CustomerName = customer.CustomerName;"
                    }
                }
            };

            //	#	Act.
            var res = sut.ToCode();

            //	#	Assert.
            CollectionAssert.AreEqual(
                new[]
                {
                    "internal Customer( Customer customer )",
                    "{",
                    "\tthis.CustomerId = customer.CustomerId;",
                    "\tthis.CustomerName = customer.CustomerName;",
                    "}"
                },
                res.ToList());
        }
Пример #19
0
        void drawThreadDestroy(Graphics g, MethodData d, float startY, float endY)
        {
            String threadID = d.methodEvent.ThreadID;

            float x = d.getColumnLeftX() + methodBodyWidth * zoomScale * 0.25f;

            Pen pen = new Pen(getThreadColor(threadID), 2 * zoomScale);
            Brush brush = new SolidBrush(getThreadColor(threadID));

            float[] dashValues = { 4, 1 };
            pen.DashPattern = dashValues;

            float arrowWidth = 5 * zoomScale;

            g.DrawLine(pen, x, startY, x, endY);
            g.DrawLine(pen, 0, endY, x, endY);

            g.DrawLine(pen, 0, endY, arrowWidth, endY - arrowWidth);
            g.DrawLine(pen, 0, endY, arrowWidth, endY + arrowWidth);
        }
 public new bool ShouldSelect(MethodData method, ISelectionContext context)
 {
     return(base.ShouldSelect(method, context));
 }
Пример #21
0
    public X86Codes ConvertIL(MethodData md, ILCode il)
    {
        string mne = il.OpCode.Name;

        if (mne == null)
        {
            return(null);
        }

        X86Codes ret = new X86Codes();

        ret.Address    = il.Address;
        ret.IsBrTarget = il.IsBrTarget;
        if (il.Operand is byte)
        {
            ret.Comment = string.Format("{0} {1:X2}", mne, il.Operand);
        }
        else if (il.Operand is short)
        {
            ret.Comment = string.Format("{0} {1:X4}", mne, il.Operand);
        }
        else if (il.Operand is int)
        {
            ret.Comment = string.Format("{0} {1:X8}", mne, il.Operand);
        }
        else
        {
            ret.Comment = mne;
        }

        int mne_last = mne.Length < 1 ? 0 : (int)(mne[mne.Length - 1] - '0');
        int nOp      = Util.GetOperandValue(il);

        switch (mne)
        {
        case "ldc.i4":
        case "ldc.i4.s":
        case "ldc.i4.0":
        case "ldc.i4.1":
        case "ldc.i4.2":
        case "ldc.i4.3":
        case "ldc.i4.4":
        case "ldc.i4.5":
        case "ldc.i4.6":
        case "ldc.i4.7":
        case "ldc.i4.8":
            ret.Codes.Add(new X86Code("mov", "ax", nOp.ToString()));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "ldloc":
        case "ldloc.s":
        case "ldloc.0":
        case "ldloc.1":
        case "ldloc.2":
        case "ldloc.3":
            ret.Codes.Add(new X86Code("push", string.Format("word [ss:bp-{0}]", (nOp + 1) * 2)));
            break;

        case "ldloca":
        case "ldloca.s":
            ret.Codes.Add(new X86Code("mov", "ax", "bp"));
            ret.Codes.Add(new X86Code("sub", string.Format("ax, {0}", (nOp + 1) * 2)));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "stloc":
        case "stloc.s":
        case "stloc.0":
        case "stloc.1":
        case "stloc.2":
        case "stloc.3":
            ret.Codes.Add(new X86Code("pop", string.Format("word [ss:bp-{0}]", (nOp + 1) * 2)));
            break;

        case "ldarg":
        case "ldarg.s":
        case "ldarg.0":
        case "ldarg.1":
        case "ldarg.2":
        case "ldarg.3":
            ret.Codes.Add(new X86Code("push", string.Format("word [ss:bp+{0}]", Util.GetArgPos(md, nOp, this.optimize))));
            break;

        case "starg":
        case "starg.s":
            ret.Codes.Add(new X86Code("pop", string.Format("word [ss:bp+{0}]", Util.GetArgPos(md, nOp, this.optimize))));
            break;

        case "ldstr":
        {
            int us = ((int)il.Operand) & 0xffffff;
            if (!this.listUS.Contains(us))
            {
                this.listUS.Add(us);
            }
            ret.Codes.Add(new X86Code("mov", "ax", string.Format("US_{0:X8}", us)));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;
        }

        case "ldsfld":
        {
            TableBase tb = this.pedata.idxm.GetTable((int)il.Operand);
            ret.Codes.Add(new X86Code("push", string.Format("word [cs:{0}]", MangleField(tb as FieldTable))));
            break;
        }

        case "stsfld":
        {
            TableBase tb = this.pedata.idxm.GetTable((int)il.Operand);
            ret.Codes.Add(new X86Code("pop", string.Format("word [cs:{0}]", MangleField(tb as FieldTable))));
            break;
        }

        case "pop":
            ret.Codes.Add(new X86Code("pop", "ax"));
            break;

        case "br":
        case "br.s":
            ret.Codes.Add(new X86Code("jmp", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "beq":
        case "beq.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "ax", "dx"));
            ret.Codes.Add(new X86Code("je", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "bne.un":
        case "bne.un.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "ax", "dx"));
            ret.Codes.Add(new X86Code("jne", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "bgt":
        case "bgt.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "ax", "dx"));
            ret.Codes.Add(new X86Code("jc", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "blt":
        case "blt.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "dx", "ax"));
            ret.Codes.Add(new X86Code("jc", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "ble":
        case "ble.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "ax", "dx"));
            ret.Codes.Add(new X86Code("jnc near", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "bge":
        case "bge.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "dx", "ax"));
            ret.Codes.Add(new X86Code("jnc", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "brfalse":
        case "brfalse.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("or", "ax", "ax"));
            ret.Codes.Add(new X86Code("jz", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "brtrue":
        case "brtrue.s":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("or", "ax", "ax"));
            ret.Codes.Add(new X86Code("jnz", string.Format("PE_{0:X8}", Girl.PEAnalyzer.Util.GetBrTarget(il))));
            if (this.optimize > 0 && nOp == 0)
            {
                ret.Ignore();
            }
            break;

        case "call":
        {
            TableBase  tb    = this.pedata.idxm.GetTable((int)il.Operand);
            MethodData tb_md = tb.Tag as MethodData;
            ret.Codes.Add(new X86Code("call", string.Format("{0}", Util.MangleFunction(tb_md))));
            if (tb_md.RetType.Element != ELEMENT_TYPE.VOID)
            {
                ret.Codes.Add(new X86Code("push", "ax"));
            }
            break;
        }

        //case "callvirt":
        //{
        //	TableBase tb = this.pedata.idxm.GetTable((int)il.Operand);
        //	MethodData tb_md = tb.Tag as MethodData;
        //	string func = Util.MangleFunction(tb_md);
        //	if (func.StartsWith("instance__")) func = func.Substring(10, func.Length - 10);
        //	sw.WriteLine("\tcall _virtual__{0}", func);
        //	if (tb_md.RetType.Element != ELEMENT_TYPE.VOID) sw.WriteLine("\tpush ax");
        //	break;
        //}
        case "ret":
            if (this.optimize == 0 || il == this.lastRet)
            {
                if (md.RetType.Element != ELEMENT_TYPE.VOID)
                {
                    ret.Codes.Add(new X86Code("pop", "ax"));
                }
                if (md.LocalVars != null || md.ParamCount > 0)
                {
                    if (md.LocalVars != null)
                    {
                        ret.Codes.Add(new X86Code("mov", "sp", "bp"));
                    }
                    ret.Codes.Add(new X86Code("pop", "bp"));
                }
                int st = Util.GetStackSize(md);
                if (st == 0)
                {
                    ret.Codes.Add(new X86Code("ret"));
                }
                else
                {
                    ret.Codes.Add(new X86Code("ret", st.ToString()));
                }
            }
            else
            {
                X86Code x = new X86Code("jmp", string.Format("PE_{0:X8}", this.lastRet.Address));
                x.Notes = "[optimize] modify";
                ret.Codes.Add(x);
                this.lastRet.IsBrTarget = true;
            }
            break;

        case "ceq":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("cmp", "ax", "dx"));
            ret.Codes.Add(new X86Code("je", string.Format("NM_{0:X8}", this.number)));
            ret.Codes.Add(new X86Code("xor", "ax", "ax"));
            ret.Codes.Add(new X86Code("jmp", string.Format("NM_{0:X8}", this.number + 1)));
            ret.Codes.Add(new X86Code(string.Format("NM_{0:X8}", this.number), true, "ceq internal", "mov", "ax", "1"));
            ret.Codes.Add(new X86Code(string.Format("NM_{0:X8}", this.number + 1), true, "ceq internal", "push", "ax"));
            this.number += 2;
            break;

        case "add":
        case "and":
        case "or":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code(mne, "ax", "dx"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "sub":
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("sub", "ax", "dx"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "mul":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("pop", "dx"));
            ret.Codes.Add(new X86Code("mul", "dx"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "div":
            ret.Codes.Add(new X86Code("pop", "cx"));
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("xor", "dx", "dx"));
            ret.Codes.Add(new X86Code("div", "cx"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "rem":
            ret.Codes.Add(new X86Code("pop", "cx"));
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("xor", "dx", "dx"));
            ret.Codes.Add(new X86Code("div", "cx"));
            ret.Codes.Add(new X86Code("push", "dx"));
            break;

        case "neg":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("neg", "ax"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "shr":
        case "shl":
            ret.Codes.Add(new X86Code("pop", "cx"));
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code(mne, "ax", "cl"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "conv.u1":
            ret.Codes.Add(new X86Code("pop", "ax"));
            ret.Codes.Add(new X86Code("mov", "ah", "0"));
            ret.Codes.Add(new X86Code("push", "ax"));
            break;

        case "conv.i2":
        case "conv.u2":
        case "conv.i4":
        case "conv.u4":
            // ignore in 16bit
            return(ret);
            //case "box":
            //{
            //	TypeRefTable t = this.pedata.idxm.GetTable((int)il.Operand) as TypeRefTable;
            //	sw.WriteLine("\tcall _box__{0}@4", GetTypeName(this.pedata.idxm.GetName(t)));
            //	sw.WriteLine("\tpush ax");
            //	break;
            //}
        }
        if (ret.Codes.Count < 1)
        {
            return(null);
        }
        return(ret);
    }
Пример #22
0
 protected virtual JobFilterInfo GetFilters(MethodData methodData)
 {
     return new JobFilterInfo(_getFiltersThunk(methodData));
 }
Пример #23
0
 private static bool IsBetterThan(Expression[] args, MethodData m1, MethodData m2)
 {
     bool better = false;
     for (int i = 0; i < args.Length; i++)
     {
         int c = CompareConversions(args[i].Type,
                                    m1.Parameters[i].ParameterType,
                                    m2.Parameters[i].ParameterType);
         if (c < 0) return false;
         if (c > 0) better = true;
     }
     return better;
 }
 protected virtual IEnumerable<JobFilterAttribute> GetMethodAttributes(
     MethodData methodData)
 {
     return methodData.GetMethodFilterAttributes(_cacheAttributeInstances);
 }
Пример #25
0
 private bool IsApplicable(MethodData method, Expression[] args)
 {
     if (method.Parameters.Length != args.Length)
         return false;
     var expressionArray = new Expression[args.Length];
     for (int index = 0; index < args.Length; ++index)
     {
         ParameterInfo parameterInfo = method.Parameters[index];
         if (parameterInfo.IsOut)
             return false;
         Expression expression = this.PromoteExpression(args[index], parameterInfo.ParameterType, false);
         if (expression == null)
             return false;
         expressionArray[index] = expression;
     }
     method.Args = expressionArray;
     return true;
 }
        public async Task TestStringInput(MethodData method)
        {
            await method.Execute().ConfigureAwait(false);

            Assert.True(SomeNullableValueTypeParameters.StringInputTested);
        }
Пример #27
0
        //建立编译文件
        public void CreateCompile(bool build)
        {
            string[] fileNames;
            //获取要生成的文件
            if (genConfig != null)
            {
                if (genConfig.controllerFiles.Count > 0)
                {
                    fileNames = new string[genConfig.controllerFiles.Count];
                    for (int i = 0; i < fileNames.Length; i++)
                    {
                        fileNames[i] = Frame.MapPath(genConfig.controllerFiles[i]);
                    }
                }
                else
                {
                    return;
                }
            }
            else
            {
                if (!Directory.Exists(Frame.MapPath(config.Controller)))
                {
                    return;
                }
                //获取所有的controls文件
                fileNames = Directory.GetFiles(Frame.MapPath(config.Controller), "*.cs", SearchOption.AllDirectories);
                if (fileNames == null || fileNames.Length < 1)
                {
                    return;
                }
            }

            //生成的代码
            string compileCode = "";
            //类名称
            string ClassName = "";

            //前面的字符串部分添加或删除后,后面的代码的相对位置
            int relative_postion = 0;

            if (fileNames.Length > 0)
            {
                Compiler     com        = new Compiler();
                FileData     fileData   = null;
                ClassData    classData  = null;
                MethodData   methodData = null;
                StreamWriter sw         = null;
                VTemplate.Engine.TemplateDocument swDebug = null;
                //VTemplate.Engine.TemplateDocument swAspx = null;

                string compileFileName = "";
                string compileDir      = "";
                string debugFileName   = "";
                string methodContent   = "";
                for (int i = 0; i < fileNames.Length; i++)
                {
                    fileData = fileData = com.GetFileData(Frame.appRoot, this.config.APP, fileNames[i], System.Text.Encoding.UTF8);

                    ClassName = Path.GetFileNameWithoutExtension(fileNames[i]);
                    classData = fileData.GetClassData(ClassName);


                    if (classData.MethodDataList.Count > 0)
                    {
                        for (int j = 0; j < classData.MethodDataList.Count; j++)
                        {
                            //只有公开方法才能访问
                            if (classData.MethodDataList[j].isPublic)
                            {
                                relative_postion = 0;
                                compileCode      = fileData.csharpCode.ToString();
                                methodData       = classData.MethodDataList[j];
                                //相对
                                compileDir = config.ChangeControllerName(config.Web + config.defaultStyle, (fileData.nameSpace + '.' + ClassName).Replace('.', '/')) + "/";
                                //绝对
                                compileFileName = Frame.MapPath(compileDir + methodData.name + ".cs");
                                if (!Directory.Exists(Path.GetDirectoryName(compileFileName)))
                                {
                                    Directory.CreateDirectory(Path.GetDirectoryName(compileFileName));
                                }
                                //调试文件
                                debugFileName = Frame.MapPath(compileDir + methodData.name + ".html");
                                //输出调试文件
                                if (!File.Exists(debugFileName))
                                {
                                    swDebug = new VTemplate.Engine.TemplateDocument(Frame.MapPath("/NFinal/Template/Debug.tpl"), System.Text.Encoding.UTF8);
                                    swDebug.SetValue("Url", config.ChangeControllerName(config.APP, (fileData.nameSpace + '.' + ClassName).Replace('.', '/')) + "/" + methodData.name + ".htm");
                                    swDebug.RenderTo(debugFileName, System.Text.Encoding.UTF8);
                                }
                                relative_postion += Replace(ref compileCode, relative_postion + fileData.start, fileData.length, "namespace " + (Frame.AssemblyTitle + compileDir.TrimEnd('/')).Replace('/', '.') + "\r\n{");
                                relative_postion += Replace(ref compileCode, relative_postion + classData.start, classData.length, "public class " +
                                                            methodData.name + "Action " + (string.IsNullOrEmpty(classData.baseName) ? "" : " : " + classData.baseName) + "\r\n\t{"
                                                            //添加初始化函数
                                                            + "\r\n\t\tpublic " + methodData.name + "Action(System.IO.TextWriter tw):base(tw){}"
                                                            + "\r\n\t\tpublic " + methodData.name + "Action(string fileName) : base(fileName) {}");
                                //循环内部所有方法
                                for (int k = 0; k < classData.MethodDataList.Count; k++)
                                {
                                    methodData = classData.MethodDataList[k];
                                    //如果两个相等,则进行替换
                                    if (j == k || (!classData.MethodDataList[k].isPublic))
                                    {
                                        #region "替换原有方法"
                                        //排除非公开和非基类的方法,替换原有方法体
                                        //if (methodData.isPublic)
                                        {
                                            methodContent = methodData.Content;
                                            SqlCompiler sqlCompiler = new NFinal.Compile.SqlCompiler();
                                            //从代码中分析出数据库相关函数
                                            List <DbFunctionData> dbFunctions = sqlCompiler.Compile(com.DeleteComment(methodContent));

                                            if (dbFunctions.Count > 0)
                                            {
                                                SqlAnalyse analyse = new SqlAnalyse();
                                                //与数据库相结合,从sql语句中分析出所有的表信息,列信息
                                                methodData.dbFunctions = analyse.FillFunctionDataList(NFinal.DB.Coding.DB.DbStore, dbFunctions);
                                            }
                                            //数据库函数替换
                                            int    content_relative_position = 0;
                                            string StructDatas = string.Empty;
                                            if (dbFunctions.Count > 0)
                                            {
                                                bool          hasSameVarName = false;
                                                List <string> varNames       = new List <string>();
                                                //添加struct类型
                                                for (int s = 0; s < dbFunctions.Count; s++)
                                                {
                                                    //去除重复项
                                                    if (varNames.Count > 0)
                                                    {
                                                        hasSameVarName = false;
                                                        for (int c = 0; c < varNames.Count; c++)
                                                        {
                                                            //如果发现重复项,则跳过循环
                                                            if (varNames[c] == dbFunctions[s].varName)
                                                            {
                                                                hasSameVarName = true;
                                                                break;
                                                            }
                                                        }
                                                        if (hasSameVarName)
                                                        {
                                                            continue;
                                                        }
                                                    }
                                                    varNames.Add(dbFunctions[s].varName);
                                                    //分析出sql返回的List<dynamic>和dynamic类型是否有用AddNewField(string fileName,Type t);添加相关的类型
                                                    NewField newFiled = new NewField(dbFunctions[s].varName);
                                                    List <NFinal.Compile.StructField> structFieldList = newFiled.GetFields(ref methodContent, methodData.name);
                                                    //添加struct字段
                                                    string StructData = sqlCompiler.SetMagicStruct(methodData.name, dbFunctions[s], structFieldList, Frame.appRoot);
                                                    StructDatas += StructData;
                                                    if (!string.IsNullOrEmpty(StructData))
                                                    {
                                                        compileCode       = compileCode.Insert(methodData.start + relative_postion, StructData);
                                                        relative_postion += StructData.Length;
                                                    }
                                                }
                                                //更换函数中的数据库操作
                                                content_relative_position += sqlCompiler.SetMagicFunction(methodData.name,
                                                                                                          ref methodContent,
                                                                                                          content_relative_position,
                                                                                                          methodData.dbFunctions,
                                                                                                          Frame.appRoot);
                                                //分析并更换其中的连接字符串
                                                content_relative_position += sqlCompiler.SetMagicConnection(methodData.name,
                                                                                                            ref methodContent,
                                                                                                            Frame.appRoot
                                                                                                            );
                                            }
                                            if (methodData.parameterTypeAndNames != string.Empty)
                                            {
                                                relative_postion += Replace(ref compileCode, relative_postion + methodData.parametersIndex, methodData.parametersLength, methodData.parameterTypeAndNames);
                                            }
                                            //从代码中分析出views函数
                                            NFinal.Compile.ViewCompiler viewCompiler = new NFinal.Compile.ViewCompiler();
                                            List <ViewData>             views        = viewCompiler.Compile(methodContent);
                                            //模版替换
                                            if (views.Count > 0)
                                            {
                                                content_relative_position = 0;
                                                content_relative_position = viewCompiler.SetMagicFunction(ref methodContent,
                                                                                                          content_relative_position,
                                                                                                          fileData.nameSpace,
                                                                                                          ClassName,
                                                                                                          methodData.name, views, config);
                                            }
                                            if (build)
                                            {
                                                relative_postion += Replace(ref compileCode, relative_postion + methodData.position, methodData.Content.Length, methodContent);
                                            }
                                            else
                                            {
                                                relative_postion += Replace(ref compileCode, relative_postion + methodData.position, methodData.Content.Length, string.Empty);
                                            }
                                            //生成自动提示类
                                            //views,Structs,DBFunctions
                                            AutoCompleteCompiler autoComplete = new AutoCompleteCompiler();
                                            autoComplete.Compile(classData.baseName, methodData, StructDatas, views, fileData.nameSpace, ClassName, config);
                                        }
                                        #endregion
                                    }
                                    //如果两个不相等
                                    else
                                    {
                                        compileCode = compileCode.Remove(relative_postion + classData.MethodDataList[k].start,
                                                                         classData.MethodDataList[k].length +
                                                                         classData.MethodDataList[k].Content.Length + 1);//去掉最后一个}
                                        relative_postion -= classData.MethodDataList[k].length +
                                                            classData.MethodDataList[k].Content.Length + 1;
                                    }
                                }
                                //写aspx页面的自动提示层

                                //写Web层.class文件
                                sw = new StreamWriter(compileFileName, false, System.Text.Encoding.UTF8);
                                sw.Write(compileCode);
                                sw.Close();
                            }
                        }
                    }
                }
            }
        }
Пример #28
0
    public bool WriteAsm(string asm)
    {
        MethodDefTable m = this.pedata.idxm.GetTable(this.pedata.cli.EntryPointToken) as MethodDefTable;

        if (m == null)
        {
            System.Console.WriteLine("Can not find entry point!");
            return(false);
        }
        this.entryPoint = m.Tag as MethodData;
        System.Console.WriteLine("Entry Point: {0}", this.entryPoint.FullName);

        bool         ok = true;
        FileStream   fs = new FileStream(asm, FileMode.Create);
        StreamWriter sw = new StreamWriter(fs);

        this.hashUS = new Hashtable();
        this.listUS = new ArrayList();
        if (this.pedata.usrstr != null)
        {
            int ad = this.pedata.usrstr.GetDataOffset(), ptr = 1;
            while (this.data[ad + ptr] != 0 && ptr < this.pedata.usrstr.Size)
            {
                DoubleInt dataSize = this.pedata.usrstr.GetDataSize(ad + ptr);
                byte[]    bytes    = Girl.PEAnalyzer.Util.GetBytes(this.data, ad + ptr + dataSize.A, dataSize.B);
                this.hashUS[ptr] = Encoding.Unicode.GetString(bytes, 0, dataSize.B - 1);
                ptr += dataSize.A + dataSize.B;
            }
        }

        this.number = 0;
        sw.WriteLine("; This file was automatically generated by IL2Asm16.");
        if (this.pre != null)
        {
            this.InsertFile(sw, this.pre);
        }
        sw.WriteLine();
        sw.WriteLine("[bits 16]");
        if (!this.noMain)
        {
            sw.WriteLine("jmp {0}", this.jumpTo);
            sw.WriteLine();

            sw.WriteLine("ILMain:");
            foreach (object obj in this.pedata.idxm.Tables[(int)MetadataTables.TypeDef])
            {
                TypeDefTable t = obj as TypeDefTable;
                foreach (object obj2 in t.Children[(int)Children.DefMethod])
                {
                    MethodDefTable mdt = obj2 as MethodDefTable;
                    MethodData     md  = mdt.Tag as MethodData;
                    if (!md.Name.EndsWith("::.cctor"))
                    {
                        continue;
                    }

                    sw.WriteLine("\tcall\t{0}", Util.MangleFunction(md));
                }
            }
            sw.WriteLine("\tcall\t{0}", Util.MangleFunction(this.entryPoint));
            sw.WriteLine("\tret");
        }

        foreach (object obj in this.pedata.idxm.Tables[(int)MetadataTables.TypeDef])
        {
            TypeDefTable t = obj as TypeDefTable;
            sw.WriteLine();
            if (!this.WriteAsm(sw, t))
            {
                ok = false;
            }
        }

        if (this.listUS.Count > 0)
        {
            sw.WriteLine();
            this.listUS.Sort();
            foreach (object obj in this.listUS)
            {
                int           ptr   = (int)obj;
                string        str   = this.hashUS[ptr] as string;
                bool          instr = false;
                StringBuilder sb    = new StringBuilder();
                foreach (char ch in str)
                {
                    if (ch < ' ')
                    {
                        if (instr)
                        {
                            sb.Append('\"');
                            instr = false;
                        }
                        if (sb.Length > 0)
                        {
                            sb.Append(", ");
                        }
                        sb.AppendFormat("0x{0:x2}", (int)ch);
                    }
                    else
                    {
                        if (!instr)
                        {
                            sb.Append('\"');
                            instr = true;
                        }
                        sb.Append(ch);
                    }
                }
                if (instr)
                {
                    sb.Append('\"');
                }
                sw.WriteLine("US_{0:X8} db {1}, {2}, 0x00", ptr, str.Length, sb);
            }
        }

        if (this.post != null)
        {
            this.InsertFile(sw, this.post);
        }
        sw.Close();
        fs.Close();
        return(ok);
    }
Пример #29
0
        private MethodData GetMethodData(MethodCall methodCall)
        {
            MethodData methodData;
            MethodBase method = methodCall.MethodBase;

            if (_methodDataCache.TryGetMethodData(method, out methodData))
            {
                return(methodData);
            }

            bool canCacheMessageData;

            Type declaringType = method.DeclaringType;

            if (declaringType == typeof(object) && method == typeof(object).GetMethod("GetType"))
            {
                canCacheMessageData = true;
                methodData          = new MethodData(method, MethodType.GetType);
            }
            else if (declaringType.IsAssignableFrom(_serviceChannel.GetType()))
            {
                canCacheMessageData = true;
                methodData          = new MethodData(method, MethodType.Channel);
            }
            else
            {
                ProxyOperationRuntime operation = _proxyRuntime.GetOperation(method, methodCall.Args, out canCacheMessageData);

                if (operation == null)
                {
                    if (_serviceChannel.Factory != null)
                    {
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.SFxMethodNotSupported1, method.Name)));
                    }
                    else
                    {
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.SFxMethodNotSupportedOnCallback1, method.Name)));
                    }
                }

                MethodType methodType;

                if (operation.IsTaskCall(methodCall))
                {
                    methodType = MethodType.TaskService;
                }
                else if (operation.IsSyncCall(methodCall))
                {
                    methodType = MethodType.Service;
                }
                else if (operation.IsBeginCall(methodCall))
                {
                    methodType = MethodType.BeginService;
                }
                else
                {
                    methodType = MethodType.EndService;
                }

                methodData = new MethodData(method, methodType, operation);
            }

            if (canCacheMessageData)
            {
                _methodDataCache.SetMethodData(methodData);
            }

            return(methodData);
        }
Пример #30
0
        private static IconAccess GetAccess(MethodData method)
        {
            if (method.Inner.IsPrivate)
                return IconAccess.Private;

            if (method.Inner.IsFamily)
                return IconAccess.Protected;

            if (method.Inner.IsAssembly || method.Inner.IsFamilyOrAssembly)
                return IconAccess.Internal;

            return IconAccess.Public;
        }
Пример #31
0
 public MethodWapper(MethodData methodData, ManagementObject wmiInstance)
 {
     Method      = methodData;
     WMIInstance = wmiInstance;
 }
        private MethodData PackMethod(MethodDefinition method)
        {
            var sinst = new List <StoredInstruction>();

            foreach (var inst in method.Body.Instructions)
            {
                if (inst.Operand is Instruction)
                {
                    continue;
                }

                var _op = inst.Operand;
                if (_op is TypeReference)
                {
                    var op = (TypeReference)_op;
                    _op = new StoredTypeReference()
                    {
                        name = op.Name,
                        ns   = op.Namespace
                    };
                }
                else if (_op is FieldReference)
                {
                    var op = (FieldReference)_op;
                    _op = new StoredFieldReference()
                    {
                        name = op.Name
                    };
                }
                else if (_op is MethodReference)
                {
                    var op = (MethodReference)_op;
                    _op = new StoredMethodReference()
                    {
                        name = op.Name
                    };
                }
                else if (_op is VariableReference)
                {
                    var op = (VariableReference)_op;
                    _op = new StoredVariableReference()
                    {
                    };
                }

                sinst.Add(new StoredInstruction()
                {
                    opcode  = inst.OpCode,
                    operand = _op
                });

                if (inst.Operand != null)
                {
                    Console.WriteLine(inst.Operand.GetType());
                }
            }

            var methodData = new MethodData()
            {
                instructions = sinst.ToArray()
            };

            Console.WriteLine(JsonConvert.SerializeObject(methodData, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            }));

            return(methodData);
        }
Пример #33
0
        protected override void OnPaint(PaintEventArgs eva)
        {
            base.OnPaint(eva);

            classData = new Hashtable();
            lastMethodData = new Hashtable();
            nextFreeColumn = 0;

            Graphics g = eva.Graphics;

            g.FillRectangle(new SolidBrush(Color.White), new Rectangle(0, 0, Width, Height));

            if (events.Count == 0) {
                return;
            }
            if (zoomScale >= 0.5)
            {
                g.TranslateTransform(padding + padding + timestampWidth, padding);
            }
            else {
                g.TranslateTransform(padding, padding);
            }

            double lastTimestamp = -1;
            double firstTimeStamp = lastTimestamp;
            float lastY = 0;
            double mediumDeltaTime = getMediumDeltaTime();
            String lastThreadId = null;

            Hashtable threadCreationY = new Hashtable();
            Hashtable threadDestroyY = new Hashtable();

            foreach (LogEvent logEvent in events)
            {
                if (logEvent is MethodEvent)
                {
                    MethodEvent e = (MethodEvent)logEvent;
                    if (unwantedObjectIDs.Contains(e.InstanceObjectID)) continue;
                    if (unwantedThreadIDs.Contains(e.ThreadID)) continue;
                    if (unwantedClassesIDs.Contains(e.MethodInfo.ClassName)) continue;
                }

                if (logEvent is ThreadEvent)
                {
                    ThreadEvent e = (ThreadEvent)logEvent;
                    if (unwantedThreadIDs.Contains(e.ThreadID)) continue;
                }

                if (lastTimestamp == -1)
                {
                    firstTimeStamp = logEvent.timestamp;
                    lastTimestamp = logEvent.timestamp;
                }

                double deltaTime = logEvent.timestamp - lastTimestamp;
                float deltaY = (float) Math.Max(20, Math.Min(40 * (deltaTime / mediumDeltaTime), 80)) * zoomScale;

                float topY = padding + lastY - 20;
                float bottomY = topY + deltaY + 40;

                bool hasToDraw = !((topY <= eva.ClipRectangle.Top && bottomY <= eva.ClipRectangle.Top) || (topY >= eva.ClipRectangle.Bottom && bottomY >= eva.ClipRectangle.Bottom));

                if (hasToDraw)
                {
                    if (zoomScale >= 0.5)
                    {
                        String time = convertToReadableNumber(lastTimestamp + deltaTime - firstTimeStamp);
                        g.DrawString(time, new Font("Courier New", 7), Brushes.Black, -padding - timestampWidth, deltaY + lastY - 7);
                    }

                    foreach (DictionaryEntry de in classData)
                    {
                        ClassData d = (ClassData)de.Value;

                        foreach (MethodData m in d.methodData)
                        {
                            if (m.classData.getColumnLeftX() < eva.ClipRectangle.Right && m.classData.getColumnRightX() > eva.ClipRectangle.Left)
                            {
                                drawMethodData(g, m, lastY, lastY + deltaY);
                            }

                        }
                    }
                }

                if (logEvent is MethodEvent)
                {
                    MethodEvent e = (MethodEvent) logEvent;

                    String currentThreadID = e.ThreadID;

                    bool mustDrawHeader = !classData.ContainsKey(e.getHash());
                    ClassData currentClassData = getOrCreateClassData(e);

                    if (mustDrawHeader)
                    {
                        drawHeader(g, e, currentClassData.getColumnLeftX(), lastY + deltaY);
                        currentClassData.creationY = lastY + deltaY;
                    }

                    if (e.EventType == MethodEvent.EventTypeEnum.EnterEvent) {

                        MethodData currentMethodData = new MethodData();

                        if (lastMethodData.ContainsKey(currentThreadID))
                            currentMethodData.callerMethodData = (MethodData) lastMethodData[currentThreadID];

                        currentMethodData.classData = currentClassData;
                        currentMethodData.methodColumnNumber = currentClassData.methodData.Count;
                        currentMethodData.methodEvent = e;

                        currentClassData.methodData.Add(currentMethodData);

                        lastMethodData[currentThreadID] = currentMethodData;

                        if (hasToDraw)
                            drawMethodEnter(g, currentMethodData, lastY + deltaY);

                        if (threadCreationY.ContainsKey(currentThreadID)) {
                            float startY = (float)threadCreationY[currentThreadID];
                            drawThreadCreate(g, currentMethodData, startY, lastY + deltaY);
                            threadCreationY.Remove(currentThreadID);
                        }

                    }
                    else if (e.EventType == MethodEvent.EventTypeEnum.LeaveEvent && currentClassData.methodData.Count > 0)
                    {

                        MethodData currentMethodData = (MethodData) currentClassData.methodData[currentClassData.methodData.Count - 1];
                        lastMethodData[currentThreadID] = currentMethodData.callerMethodData;
                        currentClassData.methodData.RemoveAt(currentClassData.methodData.Count - 1);

                        threadDestroyY[currentThreadID] = currentMethodData;
                        currentMethodData.leaveY = lastY + deltaY;

                        if (hasToDraw)
                         drawMethodLeave(g, currentMethodData, lastY + deltaY);

                    }

                    lastThreadId = currentThreadID;
                }

                if (logEvent is ExceptionEvent)
                {
                    if (hasToDraw && lastThreadId != null)
                       drawException(g, (MethodData) lastMethodData[lastThreadId], lastY + deltaY);
                }

                if (logEvent is ThreadEvent)
                {
                    ThreadEvent threadEvent = (ThreadEvent)logEvent;

                    if (threadEvent.EventType == ThreadEvent.EventTypeEnum.CreateEvent)
                    {
                        drawThreadCreated(g, threadEvent.ThreadID, lastY + deltaY);
                        threadCreationY[threadEvent.ThreadID] = lastY + deltaY;
                    }

                    if (threadEvent.EventType == ThreadEvent.EventTypeEnum.DestroyEvent)
                    {
                        MethodData md = (MethodData)threadDestroyY[threadEvent.ThreadID];
                        drawThreadDestroyed(g, threadEvent.ThreadID, lastY + deltaY);
                        if (md != null)
                            drawThreadDestroy(g, md, md.leaveY, lastY + deltaY);
                    }
                }

                lastY += deltaY;
                lastTimestamp = logEvent.timestamp;

            }

            Pen blackPen = new Pen(Color.Gray);
            foreach (DictionaryEntry d in this.classData) {
                ClassData c = (ClassData)d.Value;
                g.DrawLine(blackPen, c.getColumnMidX(), c.creationY, c.getColumnMidX(), lastY);
            }

            this.MinimumSize = new Size((int)(timestampWidth + 3.0f * padding + (nextFreeColumn * (colWidth + colInterspace)) * zoomScale), (int)(2.0f * padding * zoomScale + lastY + 40));
            this.Size = this.MinimumSize;
        }
Пример #34
0
        public void CreateDAL(bool build)
        {
            string[] fileNames;
            //获取要生成的文件
            if (genConfig != null)
            {
                if (genConfig.bllFiles.Count > 0)
                {
                    fileNames = new string[genConfig.bllFiles.Count];
                    for (int i = 0; i < fileNames.Length; i++)
                    {
                        fileNames[i] = Frame.MapPath(genConfig.bllFiles[i]);
                    }
                }
                else
                {
                    return;
                }
            }
            else
            {
                if (!Directory.Exists(Frame.MapPath(config.BLL)))
                {
                    return;
                }
                //获取所有的bll文件
                fileNames = Directory.GetFiles(Frame.MapPath(config.BLL), "*.cs", SearchOption.AllDirectories);
                if (fileNames == null || fileNames.Length < 1)
                {
                    return;
                }
            }

            //生成的代码
            string compileCode = "";
            //类名称
            string ClassName = "";

            int relative_position = 0;

            if (fileNames.Length > 0)
            {
                Compiler     com        = new Compiler();
                FileData     fileData   = null;
                ClassData    classData  = null;
                MethodData   methodData = null;
                StreamWriter sw         = null;

                string compileFileName = "";
                string compileDir      = "";
                string methodContent   = "";

                for (int i = 0; i < fileNames.Length; i++)
                {
                    relative_position = 0;
                    fileData          = com.GetFileData(Frame.appRoot, this.config.APP, fileNames[i], System.Text.Encoding.UTF8);

                    ClassName   = Path.GetFileNameWithoutExtension(fileNames[i]);
                    classData   = fileData.GetClassData(ClassName);
                    compileCode = fileData.csharpCode.ToString();
                    //相对
                    compileDir = config.ChangeBLLName(config.DAL.Trim('/'), fileData.nameSpace.Replace('.', '/'));
                    //绝对
                    compileFileName = Frame.MapPath(compileDir + "\\" + ClassName + ".cs");
                    //更改命名空间
                    relative_position += Replace(ref compileCode, relative_position + fileData.start, fileData.length, "namespace " + (Frame.AssemblyTitle + "/" + compileDir.TrimEnd('/')).Replace('/', '.') + "\r\n{");
                    if (classData.MethodDataList.Count > 0)
                    {
                        for (int j = 0; j < classData.MethodDataList.Count; j++)
                        {
                            methodData    = classData.MethodDataList[j];
                            methodContent = methodData.Content;
                            SqlCompiler sqlCompiler = new NFinal.Compile.SqlCompiler();

                            //从代码中分析出数据库相关函数
                            List <DbFunctionData> dbFunctions = sqlCompiler.Compile(com.DeleteComment(methodContent));

                            if (dbFunctions.Count > 0)
                            {
                                SqlAnalyse analyse = new SqlAnalyse();
                                //与数据库相结合,从sql语句中分析出所有的表信息,列信息
                                methodData.dbFunctions = analyse.FillFunctionDataList(NFinal.DB.Coding.DB.DbStore, dbFunctions);
                            }
                            //数据库函数替换
                            int content_relative_position = 0;
                            if (dbFunctions.Count > 0)
                            {
                                bool          hasSameVarName = false;
                                List <string> varNames       = new List <string>();
                                //添加struct类型
                                for (int s = 0; s < dbFunctions.Count; s++)
                                {
                                    //去除重复项
                                    if (varNames.Count > 0)
                                    {
                                        hasSameVarName = false;
                                        for (int c = 0; c < varNames.Count; c++)
                                        {
                                            //如果发现重复项,则跳过循环
                                            if (varNames[c] == dbFunctions[s].varName)
                                            {
                                                hasSameVarName = true;
                                                break;
                                            }
                                        }
                                        if (hasSameVarName)
                                        {
                                            continue;
                                        }
                                    }
                                    varNames.Add(dbFunctions[s].varName);
                                    //分析出sql返回的List<dynamic>和dynamic类型是否有用AddNewField(string fileName,Type t);添加相关的类型
                                    NewField newFiled = new NewField(dbFunctions[s].varName);
                                    List <NFinal.Compile.StructField> structFieldList = newFiled.GetFields(ref methodContent, methodData.name);
                                    //添加struct字段
                                    string StructData = sqlCompiler.SetMagicStruct(methodData.name, dbFunctions[s], structFieldList, Frame.appRoot);
                                    if (!string.IsNullOrEmpty(StructData))
                                    {
                                        compileCode        = compileCode.Insert(methodData.start + relative_position, StructData);
                                        relative_position += StructData.Length;
                                    }
                                }

                                //修正函数返回类型,提高执行效率
                                if (methodData.returnType.IndexOf("dynamic") > -1)
                                {
                                    string returnTypeString = "";
                                    if (new System.Text.RegularExpressions.Regex(@"List\s*<\s*dynamic\s*>").IsMatch(methodData.returnType))
                                    {
                                        returnTypeString = string.Format("NFinal.DB.NList<__{0}_{1}__>", methodData.name, methodData.returnVarName);
                                    }
                                    else
                                    {
                                        returnTypeString = string.Format("__{0}_{1}__", methodData.name, methodData.returnVarName);
                                    }
                                    relative_position += Replace(ref compileCode,
                                                                 methodData.returnTypeIndex + relative_position + classData.position,
                                                                 methodData.returnType.Length,
                                                                 returnTypeString);
                                }
                                //更换函数内的数据库操作函数
                                content_relative_position += sqlCompiler.SetMagicFunction(methodData.name,
                                                                                          ref methodContent,
                                                                                          content_relative_position,
                                                                                          methodData.dbFunctions,
                                                                                          Frame.appRoot);
                                //分析并更换其中的连接字符串
                                content_relative_position += sqlCompiler.SetMagicConnection(methodData.name,
                                                                                            ref methodContent,
                                                                                            Frame.appRoot
                                                                                            );
                            }
                            if (build)
                            {
                                relative_position += Replace(ref compileCode, relative_position + methodData.position, methodData.Content.Length, methodContent);
                            }
                            else
                            {
                                if (methodData.returnType == "void")
                                {
                                    relative_position += Replace(ref compileCode, relative_position + methodData.position, methodData.Content.Length, string.Empty);
                                }
                                else
                                {
                                    relative_position += Replace(ref compileCode, relative_position + methodData.position, methodData.Content.Length, "return null;");
                                }
                            }
                        }
                    }
                    //如果文件夹不存在则新建
                    if (!Directory.Exists(Frame.MapPath(compileDir)))
                    {
                        Directory.CreateDirectory(Frame.MapPath(compileDir));
                    }
                    //写DAL层.class文件
                    sw = new StreamWriter(compileFileName, false, System.Text.Encoding.UTF8);
                    sw.Write(compileCode);
                    sw.Close();
                }
            }
        }
Пример #35
0
        bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Expression[] args)
        {
            if (method.Parameters.Length != args.Length)
                return false;

            Expression[] promotedArgs = new Expression[args.Length];
            for (int i = 0; i < args.Length; i++)
            {
                ParameterInfo pi = method.Parameters[i];
                if (pi.IsOut)
                    return false;

                Expression promoted;
                if (pi.ParameterType.IsGenericParameter)
                {
                    promoted = args[i];
                }
                else
                {
                    promoted = PromoteExpression(args[i], pi.ParameterType, true);
                    if (promoted == null)
                        return false;
                }

                promotedArgs[i] = promoted;
            }
            method.Args = promotedArgs;

            if (method.MethodBase.IsGenericMethodDefinition &&
                method.MethodBase is MethodInfo)
            {
                var methodInfo = ((MethodInfo)method.MethodBase);
                var genericArgsType = new Type[methodInfo.GetGenericArguments().Length];
                int genericArgsTypeIndex = 0;
                for (int i = 0; i < method.Args.Length; i++)
                {
                    if (method.Parameters[i].ParameterType.IsGenericParameter)
                        genericArgsType[genericArgsTypeIndex++] = method.Args[i].Type;
                }

                method.MethodBase = methodInfo.MakeGenericMethod(genericArgsType);
            }

            return true;
        }
Пример #36
0
    //---------------------------------------------------------------------
    // 立即玩
    public async Task enterDesktopPlayNow()
    {
        if (IsEntering)
        {
            EbLog.Note("CellPlayerDesktop.enterDesktopPlayNow() 错误:正在进入中");
            return;
        }
        IsEntering = true;

        if (!string.IsNullOrEmpty(DesktopEtGuid))
        {
            await leaveDesktop();
        }

        DesktopRequestPlayerEnter request_enter;

        request_enter.desktop_etguid = "";
        request_enter.seat_index     = 255;
        request_enter.player_clip    = 0;
        request_enter.player_gold    = CoActor.Def.PropGold.get();
        request_enter.is_vip         = CoActor.Def.mPropIsVIP.get();

        var         grain = Entity.getUserData <GrainCellPlayer>();
        var         grain_desktopservice = grain.GF.GetGrain <ICellDesktopService>(0);
        DesktopInfo desktop_info         = await grain_desktopservice.searchDesktopAuto(request_enter);

        if (string.IsNullOrEmpty(desktop_info.desktop_etguid))
        {
            EbLog.Note("CellPlayerDesktop.enterDesktopPlayNow() 获取桌子信息出错");
        }
        else
        {
            EbLog.Note("CellPlayerDesktop.enterDesktopPlayNow() 获取桌子信息成功");
        }

        // Step1:监听桌子广播
        await _createDesktopStreamConsumer(desktop_info.desktop_etguid);

        // 自动下注
        int bet_chip  = 2000;
        int left_chip = CoActor.Def.PropGold.get();

        if (left_chip < bet_chip)
        {
            bet_chip = left_chip;
        }
        left_chip -= bet_chip;
        CoPlayer.CoActor.Def.PropGold.set(left_chip);

        // Step2:进入桌子并获取桌子初始化信息
        var         grain_desktop = grain.GF.GetGrain <ICellDesktop>(new Guid(desktop_info.desktop_etguid));
        DesktopData desktop_data  = await grain_desktop.s2sPlayerEnter(request_enter, CoPlayer.exportEtPlayerMirror());

        IsEntering    = false;
        DesktopEtGuid = desktop_data.desktop_cfg_data.desktop_etguid;

        DesktopNotify desktop_notify;

        desktop_notify.id   = DesktopNotifyId.DesktopInit;
        desktop_notify.data = EbTool.protobufSerialize <DesktopData>(desktop_data);

        MethodData notify_data = new MethodData();

        notify_data.method_id = MethodType.s2cPlayerDesktopNotify;
        notify_data.param1    = EbTool.protobufSerialize <DesktopNotify>(desktop_notify);
        var grain_player = grain.GF.GetGrain <ICellPlayer>(new Guid(Entity.Guid));

        grain_player.s2sNotify(notify_data);
    }
Пример #37
0
    public void Optimize(ArrayList list, MethodData md)
    {
        X86Code.Optimize(list);

        bool      bx     = true;
        Hashtable locals = new Hashtable();
        int       max    = 0;
        string    target = null;

        for (int i = 0; i < list.Count; i++)
        {
            X86Code x = list[i] as X86Code;
            if (x == null || x.ignore)
            {
                continue;
            }

            if (x.Mnemonic == "int" || x.Operand1 == "bx")
            {
                bx = false;
            }
            int p1a = x.Operand1.IndexOf("[ss:bp-"), p1b = x.Operand1.LastIndexOf(']');
            if (0 <= p1a && p1a < p1b)
            {
                string var = x.Operand1.Substring(p1a + 1, p1b - p1a - 1);
                int    v   = !locals.Contains(var) ? 1 : ((int)locals[var]) + 1;
                locals[var] = v;
                if (max < v)
                {
                    max    = v;
                    target = var;
                }
            }
            int p2a = x.Operand2.IndexOf("[ss:bp-"), p2b = x.Operand2.LastIndexOf(']');
            if (0 <= p2a && p2a < p2b)
            {
                string var = x.Operand2.Substring(p2a + 1, p2b - p2a - 1);
                int    v   = !locals.Contains(var) ? 1 : ((int)locals[var]) + 1;
                locals[var] = v;
                if (max < v)
                {
                    max    = v;
                    target = var;
                }
            }
        }
        if (bx && target != null)
        {
            for (int i = 0; i < list.Count; i++)
            {
                X86Code x = list[i] as X86Code;
                if (x == null || x.ignore)
                {
                    continue;
                }

                string op1 = x.Operand1, op2 = x.Operand2;
                int    p1 = op1.IndexOf(target), p2 = op2.IndexOf(target);
                if (p1 >= 0)
                {
                    op1 = "bx";
                }
                if (p2 >= 0)
                {
                    op2 = "bx";
                }
                if (p1 < 0 && p2 < 0)
                {
                    continue;
                }

                x.Ignore();
                X86Code xx = new X86Code(x.Mnemonic, op1, op2);
                xx.Notes = "[optimize] add";
                list.Insert(i + 1, xx);
            }
            if (md.LocalVars != null && md.LocalVars.Count == 1 && target.StartsWith("ss:bp-"))
            {
                for (int i = 0; i < list.Count; i++)
                {
                    X86Code x = list[i] as X86Code;
                    if (x == null || x.ignore)
                    {
                        continue;
                    }

                    if (x.Mnemonic == "sub" && x.Operand1 == "sp")
                    {
                        x.Ignore();
                        break;
                    }
                }
                for (int i = list.Count - 1; i >= 0; i--)
                {
                    X86Code x = list[i] as X86Code;
                    if (x == null || x.ignore)
                    {
                        continue;
                    }

                    if (x.Mnemonic == "mov" && x.Operand1 == "sp")
                    {
                        x.Ignore();
                        break;
                    }
                }
            }
        }
        X86Code.Optimize(list);
        if (md.LocalVars != null || md.ParamCount > 0 || !bx)
        {
            X86Code xb1 = new X86Code("push", "bx"), xb2 = new X86Code("pop", "bx");
            xb1.Notes = xb2.Notes = "[optimize] add";
            list.Insert(0, xb1);
            for (int i = 0; i < list.Count; i++)
            {
                X86Code x = list[i] as X86Code;
                if (x == null || x.ignore)
                {
                    continue;
                }

                if (x.Mnemonic == "ret")
                {
                    list.Insert(i, xb2);
                    i++;
                }
            }
        }
    }
        public async Task TestStringRef(MethodData method)
        {
            await method.Execute().ConfigureAwait(false);

            Assert.True(SomeOutParameters.StringRefTested);
        }
Пример #39
0
 private static bool IsBetterThan(Expression[] args, MethodData left, MethodData right)
 {
     bool flag = false;
     for (int index = 0; index < args.Length; ++index)
     {
         int num = CompareConversions(
             args[index].Type, left.Parameters[index].ParameterType, right.Parameters[index].ParameterType);
         if (num < 0)
             return false;
         if (num > 0)
             flag = true;
     }
     return flag;
 }
Пример #40
0
    //-------------------------------------------------------------------------
    public async Task <MethodData> c2sPlayerFriendRequest(MethodData method_data)
    {
        MethodData result = new MethodData();

        result.method_id = MethodType.None;

        var playerfriend_request = EbTool.protobufDeserialize <PlayerFriendRequest>(method_data.param1);

        switch (playerfriend_request.id)
        {
        case PlayerFriendRequestId.GetPlayerInfoFriend:    // 请求获取好友玩家信息
        {
            var player_etguid = EbTool.protobufDeserialize <string>(playerfriend_request.data);

            var grain = Entity.getUserData <GrainCellPlayer>();
            var grain_playerservice = grain.GF.GetGrain <ICellPlayerService>(0);
            var player_info         = await grain_playerservice.getPlayerInfoFriend(player_etguid);

            PlayerFriendResponse playerfriend_response;
            playerfriend_response.id   = PlayerFriendResponseId.GetPlayerInfoFriend;
            playerfriend_response.data = EbTool.protobufSerialize <PlayerInfoFriend>(player_info);

            result.method_id = MethodType.s2cPlayerFriendResponse;
            result.param1    = EbTool.protobufSerialize <PlayerFriendResponse>(playerfriend_response);
        }
        break;

        case PlayerFriendRequestId.RequestAddFriend:    // 请求添加为好友
        {
            var et_player_guid = EbTool.protobufDeserialize <string>(playerfriend_request.data);

            ProtocolResult r = ProtocolResult.Failed;

            // 不可以添加自己为好友
            if (et_player_guid == Entity.Guid)
            {
                r = ProtocolResult.FriendIsMe;
                goto End;
            }

            // 不可以重复添加好友
            PlayerInfo current_friend = null;
            Dictionary <string, PlayerInfo> map_friend = Def.mPropMapFriend.get();
            if (map_friend.TryGetValue(et_player_guid, out current_friend))
            {
                r = ProtocolResult.FriendExistFriend;
                goto End;
            }

            // 请求添加好友。由于加好友是双向的,需要告知被加的好友
            var grain             = Entity.getUserData <GrainCellPlayer>();
            var grain_playerproxy = grain.GF.GetGrain <ICellPlayerProxy>(new Guid(et_player_guid));
            grain_playerproxy.s2sRequestAddFriend(Entity.Guid);
            r = ProtocolResult.Success;

End:
            PlayerFriendResponse playerfriend_response;
            playerfriend_response.id   = PlayerFriendResponseId.RequestAddFriend;
            playerfriend_response.data = EbTool.protobufSerialize <ProtocolResult>(r);

            result.method_id = MethodType.s2cPlayerFriendResponse;
            result.param1    = EbTool.protobufSerialize <PlayerFriendResponse>(playerfriend_response);
        }
        break;

        case PlayerFriendRequestId.AgreeAddFriend:    // 请求是否同意添加好友
        {
            var addfriend_agree = EbTool.protobufDeserialize <AddFriendAgree>(playerfriend_request.data);

            ProtocolResult r           = ProtocolResult.Failed;
            PlayerInfo     friend_item = null;
            Dictionary <string, PlayerInfo> map_friend = Def.mPropMapFriend.get();

            var        grain = Entity.getUserData <GrainCellPlayer>();
            var        grain_playerservice = grain.GF.GetGrain <ICellPlayerService>(0);
            PlayerInfo player_info         = await grain_playerservice.getPlayerInfo(addfriend_agree.player_etguid);

            if (player_info != null && !string.IsNullOrEmpty(player_info.player_etguid))
            {
                //friend_item = new FriendItem();
                //friend_item.et_guid = player_info.player_etguid;
                //friend_item.nick_name = player_info.nick_name;
                //friend_item.icon = player_info.icon;
                //friend_item.level = player_info.level;
                //friend_item.exp = player_info.exp;
                //friend_item.chip = player_info.chip;
                //friend_item.gold = player_info.gold;
                //friend_item.individual_signature = player_info.individual_signature;// 个性签名
                //friend_item.ip_address = player_info.ip_address;// ip所在地
                //friend_item.is_vip = false;// 是否是VIP
                //friend_item.vip_level = 0;// VIP等级
                //friend_item.vip_point = 0;// VIP积分
                //friend_item.status = FriendOnlineStatus.Offline;// 好友在线状态
                //friend_item.last_online_dt = DateTime.Now;// 好友最后在线时间
                //friend_item.desktop_etguid = "";// 如果好友正在牌桌中,该牌桌的EtGuid

                r = ProtocolResult.Success;

                if (addfriend_agree.agree)
                {
                    // 好友数据添加到好友列表
                    map_friend[addfriend_agree.player_etguid] = friend_item;

                    // 通知本地客户端添加好友
                    PlayerFriendNotify friend_notify;
                    friend_notify.id   = PlayerFriendNotifyId.AddFriend;
                    friend_notify.data = EbTool.protobufSerialize(friend_item);
                    _onFriendNotify(friend_notify);

                    // 由于加好友是双向的,需要告知被加的好友
                    var grain_playerproxy = grain.GF.GetGrain <ICellPlayerProxy>(new Guid(addfriend_agree.player_etguid));
                    grain_playerproxy.s2sResponseAddFriend(Entity.Guid, addfriend_agree.agree);
                }
            }

End:
            PlayerFriendResponse playerfriend_response;
            playerfriend_response.id   = PlayerFriendResponseId.AgreeAddFriend;
            playerfriend_response.data = EbTool.protobufSerialize <ProtocolResult>(r);

            result.method_id = MethodType.s2cPlayerFriendResponse;
            result.param1    = EbTool.protobufSerialize <PlayerFriendResponse>(playerfriend_response);
        }
        break;

        case PlayerFriendRequestId.DeleteFriend:    // 请求删除好友
        {
            var et_player_guid = EbTool.protobufDeserialize <string>(playerfriend_request.data);

            ProtocolResult r = ProtocolResult.Failed;
            PlayerInfo     current_friend = null;
            Dictionary <string, PlayerInfo> map_friend = Def.mPropMapFriend.get();
            if (map_friend.TryGetValue(et_player_guid, out current_friend))
            {
                map_friend.Remove(current_friend.player_etguid);
                r = ProtocolResult.Success;
            }
            else
            {
                goto End;
            }

            // 通知本地客户端删除好友
            PlayerFriendNotify friend_notify;
            friend_notify.id   = PlayerFriendNotifyId.DeleteFriend;
            friend_notify.data = EbTool.protobufSerialize(et_player_guid);
            _onFriendNotify(friend_notify);

            // 告知被删的好友
            var grain             = Entity.getUserData <GrainCellPlayer>();
            var grain_playerproxy = grain.GF.GetGrain <ICellPlayerProxy>(new Guid(et_player_guid));
            grain_playerproxy.s2sDeleteFriend(Entity.Guid);

End:
            PlayerFriendResponse playerfriend_response;
            playerfriend_response.id   = PlayerFriendResponseId.DeleteFriend;
            playerfriend_response.data = EbTool.protobufSerialize <ProtocolResult>(r);

            result.method_id = MethodType.s2cPlayerFriendResponse;
            result.param1    = EbTool.protobufSerialize <PlayerFriendResponse>(playerfriend_response);
        }
        break;

        case PlayerFriendRequestId.FindFriend:    // 请求查找好友
        {
            var find_info = EbTool.protobufDeserialize <string>(playerfriend_request.data);

            var grain = Entity.getUserData <GrainCellPlayer>();
            var grain_playerservice = grain.GF.GetGrain <ICellPlayerService>(0);

            var list_playerinfo = await grain_playerservice.findPlayers(find_info);

            //List<FriendItem> list_frienditem = new List<FriendItem>();
            //foreach (var i in list_playerinfo)
            //{
            //    PlayerInfo player_info = i;
            //    if (string.IsNullOrEmpty(player_info.player_etguid)) continue;
            //    FriendItem friend_item = new FriendItem();
            //    friend_item.et_guid = player_info.player_etguid;
            //    friend_item.nick_name = player_info.nick_name;
            //    friend_item.icon = player_info.icon;
            //    friend_item.level = player_info.level;
            //    friend_item.exp = player_info.exp;
            //    friend_item.chip = player_info.chip;
            //    friend_item.gold = player_info.gold;
            //    friend_item.individual_signature = player_info.individual_signature;// 个性签名
            //    friend_item.ip_address = player_info.ip_address;// ip所在地
            //    friend_item.is_vip = false;// 是否是VIP
            //    friend_item.vip_level = 0;// VIP等级
            //    friend_item.vip_point = 0;// VIP积分
            //    friend_item.status = FriendOnlineStatus.Offline;// 好友在线状态
            //    friend_item.last_online_dt = DateTime.Now;// 好友最后在线时间
            //    friend_item.desktop_etguid = "";// 如果好友正在牌桌中,该牌桌的EtGuid

            //    list_frienditem.Add(friend_item);
            //}

            PlayerFriendResponse playerfriend_response;
            playerfriend_response.id   = PlayerFriendResponseId.FindFriend;
            playerfriend_response.data = EbTool.protobufSerialize <List <PlayerInfo> >(list_playerinfo);

            result.method_id = MethodType.s2cPlayerFriendResponse;
            result.param1    = EbTool.protobufSerialize <PlayerFriendResponse>(playerfriend_response);
        }
        break;

        default:
            break;
        }

        return(result);
    }
Пример #41
0
 private bool IsApplicable(MethodData method, Expression[] args)
 {
     if (method.Parameters.Length != args.Length) return false;
     Expression[] promotedArgs = new Expression[args.Length];
     for (int i = 0; i < args.Length; i++)
     {
         ParameterInfo pi = method.Parameters[i];
         if (pi.IsOut) return false;
         Expression promoted = PromoteExpression(args[i], pi.ParameterType, false);
         if (promoted == null) return false;
         promotedArgs[i] = promoted;
     }
     method.Args = promotedArgs;
     return true;
 }
Пример #42
0
    public object[] ConvertNative(MethodData md)
    {
        Stack st1 = new Stack();

        foreach (ILCode il in md.ILCodes)
        {
            st1.Push(il);
        }

        this.lastRet = null;
        Stack st2 = new Stack();

        while (st1.Count > 0)
        {
            ILCode il = st1.Pop() as ILCode;
            if (il.OpCode.Name == "ret" && this.lastRet == null)
            {
                this.lastRet = il;
            }
            else if (il.OpCode.Name == "pop" && st1.Count > 0)
            {
                ILCode il2 = st1.Peek() as ILCode;
                if (il2.OpCode.Name == "newobj")
                {
                    TableBase  tb    = this.pedata.idxm.GetTable((int)il2.Operand);
                    MethodData tb_md = tb.Tag as MethodData;
                    if (tb_md.Name == "[I8086]I8086.Inline::.ctor" && st1.Count > 1)
                    {
                        st1.Pop();
                        ILCode il3 = st1.Peek() as ILCode;
                        if (il3 != null && il3.OpCode.Name == "ldstr")
                        {
                            st1.Pop();
                            X86Codes nc = new X86Codes();
                            nc.Address    = il3.Address;
                            nc.IsBrTarget = il3.IsBrTarget;
                            nc.Comment    = "[native] inline";
                            nc.Codes.Add(X86Code.Parse(this.hashUS[((int)il3.Operand) & 0xffffff] as string));
                            st2.Push(nc);
                            continue;
                        }
                        st1.Push(il2);
                    }
                }
            }
            if (il.OpCode.Name == "call")
            {
                TableBase  tb    = this.pedata.idxm.GetTable((int)il.Operand);
                MethodData tb_md = tb.Tag as MethodData;
                string     name  = tb_md.Name;
                if (name.StartsWith("[I8086]I8086.Registers::set_"))
                {
                    string reg = name.Substring(name.Length - 2, 2).ToLower();
                    if (st1.Count > 0 && !name.EndsWith("S"))
                    {
                        ILCode il2 = st1.Peek() as ILCode;
                        string mne = il2.OpCode.Name;
                        int    nOp = Util.GetOperandValue(il2);
                        if (mne.StartsWith("ldc.i4"))
                        {
                            st1.Pop();
                            X86Codes nc = new X86Codes();
                            nc.Address    = il2.Address;
                            nc.IsBrTarget = il2.IsBrTarget;
                            nc.Comment    = "[native] set register";
                            nc.Codes.Add(new X86Code("mov", reg, nOp.ToString()));
                            st2.Push(nc);
                            continue;
                        }
                        else if (mne.StartsWith("ldloc"))
                        {
                            st1.Pop();
                            X86Codes nc = new X86Codes();
                            nc.Address    = il2.Address;
                            nc.IsBrTarget = il2.IsBrTarget;
                            nc.Comment    = "[native] set register";
                            nc.Codes.Add(new X86Code("mov", reg, string.Format("[ss:bp-{0}]", (nOp + 1) * 2)));
                            st2.Push(nc);
                            continue;
                        }
                        else if (mne.StartsWith("ldarg"))
                        {
                            st1.Pop();
                            X86Codes nc = new X86Codes();
                            nc.Address    = il2.Address;
                            nc.IsBrTarget = il2.IsBrTarget;
                            nc.Comment    = "[native] set register";
                            nc.Codes.Add(new X86Code("mov", reg, string.Format("[ss:bp+{0}]", Util.GetArgPos(md, nOp, this.optimize))));
                            st2.Push(nc);
                            continue;
                        }
                    }
                    if (name.EndsWith("X") || name.EndsWith("I") || name.EndsWith("S"))
                    {
                        X86Codes nc = new X86Codes();
                        nc.Address    = il.Address;
                        nc.IsBrTarget = il.IsBrTarget;
                        nc.Comment    = "[native] set register";
                        nc.Codes.Add(new X86Code("pop", reg));
                        st2.Push(nc);
                        continue;
                    }
                }
                else if (name.StartsWith("[I8086]I8086.Registers::get_"))
                {
                    X86Codes nc = new X86Codes();
                    nc.Address    = il.Address;
                    nc.IsBrTarget = il.IsBrTarget;
                    nc.Comment    = "[native] get register";
                    nc.Codes.Add(new X86Code("push", name.Substring(name.Length - 2, 2).ToLower()));
                    st2.Push(nc);
                    continue;
                }
                else if (name == "[I8086]I8086.IO::In" && st1.Count > 0)
                {
                    ILCode   il2 = st1.Peek() as ILCode;
                    string   mne = il2.OpCode.Name;
                    int      nOp = Util.GetOperandValue(il2);
                    X86Codes nc  = new X86Codes();
                    nc.Comment = "[native] in";
                    if (mne.StartsWith("ldc.i4"))
                    {
                        st1.Pop();
                        nc.Address    = il2.Address;
                        nc.IsBrTarget = il2.IsBrTarget;
                        nc.Codes.Add(new X86Code("in", "al", nOp.ToString()));
                    }
                    else
                    {
                        nc.Address    = il.Address;
                        nc.IsBrTarget = il.IsBrTarget;
                        nc.Codes.Add(new X86Code("pop", "dx"));
                        nc.Codes.Add(new X86Code("in", "al", "dx"));
                    }
                    nc.Codes.Add(new X86Code("mov", "ah", "0"));
                    nc.Codes.Add(new X86Code("push", "ax"));
                    st2.Push(nc);
                    continue;
                }
                else if (name == "[I8086]I8086.IO::Out")
                {
                    X86Codes nc = new X86Codes();
                    nc.Address    = il.Address;
                    nc.IsBrTarget = il.IsBrTarget;
                    nc.Comment    = "[native] out";
                    nc.Codes.Add(new X86Code("pop", "ax"));
                    nc.Codes.Add(new X86Code("pop", "dx"));
                    nc.Codes.Add(new X86Code("out", "dx", "al"));
                    st2.Push(nc);
                    continue;
                }
                else if (name == "[I8086]I8086.StringPtr::Get")
                {
                    continue;
                }
                else if (name.StartsWith("[I8086]I8086.Flags::get_"))
                {
                    string mne = "jz";
                    int    p   = name.IndexOf('_') + 1;
                    switch (name.Substring(p, name.Length - p))
                    {
                    case "NZ":
                    case "NE":
                        mne = "jnz";
                        break;

                    case "C":
                        mne = "jc";
                        break;

                    case "NC":
                        mne = "jnc";
                        break;
                    }
                    X86Codes nc = new X86Codes();
                    nc.Address    = il.Address;
                    nc.IsBrTarget = il.IsBrTarget;
                    nc.Comment    = "[native] get flag";
                    nc.Codes.Add(new X86Code(mne, string.Format("NM_{0:X8}", this.number)));
                    nc.Codes.Add(new X86Code("xor", "ax", "ax"));
                    nc.Codes.Add(new X86Code("jmp", string.Format("NM_{0:X8}", this.number + 1)));
                    nc.Codes.Add(new X86Code(string.Format("NM_{0:X8}", this.number), true, "[native] get flag internal", "mov", "ax", "1"));
                    nc.Codes.Add(new X86Code(string.Format("NM_{0:X8}", this.number + 1), true, "[native] get flag internal", "push", "ax"));
                    st2.Push(nc);
                    this.number += 2;
                    continue;
                }
            }
            st2.Push(il);
        }
        return(st2.ToArray());
    }
 public new bool ShouldSelect(MethodData method, ISelectionContext context)
 {
     return base.ShouldSelect(method, context);
 }
Пример #44
0
        public static void LogicalDiskSample()
        {
            //// Управляющий класс
            ManagementClass diskClass = new ManagementClass("Win32_LogicalDisk");

            // true - если объекты, возвращенные от WMI, должны содержать
            // измененные сведения;
            diskClass.Options.UseAmendedQualifiers = true;


            //------- описание класса
            // Коллекция объектов QualifierData
            QualifierDataCollection qualifierCollection = diskClass.Qualifiers;

            // QualifierData - содержит сведения относительно WMI описателя
            foreach (QualifierData q in qualifierCollection)
            {
                Console.WriteLine(q.Name + " = " + q.Value);
            }
            Console.WriteLine(new string('-', 45));
            //------------------------------------------------

            //------- Доступные методы класса
            Console.WriteLine("\n Доступные методы класса... ");
            MethodDataCollection diskMethods = diskClass.Methods;

            foreach (MethodData method in diskMethods)
            {
                Console.WriteLine("Метод = " + method.Name);
            }
            Console.WriteLine(new string('-', 45));
            //------------------------------------------------
            // то же, но через нумератор
            //MethodDataCollection.MethodDataEnumerator diskEnumerator =
            //           diskClass.Methods.GetEnumerator();
            //while (diskEnumerator.MoveNext())
            //{
            //    MethodData method = diskEnumerator.Current;
            //    Console.WriteLine("Method = " + method.Name);
            //}
            //Console.WriteLine(new string('-', 45));
            //-------------------------------------------------

            //------- Свойства класса
            ManagementObject diskС = new ManagementObject("Win32_LogicalDisk.DeviceID='C:'");

            PropertyDataCollection.PropertyDataEnumerator propertyEnumerator = diskС.Properties.GetEnumerator();
            while (propertyEnumerator.MoveNext())
            {
                PropertyData p = (PropertyData)propertyEnumerator.Current;
                Console.WriteLine("Найденое свойство: " + p.Name);
            }
            Console.WriteLine(new string('-', 45));
            //------------------------------------------------

            //------- Экземпляры класса
            Console.WriteLine("\n Теперь отыщем все диски... ");
            // Получим коллекцию всех экземпляров класса
            ManagementObjectCollection disks = diskClass.GetInstances();

            // Перечислитель коллекции
            ManagementObjectCollection.ManagementObjectEnumerator disksEnumerator =
                disks.GetEnumerator();
            while (disksEnumerator.MoveNext())
            {
                ManagementObject disk = (ManagementObject)disksEnumerator.Current;
                Console.WriteLine("Найден диск: " + disk["deviceid"]);
                Console.WriteLine("Размер: " + disk["Size"]);
            }
            Console.WriteLine(new string('-', 45));
            //------------------------------------------------


            // Получение сведений о методе класса
            MethodData m = diskClass.Methods["SetPowerState"];

            Console.WriteLine("Name: " + m.Name);
            Console.WriteLine("Origin: " + m.Origin);
            // аргументы
            ManagementBaseObject inParams = m.InParameters;

            foreach (PropertyData pdata in inParams.Properties)
            {
                Console.WriteLine();
                Console.WriteLine("InParam_Name: " + pdata.Name);
                Console.WriteLine("InParam_Type: " + pdata.Type);
            }
            // Возвращаемые значения
            ManagementBaseObject outParams = m.OutParameters;

            foreach (PropertyData pdata in outParams.Properties)
            {
                Console.WriteLine();
                Console.WriteLine("OutParam_Name: " + pdata.Name);
                Console.WriteLine("OutParam_Type: " + pdata.Type);
            }
        }
Пример #45
0
			public void AddNewMethod (MethodBase mb, int il_size)
			{
				if (methods == null)
					methods = new ArrayList ();

				MethodData md = new MethodData (mb, il_size);
				md.Checked = true;
				methods.Add (md);
			}
Пример #46
0
        private bool StaticCanNotInline(MethodData methodData)
        {
            if (InlineExplicitOnly && !methodData.HasAggressiveInliningAttribute)
            {
                return(true);
            }

            if (methodData.HasDoNotInlineAttribute)
            {
                return(true);
            }

            if (methodData.IsMethodImplementationReplaced)
            {
                return(true);
            }

            if (methodData.HasProtectedRegions)
            {
                return(true);
            }

            if (methodData.HasMethodPointerReferenced)
            {
                return(true);
            }

            var method = methodData.Method;

            if (method.IsVirtual && !methodData.IsDevirtualized)
            {
                return(true);
            }

            if (methodData.DoNotInline)
            {
                return(true);
            }

            if (method.DeclaringType.IsValueType &&
                method.IsVirtual &&
                !method.IsConstructor &&
                !method.IsStatic)
            {
                return(true);
            }

            var returnType = methodData.Method.Signature.ReturnType;

            // FIXME: Add rational
            if (!MosaTypeLayout.CanFitInRegister(returnType) && !returnType.IsUI8 && !returnType.IsR8)
            {
                return(true);
            }

            // FUTURE: Don't hardcode namepsace
            if (((method.MethodAttributes & MosaMethodAttributes.Public) == MosaMethodAttributes.Public) && method.DeclaringType.BaseType != null && method.DeclaringType.BaseType.Namespace == "Mosa.UnitTests")
            {
                return(true);
            }

            return(false);
        }