コード例 #1
0
        public Expression GetExpression(InstructionInfo info, IExpressionLibraryRegistry expressionLibraries)
        {
            String opcode = info.Prefix + info.Opcode.ToString("X2");
            if (!_enabledOpcodes.Contains(opcode) && IsFilterEnabled)
                return null;

            return GetExpressionImpl(info, expressionLibraries);
        }        
コード例 #2
0
        public Expression GetExpression(InstructionInfo info, IExpressionLibraryRegistry expressionLibraries)
        {
            var instructionSize = 0;

            switch (info.ParameterMode)
            {
                case InstructionParameterMode.None:
                    instructionSize = 1;
                    break;
                case InstructionParameterMode.Byte:
                    instructionSize = 2;
                    break;
                case InstructionParameterMode.Word:
                    instructionSize = 3;
                    break;
                case InstructionParameterMode.Index:
                    instructionSize = 2;
                    break;
                case InstructionParameterMode.Address:
                    instructionSize = 3;
                    break;
                case InstructionParameterMode.IndexAndByte:
                    instructionSize = 3;
                    break;
                default:
                    break;
            }

            if (info.Prefix == "DDCB" || info.Prefix == "FDCB")
            {
                instructionSize++;
            }

            if (!String.IsNullOrEmpty(info.Prefix))
                instructionSize += info.Prefix.Length / 2;

            var progExpr = expressionLibraries.GetLibrary<IProgramControlExpressionLibrary>();
            return Expression.Call(Expression.Constant(this), _enqueMethod,
                Expression.New(_historyItemConsturctor,
                    Expression.Constant(info.Mnemonic),
                    Expression.Subtract(progExpr.ProgramCounterRegister,
                        Expression.Constant(instructionSize)),
                    progExpr.ParameterByte1,
                    progExpr.ParameterByte2)
                );
        }
コード例 #3
0
 public static List<AstNodeExpr> ParseParameters(InstructionInfo InstructionInfo, Scope<string, AstLocal> Scope)
 {
     var Parameters = new List<AstNodeExpr>();
     new Regex(@"%\w+").Replace(InstructionInfo.Format, (Match) =>
     {
         switch (Match.ToString())
         {
             case "%addr": Parameters.Add(ast.Cast<ushort>(ast.Local(Scope.Get("nnn")))); break;
             case "%vx": Parameters.Add(ast.Cast<byte>(ast.Local(Scope.Get("x")))); break;
             case "%vy": Parameters.Add(ast.Cast<byte>(ast.Local(Scope.Get("y")))); break;
             case "%byte": Parameters.Add(ast.Cast<byte>(ast.Local(Scope.Get("nn")))); break;
             case "%nibble": Parameters.Add(ast.Cast<byte>(ast.Local(Scope.Get("n")))); break;
             default: throw (new Exception(Match.ToString()));
         }
         return "";
     });
     return Parameters;
 }
コード例 #4
0
        protected override Expression GetExpressionImpl(InstructionInfo info, IExpressionLibraryRegistry expressionLibraries)
        {
            var dataExpLib = expressionLibraries.GetLibrary<IDataAccessExpressionLibrary>();
            var progLib = expressionLibraries.GetLibrary<IProgramControlExpressionLibrary>();

            return Expression.Call(Expression.Constant(this), _instructionRanEvent, Expression.New(_eventArgsConstructor,
                    dataExpLib.RegisterA,
                    dataExpLib.RegisterB,
                    dataExpLib.RegisterC,
                    dataExpLib.RegisterD,
                    dataExpLib.RegisterE,
                    dataExpLib.RegisterH,
                    dataExpLib.RegisterL,
                    dataExpLib.FlagsRegister,
                    progLib.ProgramCounterRegister,
                    dataExpLib.StackPointerRegister,
                    progLib.CycleCounter,
                    Expression.Constant(info),
                    ((DataAccessExpressionLibrary)dataExpLib).SystemBusParameter
                )
            );
        }
コード例 #5
0
ファイル: SchedulingGenome.cs プロジェクト: harnold/cobe
        public SchedulingGenome(SchedulingGenomePopulation population)
        {
            this.population = population;
            this.scheduler = population.Scheduler;

            int maxSchedulingSteps = InstructionNodes.Count;

            schedule = new InstructionNode[
                maxSchedulingSteps, MachineDescription.ExecutionUnits];

            instructionInfos = new Hashtable(InstructionNodes.Count);

            foreach (InstructionNode iNode in InstructionNodes)
                instructionInfos[iNode] = new InstructionInfo();

            valueInfos = new Hashtable(RegisterValues.Count);

            foreach (ValueNode vNode in RegisterValues)
                valueInfos[vNode] = new ValueInfo();

            isValid = false;

            generationOfBirth = population.GA.Generation;
        }
コード例 #6
0
 void Format_Misc(int index, InstructionInfo info, string formattedString) => FormatBase(index, info, formattedString, FormatterFactory.Create());
コード例 #7
0
ファイル: WopEx.cs プロジェクト: migrap/SecureSocketProtocol
        /// <summary>
        /// Decrypt the data
        /// </summary>
        /// <param name="Data">The data to decrypt</param>l
        /// <param name="Offset">The index where the data starts</param>
        /// <param name="Length">The length to decrypt</param>
        public void Decrypt(byte[] Data, int Offset, int Length)
        {
            lock (DecState)
            {
                int OrgLen = Length;
                Length += Offset;

                for (int round = 0; round < Rounds; round++)
                {
                    using (PayloadWriter pw = new PayloadWriter(new System.IO.MemoryStream(Data)))
                    {
                        ulong temp_Value = DecState.IV[EncMode == WopEncMode.Simple ? 0 : DecState.IV_Pos]; //is being used for CBC Mode (Block-Cipher-Chaining Mode)
                        for (int i = Offset, k = 0; i < Length; k++)
                        {
                            pw.vStream.Position = i;
                            int   usedsize     = 0;
                            ulong value        = 0;
                            ulong OrgReadValue = 0;

                            if (i + 8 < Length)
                            {
                                OrgReadValue = BitConverter.ToUInt64(Data, i);
                                usedsize     = 8;

                                value = Decrypt_Core_Big(OrgReadValue ^ temp_Value, OrgLen, k);
                                pw.WriteULong(value);
                            }
                            else
                            {
                                OrgReadValue = Data[i];
                                usedsize     = 1;

                                value = Decrypt_Core_Small((byte)OrgReadValue, OrgLen, k);
                                pw.WriteByte((byte)value);
                            }

                            temp_Value    += OrgReadValue;
                            DecState.Seed += (int)value;
                            i             += usedsize;

                            if (EncMode != WopEncMode.Simple)
                            {
                                DecState.Key_Pos  += 1;
                                DecState.Salt_Pos += 1;
                            }
                        }
                    }
                }

                DecState.IV_Pos = (DecState.IV_Pos + 1) % DecState.IV.Length;

                switch (EncMode)
                {
                case WopEncMode.GenerateNewAlgorithm:
                {
                    InstructionInfo tempEncCode = null;
                    InstructionInfo tempDecCode = null;
                    FastRandom      fastRand    = new FastRandom(DecState.Seed);

                    for (int i = 0; i < DecState.Instructions.Length; i++)
                    {
                        GetNextRandomInstruction(fastRand, ref tempEncCode, ref tempDecCode);
                        DecState.Instructions[i] = tempDecCode;
                    }

                    if (UseDynamicCompiler)
                    {
                        DecState.Compile();
                    }
                    break;
                }

                case WopEncMode.ShuffleInstructions:
                {
                    ShuffleInstructions(DecState.Instructions, DecState.Seed);

                    if (UseDynamicCompiler)
                    {
                        DecState.Compile();
                    }
                    break;
                }
                }
            }
        }
コード例 #8
0
ファイル: FastFormatterTest.cs プロジェクト: tthtun/iced
 protected void FormatBase(int index, InstructionInfo info, string formattedString, FastFormatter formatter) =>
 FormatterTestUtils.FormatTest(info.Bitness, info.HexBytes, info.Code, info.Options, formattedString, formatter);
コード例 #9
0
        private void ApplyOperand(string str)
        {
            InstructionInfo II = (InstructionInfo)instructionEditor.DragItem;

            switch (currentPOT)
            {
            case PickOperandType.Byte:
                Byte resultByte;
                if (Byte.TryParse(str, out resultByte))
                {
                    II.NewInstruction.Operand = resultByte;
                }
                break;

            case PickOperandType.SByte:
                SByte resultSByte;
                if (SByte.TryParse(str, out resultSByte))
                {
                    II.NewInstruction.Operand = resultSByte;
                }
                break;

            case PickOperandType.Int32:
                Int32 resultInt32;
                if (Int32.TryParse(str, out resultInt32))
                {
                    II.NewInstruction.Operand = resultInt32;
                }
                break;

            case PickOperandType.Int64:
                Int64 resultInt64;
                if (Int64.TryParse(str, out resultInt64))
                {
                    II.NewInstruction.Operand = resultInt64;
                }
                break;

            case PickOperandType.Single:
                Single resultSingle;
                if (Single.TryParse(str, out resultSingle))
                {
                    II.NewInstruction.Operand = resultSingle;
                }
                break;

            case PickOperandType.Double:
                Double resultDouble;
                if (Double.TryParse(str, out resultDouble))
                {
                    II.NewInstruction.Operand = resultDouble;
                }
                break;

            case PickOperandType.String:
                II.NewInstruction.Operand = str;
                break;

            default:
                Log.Write(Log.Level.Warning, $"OperandType \"{currentPOT}\" cannot be processed with a textbox");
                break;
            }

            RedrawBoth();
        }
