Esempio n. 1
0
        internal static string EchoFloatCommand(AmxOpCode c, params uint[] arr)
        {
            string commandLeft = Commands[c].PadRight(MaxCommandLength, ' ');
            string parameters  = arr.Length == 1 ? "" : string.Join(", ", arr.Select(getFloat));

            return($"{commandLeft} {parameters}");
        }
Esempio n. 2
0
        public static AmxOpCode Invert(this AmxOpCode spop)
        {
            switch (spop)
            {
            case AmxOpCode.JSLEQ:
                return(AmxOpCode.JSGRTR);

            case AmxOpCode.JSLESS:
                return(AmxOpCode.JSGEQ);

            case AmxOpCode.JSGRTR:
                return(AmxOpCode.JSLEQ);

            case AmxOpCode.JSGEQ:
                return(AmxOpCode.JSLESS);

            case AmxOpCode.JEQ:
                return(AmxOpCode.JNEQ);

            case AmxOpCode.JNEQ:
                return(AmxOpCode.JEQ);

            case AmxOpCode.JNZ:
                return(AmxOpCode.JZER);

            case AmxOpCode.JZER:
                return(AmxOpCode.JNZ);

            case AmxOpCode.SLEQ:
                return(AmxOpCode.SGRTR);

            case AmxOpCode.SLESS:
                return(AmxOpCode.SGEQ);

            case AmxOpCode.SGRTR:
                return(AmxOpCode.SLEQ);

            case AmxOpCode.SGEQ:
                return(AmxOpCode.SLESS);

            case AmxOpCode.EQ:
                return(AmxOpCode.NEQ);

            case AmxOpCode.NEQ:
                return(AmxOpCode.EQ);

            default:
                Trace.Fail(nameof(spop));
                return(spop);
            }
        }
Esempio n. 3
0
        internal static string EchoIntCommand(AmxOpCode c, params int[] arr)
        {
            string FormatParameter(int param)
            {
                if (param < -100 || param > 100)
                {
                    return($"0x{param:X4}");
                }
                return(param.ToString());
            }

            string commandLeft = Commands[c].PadRight(MaxCommandLength, ' ');
            string parameters  = arr.Length == 0 ? "" : string.Join(", ", arr.Select(FormatParameter));

            return($"{commandLeft} {parameters}");
        }
