chrisly42/mc68000-asm-plugin
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Added 68020 Memory Indirect and Program Counter Memory Indirect addressing modes.

Browse Source
This commit is contained in:
Chris Hodges 2021-10-08 08:38:04 +02:00
parent 7462c5b02d
commit f1110ac3c9
48 changed files with 2414 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -127,7 +127,8 @@ If the current statement has no valid syntax, the instruction details of all mat
- Scoping for global symbols, labels and macros is currently the whole project.
- No support for register replacement (e.g. registers replaced by `EQUR` or `EQURL` will cause syntax errors)
- While the lexer supports the -spaces option (where a space does *NOT* introduce a comment), this cannot be configured yet (default is ON).
- No support for other processor instructions, FPU or 68020+ address modes.
- No support for other processor instructions and FPU.
- The pretty esoteric use of `ZPC`, `ZA0-ZA7` or `ZSP` for zero (omitted) address in 68020 addressing modes is unsupported.
- Unit Test coverage is not as good as it could be (ahem).
- Missing but planned features:
- Macro evaluation on invocation

784
src/main/gen/de/platon42/intellij/plugins/m68k/lexer/_M68kLexer.java
View File

File diff suppressed because it is too large Load Diff

374
src/main/gen/de/platon42/intellij/plugins/m68k/parser/M68kParser.java
View File