コード例 #10
0
 public CpuEventArgs(Int32 registerA, 
                     Int32 registerB,
                     Int32 registerC,
                     Int32 registerD,
                     Int32 registerE,
                     Int32 registerH,
                     Int32 registerL,
                     Int32 flagsRegister,
                     Int32 programCounterRegsiter,
                     Int32 stackPointerRegsiter,
                     Int32 cycleCounter,
                     InstructionInfo info,
                     ISystemBus systemBus
     )
 {
     RegisterA = registerA;
     RegisterB = registerB;
     RegisterC = registerC;
     RegisterD = registerD;
     RegisterE = registerE;
     RegisterH = registerH;
     RegisterL = registerL;
     FlagsRegister = flagsRegister;
     ProgramCounterRegister = programCounterRegsiter;
     StackPointerRegister = stackPointerRegsiter;
     CycleCounter = cycleCounter;
     Instruction = info;
     SystemBus = systemBus;
 }
コード例 #11
0
 private void FinishFile(int address, List <FunctionEnumerationResult> files, ref FunctionEnumerationResult currentFunction, ref FunctionEnumerationResult currentFile, InstructionInfo newFileInstruction)
 {
     if (newFileInstruction == null || (newFileInstruction.word1 >= 0 && newFileInstruction.word1 < ainFile.Filenames.Count))
     {
         if (newFileInstruction != null)
         {
             currentFile.name = ainFile.Filenames[newFileInstruction.word1];
             currentFile.id   = newFileInstruction.word1;
         }
         FinishFunction(address, ref currentFunction, currentFile);
         currentFile.lastAddress = address;
         files.Add(currentFile);
         currentFile          = new FunctionEnumerationResult();
         currentFile.children = new List <FunctionEnumerationResult>();
         currentFile.address  = address;
     }
 }
コード例 #12
0
ファイル: Index.xaml.cs プロジェクト: sinncoteam/fhtruck
        /// <summary>
        /// 计算路径以及转向逻辑
        /// </summary>
        /// <param name="insInfo"></param>
        /// <param name="path1"></param>
        /// <param name="path2"></param>
        /// <param name="rackItem"></param>
        private void ComputePath(InstructionInfo insInfo, string path1, string path2 = null, RackInfo rackItem = null)
        {
            string[] path1Arr    = path1.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            int      path1Length = path1Arr.Length;

            for (int i = 0; i < path1Length; i++)
            {
                string path = path1Arr[i];
                if (i == 0 && !string.IsNullOrEmpty(lastRoute)) //如果取/卸货仓位是紧邻的仓位,则指令需要跳过下一位置
                {
                    var rackInfo = rackList.Where(a => a.RouteCode == path).FirstOrDefault();
                    if (rackInfo != null)
                    {
                        var lastInfo = rackList.Where(a => a.RouteCode == lastRoute).FirstOrDefault();
                        if (lastInfo != null)
                        {
                            continue;
                        }
                    }
                }
                lastRoute = path;
                var item = routelist.Where(a => a.Routecode == path1Arr[i]).FirstOrDefault();
                if (i + 1 < path1Length)    //还有下一节点
                {
                    string next     = path1Arr[i + 1];
                    var    nextItem = routelist.Where(a => a.Routecode == next).FirstOrDefault();
                    int    xsub     = item.X - nextItem.X;
                    int    ysub     = item.Y - nextItem.Y;
                    if (xsub == 0)
                    {
                        if (ysub > 0)   //向南
                        {
                            insInfo.AddItem(path, insInfo.getWay(direction, DirectionWay.South));
                            direction = DirectionWay.South;
                        }
                        else  //向北
                        {
                            insInfo.AddItem(path, insInfo.getWay(direction, DirectionWay.North));

                            direction = DirectionWay.North;
                        }
                    }
                    else if (ysub == 0)
                    {
                        if (xsub > 0)  //向西
                        {
                            insInfo.AddItem(path, insInfo.getWay(direction, DirectionWay.West));

                            direction = DirectionWay.West;
                        }
                        else  //向东
                        {
                            insInfo.AddItem(path, insInfo.getWay(direction, DirectionWay.Easet));

                            direction = DirectionWay.Easet;
                        }
                    }
                }
                else if (!string.IsNullOrEmpty(path2))  //一期默认货架在右侧,即X正,Y负
                {
                    setRouteByRack(insInfo, path2, path, item, rackItem);
                }
            }
        }
コード例 #13
0
ファイル: Class1.cs プロジェクト: chargen/AGI-X0
        void testALS()
        {
            prepare();

            //joinIrc1();

            var absolute                 = PathHelper.AssemblyDirectory.Uri.AbsoluteUri;
            var absoluteWithoutFile      = absolute.Substring(8);
            var pathParts                = new List <string>(absoluteWithoutFile.Split(new char[] { '/' }));
            var pathPartsWithoutSpecific = pathParts;

            for (;;)
            {
                string lastPathPart = pathPartsWithoutSpecific[pathPartsWithoutSpecific.Count - 1];
                if (lastPathPart == "bin")
                {
                    break;
                }
                pathPartsWithoutSpecific.RemoveAt(pathPartsWithoutSpecific.Count - 1);
            }
            pathPartsWithoutSpecific.RemoveAt(pathPartsWithoutSpecific.Count - 1);
            pathPartsWithoutSpecific.RemoveAt(pathPartsWithoutSpecific.Count - 1);

            pathPartsWithoutSpecific.AddRange(new string[] { "MetaNixCore", "functionalSrc", "problems" });


            string directoryPath = string.Join("\\", pathPartsWithoutSpecific.ToArray());

            string[] problemsFilenames = Directory.GetFiles(directoryPath);


            PatternSymbolContext patternSymbolContext = new PatternSymbolContext();

            patternSymbolContext.lookupOrCreateSymbolIdAndUniqueIdForName("null");  // must have 0 as uniqueId
            patternSymbolContext.lookupOrCreateSymbolIdAndUniqueIdForName("true");  // must have 1 as uniqueId
            patternSymbolContext.lookupOrCreateSymbolIdAndUniqueIdForName("false"); // must have 2 as uniqueId


            Scheduler scheduler = new Scheduler();

            AdvancedAdaptiveLevinSearchProgramDatabase levinSearchProblemDatabase = new AdvancedAdaptiveLevinSearchProgramDatabase();

            SparseArrayProgramDistribution          sparseArrayProgramDistribution = new SparseArrayProgramDistribution();
            AdvancedAdaptiveLevinSearchTaskProvider levinSearchTaskProvider        = new AdvancedAdaptiveLevinSearchTaskProvider(scheduler, sparseArrayProgramDistribution, levinSearchProblemDatabase, logger);


            // overwrite for testing
            problemsFilenames = new string[] {
                @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_array_verticalAddition.txt",
                @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\level1\Induction_array_integer_exists.txt",

                /*
                 *
                 *
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_linkedlist_next.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_linkedlist_append.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_array_appendBeginningAndEnding.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_array_removeEqual.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_array_subReg0.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_array_multiplication.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\induction_array_binaryNegation.txt",
                 * @"C:\Users\r0b3\github\AGI-X0\code\c#\MetaNixCore\functionalSrc\problems\Induction_array_negation.txt",
                 */
            };

            foreach (string iterationPath in problemsFilenames)
            {
                string fileContent = File.ReadAllText(iterationPath);

                Lexer lexer = new Lexer();
                lexer.setSource(fileContent);

                Functional2LexerAndParser parser = new Functional2LexerAndParser(patternSymbolContext);
                parser.lexer = lexer;
                parser.parse();

                Pattern <Decoration> problemRootElement = parser.rootPattern;

                MetaNix.framework.pattern.Interpreter.vmAssert(problemRootElement.isBranch, false, "Must be branch!");
                MetaNix.framework.pattern.Interpreter.vmAssert(problemRootElement.decoration == null, false, "Must be pure branch!");

                Pattern <Decoration> configurationPattern = problemRootElement.referenced[0];


                AdvancedAdaptiveLevinSearchProblem levinSearchProblem = new AdvancedAdaptiveLevinSearchProblem();

                var iterationPathParts = new List <string>(iterationPath.Split(new char[] { '\\' }));

                string taskname = iterationPathParts[iterationPathParts.Count - 1].Substring(0, iterationPathParts[iterationPathParts.Count - 1].Length - 4);

                levinSearchProblem.humanReadableTaskname = taskname;


                //levinSearchProblem.enumerationMaxProgramLength = 5;
                levinSearchProblem.instructionsetCount = InstructionInfo.getNumberOfInstructions() - 16;                          /*because no call*/

                levinSearchProblem.maxNumberOfRetiredInstructions = Conversion.convertToUint(configurationPattern.referenced[1]); // TODO< derive by propability with some formula from schmidhuber >


                // read hints for indirect call candidates
                Pattern <Decoration> hintIndirectCallCandidatesPattern = configurationPattern.referenced[2];
                foreach (var iHintPattern in hintIndirectCallCandidatesPattern.referenced)
                {
                    string iHint = Conversion.convertPatternToString(iHintPattern);

                    levinSearchProblem.humanReadableIndirectlyCallableProgramNames.Add(iHint);
                }



                //levinSearchProblem.localInitialInterpreterState = new LocalInterpreterState();
                //levinSearchProblem.localInitialInterpreterState.registers = new int[3];

                //levinSearchProblem.initialInterpreterState.debugExecution = false;


                levinSearchProblem.enumerationMaxProgramLength = Conversion.convertToUint(configurationPattern.referenced[0]);

                for (int trainingSampleI = 1; trainingSampleI < problemRootElement.referenced.Length; trainingSampleI++)
                {
                    var trainingSamplePattern = problemRootElement.referenced[trainingSampleI];

                    MetaNix.framework.pattern.Interpreter.vmAssert(trainingSamplePattern.isBranch, false, "Must be branch!");
                    MetaNix.framework.pattern.Interpreter.vmAssert(trainingSamplePattern.decoration == null, false, "Must be pure branch!");

                    Pattern <Decoration> questionArrayPattern     = trainingSamplePattern.referenced[0],
                                         questionRegistersPattern = trainingSamplePattern.referenced[1],
                                         answerArrayPattern       = trainingSamplePattern.referenced[3],
                                         answerRegistersPattern   = trainingSamplePattern.referenced[4];

                    // append

                    TrainingSample createdTrainingSample = new TrainingSample();
                    createdTrainingSample.questionArray      = new List <int>(Conversion.convertToIntArray(questionArrayPattern));
                    createdTrainingSample.questionRegisters  = Conversion.convertToOptionalIntArray(questionRegistersPattern);
                    createdTrainingSample.questionArrayIndex = Conversion.convertToOptionalInt(trainingSamplePattern.referenced[2]);
                    createdTrainingSample.answerRegisters    = Conversion.convertToOptionalIntArray(answerRegistersPattern);
                    createdTrainingSample.answerArray        = new List <int>(Conversion.convertToIntArray(answerArrayPattern));
                    createdTrainingSample.answerArrayIndex   = Conversion.convertToOptionalInt(trainingSamplePattern.referenced[5]);

                    levinSearchProblem.trainingSamples.Add(createdTrainingSample);
                }



                levinSearchTaskProvider.problems.Add(levinSearchProblem);
            }



            levinSearchTaskProvider.submitFirstTask();

            for (; ;)
            {
                scheduler.process();
            }
        }
