示例#1
0
        public void Test_Optimize_StaticMath_ADD()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.ADD);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH2);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSHM1);
                scriptBefore.Emit(VM.OpCode.PUSH11);
                scriptBefore.Emit(VM.OpCode.ADD);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH10);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }
        }
示例#2
0
        public void Test_Optimize_Static_DROP()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH0);
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.DROP);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH0);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSHNULL);
                scriptBefore.Emit(VM.OpCode.DROP);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH1);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }
        }
示例#3
0
        public void Test_Optimize_StaticMath_DEC()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH0);
                scriptBefore.Emit(VM.OpCode.DEC);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.EmitPush(-1);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.EmitPush(short.MaxValue + 1);
                scriptBefore.Emit(VM.OpCode.DEC);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.EmitPush(short.MaxValue);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }
        }
示例#4
0
        private void Test_Optimize_Recalculate_Negative_JMPX_L(VM.OpCode biGJumpOpCode)
        {
            var smallJumpOpCode = (VM.OpCode)(biGJumpOpCode - 1);

            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(biGJumpOpCode, ToJumpLArg(9));        // ───┐
            scriptBefore.Emit(VM.OpCode.PUSH1);                     // <┐ │
            scriptBefore.Emit(VM.OpCode.RET);                       //  │ │
            scriptBefore.Emit(VM.OpCode.NOP);                       //  │ │
            scriptBefore.Emit(VM.OpCode.NOP);                       //  │ │
            scriptBefore.Emit(biGJumpOpCode, ToJumpLArg(-4));       //  x<┘

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(smallJumpOpCode, ToJumpArg(4));        // ───┐
            scriptAfter.Emit(VM.OpCode.PUSH1);                      // <┐ │
            scriptAfter.Emit(VM.OpCode.RET);                        //  │ │
            scriptAfter.Emit(smallJumpOpCode, ToJumpArg(-2));       //  x<┘

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(),
                                                     OptimizeParserType.DELETE_DEAD_CODE |
                                                     OptimizeParserType.USE_SHORT_ADDRESS
                                                     );

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
        public void Test_Optimize_Recalculate_BoolEqualFalse()
        {
            using (var scriptBefore = new ScriptBuilder())
            using (var scriptAfter = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.NOP);
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSH0);
                scriptBefore.Emit(VM.OpCode.EQUAL);

                var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), OptimizeParserType.DELETE_USELESS_EQUAL);

                scriptAfter.Emit(VM.OpCode.NOP);
                scriptAfter.Emit(VM.OpCode.PUSH0);

                CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
            }

            using (var scriptBefore = new ScriptBuilder())
            using (var scriptAfter = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.NOP);
                scriptBefore.Emit(VM.OpCode.PUSH0);
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.EQUAL);

                var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), OptimizeParserType.DELETE_USELESS_EQUAL);

                scriptAfter.Emit(VM.OpCode.NOP);
                scriptAfter.Emit(VM.OpCode.PUSH0);

                CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
            }
        }
示例#6
0
        public void Test_Optimize_StaticMath_MUL()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSH2);
                scriptBefore.Emit(VM.OpCode.MUL);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH2);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.EmitPush(int.MaxValue);
                scriptBefore.EmitPush(int.MaxValue);
                scriptBefore.Emit(VM.OpCode.MUL);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.EmitPush(BigInteger.Multiply(new BigInteger(int.MaxValue), new BigInteger(int.MaxValue)));

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }
        }