@ -41,8 +41,9 @@ public class M68kParser implements PsiParser, LightPsiParser {
create_token_set_(ABSOLUTE_ADDRESS_ADDRESSING_MODE, ADDRESSING_MODE, ADDRESS_REGISTER_DIRECT_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_ADDRESSING_MODE,
ADDRESS_REGISTER_INDIRECT_POST_INC_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_PRE_DEC_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE,
ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE, DATA_REGISTER_DIRECT_ADDRESSING_MODE, IMMEDIATE_DATA,
PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE,
REGISTER_LIST_ADDRESSING_MODE, SPECIAL_REGISTER_DIRECT_ADDRESSING_MODE),
MEMORY_INDIRECT_ADDRESSING_MODE, MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE,
PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE, PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE,
PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE, REGISTER_LIST_ADDRESSING_MODE, SPECIAL_REGISTER_DIRECT_ADDRESSING_MODE),
create_token_set_(BINARY_ADD_EXPR, BINARY_BITWISE_AND_EXPR, BINARY_BITWISE_OR_EXPR, BINARY_BITWISE_XOR_EXPR,
BINARY_CMP_EQ_EXPR, BINARY_CMP_GE_EXPR, BINARY_CMP_GT_EXPR, BINARY_CMP_LE_EXPR,
BINARY_CMP_LT_EXPR, BINARY_CMP_NE_EXPR, BINARY_DIV_EXPR, BINARY_LOGICAL_AND_EXPR,
@ -288,6 +289,12 @@ public class M68kParser implements PsiParser, LightPsiParser {
// | AddressRegisterIndirectAddressingMode
// | AddressRegisterIndirectWithDisplacementNewAddressingMode
// | ProgramCounterIndirectWithDisplacementNewAddressingMode
// | MemoryIndirectAddressingMode
// | ProgramCounterMemoryIndirectAddressingMode
// | MemoryIndirectPostIndexedAddressingMode
// | ProgramCounterMemoryIndirectPostIndexedAddressingMode
// | MemoryIndirectPreIndexedAddressingMode
// | ProgramCounterMemoryIndirectPreIndexedAddressingMode
// | AddressRegisterIndirectWithIndexNewAddressingMode
// | ProgramCounterIndirectWithIndexNewAddressingMode
// | AddressRegisterIndirectWithDisplacementOldAddressingMode
@ -309,6 +316,12 @@ public class M68kParser implements PsiParser, LightPsiParser {
if (!r) r = AddressRegisterIndirectAddressingMode(b, l + 1);
if (!r) r = AddressRegisterIndirectWithDisplacementNewAddressingMode(b, l + 1);
if (!r) r = ProgramCounterIndirectWithDisplacementNewAddressingMode(b, l + 1);
if (!r) r = MemoryIndirectAddressingMode(b, l + 1);
if (!r) r = ProgramCounterMemoryIndirectAddressingMode(b, l + 1);
if (!r) r = MemoryIndirectPostIndexedAddressingMode(b, l + 1);
if (!r) r = ProgramCounterMemoryIndirectPostIndexedAddressingMode(b, l + 1);
if (!r) r = MemoryIndirectPreIndexedAddressingMode(b, l + 1);
if (!r) r = ProgramCounterMemoryIndirectPreIndexedAddressingMode(b, l + 1);
if (!r) r = AddressRegisterIndirectWithIndexNewAddressingMode(b, l + 1);
if (!r) r = ProgramCounterIndirectWithIndexNewAddressingMode(b, l + 1);
if (!r) r = AddressRegisterIndirectWithDisplacementOldAddressingMode(b, l + 1);
@ -794,6 +807,186 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (expr SEPARATOR)? AddressRegister SQUARE_R (SEPARATOR expr)? ROUND_R
public static boolean MemoryIndirectAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MEMORY_INDIRECT_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && MemoryIndirectAddressingMode_2(b, l + 1);
r = r && AddressRegister(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
r = r && MemoryIndirectAddressingMode_5(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (expr SEPARATOR)?
private static boolean MemoryIndirectAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_2")) return false;
MemoryIndirectAddressingMode_2_0(b, l + 1);
return true;
}
// expr SEPARATOR
private static boolean MemoryIndirectAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = expr(b, l + 1, -1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR expr)?
private static boolean MemoryIndirectAddressingMode_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_5")) return false;
MemoryIndirectAddressingMode_5_0(b, l + 1);
return true;
}
// SEPARATOR expr
private static boolean MemoryIndirectAddressingMode_5_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_5_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L (SQUARE_L (expr SEPARATOR)? AddressRegister SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR expr)? ROUND_R
public static boolean MemoryIndirectPostIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokenFast(b, ROUND_L);
r = r && MemoryIndirectPostIndexedAddressingMode_1(b, l + 1);
r = r && IndexRegister(b, l + 1);
r = r && MemoryIndirectPostIndexedAddressingMode_3(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (SQUARE_L (expr SEPARATOR)? AddressRegister SQUARE_R SEPARATOR)?
private static boolean MemoryIndirectPostIndexedAddressingMode_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1")) return false;
MemoryIndirectPostIndexedAddressingMode_1_0(b, l + 1);
return true;
}
// SQUARE_L (expr SEPARATOR)? AddressRegister SQUARE_R SEPARATOR
private static boolean MemoryIndirectPostIndexedAddressingMode_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SQUARE_L);
r = r && MemoryIndirectPostIndexedAddressingMode_1_0_1(b, l + 1);
r = r && AddressRegister(b, l + 1);
r = r && consumeTokens(b, 0, SQUARE_R, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (expr SEPARATOR)?
private static boolean MemoryIndirectPostIndexedAddressingMode_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1_0_1")) return false;
MemoryIndirectPostIndexedAddressingMode_1_0_1_0(b, l + 1);
return true;
}
// expr SEPARATOR
private static boolean MemoryIndirectPostIndexedAddressingMode_1_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = expr(b, l + 1, -1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR expr)?
private static boolean MemoryIndirectPostIndexedAddressingMode_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_3")) return false;
MemoryIndirectPostIndexedAddressingMode_3_0(b, l + 1);
return true;
}
// SEPARATOR expr
private static boolean MemoryIndirectPostIndexedAddressingMode_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (expr SEPARATOR)? AddressRegister SEPARATOR IndexRegister SQUARE_R (SEPARATOR expr)? ROUND_R
public static boolean MemoryIndirectPreIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && MemoryIndirectPreIndexedAddressingMode_2(b, l + 1);
r = r && AddressRegister(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
r = r && IndexRegister(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
r = r && MemoryIndirectPreIndexedAddressingMode_7(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (expr SEPARATOR)?
private static boolean MemoryIndirectPreIndexedAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_2")) return false;
MemoryIndirectPreIndexedAddressingMode_2_0(b, l + 1);
return true;
}
// expr SEPARATOR
private static boolean MemoryIndirectPreIndexedAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = expr(b, l + 1, -1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR expr)?
private static boolean MemoryIndirectPreIndexedAddressingMode_7(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_7")) return false;
MemoryIndirectPreIndexedAddressingMode_7_0(b, l + 1);
return true;
}
// SEPARATOR expr
private static boolean MemoryIndirectPreIndexedAddressingMode_7_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_7_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// OPSIZE_BS|OPSIZE_W|OPSIZE_L
public static boolean OperandSize(PsiBuilder b, int l) {
@ -1034,6 +1227,183 @@ public class M68kParser implements PsiParser, LightPsiParser {
return true;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (expr SEPARATOR)? PC SQUARE_R (SEPARATOR expr)? ROUND_R
public static boolean ProgramCounterMemoryIndirectAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && ProgramCounterMemoryIndirectAddressingMode_2(b, l + 1);
r = r && consumeTokens(b, 0, PC, SQUARE_R);
r = r && ProgramCounterMemoryIndirectAddressingMode_5(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (expr SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_2")) return false;
ProgramCounterMemoryIndirectAddressingMode_2_0(b, l + 1);
return true;
}
// expr SEPARATOR
private static boolean ProgramCounterMemoryIndirectAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = expr(b, l + 1, -1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR expr)?
private static boolean ProgramCounterMemoryIndirectAddressingMode_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_5")) return false;
ProgramCounterMemoryIndirectAddressingMode_5_0(b, l + 1);
return true;
}
// SEPARATOR expr
private static boolean ProgramCounterMemoryIndirectAddressingMode_5_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_5_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L (SQUARE_L (expr SEPARATOR)? PC SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR expr)? ROUND_R
public static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokenFast(b, ROUND_L);
r = r && ProgramCounterMemoryIndirectPostIndexedAddressingMode_1(b, l + 1);
r = r && IndexRegister(b, l + 1);
r = r && ProgramCounterMemoryIndirectPostIndexedAddressingMode_3(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (SQUARE_L (expr SEPARATOR)? PC SQUARE_R SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1")) return false;
ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0(b, l + 1);
return true;
}
// SQUARE_L (expr SEPARATOR)? PC SQUARE_R SEPARATOR
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SQUARE_L);
r = r && ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1(b, l + 1);
r = r && consumeTokens(b, 0, PC, SQUARE_R, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (expr SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1")) return false;
ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1_0(b, l + 1);
return true;
}
// expr SEPARATOR
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = expr(b, l + 1, -1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR expr)?
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_3")) return false;
ProgramCounterMemoryIndirectPostIndexedAddressingMode_3_0(b, l + 1);
return true;
}
// SEPARATOR expr
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (expr SEPARATOR)? PC SEPARATOR IndexRegister SQUARE_R (SEPARATOR expr)? ROUND_R
public static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && ProgramCounterMemoryIndirectPreIndexedAddressingMode_2(b, l + 1);
r = r && consumeTokens(b, 0, PC, SEPARATOR);
r = r && IndexRegister(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
r = r && ProgramCounterMemoryIndirectPreIndexedAddressingMode_7(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (expr SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_2")) return false;
ProgramCounterMemoryIndirectPreIndexedAddressingMode_2_0(b, l + 1);
return true;
}
// expr SEPARATOR
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = expr(b, l + 1, -1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR expr)?
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_7(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_7")) return false;
ProgramCounterMemoryIndirectPreIndexedAddressingMode_7_0(b, l + 1);
return true;
}
// SEPARATOR expr
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_7_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_7_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// CURRENT_PC_SYMBOL
public static boolean ProgramCounterReference(PsiBuilder b, int l) {

23
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectAddressingMode.java Normal file
View File

@ -0,0 +1,23 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kMemoryIndirectAddressingMode extends M68kAddressingMode, M68kWithAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithOuterDisplacement {
@NotNull
M68kAddressRegister getAddressRegister();
@NotNull
List<M68kExpr> getExprList();
@Nullable
M68kExpr getBaseDisplacement();
@Nullable
M68kExpr getOuterDisplacement();
}

26
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectPostIndexedAddressingMode.java Normal file
View File

@ -0,0 +1,26 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kMemoryIndirectPostIndexedAddressingMode extends M68kAddressingMode, M68kWithAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@Nullable
M68kAddressRegister getAddressRegister();
@NotNull
M68kIndexRegister getIndexRegister();
@NotNull
List<M68kExpr> getExprList();
@Nullable
M68kExpr getBaseDisplacement();
@Nullable
M68kExpr getOuterDisplacement();
}

26
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectPreIndexedAddressingMode.java Normal file
View File

@ -0,0 +1,26 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kMemoryIndirectPreIndexedAddressingMode extends M68kAddressingMode, M68kWithAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@NotNull
M68kAddressRegister getAddressRegister();
@NotNull
M68kIndexRegister getIndexRegister();
@NotNull
List<M68kExpr> getExprList();
@Nullable
M68kExpr getBaseDisplacement();
@Nullable
M68kExpr getOuterDisplacement();
}

20
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectAddressingMode.java Normal file
View File

@ -0,0 +1,20 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kProgramCounterMemoryIndirectAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithOuterDisplacement {
@NotNull
List<M68kExpr> getExprList();
@Nullable
M68kExpr getBaseDisplacement();
@Nullable
M68kExpr getOuterDisplacement();
}

23
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectPostIndexedAddressingMode.java Normal file
View File

@ -0,0 +1,23 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kProgramCounterMemoryIndirectPostIndexedAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@NotNull
M68kIndexRegister getIndexRegister();
@NotNull
List<M68kExpr> getExprList();
@Nullable
M68kExpr getBaseDisplacement();
@Nullable
M68kExpr getOuterDisplacement();
}

23
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectPreIndexedAddressingMode.java Normal file
View File

@ -0,0 +1,23 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kProgramCounterMemoryIndirectPreIndexedAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@NotNull
M68kIndexRegister getIndexRegister();
@NotNull
List<M68kExpr> getExprList();
@Nullable
M68kExpr getBaseDisplacement();
@Nullable
M68kExpr getOuterDisplacement();
}

20
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kTypes.java
View File

@ -56,6 +56,9 @@ public interface M68kTypes {
IElementType MACRO_DEFINITION = M68kStubElementTypeFactory.stubFactory("MACRO_DEFINITION");
IElementType MACRO_NAME_DEFINITION = new M68kElementType("MACRO_NAME_DEFINITION");
IElementType MACRO_PLAIN_LINE = new M68kElementType("MACRO_PLAIN_LINE");
IElementType MEMORY_INDIRECT_ADDRESSING_MODE = new M68kElementType("MEMORY_INDIRECT_ADDRESSING_MODE");
IElementType MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE = new M68kElementType("MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE");
IElementType MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE = new M68kElementType("MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE");
IElementType OPERAND_SIZE = new M68kElementType("OPERAND_SIZE");
IElementType PAREN_EXPR = new M68kElementType("PAREN_EXPR");
IElementType PREPROCESSOR_DIRECTIVE = new M68kElementType("PREPROCESSOR_DIRECTIVE");
@ -64,6 +67,9 @@ public interface M68kTypes {
IElementType PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_REFERENCE = new M68kElementType("PROGRAM_COUNTER_REFERENCE");
IElementType REF_EXPR = new M68kElementType("REF_EXPR");
IElementType REGISTER = new M68kElementType("REGISTER");
@ -134,6 +140,8 @@ public interface M68kTypes {
IElementType ROUND_L = new M68kTokenType("ROUND_L");
IElementType ROUND_R = new M68kTokenType("ROUND_R");
IElementType SEPARATOR = new M68kTokenType("SEPARATOR");
IElementType SQUARE_L = new M68kTokenType("SQUARE_L");
IElementType SQUARE_R = new M68kTokenType("SQUARE_R");
IElementType STRINGLIT = new M68kTokenType("STRINGLIT");
IElementType SYMBOL = new M68kTokenType("SYMBOL");
IElementType SYMBOLDEF = new M68kTokenType("SYMBOLDEF");
@ -231,6 +239,12 @@ public interface M68kTypes {
return new M68kMacroNameDefinitionImpl(node);
} else if (type == MACRO_PLAIN_LINE) {
return new M68kMacroPlainLineImpl(node);
} else if (type == MEMORY_INDIRECT_ADDRESSING_MODE) {
return new M68kMemoryIndirectAddressingModeImpl(node);
} else if (type == MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE) {
return new M68kMemoryIndirectPostIndexedAddressingModeImpl(node);
} else if (type == MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE) {
return new M68kMemoryIndirectPreIndexedAddressingModeImpl(node);
} else if (type == OPERAND_SIZE) {
return new M68kOperandSizeImpl(node);
} else if (type == PAREN_EXPR) {
@ -247,6 +261,12 @@ public interface M68kTypes {
return new M68kProgramCounterIndirectWithIndexNewAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE) {
return new M68kProgramCounterIndirectWithIndexOldAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE) {
return new M68kProgramCounterMemoryIndirectAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE) {
return new M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE) {
return new M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_REFERENCE) {
return new M68kProgramCounterReferenceImpl(node);
} else if (type == REF_EXPR) {

43
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kVisitor.java
View File

@ -127,6 +127,29 @@ public class M68kVisitor extends PsiElementVisitor {
visitPsiElement(o);
}
public void visitMemoryIndirectAddressingMode(@NotNull M68kMemoryIndirectAddressingMode o) {
visitAddressingMode(o);
// visitWithAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithOuterDisplacement(o);
}
public void visitMemoryIndirectPostIndexedAddressingMode(@NotNull M68kMemoryIndirectPostIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitMemoryIndirectPreIndexedAddressingMode(@NotNull M68kMemoryIndirectPreIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitOperandSize(@NotNull M68kOperandSize o) {
visitPsiElement(o);
}
@ -161,6 +184,26 @@ public class M68kVisitor extends PsiElementVisitor {
// visitWithIndexRegister(o);
}
public void visitProgramCounterMemoryIndirectAddressingMode(@NotNull M68kProgramCounterMemoryIndirectAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithOuterDisplacement(o);
}
public void visitProgramCounterMemoryIndirectPostIndexedAddressingMode(@NotNull M68kProgramCounterMemoryIndirectPostIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitProgramCounterMemoryIndirectPreIndexedAddressingMode(@NotNull M68kProgramCounterMemoryIndirectPreIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitProgramCounterReference(@NotNull M68kProgramCounterReference o) {
visitPsiElement(o);
}

59
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectAddressingModeImpl.java Normal file
View File

@ -0,0 +1,59 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kAddressRegister;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kMemoryIndirectAddressingMode;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class M68kMemoryIndirectAddressingModeImpl extends M68kAddressingModeImpl implements M68kMemoryIndirectAddressingMode {
public M68kMemoryIndirectAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitMemoryIndirectAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kAddressRegister getAddressRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class));
}
@Override
@NotNull
public List<M68kExpr> getExprList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kExpr.class);
}
@Override
@Nullable
public M68kExpr getBaseDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 1 ? null : p1.get(0);
}
@Override
@Nullable
public M68kExpr getOuterDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 2 ? null : p1.get(1);
}
}

62
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectPostIndexedAddressingModeImpl.java Normal file
View File

@ -0,0 +1,62 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class M68kMemoryIndirectPostIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kMemoryIndirectPostIndexedAddressingMode {
public M68kMemoryIndirectPostIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitMemoryIndirectPostIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kAddressRegister getAddressRegister() {
return PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@NotNull
public List<M68kExpr> getExprList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kExpr.class);
}
@Override
@Nullable
public M68kExpr getBaseDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 1 ? null : p1.get(0);
}
@Override
@Nullable
public M68kExpr getOuterDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 2 ? null : p1.get(1);
}
}

62
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectPreIndexedAddressingModeImpl.java Normal file
View File

@ -0,0 +1,62 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class M68kMemoryIndirectPreIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kMemoryIndirectPreIndexedAddressingMode {
public M68kMemoryIndirectPreIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitMemoryIndirectPreIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kAddressRegister getAddressRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class));
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@NotNull
public List<M68kExpr> getExprList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kExpr.class);
}
@Override
@Nullable
public M68kExpr getBaseDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 1 ? null : p1.get(0);
}
@Override
@Nullable
public M68kExpr getOuterDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 2 ? null : p1.get(1);
}
}