コード例 #14
0
ファイル: Index.xaml.cs プロジェクト: sinncoteam/fhtruck
        /// <summary>
        /// 计算仓位的转向逻辑
        /// </summary>
        /// <param name="insInfo"></param>
        /// <param name="nextPathArray"></param>
        /// <param name="lastPath"></param>
        /// <param name="item"></param>
        /// <param name="rackItem"></param>
        private void setRouteByRack(InstructionInfo insInfo, string nextPathArray, string lastPath, RouteInfo item, RackInfo rackItem)
        {
            string[] path2Arr = nextPathArray.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            string   next     = path2Arr[0];
            var      nextItem = routelist.Where(a => a.Routecode == next).FirstOrDefault();
            int      xsub     = item.X - nextItem.X;
            int      ysub     = item.Y - nextItem.Y;
            int      xrack    = 0;
            int      yrack    = 0;

            if (rackItem != null)
            {
                xrack = item.X - rackItem.X;
                yrack = item.Y - rackItem.Y;
            }
            if (xsub == 0)
            {
                if (ysub > 0)   //向南
                {
                    if (lastPath == inpackroute || lastPath == outpackroute)
                    {
                        if (direction == DirectionWay.South)
                        {
                            if (xrack > 0)  //右手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                        }
                        else if (direction == DirectionWay.North)
                        {
                            if (xrack > 0) //左手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                        }
                        else if (direction == DirectionWay.West)
                        {
                            insInfo.AddItem(lastPath, TurnWay.Left);
                            //insInfo.AddItem(lastPath, TurnWay.Next);
                        }
                        else
                        {
                            insInfo.AddItem(lastPath, TurnWay.Right);
                            //insInfo.AddItem(lastPath, TurnWay.Next);
                        }
                    }
                    direction = DirectionWay.South;
                }
                else  //向北
                {
                    if (lastPath == inpackroute || lastPath == outpackroute)
                    {
                        if (direction == DirectionWay.South)
                        {
                            if (xrack > 0)  //右手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                        }
                        else if (direction == DirectionWay.North)
                        {
                            if (xrack > 0) //左手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                        }
                        else if (direction == DirectionWay.Easet)
                        {
                            insInfo.AddItem(lastPath, TurnWay.Left);
                            //insInfo.AddItem(lastPath, TurnWay.Next);
                        }
                        else
                        {
                            insInfo.AddItem(lastPath, TurnWay.Right);
                            //insInfo.AddItem(lastPath, TurnWay.Next);
                        }
                    }
                    direction = DirectionWay.North;
                }
            }
            else if (ysub == 0)
            {
                if (xsub > 0)  //向西
                {
                    if (lastPath == inpackroute || lastPath == outpackroute)
                    {
                        if (direction == DirectionWay.South)
                        {
                            insInfo.AddItem(lastPath, TurnWay.Right);
                            //insInfo.AddItem(lastPath, TurnWay.Back);
                            //insInfo.AddItem(lastPath, TurnWay.Left);
                        }
                        else if (direction == DirectionWay.Easet)
                        {
                            if (yrack > 0)  //右手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                        }
                        else if (direction == DirectionWay.West)
                        {
                            if (yrack > 0) //左手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                        }
                        else
                        {
                            insInfo.AddItem(lastPath, TurnWay.Left);
                            //insInfo.AddItem(lastPath, TurnWay.Back);
                            //insInfo.AddItem(lastPath, TurnWay.Right);
                        }
                    }
                    direction = DirectionWay.West;
                }
                else  //向东
                {
                    if (lastPath == inpackroute || lastPath == outpackroute)
                    {
                        if (direction == DirectionWay.South)
                        {
                            insInfo.AddItem(lastPath, TurnWay.Left);
                            //insInfo.AddItem(lastPath, TurnWay.Back);
                            //insInfo.AddItem(lastPath, TurnWay.Right);
                        }
                        else if (direction == DirectionWay.Easet)
                        {
                            if (yrack > 0)  //右手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                        }
                        else if (direction == DirectionWay.West)
                        {
                            if (yrack > 0)  //左手
                            {
                                insInfo.AddItem(lastPath, TurnWay.Right);
                                insInfo.AddItem(lastPath, TurnWay.Right);
                            }
                            else
                            {
                                insInfo.AddItem(lastPath, TurnWay.Left);
                                insInfo.AddItem(lastPath, TurnWay.Left);
                            }
                        }
                        else
                        {
                            insInfo.AddItem(lastPath, TurnWay.Right);
                            //insInfo.AddItem(lastPath, TurnWay.Back);
                            //insInfo.AddItem(lastPath, TurnWay.Left);
                        }
                    }
                    direction = DirectionWay.Easet;
                }
            }
        }
コード例 #15
0
 protected abstract Expression GetExpressionImpl(InstructionInfo info, IExpressionLibraryRegistry expressionLibraries);
コード例 #16
0
ファイル: SchedulingGenome.cs プロジェクト: harnold/cobe
        public virtual void Copy(
            SchedulingGenome other,
            IDictionary instructionMap,
            IDictionary valueMap)
        {
            population = other.population;
            scheduler = other.scheduler;

            schedule = new InstructionNode[
                other.schedule.GetLength(0),
                other.schedule.GetLength(1)];

            for (int i = 0; i < schedule.GetLength(0); i++) {
                for (int j = 0; j < schedule.GetLength(1); j++) {

                    InstructionNode iNode = other.schedule[i, j];

                    if (iNode != null) {
                        schedule[i, j] =
                            (InstructionNode) instructionMap[other.schedule[i, j]];
                    } else {
                        schedule[i, j] = null;
                    }
                }
            }

            valueInfos = new Hashtable();

            foreach (ValueNode vNode in other.ValueInfos.Keys) {

                ValueInfo info = new ValueInfo();
                ValueInfo otherInfo = other.GetValueInfo(vNode);

                info.Register = otherInfo.Register;
                info.Production = otherInfo.Production;
                info.LastUsage = otherInfo.LastUsage;
                valueInfos[valueMap[vNode]] = info;
            }

            instructionInfos = new Hashtable();

            foreach (InstructionNode iNode in other.InstructionInfos.Keys) {

                InstructionInfo info = new InstructionInfo();
                InstructionInfo otherInfo = other.GetInstructionInfo(iNode);

                info.SchedulingStep = otherInfo.SchedulingStep;
                instructionInfos[instructionMap[iNode]] = info;
            }

            isValid = other.isValid;
            scheduleLength = other.scheduleLength;
            violatedSchedulingConstraints = other.violatedSchedulingConstraints;
            violatedRegisterConstraints = other.violatedRegisterConstraints;
            generationOfBirth = other.generationOfBirth;
        }
コード例 #17
0
ファイル: SchedulingGenome.cs プロジェクト: harnold/cobe
        public virtual void Copy(IGenome otherGenome)
        {
            SchedulingGenome other = (SchedulingGenome) otherGenome;

            population = other.population;
            scheduler = other.scheduler;

            schedule = new InstructionNode[
                other.schedule.GetLength(0),
                other.schedule.GetLength(1)];

            for (int i = 0; i < schedule.GetLength(0); i++)
                for (int j = 0; j < schedule.GetLength(1); j++)
                    schedule[i, j] = other.schedule[i, j];

            valueInfos = new Hashtable();

            foreach (ValueNode vNode in other.ValueInfos.Keys) {

                ValueInfo info = new ValueInfo();
                ValueInfo otherInfo = other.GetValueInfo(vNode);

                info.Register = otherInfo.Register;
                info.Production = otherInfo.Production;
                info.LastUsage = otherInfo.LastUsage;
                valueInfos[vNode] = info;
            }

            instructionInfos = new Hashtable();

            foreach (InstructionNode iNode in other.InstructionInfos.Keys) {

                InstructionInfo info = new InstructionInfo();
                InstructionInfo otherInfo = other.GetInstructionInfo(iNode);

                info.SchedulingStep = otherInfo.SchedulingStep;
                instructionInfos[iNode] = info;
            }

            isValid = other.isValid;
            scheduleLength = other.scheduleLength;
            violatedSchedulingConstraints = other.violatedSchedulingConstraints;
            violatedRegisterConstraints = other.violatedRegisterConstraints;
            generationOfBirth = other.generationOfBirth;
        }
コード例 #18
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ExecutedBlock" /> class.
 /// </summary>
 /// <param name="info">The information.</param>
 /// <param name="call">The call.</param>
 internal ExecutedBlock(InstructionInfo info, CallContext call)
 {
     Info = info;
     Call = call;
 }
コード例 #19
0
        HashSet <Function> GetCalls2(Function startFunction)
        {
            HashSet <Function> calls                = new HashSet <Function>();
            int             address                 = startFunction.Address;
            int             lastAddress             = ainFile.Code.Length;
            InstructionInfo previousInstructionInfo = default(InstructionInfo);

            if (address < lastAddress)
            {
                previousInstructionInfo = Decompiler.Peek(ainFile.Code, address);
            }
            while (address < lastAddress)
            {
                int functionIndex   = -1;
                var instructionInfo = Decompiler.Peek(ainFile.Code, address);

                if (instructionInfo.instruction == Instruction.FUNC ||
                    instructionInfo.instruction == Instruction.ENDFUNC)
                {
                    break;
                }

                if (instructionInfo.instruction == Instruction.CALLFUNC ||
                    instructionInfo.instruction == Instruction.CALLMETHOD)
                {
                    functionIndex = instructionInfo.word1;
                }

                if (instructionInfo.instruction == Instruction.CALLONJUMP)
                {
                    if (previousInstructionInfo.instruction == Instruction.S_PUSH)
                    {
                        int stringIndex = previousInstructionInfo.word1;
                        if (stringIndex >= 0 && stringIndex < ainFile.Strings.Count)
                        {
                            string str = ainFile.Strings[stringIndex];
                            if (ainFile.FunctionNameToIndex.ContainsKey(str))
                            {
                                functionIndex = ainFile.FunctionNameToIndex[str];
                            }
                        }
                    }
                }

                if (instructionInfo.instruction == Instruction.FT_ASSIGNS)
                {
                    if (previousInstructionInfo.instruction == Instruction.PUSH)
                    {
                        int functionTypeNumber = previousInstructionInfo.word1;
                        if (functionTypeNumber >= 0 && functionTypeNumber < ainFile.FunctionTypes.Count)
                        {
                            var stringInstructionInfo = Decompiler.Peek(ainFile.Code, previousInstructionInfo.CurrentAddress - 6);
                            if (stringInstructionInfo.instruction == Instruction.S_PUSH)
                            {
                                int stringNumber = stringInstructionInfo.word1;
                                if (stringNumber >= 0 && stringNumber < ainFile.Strings.Count)
                                {
                                    string functionName = ainFile.Strings[stringNumber];
                                    if (ainFile.FunctionNameToIndex.ContainsKey(functionName))
                                    {
                                        var function = ainFile.Functions[ainFile.FunctionNameToIndex[functionName]];
                                        functionIndex = function.Index;
                                    }
                                }
                            }
                        }
                    }
                }

                if (functionIndex >= 0 && functionIndex < ainFile.Functions.Count)
                {
                    var function = ainFile.Functions[functionIndex];
                    if (!calls.Contains(function))
                    {
                        calls.Add(function);
                    }
                    functionIndex = -1;
                }
                address = instructionInfo.nextAddress;
                previousInstructionInfo = instructionInfo;
            }
            return(calls);
        }
コード例 #20
0
        private IEnumerable <Group> GroupInstruction()
        {
            var code = this._Function.Code;

            if (_Index >= code.Count)
            {
                yield break;
            }

            var instruction = code[_Index++];

            IEnumerable <Group> enumerable;

            var chainCount = InstructionInfo.GetChainCount(instruction.Opcode);

            if (chainCount >= 0)
            {
                enumerable = GroupBasicInstruction(chainCount);
            }
            else if (instruction.Opcode == Opcode.Constructor)
            {
                var(parameterCount, _) = (Constructor)instruction.Argument;
                enumerable             = GroupBasicInstruction(parameterCount);
            }
            else if (instruction.Opcode == Opcode.FinalFunc)
            {
                var(_, _, function) = (FinalFunc)instruction.Argument;
                var parameterCount = function.Parameters.Count;
                parameterCount++; // EndCall
                enumerable = GroupBasicInstruction(parameterCount);
            }
            else if (instruction.Opcode == Opcode.VirtualFunc)
            {
                // TODO(gibbed): dodgy af

                /*var (_, _, name) = ((short, ushort, string))instruction.Argument;
                 * var candidates = this._Cache.Definitions.Where(d => d.Name == name).ToArray();
                 * if (candidates.Length != 1)
                 * {
                 *  enumerable = GroupBasicInstruction(1);
                 * }
                 * else
                 * {
                 *  var function = (FunctionDefinition)candidates[0];
                 *  var parameterCount = function.Parameters.Count;
                 *  parameterCount++; // EndCall
                 *  enumerable = GroupBasicInstruction(parameterCount);
                 * }*/
                enumerable = GroupCallNameInstruction();
            }
            else if (instruction.Opcode == Opcode.Switch)
            {
                enumerable = GroupSwitchInstruction();
            }
            else if (instruction.Opcode == Opcode.SwitchLabel)
            {
                enumerable = GroupSwitchCaseInstruction();
            }
            else if (instruction.Opcode == Opcode.SwitchDefault)
            {
                enumerable = GroupSwitchDefaultInstruction();
            }
            else
            {
                throw new NotImplementedException();
            }

            var group = new Group(instruction);

            foreach (var child in enumerable)
            {
                group.Children.Add(child);
            }
            yield return(group);
        }
コード例 #21
0
            void EnumerateGenericInstruction(InstructionInfo instructionInfo, ArgumentKind overrideKind, ArgumentKind kindToFind, Action <int> addAction)
            {
                if (instructionInfo.totalArguments > 0)
                {
                    if (ArgumentKinds.InstructionArgumentKinds.ContainsKey((int)instructionInfo.instruction))
                    {
                        var argumentKinds = ArgumentKinds.InstructionArgumentKinds[(int)instructionInfo.instruction];
                        for (int i = 0; i < instructionInfo.totalArguments; i++)
                        {
                            var argumentKind = argumentKinds[i];
                            if (overrideKind != 0)
                            {
                                argumentKind = overrideKind;
                            }
                            int word = instructionInfo.words[i];
                            switch (argumentKind)
                            {
                            case ArgumentKind.AssignInt:
                                argumentKind = ArgumentKind.Int;
                                break;

                            case ArgumentKind.Function:
                                if (word >= 0 && word < ainFile.Functions.Count)
                                {
                                    var func = ainFile.Functions[word];
                                    previousStructType = currentStructType;
                                    currentStructType  = func.StructType;
                                }
                                break;

                            case ArgumentKind.Global:
                                if (word >= 0 && word < ainFile.Globals.Count)
                                {
                                    var global = ainFile.Globals[word];
                                    previousStructType = currentStructType;
                                    currentStructType  = global.StructType;
                                }
                                break;

                            case ArgumentKind.Library:
                                libraryNumber = word;
                                break;

                            case ArgumentKind.LibraryFunction:
                                currentStructType = -1;
                                break;

                            case ArgumentKind.Local:
                                if (word >= 0 && word < locals.Count)
                                {
                                    var local = locals[word];
                                    previousStructType = currentStructType;
                                    currentStructType  = local.StructType;
                                }
                                break;

                            case ArgumentKind.LocalMember:
                                argumentKind      = ArgumentKind.Member;
                                currentStructType = currentClass;
                                if (currentStructType >= 0 && currentStructType < ainFile.Structs.Count)
                                {
                                    var structInfo = ainFile.Structs[currentStructType];
                                    if (word >= 0 && word < structInfo.Members.Count)
                                    {
                                        var member = structInfo.Members[word];
                                        previousStructType = currentStructType;
                                        currentStructType  = member.StructType;
                                    }
                                }
                                break;

                            case ArgumentKind.Member:
                                if (currentStructType >= 0 && currentStructType < ainFile.Structs.Count)
                                {
                                    var structInfo = ainFile.Structs[currentStructType];
                                    if (word >= 0 && word < structInfo.Members.Count)
                                    {
                                        var member = structInfo.Members[word];
                                        previousStructType = currentStructType;
                                        currentStructType  = member.StructType;
                                    }
                                }
                                break;

                            case ArgumentKind.StructType:
                                currentStructType = word;
                                break;

                            case ArgumentKind.SystemCall:
                                currentStructType = -1;
                                break;
                            }
                            if (argumentKind == kindToFind)
                            {
                                addAction(word);
                            }
                        }
                    }
                }
            }
コード例 #22
0
        public FunctionEnumerationResult[] GetFilesAndFunctions()
        {
            if (ainFile.Version == 0)
            {
                return(GetFilesAndFunctionsVersion0());
            }

            int address    = 0;
            int codeLength = ainFile.Code.Length;

            HashSet <int> fileNumberSeen = new HashSet <int>();

            List <FunctionEnumerationResult> files           = new List <FunctionEnumerationResult>();
            FunctionEnumerationResult        currentFunction = null;
            FunctionEnumerationResult        currentFile     = new FunctionEnumerationResult();

            currentFile.children = new List <FunctionEnumerationResult>();

            currentFile.address = 0;

            bool            wantNewFile        = false;
            InstructionInfo newFileInstruction = null;

            bool haveFunction = false;

            while (address < codeLength)
            {
                var info = Decompiler.Peek(ainFile.Code, address);
                if (info.instruction == Instruction.EOF)
                {
                    if (!fileNumberSeen.Contains(info.word1))
                    {
                        fileNumberSeen.Add(info.word1);
                        if (wantNewFile)
                        {
                            FinishFile(address, files, ref currentFunction, ref currentFile, newFileInstruction);
                            wantNewFile        = false;
                            newFileInstruction = null;
                        }
                        wantNewFile        = true;
                        newFileInstruction = info;
                    }
                }
                if (info.instruction == Instruction.FUNC)
                {
                    if (wantNewFile)
                    {
                        FinishFile(address, files, ref currentFunction, ref currentFile, newFileInstruction);
                        wantNewFile        = false;
                        newFileInstruction = null;
                    }
                    FinishFunction(address, ref currentFunction, currentFile);

                    if (info.word1 >= 0 && info.word1 < ainFile.Functions.Count)
                    {
                        currentFunction         = new FunctionEnumerationResult();
                        currentFunction.id      = info.word1;
                        currentFunction.name    = ainFile.Functions[info.word1].Name;
                        currentFunction.address = address;
                    }
                }
                //if (info.instruction == Instruction.ENDFUNC)
                //{
                //    FinishFunction(address, ref currentFunction, currentFile);
                //}
                address = info.nextAddress;
            }
            if (currentFile.children.Count > 0)
            {
                if (String.IsNullOrEmpty(currentFile.name))
                {
                    currentFile.name = "remaining.jaf";
                }
                FinishFile(address, files, ref currentFunction, ref currentFile, newFileInstruction);
                //files.Add(currentFile);
            }

            return(files.ToArray());
        }
コード例 #23
0
ファイル: Instruction.cs プロジェクト: zhangwxyc/BPM
        public static InstructionInfo GetInstructionInfo(string FormID)
        {
            InstructionInfo info = null;

            SqlParameter[] parameters = new SqlParameter[] {
                new SqlParameter("@FormID", System.Data.SqlDbType.NVarChar, 100),
            };
            parameters[0].Value = FormID;
            DataTable dataTable = DBHelper.ExecutedProcedure("Biz.ERP_Instruction_Get", parameters);

            ///给实体赋值
            if (dataTable != null && dataTable.Rows.Count > 0)
            {
                info = new InstructionInfo();
                if (dataTable.Rows[0]["FormId"] != null && dataTable.Rows[0]["FormId"].ToString() != "")
                {
                    info.FormId = dataTable.Rows[0]["FormId"].ToString();
                }
                if (dataTable.Rows[0]["IsReport"] != null && dataTable.Rows[0]["IsReport"].ToString() != "")
                {
                    info.IsReport = int.Parse(dataTable.Rows[0]["IsReport"].ToString());
                }
                if (dataTable.Rows[0]["ErpFormId"] != null && dataTable.Rows[0]["ErpFormId"].ToString() != "")
                {
                    info.ErpFormId = dataTable.Rows[0]["ErpFormId"].ToString();
                }
                if (dataTable.Rows[0]["ErpFormType"] != null && dataTable.Rows[0]["ErpFormType"].ToString() != "")
                {
                    info.ErpFormType = dataTable.Rows[0]["ErpFormType"].ToString();
                }
                if (dataTable.Rows[0]["StartDeptId"] != null && dataTable.Rows[0]["StartDeptId"].ToString() != "")
                {
                    info.StartDeptId = dataTable.Rows[0]["StartDeptId"].ToString();
                }
                if (dataTable.Rows[0]["DeptName"] != null && dataTable.Rows[0]["DeptName"].ToString() != "")
                {
                    info.ErpFormId = dataTable.Rows[0]["DeptName"].ToString();
                }
                if (dataTable.Rows[0]["UserName"] != null && dataTable.Rows[0]["UserName"].ToString() != "")
                {
                    info.StartDeptId = dataTable.Rows[0]["UserName"].ToString();
                }
                if (dataTable.Rows[0]["CreateTime"] != null && dataTable.Rows[0]["CreateTime"].ToString() != "")
                {
                    info.CreateTime = DateTime.Parse(dataTable.Rows[0]["CreateTime"].ToString());
                }
                if (dataTable.Rows[0]["LeadersSelected"] != null && dataTable.Rows[0]["LeadersSelected"].ToString() != "")
                {
                    info.ErpFormType = dataTable.Rows[0]["LeadersSelected"].ToString();
                }
                if (dataTable.Rows[0]["ApproveResult"] != null && dataTable.Rows[0]["ApproveResult"].ToString() != "")
                {
                    info.ApproveResult = dataTable.Rows[0]["ApproveResult"].ToString();
                }
                if (dataTable.Rows[0]["IsCheckedChairman"] != null && dataTable.Rows[0]["IsCheckedChairman"].ToString() != "")
                {
                    info.IsReport = int.Parse(dataTable.Rows[0]["IsCheckedChairman"].ToString());
                }
            }
            return(info);
        }
コード例 #24
0
        public Expression GetExpression(InstructionInfo info, IExpressionLibraryRegistry expressionLibraries)
        {
            var programControl = expressionLibraries.GetLibrary<IProgramControlExpressionLibrary>();

            List<Expression> expressions = new List<Expression>();

            expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("PC: ")));

            switch (info.ParameterMode)
            {
                case InstructionParameterMode.None:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(Expression.Subtract(programControl.ProgramCounterRegister, Expression.Constant(1)), typeof(Object))));
                    break;
                case InstructionParameterMode.Byte:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(Expression.Subtract(programControl.ProgramCounterRegister, Expression.Constant(2)), typeof(Object))));
                    break;
                case InstructionParameterMode.Word:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(Expression.Subtract(programControl.ProgramCounterRegister, Expression.Constant(3)), typeof(Object))));
                    break;
                case InstructionParameterMode.Index:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(Expression.Subtract(programControl.ProgramCounterRegister, Expression.Constant(2)), typeof(Object))));
                    break;
                case InstructionParameterMode.Address:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(Expression.Subtract(programControl.ProgramCounterRegister, Expression.Constant(3)), typeof(Object))));
                    break;
                case InstructionParameterMode.IndexAndByte:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(Expression.Subtract(programControl.ProgramCounterRegister, Expression.Constant(3)), typeof(Object))));
                    break;
                default:
                    break;
            }
            expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\t")));
            
            expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant(String.Format("0x{0:X2}", info.Opcode))));
            expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\t")));

            expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant(info.Mnemonic.PadRight(15))));

            switch (info.ParameterMode)
            {
                case InstructionParameterMode.None:
                    break;
                case InstructionParameterMode.Byte:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\tn = ")));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(programControl.ParameterByte1, typeof(Object))));
                    break;
                case InstructionParameterMode.Word:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\tnn = ")));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(programControl.ParameterWord, typeof(Object))));
                    break;
                case InstructionParameterMode.Index:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\td = ")));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(programControl.ParameterByte1, typeof(Object))));
                    break;
                case InstructionParameterMode.Address:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\taddress = ")));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(programControl.ParameterWord, typeof(Object))));
                    break;
                case InstructionParameterMode.IndexAndByte:
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\tindex = ")));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(programControl.ParameterByte2, typeof(Object))));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant("\tn = ")));
                    expressions.Add(Expression.Call(debugWriteMethod, Expression.TypeAs(programControl.ParameterByte1, typeof(Object))));
                    break;
                default:
                    break;
            }

            expressions.Add(Expression.Call(debugWriteMethod, Expression.Constant(Environment.NewLine)));

            return Expression.Block(expressions);

            //return Expression.PostIncrementAssign(programControl.ParameterByte1);
        }