示例#7
0
        public void Test_Optimize_Delete_Dead_Code()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.NOP);
                scriptBefore.Emit(VM.OpCode.JMP, ToJumpArg(8));        //  ─────┐
                scriptBefore.Emit(VM.OpCode.PUSH1);                    //       |
                scriptBefore.Emit(VM.OpCode.PUSH2);                    //       |
                scriptBefore.Emit(VM.OpCode.PUSH3);                    //   ┌<┐ |
                scriptBefore.Emit(VM.OpCode.JMP, ToJumpArg(6));        //   x | |
                scriptBefore.Emit(VM.OpCode.PUSH4);                    //   | | |
                scriptBefore.Emit(VM.OpCode.JMP, ToJumpArg(-4));       //   | x<┘
                scriptBefore.Emit(VM.OpCode.NOP);                      //   |
                scriptBefore.Emit(VM.OpCode.PUSH5);                    // x<┘
                scriptBefore.Emit(VM.OpCode.NOP);
                scriptBefore.Emit(VM.OpCode.PUSH6);
                scriptBefore.Emit(VM.OpCode.RET);
                scriptBefore.Emit(VM.OpCode.PUSH7);

                var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_DEAD_CODE);

                using var scriptAfter = new ScriptBuilder();
                scriptAfter.Emit(VM.OpCode.JMP, ToJumpArg(5));
                scriptAfter.Emit(VM.OpCode.PUSH3);
                scriptAfter.Emit(VM.OpCode.JMP, ToJumpArg(4));
                scriptAfter.Emit(VM.OpCode.JMP, ToJumpArg(-3));
                scriptAfter.Emit(VM.OpCode.PUSH5);
                scriptAfter.Emit(VM.OpCode.PUSH6);
                scriptAfter.Emit(VM.OpCode.RET);

                CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.NOP);
                scriptBefore.Emit(VM.OpCode.JMP_L, ToJumpLArg(10));       //  ───┐
                scriptBefore.Emit(VM.OpCode.PUSH1);                       //     |
                scriptBefore.Emit(VM.OpCode.PUSH2);                       //     |
                scriptBefore.Emit(VM.OpCode.PUSH3);                       // x<┐ |
                scriptBefore.Emit(VM.OpCode.RET);                         //   | |
                scriptBefore.Emit(VM.OpCode.PUSH4);                       //   | |
                scriptBefore.Emit(VM.OpCode.JMP_L, ToJumpLArg(-3));       //   x<┘
                scriptBefore.Emit(VM.OpCode.PUSH5);

                var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_DEAD_CODE);

                using var scriptAfter = new ScriptBuilder();
                scriptAfter.Emit(VM.OpCode.JMP_L, ToJumpLArg(7));
                scriptAfter.Emit(VM.OpCode.PUSH3);
                scriptAfter.Emit(VM.OpCode.RET);
                scriptAfter.Emit(VM.OpCode.JMP_L, ToJumpLArg(-2));

                CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
            }
        }
        public void Build(Stream fs, Stream fspdb, bool optimizer)
        {
            this.IsBuild = false;
            this.Error   = null;

            var log = new DefLogger();

            this.modIL = new ILModule(log);
            try
            {
                modIL.LoadModule(fs, fspdb);
            }
            catch (Exception err)
            {
                log.Log("LoadModule Error:" + err.ToString());
                this.Error = err;
                return;
            }

            converterIL = new ModuleConverter(log);
            ConvOption option = new ConvOption();

#if NDEBUG
            try
#endif
            {
                converterIL.Convert(modIL, option);
                finalNEF = converterIL.outModule.Build();
                if (optimizer)
                {
                    var   opbytes = NefOptimizeTool.Optimize(finalNEF);
                    float ratio   = (opbytes.Length * 100.0f) / (float)finalNEF.Length;
                    log.Log("optimization ratio = " + ratio + "%");
                    finalNEF = opbytes;
                }
                IsBuild = true;
            }
#if NDEBUG
            catch (Exception err)
            {
                this.Error = err;
                log.Log("Convert IL->ASM Error:" + err.ToString());
                return;
            }
#endif
            try
            {
                finialABI = vmtool.FuncExport.Export(converterIL.outModule, finalNEF);
            }
            catch
            {
            }
        }
        public void Test_Optimize_RemoveNOPS()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.NOP);
            scriptBefore.Emit(VM.OpCode.NOP);

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray());

            using var scriptAfter = new ScriptBuilder();

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
        public void Test_Optimize_ConstExecution_ROT()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSH2);
                scriptBefore.Emit(VM.OpCode.PUSH3);
                scriptBefore.Emit(VM.OpCode.ROT);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH2);
                    scriptAfter.Emit(VM.OpCode.PUSH3);
                    scriptAfter.Emit(VM.OpCode.PUSH1);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSH2);
                scriptBefore.Emit(VM.OpCode.PUSHNULL);
                scriptBefore.Emit(VM.OpCode.ROT);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.Emit(VM.OpCode.PUSH2);
                    scriptAfter.Emit(VM.OpCode.PUSHNULL);
                    scriptAfter.Emit(VM.OpCode.PUSH1);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH5);
                scriptBefore.Emit(VM.OpCode.PUSH4);
                scriptBefore.EmitJump(VM.OpCode.JMP, 3);
                scriptBefore.Emit(VM.OpCode.PUSH1);
                scriptBefore.Emit(VM.OpCode.PUSH2);
                scriptBefore.Emit(VM.OpCode.PUSH3);
                scriptBefore.Emit(VM.OpCode.ROT);

                var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                CollectionAssert.AreEqual(scriptBefore.ToArray(), optimized);
            }
        }
        public void Test_Optimize_JMP_Next()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.JMP, ToJumpArg(2));        // ───┐
            scriptBefore.Emit(VM.OpCode.PUSH1);                    // <──┘

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), new OptimizeParserType[] { OptimizeParserType.DELETE_USERLESS_JMP });

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSH1);

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
示例#12
0
        public void Test_Optimize_RemoveNOPS()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.NOP);
            scriptBefore.Emit(VM.OpCode.NOP);

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(),
                                                     OptimizeParserType.DELETE_DEAD_CODE |
                                                     OptimizeParserType.USE_SHORT_ADDRESS
                                                     );

            using var scriptAfter = new ScriptBuilder();

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
示例#13
0
        public void Test_Optimize_Recalculate_BoolNotEqualTrue()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.PUSH1);
            scriptBefore.Emit(VM.OpCode.PUSH1);
            scriptBefore.Emit(VM.OpCode.NOTEQUAL);
            scriptBefore.Emit(VM.OpCode.NOP);

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSH0);
            scriptAfter.Emit(VM.OpCode.NOP);

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_USELESS_EQUAL);

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
        public void Test_Optimize_Recalculate_Positive_PUSHA()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.PUSHA, ToJumpLArg(7));  // ─┐
            scriptBefore.Emit(VM.OpCode.NOP);                   //  │
            scriptBefore.Emit(VM.OpCode.NOP);                   //  │
            scriptBefore.Emit(VM.OpCode.RET);                   // <┘

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray());

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSHA, ToJumpLArg(5));   // ─┐
            scriptAfter.Emit(VM.OpCode.RET);                    // <┘

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
示例#15
0
        public void Test_Optimize_StaticMath_DIV()
        {
            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH10);
                scriptBefore.Emit(VM.OpCode.PUSH11);
                scriptBefore.Emit(VM.OpCode.DIV);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.EmitPush(10 / 11);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.Emit(VM.OpCode.PUSH11);
                scriptBefore.Emit(VM.OpCode.PUSH10);
                scriptBefore.Emit(VM.OpCode.DIV);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.EmitPush(11 / 10);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }

            using (var scriptBefore = new ScriptBuilder())
            {
                scriptBefore.EmitPush(ushort.MaxValue);
                scriptBefore.EmitPush(short.MaxValue);
                scriptBefore.Emit(VM.OpCode.DIV);

                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptAfter.EmitPush(BigInteger.Divide(new BigInteger(ushort.MaxValue), new BigInteger(short.MaxValue)));

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_CONST_EXECUTION);
                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
            }
        }
        private void Test_Optimize_Recalculate_Positive_JMPX_L(VM.OpCode biGJumpOpCode)
        {
            var smallJumpOpCode = (VM.OpCode)(biGJumpOpCode - 1);

            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(biGJumpOpCode, ToJumpLArg(7));    // ─┐
            scriptBefore.Emit(VM.OpCode.NOP);                   //  │
            scriptBefore.Emit(VM.OpCode.NOP);                   //  │
            scriptBefore.Emit(VM.OpCode.RET);                   // <┘

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray());

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(smallJumpOpCode, ToJumpArg(2));    // ─┐
            scriptAfter.Emit(VM.OpCode.RET);                    // <┘

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
        public void Test_OptimizeSkip_Recalculate_BoolEqualTrue()
        {
            //jmp will cause skip this equal optimize
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.JMP, new byte[2]);
            scriptBefore.Emit(VM.OpCode.PUSH1);
            scriptBefore.Emit(VM.OpCode.PUSH1);
            scriptBefore.Emit(VM.OpCode.EQUAL);
            scriptBefore.Emit(VM.OpCode.NOP);

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSH1);
            scriptAfter.Emit(VM.OpCode.NOP);

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), OptimizeParserType.DELETE_USELESS_EQUAL);

            CollectionAssert.AreNotEqual(scriptAfter.ToArray(), optimized);
            CollectionAssert.AreEqual(scriptBefore.ToArray(), optimized);
        }