52
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectAddressingModeImpl.java Normal file
View File

@ -0,0 +1,52 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kProgramCounterMemoryIndirectAddressingMode;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class M68kProgramCounterMemoryIndirectAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterMemoryIndirectAddressingMode {
public M68kProgramCounterMemoryIndirectAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterMemoryIndirectAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<M68kExpr> getExprList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kExpr.class);
}
@Override
@Nullable
public M68kExpr getBaseDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 1 ? null : p1.get(0);
}
@Override
@Nullable
public M68kExpr getOuterDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 2 ? null : p1.get(1);
}
}

59
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl.java Normal file
View File

@ -0,0 +1,59 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kIndexRegister;
import de.platon42.intellij.plugins.m68k.psi.M68kProgramCounterMemoryIndirectPostIndexedAddressingMode;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterMemoryIndirectPostIndexedAddressingMode {
public M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterMemoryIndirectPostIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@NotNull
public List<M68kExpr> getExprList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kExpr.class);
}
@Override
@Nullable
public M68kExpr getBaseDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 1 ? null : p1.get(0);
}
@Override
@Nullable
public M68kExpr getOuterDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 2 ? null : p1.get(1);
}
}

59
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl.java Normal file
View File

@ -0,0 +1,59 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kIndexRegister;
import de.platon42.intellij.plugins.m68k.psi.M68kProgramCounterMemoryIndirectPreIndexedAddressingMode;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterMemoryIndirectPreIndexedAddressingMode {
public M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterMemoryIndirectPreIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@NotNull
public List<M68kExpr> getExprList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kExpr.class);
}
@Override
@Nullable
public M68kExpr getBaseDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 1 ? null : p1.get(0);
}
@Override
@Nullable
public M68kExpr getOuterDisplacement() {
List<M68kExpr> p1 = getExprList();
return p1.size() < 2 ? null : p1.get(1);
}
}