コード例 #25
0
ファイル: Parser.cs プロジェクト: gtryf/MIXWare
        private void ParseLine(Scanner s)
        {
            tokStream = s.Tokens;
            var lblText = string.Empty;

            if (tokStream.First().Type == TokenType.LABEL)
            {
                lblText = tokStream.First().Text;
                if (lblText.Length == 2 && char.IsDigit(lblText[0]) && lblText[1] == 'H')
                // This is a local symbol
                {
                    var n = byte.Parse(lblText[0].ToString());
                    if (localSymbs.ContainsKey(n))
                    {
                        localSymbs[n] = localSymbs[n] + 1;
                    }
                    else
                    {
                        localSymbs.Add(n, 1);
                    }
                    lblText = "|" + n + "-" + localSymbs[n] + "|";
                }
                if (tokStream.Skip(1).ToArray().Length > 0)
                {
                    symbolTable.Add(lblText, new MIXWord(locCounter));
                    tokStream = tokStream.Skip(1);
                }
                else
                {
                    errors.Add(new ErrorInfo
                    {
                        Column = tokStream.First().ColumnNumber,
                        Line   = LineNumber,
                        Text   = "LINE: Unexpected end of line, expected: KEYWORD or PSEUDO"
                    });
                }
            }

            // Parse the rest of the sentence
            switch (tokStream.First().Type)
            {
            case TokenType.KEYWORD:
                var instrList = from i in MIXMachine.INSTRUCTION_LIST
                                where i.Name == tokStream.First().Text
                                select i;
                InstructionInfo instr = instrList.First();
                tokStream = tokStream.Skip(1);
                MIXWord a = Address(); MIXWord index = Index(); MIXWord f = Field(); if (f == -1)
                {
                    f = instr.DefaultField;
                }
                MIXWord word = new MIXWord();
                if (a != null)
                {
                    word[0, 2] = a; word[3] = index; word[4] = f; word[5] = instr.OpCode;
                    assembly.Add(new MemoryCell {
                        SourceLocation = LineNumber, Location = locCounter, Contents = word
                    });
                }
                else
                {
                    futureRefs.Add(new FutureReference {
                        Symbol = FRefSymb, Field = f, Index = index, Location = locCounter, OpCode = instr.OpCode, SourceLocation = LineNumber
                    });
                }

                locCounter++;
                break;

            case TokenType.ORIG:
                tokStream  = tokStream.Skip(1);
                locCounter = WordValue();
                break;

            case TokenType.CON:
                tokStream = tokStream.Skip(1);
                assembly.Add(new MemoryCell {
                    SourceLocation = LineNumber, Location = locCounter, Contents = WordValue()
                });
                locCounter++;
                break;

            case TokenType.EQU:
                tokStream = tokStream.Skip(1);
                var val = WordValue();
                if (!string.IsNullOrEmpty(lblText))
                {
                    symbolTable[lblText] = val;
                }
                break;

            case TokenType.ALF:
                tokStream = tokStream.Skip(1);
                if (tokStream.First().Type != TokenType.STRING)
                {
                    errors.Add(new ErrorInfo
                    {
                        Line   = LineNumber,
                        Column = tokStream.First().ColumnNumber,
                        Text   = "LINE: Expected: STRING CONSTANT."
                    });
                }
                else
                {
                    string sc = tokStream.First().Text;

                    MIXWord w = new MIXWord();
                    for (byte i = 0; i < 5; i++)
                    {
                        w[(byte)(i + 1)] = MIXMachine.CHAR_TABLE[sc[i]];
                    }

                    assembly.Add(new MemoryCell {
                        SourceLocation = LineNumber, Location = locCounter, Contents = w
                    });
                    locCounter++;

                    tokStream = tokStream.Skip(1);
                }
                break;

            case TokenType.END:
                if (null != StartLoc)
                {
                    warnings.Add(new ErrorInfo
                    {
                        Line   = LineNumber,
                        Column = tokStream.First().ColumnNumber,
                        Text   = "LINE: Multiple appearances of the END directive."
                    });
                }
                tokStream      = tokStream.Skip(1);
                StartLoc       = WordValue();
                insertionPoint = locCounter;
                break;

            default:
                errors.Add(new ErrorInfo
                {
                    Line   = LineNumber,
                    Column = tokStream.First().ColumnNumber,
                    Text   = string.Format("LINE: Parser panic! Don't know what to do with token {0}['{1}']",
                                           tokStream.First().Type, tokStream.First().Text)
                });
                break;
            }
        }