示例#18
0
        public void Test_Optimize_Recalculate_Positive_PUSHA()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.PUSHA, ToJumpLArg(7));  // ─┐
            scriptBefore.Emit(VM.OpCode.NOP);                   //  │
            scriptBefore.Emit(VM.OpCode.NOP);                   //  │
            scriptBefore.Emit(VM.OpCode.RET);                   // <┘

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(),
                                                     OptimizeParserType.DELETE_DEAD_CODE |
                                                     OptimizeParserType.USE_SHORT_ADDRESS
                                                     );

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSHA, ToJumpLArg(5));   // ─┐
            scriptAfter.Emit(VM.OpCode.RET);                    // <┘

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
示例#19
0
        public void Test_CombinedRules()
        {
            using (var scriptBefore = new ScriptBuilder())
                using (var scriptAfter = new ScriptBuilder())
                {
                    scriptBefore.Emit(VM.OpCode.PUSH1);
                    scriptBefore.Emit(VM.OpCode.NOP);
                    scriptBefore.Emit(VM.OpCode.PUSH0);
                    scriptBefore.Emit(VM.OpCode.NOP);
                    scriptBefore.Emit(VM.OpCode.EQUAL);
                    scriptBefore.Emit(VM.OpCode.PUSH0);
                    scriptBefore.Emit(VM.OpCode.EQUAL);

                    var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_USELESS_EQUAL | OptimizeParserType.DELETE_NOP);

                    scriptAfter.Emit(VM.OpCode.PUSH1);

                    CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
                }
        }
        public void Test_Optimize_JMP_LNext()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.JMP_L, ToJumpLArg(5));       // ───┐
            scriptBefore.Emit(VM.OpCode.PUSH1);                      // <──┘

            // useshortaddress before deleteuselessjmp
            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), new OptimizeParserType[] { OptimizeParserType.USE_SHORT_ADDRESS, OptimizeParserType.DELETE_USERLESS_JMP });

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSH1);
            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);

            // deleteuselessjmp before useshortaddress
            optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), new OptimizeParserType[] { OptimizeParserType.DELETE_USERLESS_JMP, OptimizeParserType.USE_SHORT_ADDRESS });
            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);

            // use deleteuselessjmp only
            optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), new OptimizeParserType[] { OptimizeParserType.DELETE_USERLESS_JMP });
            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