6
src/main/java/de/platon42/intellij/plugins/m68k/asm/M68kIsa.kt
View File

@ -46,6 +46,12 @@ enum class AddressMode(val description: String, val syntax: String) {
ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX("address register indirect with scaled index", "(d8,An,Xn*s)"),
PROGRAM_COUNTER_INDIRECT_WITH_INDEX("program counter indirect with index", "(d8,PC,Xn)"),
PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX("program counter indirect with scaled index", "(d8,PC,Xn*s)"),
MEMORY_INDIRECT("memory indirect", "([bd,An],od)"),
MEMORY_INDIRECT_POSTINDEXED("memory indirect postindexed", "([bd,An],Xn*s,od)"),
MEMORY_INDIRECT_PREINDEXED("memory indirect preindexed", "([bd,An,Xn*s],od)"),
PROGRAM_COUNTER_MEMORY_INDIRECT("program counter memory indirect", "([bd,PC],od)"),
PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED("program counter memory indirect postindexed", "([bd,PC],Xn*s,od)"),
PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED("program counter memory indirect preindexed", "([bd,PC,Xn*s],od)"),
SPECIAL_REGISTER_DIRECT("special register", "sr|ccr|usp|vbr"),
REGISTER_LIST("register list", "list"),
IMMEDIATE_DATA("immediate", "#<xxx>"),

5
src/main/java/de/platon42/intellij/plugins/m68k/lexer/_M68kLexer.flex
View File

@ -168,7 +168,6 @@ PLAIN_MACRO_LINE=[^;\r\n]+
"+" { return OP_PLUS; }
"-" { return OP_MINUS; }
"*" { yybegin(exprOpState); return CURRENT_PC_SYMBOL; }
}
<EXPR> {
@ -218,6 +217,8 @@ PLAIN_MACRO_LINE=[^;\r\n]+
"vbr" { yybegin(exprOpState); return REG_VBR; }
"#" { return HASH; }
"\[" { return SQUARE_L; }
// "\]" { return SQUARE_R; }
{SYMBOL} { yybegin(exprOpState); return SYMBOL; }
}
@ -226,6 +227,8 @@ PLAIN_MACRO_LINE=[^;\r\n]+
{OPSIZE_BS} { return OPSIZE_BS; }
{OPSIZE_W} { return OPSIZE_W; }
{OPSIZE_L} { return OPSIZE_L; }
"\[" { return SQUARE_L; }
"\]" { return SQUARE_R; }
}
<WAITEOL>