コード例 #26
0
ファイル: CallEmitter.cs プロジェクト: m9ra/MEFEditor_v2.0
 /// <summary>
 /// Create new instruction info for block starting with next emitted instruction.
 /// </summary>
 /// <returns>Created instruction info.</returns>
 public override InstructionInfo StartNewInfoBlock()
 {
     _currentBlockInfo = new InstructionInfo(_currentGroupID);
     return(_currentBlockInfo);
 }
コード例 #27
0
        // \param indirectCall is not -1 if the instruction is an indirect call to another function
        public static void dispatch(
            GlobalInterpreterState globalState,
            LocalInterpreterState localState,
            Instruction instr,
            out bool success,
            out int indirectCall
            )
        {
            indirectCall = -1;

            uint instructionWithoutRelative;
            int  relative;

            decodeInstruction(instr.code, out instructionWithoutRelative, out relative);

            switch (instructionWithoutRelative)
            {
            case INSTRUCTION_RET: Operations.@return(localState, out success); return;

            case 1: ArrayOperations.macroArrayAdvanceOrExit(globalState, localState, relative, out success); return;

            case 2: ArrayOperations.macroArrayNotEndOrExit(globalState, localState, relative, out success); return;

            case 3: Operations.jump(localState, relative); success = true; return;

            case 4: Operations.jumpIfNotFlag(localState, relative); success = true; return;

            case 5: Operations.call(localState, relative); success = true; return;

            case 6: ArrayOperationsTwoArgumentWrapper.arrayMove(globalState, localState, -1, int.MaxValue, out success); return;

            case 7: ArrayOperationsTwoArgumentWrapper.arrayMove(globalState, localState, 1, int.MaxValue, out success); return;

            case 8: ArrayOperationsTwoArgumentWrapper.arrayRemove(globalState, localState, int.MaxValue, int.MaxValue, out success); return;

            case 9: ArrayOperationsTwoArgumentWrapper.arrayCompareWithRegister(globalState, localState, 0, int.MaxValue, out success); return;

            case 10: ArrayOperationsTwoArgumentWrapper.arrayCompareWithRegister(globalState, localState, 1, int.MaxValue, out success); return;

            case 11: ArrayOperations.insert(globalState, localState, /*reg*/ 0, out success); return;

            case 12: ArrayOperations.insert(globalState, localState, /*reg*/ 1, out success); return;

            case 13: ArrayOperations.insert(globalState, localState, /*reg*/ 2, out success); return;

            case 14: ArrayOperations.setIdxRelative(globalState, localState, 0, 0, out success); return;

            case 15: ArrayOperations.setIdxRelative(globalState, localState, 0, -1, out success); return; // -1 is end of array

            case 16: ArrayOperations.idxFlag(globalState, localState, 0, 1, out success); return;         // TODO< should be an intrinsic command which gets added by default >

            case 17: ArrayOperations.valid(globalState, localState, /*array*/ 0, out success); return;

            case 18: ArrayOperations.read(globalState, localState, /*array*/ 0, /*register*/ 0, out success); return;

            case 19: ArrayOperations.idx2Reg(globalState, localState, /*array*/ 0, /*register*/ 0, out success); return;

            case 20: Operations.movImmediate(localState, /*register*/ 0, 0, out success); return;

            case 21: Operations.movImmediate(localState, /*register*/ 0, 1, out success); return;

            case 22: Operations.movImmediate(localState, /*register*/ 0, 3, out success); return;

            case 23: ArrayOperations.arrayMovToArray(globalState, localState, /*array*/ 0, /*register*/ 0, out success); return;

            case 24: Operations.mulRegisterImmediate(localState, /*register*/ 0, -1); success = true; return;

            case 25: Operations.binaryNegate(globalState, localState, /*register*/ 0); success = true; return;

            case 26: ArrayOperations.macroArrayAdvanceOrExit(globalState, localState, -4, out success); return;

            case 27: Operations.movImmediate(localState, /*register*/ 1, 0, out success); return;

            case 28: Operations.movImmediate(localState, /*register*/ 1, 1, out success); return;

            case 29: Operations.movImmediate(localState, /*register*/ 1, 3, out success); return;

            case 30: ArrayOperations.read(globalState, localState, /*array*/ 0, /*register*/ 1, out success); return;

            case 31: Operations.mulRegisterRegister(localState, 0, 1); success = true; return;

            case 32: Operations.addRegisterRegister(localState, 0, 1); success = true; return;

            case 33: ArrayOperations.arrayMovToArray(globalState, localState, /*array*/ 0, /*register*/ 1, out success); return;

            case 34: Operations.subRegisterRegister(localState, 1, 0); success = true; return;

            case 35: ArrayOperations.read(globalState, localState, /*array*/ 0, /*register*/ 1, out success); return;

            case 36: ArrayOperations.reg2idx(globalState, localState, /*register*/ 0, /*array*/ 0, out success); return;

            case 37: Operations.compareRegister(localState, /*register*/ 0, /*register*/ 1, /*type*/ -1); success = true; return;  // TODO< maybe using relative value as immediate >

            case 38: Operations.random(globalState, localState, 0, 0, out success); return;

            case 39: ArrayOperations.length(globalState, localState, /*destRegister*/ 0, out success); return;
            }

            // if we are here we have instrution with hardcoded parameters

            uint baseInstruction = InstructionInfo.getNumberOfHardcodedSingleInstructions();

            Debug.Assert(instructionWithoutRelative >= baseInstruction);
            int currentBaseInstruction = (int)baseInstruction;



            // add register constant
            if (instructionWithoutRelative <= currentBaseInstruction + 3)
            {
                int subInstruction = (int)instructionWithoutRelative - currentBaseInstruction; // which instruction do we choose from the pool

                if (subInstruction == 0)
                {
                    Operations.add(localState, /*register*/ 0, -1);
                    success = true;
                }
                else if (subInstruction == 1)
                {
                    Operations.add(localState, /*register*/ 0, 2);
                    success = true;
                }
                else if (subInstruction == 2)
                {
                    Operations.add(localState, /*register*/ 1, -1);
                    success = true;
                }
            }

            currentBaseInstruction += 3;


            // addFlag reg0 constant
            if (instructionWithoutRelative <= currentBaseInstruction + 1)
            {
                // currently just compare reg0 with zero
                Operations.addFlag(localState, /*register*/ 0, 1);
                success = true;
                return;
            }

            currentBaseInstruction += 1;



            // indirect table call
            if (instructionWithoutRelative <= currentBaseInstruction + 1)
            {
                // currently just compare reg0 with zero
                indirectCall = 0;
                success      = true;
                return;
            }

            currentBaseInstruction += 1;

            // additional instructions
            GlobalInterpreterState.AdditionalOperationsDelegateType additionalOperationDelegate;
            if (globalState.additionalOperations.TryGetValue(instructionWithoutRelative, out additionalOperationDelegate))
            {
                additionalOperationDelegate(globalState, localState, out success);
                return;
            }


            // unknown instruction
            success = false;
        }
