OSDN Git Service

[General] Convert sourcecode's CRLF format: DOS(WINDOWS) to Unix, to apply patches...
[csp-qt/common_source_project-fm7.git] / source / src / vm / mame / emu / cpu / i86 / modrm286.h
index 4adc0b0..6939e91 100644 (file)
-static struct\r
-{\r
-       struct\r
-       {\r
-               WREGS w[256];\r
-               BREGS b[256];\r
-       } reg;\r
-       struct\r
-       {\r
-               WREGS w[256];\r
-               BREGS b[256];\r
-       } RM;\r
-} Mod_RM;\r
-\r
-#define RegWord(ModRM) cpustate->regs.w[Mod_RM.reg.w[ModRM]]\r
-#define RegByte(ModRM) cpustate->regs.b[Mod_RM.reg.b[ModRM]]\r
-\r
-#define GetRMWord(ModRM) \\r
-       ((ModRM) >= 0xc0 ? cpustate->regs.w[Mod_RM.RM.w[ModRM]] : ( (*GetEA[ModRM])(cpustate), i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_READ), ReadWord( cpustate->ea ) ))\r
-\r
-#define PutbackRMWord(ModRM,val)                                                                        \\r
-{                                                                                                       \\r
-       if (ModRM >= 0xc0) cpustate->regs.w[Mod_RM.RM.w[ModRM]]=val;                                        \\r
-       else                                                                                                \\r
-       {                                                                                                   \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_WRITE);   \\r
-               WriteWord(cpustate->ea,val);                                                                    \\r
-       }                                                                                                   \\r
-}\r
-\r
-#define GetnextRMWord                                                                                                                   \\r
-       (                                                                                                                                   \\r
-       i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->ea + 2 - cpustate->base[cpustate->ea_seg], I80286_WORD, I80286_READ), \\r
-       ReadWord(cpustate->ea+2)                                                                                                            \\r
-       )\r
-\r
-#define GetRMWordOffset(offs)                                                                                       \\r
-               (                                                                                                           \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_WORD, I80286_READ), \\r
-               ReadWord(cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs))                                             \\r
-               )\r
-\r
-#define GetRMByteOffset(offs)                                                                                       \\r
-               (                                                                                                           \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_BYTE, I80286_READ), \\r
-               ReadByte(cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs))                                             \\r
-               )\r
-\r
-#define PutRMWord(ModRM,val)                                                                            \\r
-{                                                                                                       \\r
-       if (ModRM >= 0xc0)                                                                                  \\r
-               cpustate->regs.w[Mod_RM.RM.w[ModRM]]=val;                                                       \\r
-       else {                                                                                              \\r
-               (*GetEA[ModRM])(cpustate);                                                                      \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_WRITE);   \\r
-               WriteWord( cpustate->ea ,val);                                                                  \\r
-       }                                                                                                   \\r
-}\r
-\r
-#define PutRMWordOffset(offs, val)                                                                                      \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_WORD, I80286_WRITE);    \\r
-               WriteWord( cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs), val)\r
-\r
-#define PutRMByteOffset(offs, val)                                                                                      \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_BYTE, I80286_WRITE);    \\r
-               WriteByte( cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs), val)\r
-\r
-#define PutImmRMWord(ModRM)                                                                             \\r
-{                                                                                                       \\r
-       WORD val;                                                                                           \\r
-       if (ModRM >= 0xc0)                                                                                  \\r
-               FETCHWORD(cpustate->regs.w[Mod_RM.RM.w[ModRM]])                                                 \\r
-       else {                                                                                              \\r
-               (*GetEA[ModRM])(cpustate);                                                                      \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_WRITE);   \\r
-               FETCHWORD(val)                                                                                  \\r
-               WriteWord( cpustate->ea , val);                                                                 \\r
-       }                                                                                                   \\r
-}\r
-\r
-#define GetRMByte(ModRM) \\r
-       ((ModRM) >= 0xc0 ? cpustate->regs.b[Mod_RM.RM.b[ModRM]] : ( (*GetEA[ModRM])(cpustate), i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_READ), ReadByte( cpustate->ea )) )\r
-\r
-#define PutRMByte(ModRM,val)                                                                            \\r
-{                                                                                                       \\r
-       if (ModRM >= 0xc0)                                                                                  \\r
-               cpustate->regs.b[Mod_RM.RM.b[ModRM]]=val;                                                       \\r
-       else                                                                                                \\r
-       {                                                                                                   \\r
-               (*GetEA[ModRM])(cpustate);                                                                      \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_WRITE);   \\r
-               WriteByte( cpustate->ea,val);                                                                   \\r
-       }                                                                                                   \\r
-}\r
-\r
-#define PutImmRMByte(ModRM)                                                                             \\r
-{                                                                                                       \\r
-       if (ModRM >= 0xc0)                                                                                  \\r
-               cpustate->regs.b[Mod_RM.RM.b[ModRM]]=FETCH;                                                     \\r
-       else {                                                                                              \\r
-               (*GetEA[ModRM])(cpustate);                                                                      \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_WRITE);   \\r
-               WriteByte( cpustate->ea , FETCH );                                                              \\r
-       }                                                                                                   \\r
-}\r
-\r
-#define PutbackRMByte(ModRM,val)                                                                        \\r
-{                                                                                                       \\r
-       if (ModRM >= 0xc0)                                                                                  \\r
-               cpustate->regs.b[Mod_RM.RM.b[ModRM]]=val;                                                       \\r
-       else                                                                                                \\r
-       {                                                                                                   \\r
-               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_WRITE);   \\r
-               WriteByte(cpustate->ea,val);                                                                    \\r
-       }                                                                                                   \\r
-}\r
-\r
-#define DEF_br8(dst,src)                    \\r
-       unsigned ModRM = FETCHOP;               \\r
-       unsigned src = RegByte(ModRM);          \\r
-       unsigned dst = GetRMByte(ModRM)\r
-\r
-#define DEF_wr16(dst,src)                   \\r
-       unsigned ModRM = FETCHOP;               \\r
-       unsigned src = RegWord(ModRM);          \\r
-       unsigned dst = GetRMWord(ModRM)\r
-\r
-#define DEF_r8b(dst,src)                    \\r
-       unsigned ModRM = FETCHOP;               \\r
-       unsigned dst = RegByte(ModRM);          \\r
-       unsigned src = GetRMByte(ModRM)\r
-\r
-#define DEF_r16w(dst,src)                   \\r
-       unsigned ModRM = FETCHOP;               \\r
-       unsigned dst = RegWord(ModRM);          \\r
-       unsigned src = GetRMWord(ModRM)\r
-\r
-#define DEF_ald8(dst,src)                   \\r
-       unsigned src = FETCHOP;                 \\r
-       unsigned dst = cpustate->regs.b[AL]\r
-\r
-#define DEF_axd16(dst,src)                  \\r
-       unsigned src = FETCHOP;                 \\r
-       unsigned dst = cpustate->regs.w[AX];    \\r
-       src += (FETCH << 8)\r
+static struct
+{
+       struct
+       {
+               WREGS w[256];
+               BREGS b[256];
+       } reg;
+       struct
+       {
+               WREGS w[256];
+               BREGS b[256];
+       } RM;
+} Mod_RM;
+
+#define RegWord(ModRM) cpustate->regs.w[Mod_RM.reg.w[ModRM]]
+#define RegByte(ModRM) cpustate->regs.b[Mod_RM.reg.b[ModRM]]
+
+#define GetRMWord(ModRM) \
+       ((ModRM) >= 0xc0 ? cpustate->regs.w[Mod_RM.RM.w[ModRM]] : ( (*GetEA[ModRM])(cpustate), i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_READ), ReadWord( cpustate->ea ) ))
+
+#define PutbackRMWord(ModRM,val)                                                                        \
+{                                                                                                       \
+       if (ModRM >= 0xc0) cpustate->regs.w[Mod_RM.RM.w[ModRM]]=val;                                        \
+       else                                                                                                \
+       {                                                                                                   \
+               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_WRITE);   \
+               WriteWord(cpustate->ea,val);                                                                    \
+       }                                                                                                   \
+}
+
+#define GetnextRMWord                                                                                                                   \
+       (                                                                                                                                   \
+       i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->ea + 2 - cpustate->base[cpustate->ea_seg], I80286_WORD, I80286_READ), \
+       ReadWord(cpustate->ea+2)                                                                                                            \
+       )
+
+#define GetRMWordOffset(offs)                                                                                       \
+               (                                                                                                           \
+               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_WORD, I80286_READ), \
+               ReadWord(cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs))                                             \
+               )
+
+#define GetRMByteOffset(offs)                                                                                       \
+               (                                                                                                           \
+               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_BYTE, I80286_READ), \
+               ReadByte(cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs))                                             \
+               )
+
+#define PutRMWord(ModRM,val)                                                                            \
+{                                                                                                       \
+       if (ModRM >= 0xc0)                                                                                  \
+               cpustate->regs.w[Mod_RM.RM.w[ModRM]]=val;                                                       \
+       else {                                                                                              \
+               (*GetEA[ModRM])(cpustate);                                                                      \
+               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_WRITE);   \
+               WriteWord( cpustate->ea ,val);                                                                  \
+       }                                                                                                   \
+}
+
+#define PutRMWordOffset(offs, val)                                                                                      \
+               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_WORD, I80286_WRITE);    \
+               WriteWord( cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs), val)
+
+#define PutRMByteOffset(offs, val)                                                                                      \
+               i80286_check_permission(cpustate, cpustate->ea_seg, (UINT16)(cpustate->eo+offs), I80286_BYTE, I80286_WRITE);    \
+               WriteByte( cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs), val)
+
+#define PutImmRMWord(ModRM)                                                                             \
+{                                                                                                       \
+       WORD val;                                                                                           \
+       if (ModRM >= 0xc0)                                                                                  \
+               FETCHWORD(cpustate->regs.w[Mod_RM.RM.w[ModRM]])                                                 \
+       else {                                                                                              \
+               (*GetEA[ModRM])(cpustate);                                                                      \
+               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_WORD, I80286_WRITE);   \
+               FETCHWORD(val)                                                                                  \
+               WriteWord( cpustate->ea , val);                                                                 \
+       }                                                                                                   \
+}
+
+#define GetRMByte(ModRM) \
+       ((ModRM) >= 0xc0 ? cpustate->regs.b[Mod_RM.RM.b[ModRM]] : ( (*GetEA[ModRM])(cpustate), i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_READ), ReadByte( cpustate->ea )) )
+
+#define PutRMByte(ModRM,val)                                                                            \
+{                                                                                                       \
+       if (ModRM >= 0xc0)                                                                                  \
+               cpustate->regs.b[Mod_RM.RM.b[ModRM]]=val;                                                       \
+       else                                                                                                \
+       {                                                                                                   \
+               (*GetEA[ModRM])(cpustate);                                                                      \
+               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_WRITE);   \
+               WriteByte( cpustate->ea,val);                                                                   \
+       }                                                                                                   \
+}
+
+#define PutImmRMByte(ModRM)                                                                             \
+{                                                                                                       \
+       if (ModRM >= 0xc0)                                                                                  \
+               cpustate->regs.b[Mod_RM.RM.b[ModRM]]=FETCH;                                                     \
+       else {                                                                                              \
+               (*GetEA[ModRM])(cpustate);                                                                      \
+               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_WRITE);   \
+               WriteByte( cpustate->ea , FETCH );                                                              \
+       }                                                                                                   \
+}
+
+#define PutbackRMByte(ModRM,val)                                                                        \
+{                                                                                                       \
+       if (ModRM >= 0xc0)                                                                                  \
+               cpustate->regs.b[Mod_RM.RM.b[ModRM]]=val;                                                       \
+       else                                                                                                \
+       {                                                                                                   \
+               i80286_check_permission(cpustate, cpustate->ea_seg, cpustate->eo, I80286_BYTE, I80286_WRITE);   \
+               WriteByte(cpustate->ea,val);                                                                    \
+       }                                                                                                   \
+}
+
+#define DEF_br8(dst,src)                    \
+       unsigned ModRM = FETCHOP;               \
+       unsigned src = RegByte(ModRM);          \
+       unsigned dst = GetRMByte(ModRM)
+
+#define DEF_wr16(dst,src)                   \
+       unsigned ModRM = FETCHOP;               \
+       unsigned src = RegWord(ModRM);          \
+       unsigned dst = GetRMWord(ModRM)
+
+#define DEF_r8b(dst,src)                    \
+       unsigned ModRM = FETCHOP;               \
+       unsigned dst = RegByte(ModRM);          \
+       unsigned src = GetRMByte(ModRM)
+
+#define DEF_r16w(dst,src)                   \
+       unsigned ModRM = FETCHOP;               \
+       unsigned dst = RegWord(ModRM);          \
+       unsigned src = GetRMWord(ModRM)
+
+#define DEF_ald8(dst,src)                   \
+       unsigned src = FETCHOP;                 \
+       unsigned dst = cpustate->regs.b[AL]
+
+#define DEF_axd16(dst,src)                  \
+       unsigned src = FETCHOP;                 \
+       unsigned dst = cpustate->regs.w[AX];    \
+       src += (FETCH << 8)