Beispiel #1
0
        public string AssembleLine(string line)
        {
            AntlrInputStream stream = new AntlrInputStream(line);
            CheatASMLexer    lexer  = new CheatASMLexer(stream);
            CheatASMParser   parser = new CheatASMParser(new CommonTokenStream(lexer));

            parser.ErrorHandler   = new DefaultErrorStrategy();
            parser.TrimParseTree  = true;
            parser.BuildParseTree = true;
            parser.AddErrorListener(this);
            StatementContext stmt = null;

            errorMsg = null;
            errorPos = 0;
            stmt     = parser.statement();

            if (errorMsg != null)
            {
                return("# Error: " + errorMsg + " -- " + line);
            }
            CheatOpcode op = null;

            if (stmt.opCode0() != null)
            {
                OpCode0Context    opCtx   = stmt.opCode0();
                StoreStaticOpcode opTyped = new StoreStaticOpcode();
                op = opTyped;

                opTyped.BitWidth        = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                opTyped.MemType         = Enum.Parse <MemoryAccessType>(opCtx.memType.Text, true);
                opTyped.OffsetRegister  = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);
                opTyped.RelativeAddress = Convert.ToUInt64(opCtx.offset.Text, 16);
                opTyped.Value           = Convert.ToUInt64(opCtx.value.Text, 16);
                /* assemble opcode 0 */
            }
            else if (stmt.opCode1() != null)
            {
                OpCode1Context    opCtx   = stmt.opCode1();
                ConditionalOpcode opTyped = new ConditionalOpcode();
                op = opTyped;

                opTyped.BitWidth = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                opTyped.MemType  = Enum.Parse <MemoryAccessType>(opCtx.memType.Text, true);

                opTyped.Condition = Enum.Parse <ConditionalComparisonType>(opCtx.cond.Text, true);
                opTyped.Immediate = Convert.ToUInt64(opCtx.offset.Text, 16);
                opTyped.Value     = Convert.ToUInt64(opCtx.value.Text, 16);
            }
            else if (stmt.opCode2() != null)
            {
                op = new EndConditionalOpcode();
            }
            else if (stmt.opCode3() != null)
            {
                OpCode3Context opCtx   = stmt.opCode3();
                LoopOpcode     opTyped = new LoopOpcode();
                op = opTyped;

                if (opCtx.endloop != null)
                {
                    opTyped.IsEnd         = true;
                    opTyped.RegisterIndex = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);
                }
                else
                {
                    opTyped.IsEnd         = false;
                    opTyped.RegisterIndex = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);
                    opTyped.Count         = Convert.ToUInt32(opCtx.value.Text, 16);
                }
            }
            else if (stmt.opCode4() != null)
            {
                OpCode4Context           opCtx   = stmt.opCode4();
                LoadRegisterStaticOpcode opTyped = new LoadRegisterStaticOpcode();
                op = opTyped;


                opTyped.RegisterIndex = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);
                opTyped.Value         = Convert.ToUInt64(opCtx.value.Text, 16);
            }
            else if (stmt.opCode5() != null)
            {
                OpCode5Context           opCtx   = stmt.opCode5();
                LoadRegisterMemoryOpcode opTyped = new LoadRegisterMemoryOpcode();
                op = opTyped;

                opTyped.BitWidth = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);

                opTyped.RegisterIndex = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);
                opTyped.Immediate     = Convert.ToUInt64(opCtx.offset.Text, 16);

                if (opCtx.memType != null)
                {
                    opTyped.MemType = Enum.Parse <MemoryAccessType>(opCtx.memType.Text, true);
                }
                else
                {
                    opTyped.UseReg = true;
                }
            }
            else if (stmt.opCode6() != null)
            {
                OpCode6Context             opCtx   = stmt.opCode6();
                StoreStaticToAddressOpcode opTyped = new StoreStaticToAddressOpcode();
                op = opTyped;

                opTyped.BitWidth      = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                opTyped.RegisterIndex = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);

                if (opCtx.increment != null)
                {
                    opTyped.IncrementFlag = true;
                }
                if (opCtx.offsetReg != null)
                {
                    opTyped.OffsetEnableFlag = true;
                    opTyped.OffsetRegister   = Convert.ToUInt16(opCtx.offsetReg.Text.Substring(1), 16);
                }

                opTyped.Value = Convert.ToUInt64(opCtx.value.Text, 16);
            }
            else if (stmt.opCode7() != null)
            {
                OpCode7Context         opCtx   = stmt.opCode7();
                LegacyArithmeticOpcode opTyped = new LegacyArithmeticOpcode();
                op = opTyped;

                opTyped.BitWidth      = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                opTyped.RegisterIndex = Convert.ToUInt16(opCtx.register.Text.Substring(1), 16);
                opTyped.MathType      = Enum.Parse <RegisterArithmeticType>(opCtx.func.Text, true);
                opTyped.Value         = Convert.ToUInt32(opCtx.value.Text, 16);
            }
            else if (stmt.opCode8() != null)
            {
                OpCode8Context            opCtx   = stmt.opCode8();
                KeypressConditionalOpcode opTyped = new KeypressConditionalOpcode();
                op = opTyped;

                opTyped.Mask = Enum.Parse <KeyMask>(opCtx.key.Text);
            }
            else if (stmt.opCode9() != null)
            {
                OpCode9Context   opCtx   = stmt.opCode9();
                ArithmeticOpcode opTyped = new ArithmeticOpcode();
                op = opTyped;

                opTyped.BitWidth     = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                opTyped.RegisterDest = Convert.ToUInt16(opCtx.dest.Text.Substring(1), 16);
                opTyped.MathType     = Enum.Parse <RegisterArithmeticType>(opCtx.func.Text, true);

                opTyped.RegisterLeft = Convert.ToUInt16(opCtx.leftReg.Text.Substring(1), 16);

                if (opCtx.rightReg != null)
                {
                    opTyped.RightHandRegister = true;
                    opTyped.RegisterRight     = Convert.ToUInt16(opCtx.rightReg.Text.Substring(1), 16);
                }
                else
                {
                    opTyped.RightHandRegister = false;
                    opTyped.Value             = opTyped.Value = Convert.ToUInt64(opCtx.value.Text);
                }
            }
            else if (stmt.opCodeA() != null)
            {
                OpCodeAContext opCtx = stmt.opCodeA();
                StoreRegisterToAddressOpcode opTyped = new StoreRegisterToAddressOpcode();
                op = opTyped;

                opTyped.BitWidth = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                if (opCtx.baseReg != null)
                {
                    opTyped.AddressRegister = uint.Parse(opCtx.baseReg.Text.Substring(1));
                }
                opTyped.SourceRegister = uint.Parse(opCtx.sourceReg.Text.Substring(1));
                if (opCtx.increment != null)
                {
                    opTyped.IncrementFlag = true;
                }
                opTyped.OffsetType = 0;

                if (opCtx.memType != null)
                {
                    opTyped.MemType = Enum.Parse <MemoryAccessType>(opCtx.memType.Text);
                    /* has to be OffsetType 3,4,5 */
                    bool hasReg = opCtx.baseReg != null;
                    bool hasVal = opCtx.value != null;

                    if (hasReg && hasVal)
                    {
                        /* type 5 */
                        opTyped.OffsetType      = 5;
                        opTyped.OffsetRegister  = Convert.ToUInt16(opCtx.baseReg.Text.Substring(1), 16);
                        opTyped.RelativeAddress = Convert.ToUInt64(opCtx.value.Text, 16);
                    }
                    else if (hasReg)
                    {
                        /* type 3 */
                        opTyped.OffsetType     = 3;
                        opTyped.OffsetRegister = Convert.ToUInt16(opCtx.baseReg.Text.Substring(1), 16);
                    }
                    else if (hasVal)
                    {
                        /* type 4 */
                        opTyped.OffsetType      = 4;
                        opTyped.RelativeAddress = Convert.ToUInt64(opCtx.value.Text, 16);
                    }
                }
                else
                {
                    /* has to be OffsetType 1,2 */
                    if (opCtx.regIndex != null)
                    {
                        opTyped.OffsetType     = 1;
                        opTyped.OffsetRegister = Convert.ToUInt16(opCtx.regIndex.Text.Substring(1), 16);
                    }
                    if (opCtx.value != null)
                    {
                        opTyped.OffsetType      = 2;
                        opTyped.RelativeAddress = Convert.ToUInt64(opCtx.value.Text, 16);
                    }
                }
            }
            else if (stmt.opCodeC0() != null)
            {
                OpCodeC0Context           opCtx   = stmt.opCodeC0();
                RegisterConditionalOpcode opTyped = new RegisterConditionalOpcode();
                op = opTyped;

                opTyped.BitWidth       = Enum.Parse <BitWidthType>(opCtx.bitWidth.Text, true);
                opTyped.Condition      = Enum.Parse <ConditionalComparisonType>(opCtx.cond.Text, true);
                opTyped.SourceRegister = Convert.ToUInt16(opCtx.source.Text.Substring(1), 16);
                if (opCtx.memType != null)
                {
                    opTyped.MemType = Enum.Parse <MemoryAccessType>(opCtx.memType.Text, true);

                    /* operand type is either 0 or 1... */
                    if (opCtx.offset != null)
                    {
                        opTyped.RelativeAddress = Convert.ToUInt64(opCtx.offset.Text, 16);
                        opTyped.OperandType     = 0;
                    }
                    else if (opCtx.offsetReg != null)
                    {
                        opTyped.OffsetRegister = Convert.ToUInt16(opCtx.offsetReg.Text.Substring(1), 16);
                        opTyped.OperandType    = 1;
                    }
                }
                else if (opCtx.addrReg != null)
                {
                    /* operand type is either 2 or 3 */
                    if (opCtx.offset != null)
                    {
                        opTyped.RelativeAddress = Convert.ToUInt64(opCtx.offset.Text, 16);
                        opTyped.OperandType     = 2;
                    }
                    else if (opCtx.offsetReg != null)
                    {
                        opTyped.OffsetRegister = Convert.ToUInt16(opCtx.offsetReg.Text.Substring(1), 16);
                        opTyped.OperandType    = 3;
                    }
                }
                else if (opCtx.value != null)
                {
                    opTyped.Value       = Convert.ToUInt64(opCtx.value.Text, 16);
                    opTyped.OperandType = 4;
                }
                else if (opCtx.otherReg != null)
                {
                    opTyped.OtherRegister = Convert.ToUInt16(opCtx.otherReg.Text.Substring(1), 16);
                    opTyped.OperandType   = 5;
                }
                else
                {
                    throw new NotSupportedException();
                }
            }

            return(op.ToByteString());
        }