コード例 #28
0
        private void lbxAllInstruct_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            InstructionInfo II = ((InstructionInfo)lbxAllInstruct.SelectedElement);

            lbxSwitchInstruct.AddItem(new InstructElement(II.NewInstruction, II.NewInstructionNum));
        }
コード例 #29
0
        List <Instruction> GetInstructions(SbAddress sbAddress, uint numInstructions,
                                           bool withSource)
        {
            _lineEntryCache.Clear();
            var instructions = new List <Instruction>();

            // If we need source information, we look at the previous instruction to find out
            // if it is on the same line and/or in the same file.
            var position = SourcePosition.Empty;

            if (withSource)
            {
                // Find previous instruction and initialize lineAddress and lastLine here.
                SbAddress previousSbAddress =
                    _target.ResolveLoadAddress(sbAddress.GetLoadAddress(_target) - 1);
                if (previousSbAddress != null)
                {
                    position = GetPositionForAddress(previousSbAddress);
                }
            }

            uint numInstructionsRead = 0;
            List <InstructionInfo> cachedInstructions =
                _target.ReadInstructionInfos(sbAddress, numInstructions, _flavor);

            for (int i = 0; i < cachedInstructions.Count; i++)
            {
                Instruction currentInstruction = new Instruction();

                if (numInstructionsRead >= numInstructions)
                {
                    break;
                }

                numInstructionsRead++;

                InstructionInfo instruction = cachedInstructions[i];

                _lineEntryCache.Add(instruction.Address, instruction.LineEntry);

                currentInstruction.Address = instruction.Address;

                // Since Visual Studio doesn't do a good job formatting opcode and operands, in
                // addition to not providing a field to show instruction comments, do all the
                // formatting ourselves and put the entire string in the opcode field.
                string operands          = instruction.Operands;
                string comment           = instruction.Comment;
                string instructionString = $"{instruction.Mnemonic,-10}";
                if (string.IsNullOrEmpty(comment))
                {
                    instructionString += $" {operands}";
                }
                else
                {
                    instructionString += $" {operands,-30} # {comment}";
                }
                currentInstruction.Text = instructionString;

                if (!string.IsNullOrEmpty(instruction.SymbolName))
                {
                    currentInstruction.Symbol = instruction.SymbolName;
                }

                // If we so far believe we should get source position, let us get it here.
                if (withSource)
                {
                    SourcePosition lastPosition = position;
                    position = GetPositionFor(instruction.LineEntry);
                    WritePositionToInstruction(lastPosition, position, i == 0,
                                               ref currentInstruction);
                }
                instructions.Add(currentInstruction);
            }
            return(instructions);
        }