示例#21
0
        public void Test_Optimize_Recalculate_Negative_PUSHA()
        {
            using var scriptBefore = new ScriptBuilder();
            scriptBefore.Emit(VM.OpCode.PUSHA, ToJumpLArg(9));      // ───┐
            scriptBefore.Emit(VM.OpCode.PUSH1);                     // <┐ │
            scriptBefore.Emit(VM.OpCode.RET);                       //  │ │
            scriptBefore.Emit(VM.OpCode.NOP);                       //  │ │
            scriptBefore.Emit(VM.OpCode.NOP);                       //  │ │
            scriptBefore.Emit(VM.OpCode.PUSHA, ToJumpLArg(-4));     //  x<┘

            using var scriptAfter = new ScriptBuilder();
            scriptAfter.Emit(VM.OpCode.PUSHA, ToJumpLArg(7));       // ───┐
            scriptAfter.Emit(VM.OpCode.PUSH1);                      // <┐ │
            scriptAfter.Emit(VM.OpCode.RET);                        //  │ │
            scriptAfter.Emit(VM.OpCode.PUSHA, ToJumpLArg(-2));      //  x<┘

            var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(),
                                                     OptimizeParserType.DELETE_DEAD_CODE,
                                                     OptimizeParserType.USE_SHORT_ADDRESS
                                                     );

            CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized);
        }