Beispiel #2
0
        public string DisassembleLine(string line)
        {
            /* trim the line... */
            line = line.Trim();
            StringBuilder sb = new StringBuilder();
            CheatOpcode   op = null;

            /* its a code... lets parse it */
            try
            {
                uint[] blocks = line.Split(' ').Select(s => uint.Parse(s, NumberStyles.HexNumber)).ToArray();

                switch (line[0])
                {
                case '0':
                    op = new StoreStaticOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                case '1':
                    op = new ConditionalOpcode(blocks);
                    WriteOpcode(op, sb);
                    conditionalIndent++;
                    break;

                case '2':
                    op = new EndConditionalOpcode(blocks);
                    conditionalIndent--;
                    WriteOpcode(op, sb);
                    break;

                case '3':
                    op = new LoopOpcode(blocks);
                    if (((LoopOpcode)op).IsEnd)
                    {
                        conditionalIndent--;
                    }
                    WriteOpcode(op, sb);
                    if (((LoopOpcode)op).IsEnd == false)
                    {
                        conditionalIndent++;
                    }
                    break;

                case '4':
                    op = new LoadRegisterStaticOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                case '5':
                    /*mov(b/w/d/q) R0 [HEAP+IMM]*/
                    op = new LoadRegisterMemoryOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                case '6':
                    op = new StoreStaticToAddressOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                case '7':
                    op = new LegacyArithmeticOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                case '8':
                    op = new KeypressConditionalOpcode(blocks);
                    WriteOpcode(op, sb);
                    conditionalIndent++;
                    break;

                case '9':
                    op = new ArithmeticOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                case 'a':
                case 'A':
                    op = new StoreRegisterToAddressOpcode(blocks);
                    WriteOpcode(op, sb);
                    break;

                default:
                    Debugger.Break();
                    break;

                case 'B':
                    /* reserved */
                    break;

                case 'C':
                    /* Extended width set 1 */
                    switch (line[1])
                    {
                    case '0':
                        /* Compare register */
                        op = new RegisterConditionalOpcode(blocks);
                        WriteOpcode(op, sb);
                        conditionalIndent++;
                        break;
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                var indent = string.Concat(Enumerable.Repeat("  ", (int)conditionalIndent));
                sb.Append(indent);
                sb.Append("# Invalid Cheat Opcode: " + line.Trim());
            }
            return(sb.ToString());
        }