コード例 #30
0
 void Format(int index, InstructionInfo info, string formattedString) => FormatBase(index, info, formattedString, GasFormatterFactory.Create_NoSuffix());
コード例 #31
0
        public int Seek(enum_SEEK_START seekStart, IDebugCodeContext2 codeContext,
                        ulong codeLocationId, long numInstructions)
        {
            if (seekStart == enum_SEEK_START.SEEK_START_CODECONTEXT)
            {
                _address = codeContext.GetAddress();
            }
            else if (seekStart == enum_SEEK_START.SEEK_START_CODELOCID)
            {
                _address = codeLocationId;
            }

            SbAddress sbAddress = _target.ResolveLoadAddress(_address);

            if (sbAddress == null)
            {
                return(VSConstants.E_FAIL);
            }

            if (numInstructions > 0)
            {
                // seek forward
                numInstructions++;
                List <InstructionInfo> instructions =
                    _target.ReadInstructionInfos(sbAddress, (uint)numInstructions, _flavor);
                if (instructions.Count > 0)
                {
                    numInstructions = Math.Min(numInstructions, instructions.Count);
                    _address        = instructions[(int)numInstructions - 1].Address;
                }
            }
            else if (numInstructions < 0)
            {
                // TODO: Get opcode sizes from LLDB.
                // Hard-code the opcode sizes for x86_64. Currently LLDB doesn't expose this
                // information, and this is the only architecture we support.
                uint minOpcodeSize = 1;
                uint maxOpcodeSize = 15;

                // When seeking backwards we don't know the exact address since x86_64 is a variable
                // size instruction architecture. Instead we figure out the max range to fit a
                // specific number of instructions.
                uint maxRangeForInstructions = (uint)Math.Abs(numInstructions) * maxOpcodeSize;

                // Since x86_64 is a variable size instruction architecture we don't know the exact
                // number of instructions in a specific address range. Assume the smallest opcode
                // size and that will be the number of instructions we need to read.
                uint maxNumberInstructions = maxRangeForInstructions / minOpcodeSize;

                // Using the start address and the max possible range, we can determine the lower
                // bound for where we should start reading instructions from.
                ulong endAddress = _address - maxRangeForInstructions;

                // The instruction where we should start the seek.
                List <InstructionInfo> startInstructionList =
                    _target.ReadInstructionInfos(sbAddress, 1, _flavor);
                if (startInstructionList.Count == 0)
                {
                    Trace.WriteLine(
                        "Failed to seek backwards. Unable to read " +
                        $"instruction at 0x{_address:X} so we have no start point for the seek");
                    return(VSConstants.E_FAIL);
                }

                InstructionInfo startInstruction = startInstructionList[0];

                // We know there is an instruction around the |endAddress| but we don't know exactly
                // where it starts (because variable size instructions). LLDB will stop reading if
                // it runs into a bad instruction. We use that to our advantage and start reading
                // instructions from the |endAddress| + offset until LLDB returns us the number of
                // instructions we requested. We can then be fairly certain |endAddress| + offset is
                // the address to a valid instruction.
                int startIndex = -1;
                List <InstructionInfo> validInstructions = null;
                for (ulong i = 0; i < maxOpcodeSize; i++)
                {
                    ulong     seekAddress               = endAddress + i;
                    SbAddress seekSbAddress             = _target.ResolveLoadAddress(seekAddress);
                    List <InstructionInfo> instructions = _target.ReadInstructionInfos(
                        seekSbAddress, maxNumberInstructions + 1, _flavor);
                    // Shortcut: Continue if we did not get enough instructions.
                    if (instructions == null || instructions.Count < Math.Abs(numInstructions))
                    {
                        continue;
                    }
                    // Only accept the instructions if our start instruction is there.
                    try
                    {
                        startIndex = instructions.BinarySearch(startInstruction,
                                                               new InstructionComparator());
                        if (startIndex >= 0)
                        {
                            validInstructions = instructions;
                            break;
                        }
                    }
                    catch (InvalidOperationException e)
                    {
                        Trace.WriteLine(e);
                    }
                }

                if (startIndex < 0)
                {
                    Trace.WriteLine(
                        "Failed to seek backwards. Unable to find an instruction with " +
                        $"address 0x{_address:X} so we have no start point for the seek");
                    return(VSConstants.E_FAIL);
                }

                // Add the |startIndex| and the negative |numInstructions| to get the index of the
                // instruction to which we want to seek.
                int seekIndex = startIndex + (int)numInstructions;
                if (validInstructions == null || seekIndex < 0 ||
                    seekIndex >= validInstructions.Count)
                {
                    Trace.WriteLine($"Failed to seek backwards. Seek index {seekIndex} is out " +
                                    "of range");
                    return(VSConstants.E_FAIL);
                }
                _address = validInstructions[seekIndex].Address;
            }

            return(VSConstants.S_OK);
        }