85
src/main/java/de/platon42/intellij/plugins/m68k/m68k.bnf
View File

@ -259,6 +259,12 @@ AddressingMode ::= ImmediateData
| AddressRegisterIndirectAddressingMode
| AddressRegisterIndirectWithDisplacementNewAddressingMode
| ProgramCounterIndirectWithDisplacementNewAddressingMode
| MemoryIndirectAddressingMode
| ProgramCounterMemoryIndirectAddressingMode
| MemoryIndirectPostIndexedAddressingMode
| ProgramCounterMemoryIndirectPostIndexedAddressingMode
| MemoryIndirectPreIndexedAddressingMode
| ProgramCounterMemoryIndirectPreIndexedAddressingMode
| AddressRegisterIndirectWithIndexNewAddressingMode
| ProgramCounterIndirectWithIndexNewAddressingMode
| AddressRegisterIndirectWithDisplacementOldAddressingMode
@ -324,6 +330,47 @@ AddressRegisterIndirectWithIndexNewAddressingMode ::= ROUND_L (expr SEPARATOR)?
]
}
MemoryIndirectAddressingMode ::= ROUND_L SQUARE_L (expr SEPARATOR)? AddressRegister SQUARE_R (SEPARATOR expr)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "expr[0]"
outerDisplacement = "expr[1]"
]
}
MemoryIndirectPostIndexedAddressingMode ::= ROUND_L (SQUARE_L (expr SEPARATOR)? AddressRegister SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR expr)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "expr[0]"
outerDisplacement = "expr[1]"
]
}
MemoryIndirectPreIndexedAddressingMode ::= ROUND_L SQUARE_L (expr SEPARATOR)? AddressRegister SEPARATOR IndexRegister SQUARE_R (SEPARATOR expr)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "expr[0]"
outerDisplacement = "expr[1]"
]
}
ProgramCounterIndirectWithDisplacementOldAddressingMode ::= (ROUND_L PC ROUND_R) | (expr ROUND_L PC ROUND_R)
{
implements = ["de.platon42.intellij.plugins.m68k.psi.M68kWithDisplacement"]
@ -362,6 +409,44 @@ ProgramCounterIndirectWithIndexNewAddressingMode ::= ROUND_L (expr SEPARATOR)? P
]
}
ProgramCounterMemoryIndirectAddressingMode ::= ROUND_L SQUARE_L (expr SEPARATOR)? PC SQUARE_R (SEPARATOR expr)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "expr[0]"
outerDisplacement = "expr[1]"
]
}
ProgramCounterMemoryIndirectPostIndexedAddressingMode ::= ROUND_L (SQUARE_L (expr SEPARATOR)? PC SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR expr)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "expr[0]"
outerDisplacement = "expr[1]"
]
}
ProgramCounterMemoryIndirectPreIndexedAddressingMode ::= ROUND_L SQUARE_L (expr SEPARATOR)? PC SEPARATOR IndexRegister SQUARE_R (SEPARATOR expr)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "expr[0]"
outerDisplacement = "expr[1]"
]
}
AbsoluteAddressAddressingMode ::= expr AddressSize? !ROUND_L
RegisterRange ::= (DataRegister OP_MINUS DataRegister) | (AddressRegister OP_MINUS AddressRegister) | (DataRegister OP_MINUS AddressRegister) {

7
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kAddressModeUtil.kt
View File

@ -18,6 +18,12 @@ object M68kAddressModeUtil {
is M68kProgramCounterIndirectWithDisplacementOldAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT
is M68kProgramCounterIndirectWithIndexNewAddressingMode -> if (hasScale(addressingMode)) AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
is M68kProgramCounterIndirectWithIndexOldAddressingMode -> if (hasScale(addressingMode)) AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
is M68kMemoryIndirectAddressingMode -> AddressMode.MEMORY_INDIRECT
is M68kMemoryIndirectPreIndexedAddressingMode -> AddressMode.MEMORY_INDIRECT_PREINDEXED
is M68kMemoryIndirectPostIndexedAddressingMode -> AddressMode.MEMORY_INDIRECT_POSTINDEXED
is M68kProgramCounterMemoryIndirectAddressingMode -> AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT
is M68kProgramCounterMemoryIndirectPreIndexedAddressingMode -> AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED
is M68kProgramCounterMemoryIndirectPostIndexedAddressingMode -> AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED
is M68kSpecialRegisterDirectAddressingMode -> AddressMode.SPECIAL_REGISTER_DIRECT
is M68kDataRegisterDirectAddressingMode -> AddressMode.DATA_REGISTER_DIRECT
is M68kAddressRegisterDirectAddressingMode -> AddressMode.ADDRESS_REGISTER_DIRECT
@ -27,6 +33,7 @@ object M68kAddressModeUtil {
}
}
// TODO add evaluation of constant expressions and allow scale == 1 as false
private fun hasScale(addressingMode: M68kWithIndexRegister) = addressingMode.indexRegister.indexScale != null
fun getOtherReadWriteModifyRegisters(rwm: Int): List<Pair<Register, Int>> {

6
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithBaseDisplacement.kt Normal file
View File

@ -0,0 +1,6 @@
package de.platon42.intellij.plugins.m68k.psi
interface M68kWithBaseDisplacement : M68kAddressingMode {
val baseDisplacement: M68kExpr?
}

6
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOuterDisplacement.kt Normal file
View File

@ -0,0 +1,6 @@
package de.platon42.intellij.plugins.m68k.psi
interface M68kWithOuterDisplacement : M68kAddressingMode {
val outerDisplacement: M68kExpr?
}

121
src/test/java/de/platon42/intellij/plugins/m68k/parser/AddressingModesTest.kt
View File

@ -92,6 +92,127 @@ internal class AddressingModesTest : AbstractParsingTest() {
testGoodSyntax(testCase, " move.l (pc,d0.w),(pc,a3)\n")
}
@Test
internal fun memory_indirect_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1],124),([-12,a0],-120)\n")
}
@Test
internal fun memory_indirect_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1],124),([a0],-120)\n")
}
@Test
internal fun memory_indirect_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1]),([-12,a0])\n")
}
@Test
internal fun memory_indirect_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1]),([a0])\n")
}
@Test
internal fun memory_indirect_post_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1],a0.w*4,124),([-12,a0],d0.l*8,-120)\n")
}
@Test
internal fun memory_indirect_post_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1],a0,124),([a0],d0.l*8,-120)\n")
}
@Test
internal fun memory_indirect_post_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1],a0),([-12,a0],d0.l*8)\n")
}
@Test
internal fun memory_indirect_post_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1],a0),([a0],d0)\n")
}
@Test
internal fun memory_indirect_pre_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1,a0.w*4],124),([-12,a0,d0.l*8],-120)\n")
}
@Test
internal fun memory_indirect_pre_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1,a0],124),([a0,d0.l*8],-120)\n")
}
@Test
internal fun memory_indirect_pre_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1,a0]),([-12,a0,d0.l*8])\n")
}
@Test
internal fun memory_indirect_pre_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1,a0]),([a0,d0])\n")
}
@Test
internal fun pc_memory_indirect_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc],124),d0\n")
}
@Test
internal fun pc_memory_indirect_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc],124),d0\n")
}
@Test
internal fun pc_memory_indirect_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc]),d0\n")
}
@Test
internal fun pc_memory_indirect_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc]),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc],a0.w*4,124),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc],a0.l*4,124),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc],a0),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc],a0*4),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc,a0.w*4],124),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc,a0*4],124),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc,a0]),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc,a0.l*4]),d0\n")
}
@Test
internal fun absolute_address(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l 4.w,a6\n")

25
src/test/resources/parser/addressingmodes/memory_indirect_minimal.txt Normal file
View File

@ -0,0 +1,25 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

33
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_minimal.txt Normal file
View File

@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

61
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_with_all_params.txt Normal file
View File

@ -0,0 +1,61 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

47
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_base_displacement.txt Normal file
View File

@ -0,0 +1,47 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

47
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_outer_displacement.txt Normal file
View File

@ -0,0 +1,47 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

33
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_minimal.txt Normal file
View File

@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

61
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_with_all_params.txt Normal file
View File

@ -0,0 +1,61 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

47
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_base_displacement.txt Normal file
View File

@ -0,0 +1,47 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

47
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_outer_displacement.txt Normal file
View File

@ -0,0 +1,47 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

41
src/test/resources/parser/addressingmodes/memory_indirect_with_all_params.txt Normal file
View File

@ -0,0 +1,41 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

33
src/test/resources/parser/addressingmodes/memory_indirect_without_base_displacement.txt Normal file
View File

@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

33
src/test/resources/parser/addressingmodes/memory_indirect_without_outer_displacement.txt Normal file
View File

@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')

20
src/test/resources/parser/addressingmodes/pc_memory_indirect_minimal.txt Normal file
View File

@ -0,0 +1,20 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

28
src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_minimal.txt Normal file
View File

@ -0,0 +1,28 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

36
src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_with_all_params.txt Normal file
View File

@ -0,0 +1,36 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

33
src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_without_base_displacement.txt Normal file
View File

@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

27
src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_without_outer_displacement.txt Normal file
View File

@ -0,0 +1,27 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

30
src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_minimal.txt Normal file
View File

@ -0,0 +1,30 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

36
src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_with_all_params.txt Normal file
View File

@ -0,0 +1,36 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

31
src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_without_base_displacement.txt Normal file
View File

@ -0,0 +1,31 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

27
src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_without_outer_displacement.txt Normal file
View File

@ -0,0 +1,27 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

26
src/test/resources/parser/addressingmodes/pc_memory_indirect_with_all_params.txt Normal file
View File

@ -0,0 +1,26 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

23
src/test/resources/parser/addressingmodes/pc_memory_indirect_without_base_displacement.txt Normal file
View File

@ -0,0 +1,23 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

23
src/test/resources/parser/addressingmodes/pc_memory_indirect_without_outer_displacement.txt Normal file
View File

@ -0,0 +1,23 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')