示例#22
0
        public void Build(Stream fs, Stream fspdb, bool optimizer)
        {
            this.IsBuild      = false;
            this.Error        = null;
            this.UseOptimizer = optimizer;

            var log = new DefLogger();

            this.modIL = new ILModule(log);
            try
            {
                modIL.LoadModule(fs, fspdb);
            }
            catch (Exception err)
            {
                log.Log("LoadModule Error:" + err.ToString());
                this.Error = err;
                return;
            }

            converterIL = new ModuleConverter(log);
            Dictionary <int, int> addrConvTable = null;
            ConvOption            option        = new ConvOption();

#if NDEBUG
            try
#endif
            {
                converterIL.Convert(modIL, option);
                finalNEFScript = converterIL.outModule.Build();
                if (optimizer)
                {
                    List <int> entryPoints = new List <int>();
                    foreach (var f in converterIL.outModule.mapMethods.Values)
                    {
                        if (!entryPoints.Contains(f.funcaddr))
                        {
                            entryPoints.Add(f.funcaddr);
                        }
                    }
                    var   opbytes = NefOptimizeTool.Optimize(finalNEFScript, entryPoints.ToArray(), out addrConvTable);
                    float ratio   = (opbytes.Length * 100.0f) / (float)finalNEFScript.Length;
                    log.Log("optimization ratio = " + ratio + "%");
                    finalNEFScript = opbytes;
                }
                IsBuild = true;
            }
#if NDEBUG
            catch (Exception err)
            {
                this.Error = err;
                log.Log("Convert IL->ASM Error:" + err.ToString());
                return;
            }
#endif
            try
            {
                finalABI = FuncExport.GenerateAbi(converterIL.outModule, addrConvTable);
            }
            catch (Exception err)
            {
                log.Log("Gen Abi Error:" + err.ToString());
                this.Error = err;
                return;
            }

            try
            {
                debugInfo = DebugExport.Export(converterIL.outModule, finalNEFScript, addrConvTable);
            }
            catch (Exception err)
            {
                log.Log("Gen debugInfo Error:" + err.ToString());
                this.Error = err;
                return;
            }

            try
            {
                finalManifest = FuncExport.GenerateManifest(finalABI, converterIL.outModule);
            }
            catch (Exception err)
            {
                log.Log("Gen Manifest Error:" + err.ToString());
                this.Error = err;
                return;
            }

            try
            {
                nefFile = new NefFile
                {
                    Compiler = "neon-" + Version.Parse(((AssemblyFileVersionAttribute)Assembly.GetAssembly(typeof(Program))
                                                        .GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version).ToString(),
                    Tokens = converterIL.methodTokens.ToArray(),
                    Script = finalNEFScript
                };
                nefFile.CheckSum = NefFile.ComputeChecksum(nefFile);
            }
            catch (Exception err)
            {
                log.Log("Write Bytes Error:" + err.ToString());
                return;
            }
        }
示例#23
0
        public void Build(Stream fs, Stream fspdb, bool optimizer)
        {
            this.IsBuild      = false;
            this.Error        = null;
            this.UseOptimizer = optimizer;

            var log = new DefLogger();

            this.modIL = new ILModule(log);
            try
            {
                modIL.LoadModule(fs, fspdb);
            }
            catch (Exception err)
            {
                log.Log("LoadModule Error:" + err.ToString());
                this.Error = err;
                return;
            }

            converterIL = new ModuleConverter(log);
            Dictionary <int, int> addrConvTable = null;
            ConvOption            option        = new ConvOption();

#if NDEBUG
            try
#endif
            {
                converterIL.Convert(modIL, option);
                finalNEFScript = converterIL.outModule.Build();
                if (optimizer)
                {
                    List <int> entryPoints = new List <int>();
                    foreach (var f in converterIL.outModule.mapMethods.Values)
                    {
                        if (!entryPoints.Contains(f.funcaddr))
                        {
                            entryPoints.Add(f.funcaddr);
                        }
                    }
                    var   opbytes = NefOptimizeTool.Optimize(finalNEFScript, entryPoints.ToArray(), out addrConvTable);
                    float ratio   = (opbytes.Length * 100.0f) / (float)finalNEFScript.Length;
                    log.Log("optimization ratio = " + ratio + "%");
                    finalNEFScript = opbytes;
                }
                IsBuild = true;
            }
#if NDEBUG
            catch (Exception err)
            {
                this.Error = err;
                log.Log("Convert IL->ASM Error:" + err.ToString());
                return;
            }
#endif
            try
            {
                finalABI = FuncExport.GenerateAbi(converterIL.outModule, addrConvTable);
            }
            catch (Exception err)
            {
                log.Log("Gen Abi Error:" + err.ToString());
                this.Error = err;
                return;
            }

            try
            {
                debugInfo = DebugExport.Export(converterIL.outModule, finalNEFScript, addrConvTable);
            }
            catch (Exception err)
            {
                log.Log("Gen debugInfo Error:" + err.ToString());
                this.Error = err;
                return;
            }

            try
            {
                finalManifest = FuncExport.GenerateManifest(finalABI, converterIL.outModule);
            }
            catch (Exception err)
            {
                log.Log("Gen Manifest Error:" + err.ToString());
                this.Error = err;
                return;
            }
        }
示例#24
0
        public static int Compile(Options options)
        {
            // Set console
            Console.OutputEncoding = Encoding.UTF8;
            var log = new DefLogger();

            log.Log("Neo.Compiler.MSIL console app v" + Assembly.GetEntryAssembly().GetName().Version);

            var fileInfo = new FileInfo(options.File);

            // Set current directory
            if (!fileInfo.Exists)
            {
                log.Log("Could not find file " + fileInfo.FullName);
                return(-1);
            }

            Stream fs;
            Stream fspdb;
            var    onlyname = Path.GetFileNameWithoutExtension(fileInfo.Name);
            var    path     = fileInfo.Directory.FullName;

            if (!string.IsNullOrEmpty(path))
            {
                try
                {
                    Directory.SetCurrentDirectory(path);
                }
                catch
                {
                    log.Log("Could not find path: " + path);
                    return(-1);
                }
            }

            switch (fileInfo.Extension.ToLowerInvariant())
            {
            case ".csproj":
            {
                // Compile csproj file

                log.Log("Compiling from csproj project");
                var output = Compiler.CompileCSProj(fileInfo.FullName);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".vbproj":
            {
                // Compile vbproj file

                log.Log("Compiling from vbproj project");
                var output = Compiler.CompileVBProj(fileInfo.FullName);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".cs":
            {
                // Compile C# files

                log.Log("Compiling from c# source");
                var output = Compiler.CompileCSFiles(new string[] { fileInfo.FullName }, new string[0]);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".vb":
            {
                // Compile VB files

                log.Log("Compiling from VB source");
                var output = Compiler.CompileVBFiles(new string[] { fileInfo.FullName }, new string[0]);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".dll":
            {
                string filepdb = onlyname + ".pdb";

                // Open file
                try
                {
                    fs = fileInfo.OpenRead();

                    if (File.Exists(filepdb))
                    {
                        fspdb = File.OpenRead(filepdb);
                    }
                    else
                    {
                        fspdb = null;
                    }
                }
                catch (Exception err)
                {
                    log.Log("Open File Error:" + err.ToString());
                    return(-1);
                }
                break;
            }

            default:
            {
                log.Log("File format not supported by neon: " + path);
                return(-1);
            }
            }

            ILModule mod = new ILModule(log);

            // Load module
            try
            {
                mod.LoadModule(fs, fspdb);
            }
            catch (Exception err)
            {
                log.Log("LoadModule Error:" + err.ToString());
                return(-1);
            }
            byte[]    bytes;
            int       bSucc   = 0;
            string    jsonstr = null;
            NeoModule module  = null;

            // Convert and build
            try
            {
                var        conv   = new ModuleConverter(log);
                ConvOption option = new ConvOption();
                module = conv.Convert(mod, option);
                bytes  = module.Build();
                log.Log("convert succ");

                if (options.Optimize)
                {
                    var optimize = NefOptimizeTool.Optimize(bytes);
                    log.Log("optimization succ " + (((bytes.Length / (optimize.Length + 0.0)) * 100.0) - 100).ToString("0.00 '%'"));
                    bytes = optimize;
                }

                try
                {
                    var           outjson = vmtool.FuncExport.Export(module, bytes);
                    StringBuilder sb      = new StringBuilder();
                    outjson.ConvertToStringWithFormat(sb, 0);
                    jsonstr = sb.ToString();
                    log.Log("gen abi succ");
                }
                catch (Exception err)
                {
                    log.Log("gen abi Error:" + err.ToString());
                }
            }
            catch (Exception err)
            {
                log.Log("Convert Error:" + err.ToString());
                return(-1);
            }

            // Write bytes

            try
            {
                string bytesname = onlyname + ".nef";
                var    nef       = new NefFile
                {
                    Compiler = "neon",
                    Version  = Version.Parse(((AssemblyFileVersionAttribute)Assembly.GetExecutingAssembly()
                                              .GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version),
                    Script     = bytes,
                    ScriptHash = bytes.ToScriptHash()
                };
                nef.CheckSum = NefFile.ComputeChecksum(nef);

                File.Delete(bytesname);
                using (var stream = File.OpenWrite(bytesname))
                    using (var writer = new BinaryWriter(stream))
                    {
                        nef.Serialize(writer);
                    }
                log.Log("write:" + bytesname);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write Bytes Error:" + err.ToString());
                return(-1);
            }

            try
            {
                string abiname = onlyname + ".abi.json";

                File.Delete(abiname);
                File.WriteAllText(abiname, jsonstr);
                log.Log("write:" + abiname);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write abi Error:" + err.ToString());
                return(-1);
            }

            try
            {
                var features = module == null ? ContractFeatures.NoProperty : module.attributes
                               .Where(u => u.AttributeType.Name == "FeaturesAttribute")
                               .Select(u => (ContractFeatures)u.ConstructorArguments.FirstOrDefault().Value)
                               .FirstOrDefault();

                var extraAttributes = module == null ? new List <Mono.Collections.Generic.Collection <CustomAttributeArgument> >() : module.attributes.Where(u => u.AttributeType.Name == "ManifestExtraAttribute").Select(attribute => attribute.ConstructorArguments).ToList();

                var extra   = BuildExtraAttributes(extraAttributes);
                var storage = features.HasFlag(ContractFeatures.HasStorage).ToString().ToLowerInvariant();
                var payable = features.HasFlag(ContractFeatures.Payable).ToString().ToLowerInvariant();

                string manifest    = onlyname + ".manifest.json";
                string defManifest =
                    @"{""groups"":[],""features"":{""storage"":" + storage + @",""payable"":" + payable + @"},""abi"":" +
                    jsonstr +
                    @",""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safeMethods"":[],""extra"":" + extra + "}";

                File.Delete(manifest);
                File.WriteAllText(manifest, defManifest);
                log.Log("write:" + manifest);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write manifest Error:" + err.ToString());
                return(-1);
            }

            try
            {
                fs.Dispose();
                if (fspdb != null)
                {
                    fspdb.Dispose();
                }
            }
            catch
            {
            }

            if (bSucc == 3)
            {
                log.Log("SUCC");
                return(0);
            }

            return(-1);
        }
示例#25
0
        public void Build(Stream fs, Stream fspdb, bool optimizer)
        {
            this.IsBuild      = false;
            this.Error        = null;
            this.UseOptimizer = optimizer;

            var log = new DefLogger();

            this.modIL = new ILModule(log);
            try
            {
                modIL.LoadModule(fs, fspdb);
            }
            catch (Exception err)
            {
                log.Log("LoadModule Error:" + err.ToString());
                this.Error = err;
                return;
            }

            converterIL = new ModuleConverter(log);
            Dictionary <int, int> addrConvTable = null;
            ConvOption            option        = new ConvOption();

#if NDEBUG
            try
#endif
            {
                converterIL.Convert(modIL, option);
                finalNEF = converterIL.outModule.Build();
                if (optimizer)
                {
                    var   opbytes = NefOptimizeTool.Optimize(finalNEF, out addrConvTable);
                    float ratio   = (opbytes.Length * 100.0f) / (float)finalNEF.Length;
                    log.Log("optimization ratio = " + ratio + "%");
                    finalNEF = opbytes;
                }
                IsBuild = true;
            }
#if NDEBUG
            catch (Exception err)
            {
                this.Error = err;
                log.Log("Convert IL->ASM Error:" + err.ToString());
                return;
            }
#endif
            try
            {
                finialABI = vmtool.FuncExport.Export(converterIL.outModule, finalNEF, addrConvTable);
            }
            catch (Exception e)
            {
                throw e;
            }

            try
            {
                var features = converterIL.outModule == null ? ContractFeatures.NoProperty : converterIL.outModule.attributes
                               .Where(u => u.AttributeType.Name == "FeaturesAttribute")
                               .Select(u => (ContractFeatures)u.ConstructorArguments.FirstOrDefault().Value)
                               .FirstOrDefault();

                var extraAttributes = converterIL.outModule == null ? new List <Mono.Collections.Generic.Collection <CustomAttributeArgument> >()
                    : converterIL.outModule.attributes.Where(u => u.AttributeType.Name == "ManifestExtraAttribute").Select(attribute => attribute.ConstructorArguments).ToList();
                var storage = features.HasFlag(ContractFeatures.HasStorage).ToString().ToLowerInvariant();
                var payable = features.HasFlag(ContractFeatures.Payable).ToString().ToLowerInvariant();

                finalManifest =
                    @"{""groups"":[],""features"":{""storage"":" + storage + @",""payable"":" + payable + @"},""abi"":" +
                    finialABI +
                    @",""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safeMethods"":[],""extra"":[]" + "}";
            }
            catch
            {
            }
        }
示例#26
0
        public static int Compile(Options options, ILogger log = null)
        {
            // Set console
            Console.OutputEncoding = Encoding.UTF8;
            log ??= new DefLogger();
            log.Log("Neo.Compiler.MSIL console app v" + Assembly.GetAssembly(typeof(Program)).GetName().Version);

            var fileInfo = new FileInfo(options.File);

            // Set current directory
            if (!fileInfo.Exists)
            {
                log.Log("Could not find file " + fileInfo.FullName);
                return(-1);
            }

            Stream fs;
            Stream fspdb;
            var    onlyname = Path.GetFileNameWithoutExtension(fileInfo.Name);
            var    path     = fileInfo.Directory.FullName;

            if (!string.IsNullOrEmpty(path))
            {
                try
                {
                    Directory.SetCurrentDirectory(path);
                }
                catch
                {
                    log.Log("Could not find path: " + path);
                    return(-1);
                }
            }

            switch (fileInfo.Extension.ToLowerInvariant())
            {
            case ".csproj":
            {
                // Compile csproj file

                log.Log("Compiling from csproj project");
                var output = Compiler.CompileCSProj(fileInfo.FullName);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".vbproj":
            {
                // Compile vbproj file

                log.Log("Compiling from vbproj project");
                var output = Compiler.CompileVBProj(fileInfo.FullName);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".cs":
            {
                // Compile C# files

                log.Log("Compiling from c# source");
                var output = Compiler.CompileCSFiles(new string[] { fileInfo.FullName }, new string[0]);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".vb":
            {
                // Compile VB files

                log.Log("Compiling from VB source");
                var output = Compiler.CompileVBFiles(new string[] { fileInfo.FullName }, new string[0]);
                fs    = new MemoryStream(output.Dll);
                fspdb = new MemoryStream(output.Pdb);
                break;
            }

            case ".dll":
            {
                string filepdb = onlyname + ".pdb";

                // Open file
                try
                {
                    fs = fileInfo.OpenRead();

                    if (File.Exists(filepdb))
                    {
                        fspdb = File.OpenRead(filepdb);
                    }
                    else
                    {
                        fspdb = null;
                    }
                }
                catch (Exception err)
                {
                    log.Log("Open File Error:" + err.ToString());
                    return(-1);
                }
                break;
            }

            default:
            {
                log.Log("File format not supported by neon: " + path);
                return(-1);
            }
            }

            ILModule mod = new ILModule(log);

            // Load module
            try
            {
                mod.LoadModule(fs, fspdb);
            }
            catch (Exception err)
            {
                log.Log("LoadModule Error:" + err.ToString());
                return(-1);
            }
            JObject abi;

            byte[]    bytes;
            int       bSucc    = 0;
            string    debugstr = null;
            NeoModule module;

            // Convert and build
            try
            {
                var        conv   = new ModuleConverter(log);
                ConvOption option = new ConvOption();
                module = conv.Convert(mod, option);
                bytes  = module.Build();
                log.Log("convert succ");
                Dictionary <int, int> addrConvTable = null;
                if (options.Optimize)
                {
                    HashSet <int> entryPoints = new HashSet <int>();
                    foreach (var func in module.mapMethods)
                    {
                        entryPoints.Add(func.Value.funcaddr);
                    }
                    var optimize = NefOptimizeTool.Optimize(bytes, entryPoints.ToArray(), out addrConvTable);
                    log.Log("optimization succ " + (((bytes.Length / (optimize.Length + 0.0)) * 100.0) - 100).ToString("0.00 '%'"));
                    bytes = optimize;
                }

                try
                {
                    abi = FuncExport.Export(module, bytes, addrConvTable);
                    log.Log("gen abi succ");
                }
                catch (Exception err)
                {
                    log.Log("gen abi Error:" + err.ToString());
                    return(-1);
                }

                try
                {
                    var outjson = DebugExport.Export(module, bytes, addrConvTable);
                    debugstr = outjson.ToString(false);
                    log.Log("gen debug succ");
                }
                catch (Exception err)
                {
                    log.Log("gen debug Error:" + err.ToString());
                }
            }
            catch (Exception err)
            {
                log.Log("Convert Error:" + err.ToString());
                return(-1);
            }

            // Write bytes

            try
            {
                string bytesname = onlyname + ".nef";
                var    nef       = new NefFile
                {
                    Compiler = "neon",
                    Version  = Version.Parse(((AssemblyFileVersionAttribute)Assembly.GetAssembly(typeof(Program))
                                              .GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version),
                    Script     = bytes,
                    ScriptHash = bytes.ToScriptHash()
                };
                nef.CheckSum = NefFile.ComputeChecksum(nef);

                File.Delete(bytesname);
                using (var stream = File.OpenWrite(bytesname))
                    using (var writer = new BinaryWriter(stream))
                    {
                        nef.Serialize(writer);
                    }
                log.Log("write:" + bytesname);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write Bytes Error:" + err.ToString());
                return(-1);
            }

            try
            {
                var    sbABI   = abi.ToString(false);
                string abiname = onlyname + ".abi.json";

                File.Delete(abiname);
                File.WriteAllText(abiname, sbABI.ToString());
                log.Log("write:" + abiname);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write abi Error:" + err.ToString());
                return(-1);
            }

            try
            {
                string debugname = onlyname + ".debug.json";
                string debugzip  = onlyname + ".nefdbgnfo";

                var tempName = Path.GetTempFileName();
                File.Delete(tempName);
                File.WriteAllText(tempName, debugstr);
                File.Delete(debugzip);
                using (var archive = ZipFile.Open(debugzip, ZipArchiveMode.Create))
                {
                    archive.CreateEntryFromFile(tempName, Path.GetFileName(debugname));
                }
                File.Delete(tempName);
                log.Log("write:" + debugzip);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write debug Error:" + err.ToString());
                return(-1);
            }

            try
            {
                string manifest    = onlyname + ".manifest.json";
                var    defManifest = FuncExport.GenerateManifest(abi, module);

                File.Delete(manifest);
                File.WriteAllText(manifest, defManifest);
                log.Log("write:" + manifest);
                bSucc++;
            }
            catch (Exception err)
            {
                log.Log("Write manifest Error:" + err.ToString());
                return(-1);
            }

            try
            {
                fs.Dispose();
                if (fspdb != null)
                {
                    fspdb.Dispose();
                }
            }
            catch
            {
            }

            if (bSucc == 4)
            {
                log.Log("SUCC");
                return(0);
            }

            return(-1);
        }