コード例 #32
0
ファイル: WopEx.cs プロジェクト: migrap/SecureSocketProtocol
        private static void GetNextRandomInstruction(FastRandom rnd, ref InstructionInfo EncInstruction, ref InstructionInfo DecInstruction)
        {
            lock (RndInstLock)
            {
                Instruction[] InstructionList = new Instruction[]
                {
                    //Instruction.BitLeft, //unstable do not use
                    Instruction.Minus,
                    Instruction.Plus,
                    //Instruction.ForLoop_PlusMinus,
                    //Instruction.RotateLeft_Big,
                    //Instruction.RotateLeft_Small,
                    Instruction.SwapBits,
                    Instruction.XOR
                };

                Instruction inst = InstructionList[rnd.Next(0, InstructionList.Length)];

                switch (inst)
                {
                case Instruction.BitLeft:
                {
                    int bitSize = rnd.Next(1, 3);     //maybe needs to be higher ?
                    EncInstruction = new InstructionInfo(inst, bitSize);
                    DecInstruction = new InstructionInfo(Instruction.BitRight, bitSize);
                    break;
                }

                case Instruction.Minus:
                {
                    byte[] TempDate = new byte[32];
                    rnd.NextBytes(TempDate);

                    EncInstruction = new InstructionInfo(inst, new BigInteger(TempDate));
                    DecInstruction = new InstructionInfo(Instruction.Plus, new BigInteger(TempDate));
                    break;
                }

                case Instruction.Plus:
                {
                    byte[] TempDate = new byte[32];
                    rnd.NextBytes(TempDate);

                    EncInstruction = new InstructionInfo(inst, new BigInteger(TempDate));
                    DecInstruction = new InstructionInfo(Instruction.Minus, new BigInteger(TempDate));
                    break;
                }

                case Instruction.ForLoop_PlusMinus:
                {
                    int size  = rnd.Next();
                    int size2 = rnd.Next();
                    int loops = rnd.Next(2, 255);

                    EncInstruction = new InstructionInfo(inst, (uint)size, (uint)size2, loops);
                    DecInstruction = new InstructionInfo(inst, (uint)size, (uint)size2, loops);
                    break;
                }

                case Instruction.RotateLeft_Big:
                {
                    byte bitSize = (byte)rnd.Next(1, 60);

                    EncInstruction = new InstructionInfo(inst, (uint)bitSize);
                    DecInstruction = new InstructionInfo(Instruction.RotateRight_Big, (uint)bitSize);
                    break;
                }

                case Instruction.RotateLeft_Small:
                {
                    byte bitSize = (byte)rnd.Next(1, 30);

                    EncInstruction = new InstructionInfo(inst, (uint)bitSize);
                    DecInstruction = new InstructionInfo(Instruction.RotateRight_Small, (uint)bitSize);
                    break;
                }

                case Instruction.SwapBits:
                {
                    EncInstruction = new InstructionInfo(inst, 0);
                    DecInstruction = new InstructionInfo(inst, 0);
                    break;
                }

                case Instruction.XOR:
                {
                    byte[] TempDate = new byte[32];
                    rnd.NextBytes(TempDate);

                    EncInstruction = new InstructionInfo(inst, new BigInteger(TempDate));
                    DecInstruction = new InstructionInfo(inst, new BigInteger(TempDate));
                    break;
                }

                default: { break; }
                }
            }
        }
コード例 #33
0
ファイル: MipsAsm.cs プロジェクト: jfhr/mips-emulator
 private static void AddInstruction(InstructionSyntaxType type, string name, uint functionOrOpcode, string help)
 {
     Instructions[name] = new InstructionInfo(type, functionOrOpcode, help);
 }
コード例 #34
0
 void Format(int index, InstructionInfo info, string formattedString) => FormatBase(index, info, formattedString, MasmFormatterFactory.Create_NoMemSize());
コード例 #35
0
        public List <InstructionInfo> ReadInstructionInfos(SbAddress address, uint count,
                                                           string flavor)
        {
            SbProcess process      = _sbTarget.GetProcess();
            var       instructions = new List <InstructionInfo>();

            while (instructions.Count < count)
            {
                SbMemoryRegionInfo memoryRegion = null;
                SbError            error        = process.GetMemoryRegionInfo(address.GetLoadAddress(_sbTarget),
                                                                              out memoryRegion);

                if (error.Fail())
                {
                    Trace.WriteLine("Unable to retrieve memory region info.");
                    return(new List <InstructionInfo>());
                }

                // If the address we are given is not mapped we should not try to disassemble it.
                if (!memoryRegion.IsMapped())
                {
                    uint instructionsLeft = count - (uint)instructions.Count;

                    ulong nextAddress = AddUnmappedInstructions(address, instructionsLeft,
                                                                memoryRegion, instructions);

                    address = _sbTarget.ResolveLoadAddress(nextAddress);

                    // Continue in case we still need more instructions
                    continue;
                }

                List <SbInstruction> sbInstructions =
                    _sbTarget.ReadInstructions(address, count - (uint)instructions.Count, flavor);
                foreach (SbInstruction sbInstruction in sbInstructions)
                {
                    SbAddress sbAddress = sbInstruction.GetAddress();
                    if (sbAddress == null)
                    {
                        // It should never happen that we cannot get an address for an instruction
                        Trace.WriteLine("Unable to retrieve address.");
                        return(new List <InstructionInfo>());
                    }

                    ulong instructionAddress = sbAddress.GetLoadAddress(_sbTarget);

                    SbSymbol symbol = sbAddress.GetSymbol();

                    string symbolName = null;
                    // Only set symbolName if it is the start of a function
                    SbAddress startAddress = symbol?.GetStartAddress();
                    if (startAddress != null &&
                        startAddress.GetLoadAddress(_sbTarget) == instructionAddress)
                    {
                        symbolName = symbol.GetName();
                    }

                    SbLineEntry   lineEntry     = sbAddress.GetLineEntry();
                    LineEntryInfo lineEntryInfo = null;
                    if (lineEntry != null)
                    {
                        lineEntryInfo = new LineEntryInfo {
                            FileName  = lineEntry.GetFileName(),
                            Directory = lineEntry.GetDirectory(),
                            Line      = lineEntry.GetLine(),
                            Column    = lineEntry.GetColumn(),
                        };
                    }

                    // Create a new instruction and fill in the values
                    var instruction = new InstructionInfo {
                        Address    = instructionAddress,
                        Operands   = sbInstruction.GetOperands(_sbTarget),
                        Comment    = sbInstruction.GetComment(_sbTarget),
                        Mnemonic   = sbInstruction.GetMnemonic(_sbTarget),
                        SymbolName = symbolName,
                        LineEntry  = lineEntryInfo,
                    };
                    instructions.Add(instruction);
                }

                // If we haven't managed to retrieve all the instructions we wanted, add
                // an invalid instruction and keep going from the next address.
                if (instructions.Count < count)
                {
                    ulong nextAddress =
                        AddInvalidInstruction(address, sbInstructions, instructions);

                    // Set the address to the next address after the invalid instruction
                    address = _sbTarget.ResolveLoadAddress(nextAddress);
                }
            }
            return(instructions);
        }
コード例 #36
0
 public InstructionDynarecInfo(InstructionInfo InstructionInfo, uint[] Params)
 {
     this.InstructionInfo = InstructionInfo;
     this.Params = Params;
     //this.GenerateDynarecCode = GenerateDynarecCode;
 }
コード例 #37
0
ファイル: CallStack.cs プロジェクト: PhilipBrockmeyer/Wren
 protected override Expression GetExpressionImpl(InstructionInfo info, IExpressionLibraryRegistry expressionLibraries)
 {
     throw new NotImplementedException();
 }