Esempio n. 4
0
 public static AmxOpCode Invert(this AmxOpCode spop)
 {
     return(spop switch
     {
         AmxOpCode.JSLEQ => AmxOpCode.JSGRTR,
         AmxOpCode.JSLESS => AmxOpCode.JSGEQ,
         AmxOpCode.JSGRTR => AmxOpCode.JSLEQ,
         AmxOpCode.JSGEQ => AmxOpCode.JSLESS,
         AmxOpCode.JEQ => AmxOpCode.JNEQ,
         AmxOpCode.JNEQ => AmxOpCode.JEQ,
         AmxOpCode.JNZ => AmxOpCode.JZER,
         AmxOpCode.JZER => AmxOpCode.JNZ,
         AmxOpCode.SLEQ => AmxOpCode.SGRTR,
         AmxOpCode.SLESS => AmxOpCode.SGEQ,
         AmxOpCode.SGRTR => AmxOpCode.SLEQ,
         AmxOpCode.SGEQ => AmxOpCode.SLESS,
         AmxOpCode.EQ => AmxOpCode.NEQ,
         AmxOpCode.NEQ => AmxOpCode.EQ,
         _ => throw new ArgumentException(nameof(spop))
     });
Esempio n. 5
0
        public void ParseOp(AmxOpCode op, ref int cip, ref Cell tgt)
        {
            void GETPARAM_P(Cell v, AmxOpCode o)
            {
            }                                                      // (v = ((Cell) (o) >> (int) (CellSize * 4)));}

            switch (op)
            {
            case AmxOpCode.CONST:
            case AmxOpCode.CONST_S:
                cip += CellSize * 2;
                break;

            /* Packed Instructions */
            case AmxOpCode.CONST_P_PRI:
            case AmxOpCode.CONST_P_ALT:
            case AmxOpCode.ADDR_P_PRI:
            case AmxOpCode.ADDR_P_ALT:
            case AmxOpCode.STRB_P_I:
            case AmxOpCode.LIDX_P_B:
            case AmxOpCode.IDXADDR_P_B:
            case AmxOpCode.ALIGN_P_PRI:
            case AmxOpCode.PUSH_P_C:
            case AmxOpCode.PUSH_P:
            case AmxOpCode.PUSH_P_S:
            case AmxOpCode.STACK_P:
            case AmxOpCode.HEAP_P:
            case AmxOpCode.SHL_P_C_PRI:
            case AmxOpCode.SHL_P_C_ALT:
            case AmxOpCode.ADD_P_C:
            case AmxOpCode.SMUL_P_C:
            case AmxOpCode.ZERO_P:
            case AmxOpCode.ZERO_P_S:
            case AmxOpCode.EQ_P_C_PRI:
            case AmxOpCode.EQ_P_C_ALT:
            case AmxOpCode.MOVS_P:
            case AmxOpCode.CMPS_P:
            case AmxOpCode.FILL_P:
            case AmxOpCode.HALT_P:
            case AmxOpCode.BOUNDS_P:
            case AmxOpCode.PUSH_P_ADR:
                break;

            /* Packed Instructions referencing pointers */
            case AmxOpCode.LOAD_P_PRI:
            case AmxOpCode.LOAD_P_ALT:
            case AmxOpCode.INC_P:
            case AmxOpCode.DEC_P:
                GETPARAM_P(tgt, op);
                break;

            /* Packed Instructions referencing stack */
            case AmxOpCode.LOAD_P_S_PRI:
            case AmxOpCode.LOAD_P_S_ALT:
            case AmxOpCode.LREF_P_S_PRI:
            case AmxOpCode.LREF_P_S_ALT:
            case AmxOpCode.INC_P_S:
            case AmxOpCode.DEC_P_S:
                GETPARAM_P(tgt, op);                           /* verify address */
                break;

            /* Single-Value Instructions */
            case AmxOpCode.LODB_I:
            case AmxOpCode.CONST_PRI:
            case AmxOpCode.CONST_ALT:
            case AmxOpCode.ADDR_PRI:
            case AmxOpCode.ADDR_ALT:
            case AmxOpCode.STRB_I:
            case AmxOpCode.LIDX_B:
            case AmxOpCode.IDXADDR_B:
            case AmxOpCode.ALIGN_PRI:
            case AmxOpCode.LCTRL:
            case AmxOpCode.SCTRL:
            case AmxOpCode.PICK:
            case AmxOpCode.PUSH_C:
            case AmxOpCode.PUSH:
            case AmxOpCode.PUSH_S:
            case AmxOpCode.STACK:
            case AmxOpCode.HEAP:
            case AmxOpCode.SHL_C_PRI:
            case AmxOpCode.SHL_C_ALT:
            case AmxOpCode.ADD_C:
            case AmxOpCode.SMUL_C:
            case AmxOpCode.ZERO:
            case AmxOpCode.ZERO_S:
            case AmxOpCode.EQ_C_PRI:
            case AmxOpCode.EQ_C_ALT:
            case AmxOpCode.MOVS:
            case AmxOpCode.CMPS:
            case AmxOpCode.FILL:
            case AmxOpCode.HALT:
            case AmxOpCode.BOUNDS:
            case AmxOpCode.PUSH_ADR:
                cip += CellSize;
                break;

            case AmxOpCode.LOAD_PRI:
            case AmxOpCode.LOAD_ALT:
            case AmxOpCode.INC:
            case AmxOpCode.DEC:
                //VerifyAddress(0, );
                cip += CellSize;
                break;

            case AmxOpCode.LOAD_S_PRI:
            case AmxOpCode.LOAD_S_ALT:
            case AmxOpCode.LREF_S_PRI:
            case AmxOpCode.LREF_S_ALT:
            case AmxOpCode.INC_S:
            case AmxOpCode.DEC_S:
                cip += CellSize;
                break;

            /* Parameterless Instructions */
            case AmxOpCode.LOAD_I:
            case AmxOpCode.STOR_I:
            case AmxOpCode.LIDX:
            case AmxOpCode.IDXADDR:
            case AmxOpCode.XCHG:
            case AmxOpCode.PUSH_PRI:
            case AmxOpCode.PUSH_ALT:
            case AmxOpCode.PPRI:
            case AmxOpCode.PALT:
            case AmxOpCode.PROC:
            case AmxOpCode.RET:
            case AmxOpCode.RETN:
            case AmxOpCode.SHL:
            case AmxOpCode.SHR:
            case AmxOpCode.SSHR:
            case AmxOpCode.SMUL:
            case AmxOpCode.SDIV:
            case AmxOpCode.ADD:
            case AmxOpCode.SUB:
            case AmxOpCode.AND:
            case AmxOpCode.OR:
            case AmxOpCode.XOR:
            case AmxOpCode.NOT:
            case AmxOpCode.NEG:
            case AmxOpCode.INVERT:
            case AmxOpCode.ZERO_PRI:
            case AmxOpCode.ZERO_ALT:
            case AmxOpCode.EQ:
            case AmxOpCode.NEQ:
            case AmxOpCode.SLESS:
            case AmxOpCode.SLEQ:
            case AmxOpCode.SGRTR:
            case AmxOpCode.SGEQ:
            case AmxOpCode.INC_PRI:
            case AmxOpCode.INC_ALT:
            case AmxOpCode.INC_I:
            case AmxOpCode.DEC_PRI:
            case AmxOpCode.DEC_ALT:
            case AmxOpCode.DEC_I:
            case AmxOpCode.SWAP_PRI:
            case AmxOpCode.SWAP_ALT:
            case AmxOpCode.NOP:
            case AmxOpCode.BREAK:
                break;

            /* Jump w/ Relocation */
            case AmxOpCode.CALL:
            case AmxOpCode.JUMP:
            case AmxOpCode.JZER:
            case AmxOpCode.JNZ:
            case AmxOpCode.JEQ:
            case AmxOpCode.JNEQ:
            case AmxOpCode.JSLESS:
            case AmxOpCode.JSLEQ:
            case AmxOpCode.JSGRTR:
            case AmxOpCode.JSGEQ:
            case AmxOpCode.SWITCH:
                /* if this file is an older version (absolute references instead of the
                 * current use of position-independent code), convert the parameter
                 * to position-independent code first
                 */
                cip += CellSize;
                break;

            /* overlay opcodes (overlays must be enabled) */
            case AmxOpCode.ISWITCH:
                Debug.Assert(Header.FileVersion >= 10);
                /* drop through */
                goto case AmxOpCode.ICALL;

            case AmxOpCode.ICALL:
                cip += CellSize;
                /* drop through */
                goto case AmxOpCode.IRETN;

            case AmxOpCode.IRETN:
                Debug.Assert(Header.Overlays != 0 && Header.Overlays != Header.NameTable);
                //return AmxError.OVERLAY;       /* no overlay callback */
                break;

            case AmxOpCode.ICASETBL:
            {
                Cell num;
                //DBGPARAM(num);    /* number of records follows the opcode */
                //cip += (2 * num + 1) * CellSize;
                //if (Header.Overlays == 0)
                // return AmxError.OVERLAY;       /* no overlay callback */
                break;
            }                     /* case */

            case AmxOpCode.SYSREQ_C:
                cip        += CellSize;
                sysreq_flg |= 0x01;                         /* mark SYSREQ found */
                break;

            case AmxOpCode.SYSREQ_N:
                cip        += CellSize * 2;
                sysreq_flg |= 0x02;                         /* mark SYSREQ.N found */
                break;

            case AmxOpCode.CASETBL:
            {
                DBGPARAM(out var num);
                //cip += (2 * num + 1) * CellSize;
                break;
            }

            default:
                Header.Flags &= ~AmxFlags.VERIFY;
                //return AmxError.INVINSTR;
                break;
            }

            void DBGPARAM(out Cell v) => v = null;               // v = (Cell)(amx->code + (int)cip), cip += CellSize)
        }
Esempio n. 6
0
File: Amx.cs Progetto: PMArkive/pkNX
 static void GETPARAM_P(Cell v, AmxOpCode o)
 {
 }                                               // (v = ((Cell) (o) >> (int) (CellSize * 4)));}
Esempio n. 7
0
File: Amx.cs Progetto: PMArkive/pkNX
 public void ParseOp(AmxOpCode op, ref int cip, ref Cell tgt)
 {
Esempio n. 8
0
 internal static string EchoIntCommand(AmxOpCode c, params int[] arr)
 {