Updated dependencies. Tests work again. Cosmetics, fixed warnings.

Fixed condition code for asr/lsr/lsl, which is has a different behaviour for V flag than asl.

README.md

@@ -1,4 +1,4 @@
-# MC68000 Assembly Language Plugin [![Build Status](https://travis-ci.com/chrisly42/mc68000-asm-plugin.svg?branch=main)](https://travis-ci.com/chrisly42/mc68000-asm-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/mc68000-asm-plugin/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/chrisly42/mc68000-asm-plugin?branch=main)
+# MC68000 Assembly Language Plugin [![Build Status](https://app.travis-ci.com/chrisly42/mc68000-asm-plugin.svg?branch=master)](https://app.travis-ci.com/chrisly42/mc68000-asm-plugin)
 
 _MC68000 Assembly Language Plugin_ is plugin for Jetbrains IDEs (CLion, IntelliJ, etc.).
 
@@ -6,16 +6,17 @@ _MC68000 Assembly Language Plugin_ is plugin for Jetbrains IDEs (CLion, IntelliJ
 
 ## Purpose
 
-This plugin delivers support for MC68000 assembly language files ([VAsm](http://sun.hasenbraten.de/vasm/) / DevPac-Style).
+This plugin delivers support for MC680xx assembly language files ([VAsm](http://sun.hasenbraten.de/vasm/) / DevPac-Style).
 
 It adds a language parser with syntax highlighting, referencing and refactoring support, and a few more features.
 
 I'm an Amiga retro democoder (among other things), and the lack of a plugin for M68k was the motivation to write one. Also, diving deep into custom language
 plugins has a steep learning curve.
 
-When I started the plugin in July 2021, I was not aware of the [M68k plugin efforts by Jetbrains employee Yann Cébron](https://github.com/YannCebron/m68kplugin)
+When I started the plugin in July 2021, I was unaware of the [M68k plugin efforts by Jetbrains employee Yann Cébron](https://github.com/YannCebron/m68kplugin)
-who has been working on the same topic for quite some time. At the time of writing, his plugin however, has not been release yet. Nevertheless, it has a lot of
+who has been working on the same topic for quite some time. *On 01-Oct-21, he released
-awesome features and is pretty advanced. Check it out. You can install both plugins at the same time and see what suits you more.
+his [first public version](https://plugins.jetbrains.com/plugin/17712-motorola-68000-series-assembler).* Check it out. You can install both plugins at the same
+time and see what suits you more.
 
 Big kudos to Yann -- a few features were _inspired_ by his code.
 
@@ -24,8 +25,8 @@ to get started, and I can return to demo coding with its current state.
 
 ## Features
 
-- Parser / Lexer for MC68000 (yes, only 68000 right now!) assembly language files in VAsm / DevPac style
+- Parser / Lexer for MC680xx assembly language files in VAsm / DevPac style
-- Validates the assembly syntax against the 68000 ISA.
+- Validates the assembly syntax against the 68000/68010 ISA and 68020+ addressing modes (no complete >68020 support yet!)
 - Syntax highlighting and Color Settings Page (you should really modify the color settings to your likings!)
 - Mnemonics code completion
 - Symbols / labels / macros code completion
@@ -89,9 +90,14 @@ weak warnings as missing macro evaluation will not resolve symbols defined via `
 
 Provides the assigned value of a `=`, `set` or `equ` symbol definition when hovering over a symbol.
 
-#### M68kGlobalLabel
+#### M68kMacroDefinition
 
-Shows the comments above the label and if the first statement after the label is a directive like `include` or `dc.b`, shows it, too.
+When used over a macro invocation, shows the expanded macro contents (only the \1 to \9 and \a to \z are expanded according to the parameters used).
+
+#### M68kLabelDefinition
+
+Shows the comments above the label (local or global) and an end-of-line comment, if available. If the first statement after the label is a directive
+like `include` or `dc.b`, it will be shown, too.
 
 #### M68kRegisterFlow
 
@@ -118,10 +124,14 @@ If the current statement has no valid syntax, the instruction details of all mat
 - `Find Usages` always shows _"Unclassified"_ though it shouldn't (?)
 - `END` detection was breaking parsing, so this is disabled for now until I find a working solution.
 - Macro invocations are not yet evaluated, thus no referencing to symbols defined via macros (e.g. `STRUCT`).
-- Scoping for global symbols and labels is currently the whole project.
+- 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 introduces a comment), this cannot be configured yet (default is off).
+- No support for other processor instructions and FPU. Yet.
-- No support for other processor instructions, FPU or 68020+ address modes.
+- The pretty esoteric use of `ZPC`, `ZA0-ZA7` or `ZSP` for zero (omitted) address in 68020 addressing modes is unsupported.
+- Devpac allowed shuffling of (base) displacement and other parameters inside the new syntax (68020+) brackets. Well, I don't. Only strict `(bd,An,Xn*s)` or
+  `([bd,An],Xn*s,od)` order allowed.
+- Switching the spaces option usually needs the caches to be invalidated. Find Usages word scanner always uses default settings, as it is not configurable per
+  project :-/
 - Unit Test coverage is not as good as it could be (ahem).
 - Missing but planned features:
     - Macro evaluation on invocation
@@ -154,6 +164,23 @@ are appreciated. It really is keeping me motivated to continue development.
 
 ## Changelog
 
+### V0.9 (16-Aug-22)
+
+- Maintenance. Updated all dependencies to the latest versions.
+- Bugfix: Fixed condition code for `asr/lsr/lsl`, which is has a different behaviour for V flag than `asl`.
+- Bugfix: Fixed 'Unknown op size' exception when uppercase sizes were used.
+- Bugfix: Refactoring was broken for newer IDE versions, at least for me, this now works again by unknown magic.
+
+### V0.8 (15-Oct-21)
+
+- New: Support for MC68020+ addressing modes! However, MC68020+ specific instructions have not been added yet.
+- New: Full support for MC68010 ISA (`movec`, `moves` and new special registers `SFC` and `DFC`).
+- Enhancement: Label documentation now also works for local labels and includes end-of-line comment for label, too.
+- Enhancement: Symbol definition documentation now also includes comments in the same way as the label documentation does.
+- New: Macro definition / invocation documentation provider that even tries to expand macros.
+- New: Added Language settings page with one option so far (-spaces option).
+- New: Added some more settings for maximum parsed lines inside a macro and maximum displayed lines of code for documentation.
+
 ### V0.7 (26-Sep-21)
 
 - Bugfix: `btst` with pc-relative and weird immediate mode was missing (courtesy of Yann).

build.gradle

@@ -1,13 +1,13 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '1.1.6'
+    id 'org.jetbrains.intellij' version '1.8.0'
-    id 'org.jetbrains.kotlin.jvm' version '1.5.21'
+    id 'org.jetbrains.kotlin.jvm' version '1.7.10'
     id 'jacoco'
     id 'com.github.kt3k.coveralls' version '2.12.0'
 }
 
 group = 'de.platon42'
-version = '0.7'
+version = '0.9'
 sourceCompatibility = "1.8"
 targetCompatibility = "1.8"
 
@@ -22,11 +22,12 @@ repositories {
 
 dependencies {
     implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
-    testImplementation "org.assertj:assertj-core:3.21.0"
+    testImplementation 'org.assertj:assertj-core:3.23.1'
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
     testImplementation "org.jetbrains.kotlin:kotlin-reflect"
+    testImplementation 'org.junit.platform:junit-platform-launcher:1.9.0'
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
 }
 
@@ -42,32 +43,30 @@ compileTestKotlin {
 }
 
 intellij {
-    setVersion("2021.2.2") // LATEST-EAP-SNAPSHOT
+    setVersion("2022.2") // LATEST-EAP-SNAPSHOT
     setUpdateSinceUntilBuild(false)
 //    setPlugins(["com.intellij.java"])
 }
 
 runPluginVerifier {
-    ideVersions = ["IC-203.6682.168", "IC-212.5284.40", // 2020.3 - 2021.2.2
+    ideVersions = ["IC-203.6682.168", "IC-222.3345.118", // 2020.3 - 2022.2
-                   "CL-203.5981.166", "CL-203.8084.11", // 2020.3
+                   "CL-203.8084.11", // 2020.3
-                   "CL-211.6693.114", "CL-211.7628.27", // 2021.1
+                   "CL-211.7628.27", // 2021.1
-                   "CL-212.4746.93", "CL-212.5284.51"] // 2021.2 - 2021.2.2
+                   "CL-212.5712.21", // 2021.2
+                   "CL-213.7172.20", // 2021.3.4
+                   "CL-221.5080.224", // 2022.1
+                   "CL-222.3345.126"] // 2022.2
     downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
 }
 
 patchPluginXml {
     setChangeNotes("""
-  <p>I still got zero feedback and zero <a href="https://plugins.jetbrains.com/plugin/17268-mc68000-assembly-language-support/reviews">ratings</a> :-(</p>
+  <h4>V0.9 (16-Aug-22)</h4>
-  <h4>V0.7 (26-Sep-21)</h4>
     <ul>
-      <li>Bugfix: 'btst' with pc-relative and weird immediate mode was missing (courtesy of Yann).
+    <li>Maintenance. Updated all dependencies to the latest versions.
-      <li>Bugfix: 'movem' with pc-relative mode was missing for weird immediate mode (courtesy of Yann).
+    <li>Bugfix: Fixed condition code for asr/lsr/lsl, which is has a different behaviour for V flag than asl.
-      <li>Bugfix: Special registers for address mode matching only worked with lower case register names (courtesy of Yann).
+    <li>Bugfix: Fixed 'Unknown op size' exception when uppercase sizes were used.
-      <li>Enhancement: Assembler syntax with implicit immediate 1 for shifts and rotations no longer cause syntax errors (courtesy of Yann).
+    <li>Bugfix: Refactoring was broken for newer IDE versions, at least for me, this now works again by unknown magic.
-      <li>Enhancement: Documentation for instruction with special register shows specific register expected.
-      <li>New: Added documentation provider info for global labels. Shows directives and comments above.
-      <li>Bugfix: Fixed BNF for labels with preprocessor statements.
-      <li>Disabled: 'END' detection was breaking parsing, causing havoc.
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/mc68000-asm-plugin#changelog">Github project site</a>.</p>
 """)
@@ -80,10 +79,17 @@ test {
     testLogging {
         events "passed", "skipped", "failed"
     }
+    runIde {
+        jvmArgs '--add-exports', 'java.base/jdk.internal.vm=ALL-UNNAMED'
+    }
+}
+
+tasks.coveralls {
+    dependsOn jacocoTestReport
 }
 
 jacoco {
-    toolVersion = '0.8.7'
+    toolVersion = '0.8.8'
 }
 
 jacocoTestReport {

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -40,8 +40,10 @@ public class M68kParser implements PsiParser, LightPsiParser {
             create_token_set_(ADDRESS_REGISTER, DATA_REGISTER, REGISTER, SPECIAL_REGISTER),
             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,
+                    ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE, DATA_REGISTER_DIRECT_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,
+                    IMMEDIATE_DATA, 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_BASE_DISPLACEMENT_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,
@@ -210,6 +212,37 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return r;
     }
 
+    /* ********************************************************** */
+    // ROUND_L (internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3)? ROUND_R
+    public static boolean AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode")) return false;
+        if (!nextTokenIsFast(b, ROUND_L)) return false;
+        boolean r;
+        Marker m = enter_section_(b, l, _NONE_, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, "<AddressingMode>");
+        r = consumeTokenFast(b, ROUND_L);
+        r = r && AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1(b, l + 1);
+        r = r && consumeToken(b, ROUND_R);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
+    // (internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3)?
+    private static boolean AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1")) return false;
+        AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1_0(b, l + 1);
+        return true;
+    }
+
+    // internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3
+    private static boolean AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1_0")) return false;
+        boolean r;
+        r = internalBaseDisplacementOption1(b, l + 1);
+        if (!r) r = internalBaseDisplacementOption2(b, l + 1);
+        if (!r) r = internalBaseDisplacementOption3(b, l + 1);
+        return r;
+    }
+
     /* ********************************************************** */
     // ROUND_L (expr SEPARATOR)? AddressRegister SEPARATOR IndexRegister ROUND_R
     public static boolean AddressRegisterIndirectWithIndexNewAddressingMode(PsiBuilder b, int l) {
@@ -294,6 +327,14 @@ public class M68kParser implements PsiParser, LightPsiParser {
     //                 | ProgramCounterIndirectWithDisplacementOldAddressingMode
     //                 | AddressRegisterIndirectWithIndexOldAddressingMode
     //                 | ProgramCounterIndirectWithIndexOldAddressingMode
+    //                 | AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode
+    //                 | ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode
+    //                 | MemoryIndirectAddressingMode
+    //                 | ProgramCounterMemoryIndirectAddressingMode
+    //                 | MemoryIndirectPostIndexedAddressingMode
+    //                 | ProgramCounterMemoryIndirectPostIndexedAddressingMode
+    //                 | MemoryIndirectPreIndexedAddressingMode
+    //                 | ProgramCounterMemoryIndirectPreIndexedAddressingMode
     //                 | SpecialRegisterDirectAddressingMode
     //                 | DataRegisterDirectAddressingMode
     //                 | AddressRegisterDirectAddressingMode
@@ -315,6 +356,14 @@ public class M68kParser implements PsiParser, LightPsiParser {
         if (!r) r = ProgramCounterIndirectWithDisplacementOldAddressingMode(b, l + 1);
         if (!r) r = AddressRegisterIndirectWithIndexOldAddressingMode(b, l + 1);
         if (!r) r = ProgramCounterIndirectWithIndexOldAddressingMode(b, l + 1);
+        if (!r) r = AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(b, l + 1);
+        if (!r) r = ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(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 = SpecialRegisterDirectAddressingMode(b, l + 1);
         if (!r) r = DataRegisterDirectAddressingMode(b, l + 1);
         if (!r) r = AddressRegisterDirectAddressingMode(b, l + 1);
@@ -425,6 +474,25 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return r;
     }
 
+    /* ********************************************************** */
+    // expr DataWidth?
+    public static boolean BaseDisplacement(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "BaseDisplacement")) return false;
+        boolean r;
+        Marker m = enter_section_(b, l, _NONE_, BASE_DISPLACEMENT, "<base displacement>");
+        r = expr(b, l + 1, -1);
+        r = r && BaseDisplacement_1(b, l + 1);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
+    // DataWidth?
+    private static boolean BaseDisplacement_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "BaseDisplacement_1")) return false;
+        DataWidth(b, l + 1);
+        return true;
+    }
+
     /* ********************************************************** */
     // DataRegister | AddressRegister
     static boolean DataOrAddressRegister(PsiBuilder b, int l) {
@@ -532,13 +600,14 @@ public class M68kParser implements PsiParser, LightPsiParser {
     }
 
     /* ********************************************************** */
-    // DataOrAddressRegister DataWidth?
+    // DataOrAddressRegister DataWidth? (OP_AR_MUL IndexScale)?
     public static boolean IndexRegister(PsiBuilder b, int l) {
         if (!recursion_guard_(b, l, "IndexRegister")) return false;
         boolean r;
         Marker m = enter_section_(b, l, _NONE_, INDEX_REGISTER, "<index register>");
         r = DataOrAddressRegister(b, l + 1);
         r = r && IndexRegister_1(b, l + 1);
+        r = r && IndexRegister_2(b, l + 1);
         exit_section_(b, l, m, r, false, null);
         return r;
     }
@@ -550,6 +619,35 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return true;
     }
 
+    // (OP_AR_MUL IndexScale)?
+    private static boolean IndexRegister_2(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "IndexRegister_2")) return false;
+        IndexRegister_2_0(b, l + 1);
+        return true;
+    }
+
+    // OP_AR_MUL IndexScale
+    private static boolean IndexRegister_2_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "IndexRegister_2_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, OP_AR_MUL);
+        r = r && IndexScale(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // expr
+    public static boolean IndexScale(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "IndexScale")) return false;
+        boolean r;
+        Marker m = enter_section_(b, l, _NONE_, INDEX_SCALE, "<scale value>");
+        r = expr(b, l + 1, -1);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
     /* ********************************************************** */
     // AsmInstruction | MacroCall
     static boolean Instruction(PsiBuilder b, int l) {
@@ -764,6 +862,193 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return r;
     }
 
+    /* ********************************************************** */
+    // ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? AddressRegister SQUARE_R (SEPARATOR OuterDisplacement)? 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;
+    }
+
+    // (BaseDisplacement 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;
+    }
+
+    // BaseDisplacement 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 = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR OuterDisplacement)?
+    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 OuterDisplacement
+    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 && OuterDisplacement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // ROUND_L (SQUARE_L (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? 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 (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) 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 (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) 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 && consumeTokens(b, 0, SQUARE_R, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2
+    private static boolean MemoryIndirectPostIndexedAddressingMode_1_0_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1_0_1")) return false;
+        boolean r;
+        r = internalMemoryIndirectPostIndexedOption1(b, l + 1);
+        if (!r) r = internalMemoryIndirectPostIndexedOption2(b, l + 1);
+        return r;
+    }
+
+    // (SEPARATOR OuterDisplacement)?
+    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 OuterDisplacement
+    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 && OuterDisplacement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? 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 && MemoryIndirectPreIndexedAddressingMode_3(b, l + 1);
+        r = r && IndexRegister(b, l + 1);
+        r = r && consumeToken(b, SQUARE_R);
+        r = r && MemoryIndirectPreIndexedAddressingMode_6(b, l + 1);
+        r = r && consumeToken(b, ROUND_R);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
+    // (BaseDisplacement 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;
+    }
+
+    // BaseDisplacement 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 = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (AddressRegister SEPARATOR)?
+    private static boolean MemoryIndirectPreIndexedAddressingMode_3(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_3")) return false;
+        MemoryIndirectPreIndexedAddressingMode_3_0(b, l + 1);
+        return true;
+    }
+
+    // AddressRegister SEPARATOR
+    private static boolean MemoryIndirectPreIndexedAddressingMode_3_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_3_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = AddressRegister(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR OuterDisplacement)?
+    private static boolean MemoryIndirectPreIndexedAddressingMode_6(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_6")) return false;
+        MemoryIndirectPreIndexedAddressingMode_6_0(b, l + 1);
+        return true;
+    }
+
+    // SEPARATOR OuterDisplacement
+    private static boolean MemoryIndirectPreIndexedAddressingMode_6_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_6_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeTokenFast(b, SEPARATOR);
+        r = r && OuterDisplacement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
     /* ********************************************************** */
     // OPSIZE_BS|OPSIZE_W|OPSIZE_L
     public static boolean OperandSize(PsiBuilder b, int l) {
@@ -777,6 +1062,25 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return r;
     }
 
+    /* ********************************************************** */
+    // expr DataWidth?
+    public static boolean OuterDisplacement(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "OuterDisplacement")) return false;
+        boolean r;
+        Marker m = enter_section_(b, l, _NONE_, OUTER_DISPLACEMENT, "<outer displacement>");
+        r = expr(b, l + 1, -1);
+        r = r && OuterDisplacement_1(b, l + 1);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
+    // DataWidth?
+    private static boolean OuterDisplacement_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "OuterDisplacement_1")) return false;
+        DataWidth(b, l + 1);
+        return true;
+    }
+
     /* ********************************************************** */
     // (expr|AddressingMode) (SEPARATOR (expr|AddressingMode))*
     static boolean PlainOperands(PsiBuilder b, int l) {
@@ -949,6 +1253,58 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return r;
     }
 
+    /* ********************************************************** */
+    // ROUND_L (BaseDisplacement SEPARATOR)? PC (SEPARATOR IndexRegister)? ROUND_R
+    public static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode")) return false;
+        if (!nextTokenIsFast(b, ROUND_L)) return false;
+        boolean r;
+        Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, "<AddressingMode>");
+        r = consumeTokenFast(b, ROUND_L);
+        r = r && ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1(b, l + 1);
+        r = r && consumeToken(b, PC);
+        r = r && ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3(b, l + 1);
+        r = r && consumeToken(b, ROUND_R);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
+    // (BaseDisplacement SEPARATOR)?
+    private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1")) return false;
+        ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1_0(b, l + 1);
+        return true;
+    }
+
+    // BaseDisplacement SEPARATOR
+    private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR IndexRegister)?
+    private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3")) return false;
+        ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3_0(b, l + 1);
+        return true;
+    }
+
+    // SEPARATOR IndexRegister
+    private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeTokenFast(b, SEPARATOR);
+        r = r && IndexRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
     /* ********************************************************** */
     // ROUND_L (expr SEPARATOR)? PC SEPARATOR IndexRegister ROUND_R
     public static boolean ProgramCounterIndirectWithIndexNewAddressingMode(PsiBuilder b, int l) {
@@ -1004,6 +1360,183 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return true;
     }
 
+    /* ********************************************************** */
+    // ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R (SEPARATOR OuterDisplacement)? 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;
+    }
+
+    // (BaseDisplacement 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;
+    }
+
+    // BaseDisplacement 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 = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR OuterDisplacement)?
+    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 OuterDisplacement
+    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 && OuterDisplacement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // ROUND_L (SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? 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 (BaseDisplacement 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 (BaseDisplacement 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;
+    }
+
+    // (BaseDisplacement 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;
+    }
+
+    // BaseDisplacement 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 = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR OuterDisplacement)?
+    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 OuterDisplacement
+    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 && OuterDisplacement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SEPARATOR IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? 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;
+    }
+
+    // (BaseDisplacement 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;
+    }
+
+    // BaseDisplacement 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 = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR OuterDisplacement)?
+    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 OuterDisplacement
+    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 && OuterDisplacement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
     /* ********************************************************** */
     // CURRENT_PC_SYMBOL
     public static boolean ProgramCounterReference(PsiBuilder b, int l) {
@@ -1131,7 +1664,7 @@ public class M68kParser implements PsiParser, LightPsiParser {
     }
 
     /* ********************************************************** */
-    // REG_CCR | REG_SR | REG_USP | REG_VBR
+    // REG_CCR | REG_SR | REG_USP | REG_VBR | REG_SFC | REG_DFC
     public static boolean SpecialRegister(PsiBuilder b, int l) {
         if (!recursion_guard_(b, l, "SpecialRegister")) return false;
         boolean r;
@@ -1140,6 +1673,8 @@ public class M68kParser implements PsiParser, LightPsiParser {
         if (!r) r = consumeToken(b, REG_SR);
         if (!r) r = consumeToken(b, REG_USP);
         if (!r) r = consumeToken(b, REG_VBR);
+        if (!r) r = consumeToken(b, REG_SFC);
+        if (!r) r = consumeToken(b, REG_DFC);
         exit_section_(b, l, m, r, false, null);
         return r;
     }
@@ -1179,6 +1714,213 @@ public class M68kParser implements PsiParser, LightPsiParser {
         return r;
     }
 
+    /* ********************************************************** */
+    // (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister
+    static boolean internalBaseDisplacementOption1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption1")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = internalBaseDisplacementOption1_0(b, l + 1);
+        r = r && internalBaseDisplacementOption1_1(b, l + 1);
+        r = r && IndexRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (BaseDisplacement SEPARATOR)?
+    private static boolean internalBaseDisplacementOption1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_0")) return false;
+        internalBaseDisplacementOption1_0_0(b, l + 1);
+        return true;
+    }
+
+    // BaseDisplacement SEPARATOR
+    private static boolean internalBaseDisplacementOption1_0_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_0_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (AddressRegister SEPARATOR)?
+    private static boolean internalBaseDisplacementOption1_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_1")) return false;
+        internalBaseDisplacementOption1_1_0(b, l + 1);
+        return true;
+    }
+
+    // AddressRegister SEPARATOR
+    private static boolean internalBaseDisplacementOption1_1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_1_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = AddressRegister(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // (BaseDisplacement SEPARATOR)? AddressRegister (SEPARATOR IndexRegister)?
+    static boolean internalBaseDisplacementOption2(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption2")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = internalBaseDisplacementOption2_0(b, l + 1);
+        r = r && AddressRegister(b, l + 1);
+        r = r && internalBaseDisplacementOption2_2(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (BaseDisplacement SEPARATOR)?
+    private static boolean internalBaseDisplacementOption2_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_0")) return false;
+        internalBaseDisplacementOption2_0_0(b, l + 1);
+        return true;
+    }
+
+    // BaseDisplacement SEPARATOR
+    private static boolean internalBaseDisplacementOption2_0_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_0_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR IndexRegister)?
+    private static boolean internalBaseDisplacementOption2_2(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_2")) return false;
+        internalBaseDisplacementOption2_2_0(b, l + 1);
+        return true;
+    }
+
+    // SEPARATOR IndexRegister
+    private static boolean internalBaseDisplacementOption2_2_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_2_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, SEPARATOR);
+        r = r && IndexRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // BaseDisplacement (SEPARATOR AddressRegister)? (SEPARATOR IndexRegister)?
+    static boolean internalBaseDisplacementOption3(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption3")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = BaseDisplacement(b, l + 1);
+        r = r && internalBaseDisplacementOption3_1(b, l + 1);
+        r = r && internalBaseDisplacementOption3_2(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR AddressRegister)?
+    private static boolean internalBaseDisplacementOption3_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_1")) return false;
+        internalBaseDisplacementOption3_1_0(b, l + 1);
+        return true;
+    }
+
+    // SEPARATOR AddressRegister
+    private static boolean internalBaseDisplacementOption3_1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_1_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, SEPARATOR);
+        r = r && AddressRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR IndexRegister)?
+    private static boolean internalBaseDisplacementOption3_2(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_2")) return false;
+        internalBaseDisplacementOption3_2_0(b, l + 1);
+        return true;
+    }
+
+    // SEPARATOR IndexRegister
+    private static boolean internalBaseDisplacementOption3_2_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_2_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, SEPARATOR);
+        r = r && IndexRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // (BaseDisplacement SEPARATOR)? AddressRegister
+    static boolean internalMemoryIndirectPostIndexedOption1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption1")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = internalMemoryIndirectPostIndexedOption1_0(b, l + 1);
+        r = r && AddressRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (BaseDisplacement SEPARATOR)?
+    private static boolean internalMemoryIndirectPostIndexedOption1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption1_0")) return false;
+        internalMemoryIndirectPostIndexedOption1_0_0(b, l + 1);
+        return true;
+    }
+
+    // BaseDisplacement SEPARATOR
+    private static boolean internalMemoryIndirectPostIndexedOption1_0_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption1_0_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = BaseDisplacement(b, l + 1);
+        r = r && consumeToken(b, SEPARATOR);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // BaseDisplacement (SEPARATOR AddressRegister)?
+    static boolean internalMemoryIndirectPostIndexedOption2(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption2")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = BaseDisplacement(b, l + 1);
+        r = r && internalMemoryIndirectPostIndexedOption2_1(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // (SEPARATOR AddressRegister)?
+    private static boolean internalMemoryIndirectPostIndexedOption2_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption2_1")) return false;
+        internalMemoryIndirectPostIndexedOption2_1_0(b, l + 1);
+        return true;
+    }
+
+    // SEPARATOR AddressRegister
+    private static boolean internalMemoryIndirectPostIndexedOption2_1_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption2_1_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, SEPARATOR);
+        r = r && AddressRegister(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
     /* ********************************************************** */
     // !<<eof>> (MacroDefinition | statement) (<<eof>>|EOL)
     static boolean line(PsiBuilder b, int l) {

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode.java

@@ -0,0 +1,17 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode extends M68kAddressingMode, M68kWithOptionalAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithOptionalIndexRegister {
+
+    @Nullable
+    M68kAddressRegister getAddressRegister();
+
+    @Nullable
+    M68kIndexRegister getIndexRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kBaseDisplacement.java

@@ -0,0 +1,15 @@
+// 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;
+
+public interface M68kBaseDisplacement extends M68kPsiElement {
+
+    @Nullable
+    M68kDataWidth getDataWidth();
+
+    @NotNull
+    M68kExpr getExpr();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kIndexRegister.java

@@ -9,6 +9,9 @@ public interface M68kIndexRegister extends M68kPsiElement {
     @Nullable
     M68kDataWidth getDataWidth();
 
+    @Nullable
+    M68kIndexScale getIndexScale();
+
     @NotNull
     M68kRegister getRegister();
 

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kIndexScale.java

@@ -0,0 +1,11 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface M68kIndexScale extends M68kPsiElement {
+
+    @NotNull
+    M68kExpr getIndexScale();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectAddressingMode.java

@@ -0,0 +1,18 @@
+// 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;
+
+public interface M68kMemoryIndirectAddressingMode extends M68kAddressingMode, M68kWithAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithOuterDisplacement {
+
+    @NotNull
+    M68kAddressRegister getAddressRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+    @Nullable
+    M68kOuterDisplacement getOuterDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectPostIndexedAddressingMode.java

@@ -0,0 +1,21 @@
+// 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;
+
+public interface M68kMemoryIndirectPostIndexedAddressingMode extends M68kAddressingMode, M68kWithOptionalAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
+
+    @Nullable
+    M68kAddressRegister getAddressRegister();
+
+    @NotNull
+    M68kIndexRegister getIndexRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+    @Nullable
+    M68kOuterDisplacement getOuterDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectPreIndexedAddressingMode.java

@@ -0,0 +1,21 @@
+// 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;
+
+public interface M68kMemoryIndirectPreIndexedAddressingMode extends M68kAddressingMode, M68kWithOptionalAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
+
+    @Nullable
+    M68kAddressRegister getAddressRegister();
+
+    @NotNull
+    M68kIndexRegister getIndexRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+    @Nullable
+    M68kOuterDisplacement getOuterDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kOuterDisplacement.java

@@ -0,0 +1,15 @@
+// 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;
+
+public interface M68kOuterDisplacement extends M68kPsiElement {
+
+    @Nullable
+    M68kDataWidth getDataWidth();
+
+    @NotNull
+    M68kExpr getExpr();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode.java

@@ -0,0 +1,14 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithOptionalIndexRegister {
+
+    @Nullable
+    M68kIndexRegister getIndexRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectAddressingMode.java

@@ -0,0 +1,14 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface M68kProgramCounterMemoryIndirectAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithOuterDisplacement {
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+    @Nullable
+    M68kOuterDisplacement getOuterDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectPostIndexedAddressingMode.java

@@ -0,0 +1,18 @@
+// 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;
+
+public interface M68kProgramCounterMemoryIndirectPostIndexedAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
+
+    @NotNull
+    M68kIndexRegister getIndexRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+    @Nullable
+    M68kOuterDisplacement getOuterDisplacement();
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectPreIndexedAddressingMode.java

@@ -0,0 +1,18 @@
+// 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;
+
+public interface M68kProgramCounterMemoryIndirectPreIndexedAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
+
+    @NotNull
+    M68kIndexRegister getIndexRegister();
+
+    @Nullable
+    M68kBaseDisplacement getBaseDisplacement();
+
+    @Nullable
+    M68kOuterDisplacement getOuterDisplacement();
+
+}

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

@@ -18,12 +18,14 @@ public interface M68kTypes {
     IElementType ADDRESS_REGISTER_INDIRECT_PRE_DEC_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_PRE_DEC_ADDRESSING_MODE");
     IElementType ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE");
     IElementType ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE");
+    IElementType ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE");
     IElementType ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE");
     IElementType ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE");
     IElementType ADDRESS_SIZE = new M68kElementType("ADDRESS_SIZE");
     IElementType ASM_INSTRUCTION = new M68kElementType("ASM_INSTRUCTION");
     IElementType ASM_OP = new M68kElementType("ASM_OP");
     IElementType ASSIGNMENT = new M68kElementType("ASSIGNMENT");
+    IElementType BASE_DISPLACEMENT = new M68kElementType("BASE_DISPLACEMENT");
     IElementType BINARY_ADD_EXPR = new M68kElementType("BINARY_ADD_EXPR");
     IElementType BINARY_BITWISE_AND_EXPR = new M68kElementType("BINARY_BITWISE_AND_EXPR");
     IElementType BINARY_BITWISE_OR_EXPR = new M68kElementType("BINARY_BITWISE_OR_EXPR");
@@ -49,20 +51,29 @@ public interface M68kTypes {
     IElementType GLOBAL_LABEL = M68kStubElementTypeFactory.stubFactory("GLOBAL_LABEL");
     IElementType IMMEDIATE_DATA = new M68kElementType("IMMEDIATE_DATA");
     IElementType INDEX_REGISTER = new M68kElementType("INDEX_REGISTER");
+    IElementType INDEX_SCALE = new M68kElementType("INDEX_SCALE");
     IElementType LITERAL_EXPR = new M68kElementType("LITERAL_EXPR");
     IElementType LOCAL_LABEL = new M68kElementType("LOCAL_LABEL");
     IElementType MACRO_CALL = new M68kElementType("MACRO_CALL");
     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 OUTER_DISPLACEMENT = new M68kElementType("OUTER_DISPLACEMENT");
     IElementType PAREN_EXPR = new M68kElementType("PAREN_EXPR");
     IElementType PREPROCESSOR_DIRECTIVE = new M68kElementType("PREPROCESSOR_DIRECTIVE");
     IElementType PREPROCESSOR_KEYWORD = new M68kElementType("PREPROCESSOR_KEYWORD");
     IElementType PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE");
     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_BASE_DISPLACEMENT_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_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");
@@ -126,6 +137,8 @@ public interface M68kTypes {
     IElementType OTHER_DIRECTIVE = new M68kTokenType("OTHER_DIRECTIVE");
     IElementType PC = new M68kTokenType("PC");
     IElementType REG_CCR = new M68kTokenType("REG_CCR");
+    IElementType REG_DFC = new M68kTokenType("REG_DFC");
+    IElementType REG_SFC = new M68kTokenType("REG_SFC");
     IElementType REG_SP = new M68kTokenType("REG_SP");
     IElementType REG_SR = new M68kTokenType("REG_SR");
     IElementType REG_USP = new M68kTokenType("REG_USP");
@@ -133,6 +146,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");
@@ -156,6 +171,8 @@ public interface M68kTypes {
                 return new M68kAddressRegisterIndirectWithDisplacementNewAddressingModeImpl(node);
             } else if (type == ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE) {
                 return new M68kAddressRegisterIndirectWithDisplacementOldAddressingModeImpl(node);
+            } else if (type == ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE) {
+                return new M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl(node);
             } else if (type == ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE) {
                 return new M68kAddressRegisterIndirectWithIndexNewAddressingModeImpl(node);
             } else if (type == ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE) {
@@ -168,6 +185,8 @@ public interface M68kTypes {
                 return new M68kAsmOpImpl(node);
             } else if (type == ASSIGNMENT) {
                 return new M68kAssignmentImpl(node);
+            } else if (type == BASE_DISPLACEMENT) {
+                return new M68kBaseDisplacementImpl(node);
             } else if (type == BINARY_ADD_EXPR) {
                 return new M68kBinaryAddExprImpl(node);
             } else if (type == BINARY_BITWISE_AND_EXPR) {
@@ -216,6 +235,8 @@ public interface M68kTypes {
                 return new M68kImmediateDataImpl(node);
             } else if (type == INDEX_REGISTER) {
                 return new M68kIndexRegisterImpl(node);
+            } else if (type == INDEX_SCALE) {
+                return new M68kIndexScaleImpl(node);
             } else if (type == LITERAL_EXPR) {
                 return new M68kLiteralExprImpl(node);
             } else if (type == LOCAL_LABEL) {
@@ -228,8 +249,16 @@ 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 == OUTER_DISPLACEMENT) {
+                return new M68kOuterDisplacementImpl(node);
             } else if (type == PAREN_EXPR) {
                 return new M68kParenExprImpl(node);
             } else if (type == PREPROCESSOR_DIRECTIVE) {
@@ -240,10 +269,18 @@ public interface M68kTypes {
                 return new M68kProgramCounterIndirectWithDisplacementNewAddressingModeImpl(node);
             } else if (type == PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE) {
                 return new M68kProgramCounterIndirectWithDisplacementOldAddressingModeImpl(node);
+            } else if (type == PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE) {
+                return new M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(node);
             } else if (type == PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE) {
                 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) {

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

@@ -45,6 +45,13 @@ public class M68kVisitor extends PsiElementVisitor {
         // visitWithDisplacement(o);
     }
 
+    public void visitAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(@NotNull M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode o) {
+        visitAddressingMode(o);
+        // visitWithOptionalAddressRegisterIndirect(o);
+        // visitWithBaseDisplacement(o);
+        // visitWithOptionalIndexRegister(o);
+    }
+
     public void visitAddressRegisterIndirectWithIndexNewAddressingMode(@NotNull M68kAddressRegisterIndirectWithIndexNewAddressingMode o) {
         visitAddressingMode(o);
         // visitWithAddressRegisterIndirect(o);
@@ -79,6 +86,10 @@ public class M68kVisitor extends PsiElementVisitor {
         visitPsiElement(o);
     }
 
+    public void visitBaseDisplacement(@NotNull M68kBaseDisplacement o) {
+        visitPsiElement(o);
+    }
+
     public void visitDataRegister(@NotNull M68kDataRegister o) {
         visitRegister(o);
     }
@@ -103,6 +114,10 @@ public class M68kVisitor extends PsiElementVisitor {
         visitPsiElement(o);
     }
 
+    public void visitIndexScale(@NotNull M68kIndexScale o) {
+        visitPsiElement(o);
+    }
+
     public void visitLocalLabel(@NotNull M68kLocalLabel o) {
         visitNamedElement(o);
     }
@@ -123,10 +138,37 @@ 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);
+        // visitWithOptionalAddressRegisterIndirect(o);
+        // visitWithBaseDisplacement(o);
+        // visitWithIndexRegister(o);
+        // visitWithOuterDisplacement(o);
+    }
+
+    public void visitMemoryIndirectPreIndexedAddressingMode(@NotNull M68kMemoryIndirectPreIndexedAddressingMode o) {
+        visitAddressingMode(o);
+        // visitWithOptionalAddressRegisterIndirect(o);
+        // visitWithBaseDisplacement(o);
+        // visitWithIndexRegister(o);
+        // visitWithOuterDisplacement(o);
+    }
+
     public void visitOperandSize(@NotNull M68kOperandSize o) {
         visitPsiElement(o);
     }
 
+    public void visitOuterDisplacement(@NotNull M68kOuterDisplacement o) {
+        visitPsiElement(o);
+    }
+
     public void visitPreprocessorDirective(@NotNull M68kPreprocessorDirective o) {
         visitPsiElement(o);
     }
@@ -145,6 +187,12 @@ public class M68kVisitor extends PsiElementVisitor {
         // visitWithDisplacement(o);
     }
 
+    public void visitProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(@NotNull M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode o) {
+        visitAddressingMode(o);
+        // visitWithBaseDisplacement(o);
+        // visitWithOptionalIndexRegister(o);
+    }
+
     public void visitProgramCounterIndirectWithIndexNewAddressingMode(@NotNull M68kProgramCounterIndirectWithIndexNewAddressingMode o) {
         visitAddressingMode(o);
         // visitWithDisplacement(o);
@@ -157,6 +205,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);
     }

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl.java

@@ -0,0 +1,46 @@
+// 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;
+
+public class M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl extends M68kAddressingModeImpl implements M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode {
+
+    public M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(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
+    @Nullable
+    public M68kIndexRegister getIndexRegister() {
+        return PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kBaseDisplacementImpl.java

@@ -0,0 +1,43 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi.impl;
+
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import de.platon42.intellij.plugins.m68k.psi.M68kBaseDisplacement;
+import de.platon42.intellij.plugins.m68k.psi.M68kDataWidth;
+import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class M68kBaseDisplacementImpl extends ASTWrapperPsiElement implements M68kBaseDisplacement {
+
+    public M68kBaseDisplacementImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitBaseDisplacement(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+    @Override
+    @Nullable
+    public M68kDataWidth getDataWidth() {
+        return PsiTreeUtil.getChildOfType(this, M68kDataWidth.class);
+    }
+
+    @Override
+    @NotNull
+    public M68kExpr getExpr() {
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kExpr.class));
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kGlobalLabelImpl.java

@@ -19,8 +19,8 @@ public class M68kGlobalLabelImpl extends M68kGlobalLabelMixin implements M68kGlo
         super(node);
     }
 
-    public M68kGlobalLabelImpl(@NotNull M68kGlobalLabelStub stub, @NotNull IStubElementType<?, ?> nodeType) {
+    public M68kGlobalLabelImpl(@NotNull M68kGlobalLabelStub stub, @NotNull IStubElementType<?, ?> type) {
-        super(stub, nodeType);
+        super(stub, type);
     }
 
     public void accept(@NotNull M68kVisitor visitor) {

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kIndexRegisterImpl.java

@@ -31,6 +31,12 @@ public class M68kIndexRegisterImpl extends ASTWrapperPsiElement implements M68kI
         return PsiTreeUtil.getChildOfType(this, M68kDataWidth.class);
     }
 
+    @Override
+    @Nullable
+    public M68kIndexScale getIndexScale() {
+        return PsiTreeUtil.getChildOfType(this, M68kIndexScale.class);
+    }
+
     @Override
     @NotNull
     public M68kRegister getRegister() {

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kIndexScaleImpl.java

@@ -0,0 +1,35 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi.impl;
+
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+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.M68kIndexScale;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+
+public class M68kIndexScaleImpl extends ASTWrapperPsiElement implements M68kIndexScale {
+
+    public M68kIndexScaleImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitIndexScale(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+    @Override
+    @NotNull
+    public M68kExpr getIndexScale() {
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kExpr.class));
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMacroDefinitionImpl.java

@@ -19,8 +19,8 @@ public class M68kMacroDefinitionImpl extends M68kMacroDefinitionMixin implements
         super(node);
     }
 
-    public M68kMacroDefinitionImpl(@NotNull M68kMacroDefinitionStub stub, @NotNull IStubElementType<?, ?> nodeType) {
+    public M68kMacroDefinitionImpl(@NotNull M68kMacroDefinitionStub stub, @NotNull IStubElementType<?, ?> type) {
-        super(stub, nodeType);
+        super(stub, type);
     }
 
     public void accept(@NotNull M68kVisitor visitor) {

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectAddressingModeImpl.java

@@ -0,0 +1,46 @@
+// 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;
+
+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
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kOuterDisplacement getOuterDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectPostIndexedAddressingModeImpl.java

@@ -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.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+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
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kOuterDisplacement getOuterDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectPreIndexedAddressingModeImpl.java

@@ -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.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+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
+    @Nullable
+    public M68kAddressRegister getAddressRegister() {
+        return PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class);
+    }
+
+    @Override
+    @NotNull
+    public M68kIndexRegister getIndexRegister() {
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
+    }
+
+    @Override
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kOuterDisplacement getOuterDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kOuterDisplacementImpl.java

@@ -0,0 +1,43 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi.impl;
+
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import de.platon42.intellij.plugins.m68k.psi.M68kDataWidth;
+import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
+import de.platon42.intellij.plugins.m68k.psi.M68kOuterDisplacement;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class M68kOuterDisplacementImpl extends ASTWrapperPsiElement implements M68kOuterDisplacement {
+
+    public M68kOuterDisplacementImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitOuterDisplacement(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+    @Override
+    @Nullable
+    public M68kDataWidth getDataWidth() {
+        return PsiTreeUtil.getChildOfType(this, M68kDataWidth.class);
+    }
+
+    @Override
+    @NotNull
+    public M68kExpr getExpr() {
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kExpr.class));
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl.java

@@ -0,0 +1,43 @@
+// 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.M68kBaseDisplacement;
+import de.platon42.intellij.plugins.m68k.psi.M68kIndexRegister;
+import de.platon42.intellij.plugins.m68k.psi.M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode {
+
+    public M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+    @Override
+    @Nullable
+    public M68kIndexRegister getIndexRegister() {
+        return PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectAddressingModeImpl.java

@@ -0,0 +1,43 @@
+// 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.M68kBaseDisplacement;
+import de.platon42.intellij.plugins.m68k.psi.M68kOuterDisplacement;
+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;
+
+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
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kOuterDisplacement getOuterDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl.java

@@ -0,0 +1,46 @@
+// 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;
+
+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
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kOuterDisplacement getOuterDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl.java

@@ -0,0 +1,46 @@
+// 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;
+
+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
+    @Nullable
+    public M68kBaseDisplacement getBaseDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
+    }
+
+    @Override
+    @Nullable
+    public M68kOuterDisplacement getOuterDisplacement() {
+        return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
+    }
+
+}

src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kSymbolDefinitionImpl.java

@@ -19,8 +19,8 @@ public class M68kSymbolDefinitionImpl extends M68kSymbolDefinitionMixin implemen
         super(node);
     }
 
-    public M68kSymbolDefinitionImpl(@NotNull M68kSymbolDefinitionStub stub, @NotNull IStubElementType<?, ?> nodeType) {
+    public M68kSymbolDefinitionImpl(@NotNull M68kSymbolDefinitionStub stub, @NotNull IStubElementType<?, ?> type) {
-        super(stub, nodeType);
+        super(stub, type);
     }
 
     public void accept(@NotNull M68kVisitor visitor) {

src/main/java/de/platon42/intellij/plugins/m68k/M68kFileElementType.kt

@@ -10,7 +10,7 @@ class M68kFileElementType private constructor() : ILightStubFileElementType<PsiF
         @JvmField
         val INSTANCE = M68kFileElementType()
 
-        const val STUB_VERSION = 6
+        const val STUB_VERSION = 7
         const val STUB_EXTERNAL_ID_PREFIX = "MC68000."
         const val EXTERNAL_ID = STUB_EXTERNAL_ID_PREFIX + "FILE"
     }

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

@@ -1,5 +1,7 @@
 package de.platon42.intellij.plugins.m68k.asm
 
+import java.util.*
+
 enum class Machine {
     MC68000,
     MC68010,
@@ -9,6 +11,10 @@ enum class Machine {
     MC68060
 }
 
+private val MC68000_ONLY = EnumSet.of(Machine.MC68000)
+private val MC68020_PLUS = EnumSet.range(Machine.MC68020, Machine.MC68060)
+private val ALL_MACHINES = EnumSet.allOf(Machine::class.java)
+
 enum class Register(val regname: String, val num: Int) {
     D0("d0", 0),
     D1("d1", 1),
@@ -43,7 +49,17 @@ enum class AddressMode(val description: String, val syntax: String) {
     ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT("address register indirect with displacement", "(d16,An)"),
     PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT("program counter indirect with displacement", "(d16,PC)"),
     ADDRESS_REGISTER_INDIRECT_WITH_INDEX("address register indirect with index", "(d8,An,Xn)"),
+    ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX("address register indirect with scaled index", "(d8,An,Xn*s)"),
+    ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT("address register indirect with index (base displacement)", "(bd,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)"),
+    PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT("program counter indirect with index (base displacement)", "(bd,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>"),
@@ -128,7 +144,7 @@ data class AllowedAdrMode(
 data class IsaData(
     val mnemonic: String,
     val description: String,
-    val machine: Set<Machine> = setOf(Machine.MC68000),
+    val machine: Set<Machine> = MC68000_ONLY,
     val altMnemonics: List<String> = emptyList(),
     val conditionCodes: List<String> = emptyList(),
     val id: String = mnemonic,
@@ -156,6 +172,21 @@ object M68kIsa {
         AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX,
     )
 
+    private val ALL_68020_MODES = ALL_68000_MODES.plus(
+        setOf(
+            AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX,
+            AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT,
+            AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX,
+            AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT,
+            AddressMode.MEMORY_INDIRECT,
+            AddressMode.MEMORY_INDIRECT_POSTINDEXED,
+            AddressMode.MEMORY_INDIRECT_PREINDEXED,
+            AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT,
+            AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED,
+            AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED
+        )
+    )
+
     private val ALL_EXCEPT_IMMEDIATE_AND_PC_REL = setOf(
         AddressMode.DATA_REGISTER_DIRECT,
         AddressMode.ADDRESS_REGISTER_DIRECT,
@@ -167,6 +198,16 @@ object M68kIsa {
         AddressMode.ABSOLUTE_ADDRESS
     )
 
+    private val ALL_68020_MODES_EXCEPT_IMMEDIATE_AND_PC_REL = ALL_EXCEPT_IMMEDIATE_AND_PC_REL.plus(
+        setOf(
+            AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX,
+            AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT,
+            AddressMode.MEMORY_INDIRECT,
+            AddressMode.MEMORY_INDIRECT_POSTINDEXED,
+            AddressMode.MEMORY_INDIRECT_PREINDEXED,
+        )
+    )
+
     private val ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL = setOf(
         AddressMode.DATA_REGISTER_DIRECT,
         AddressMode.ADDRESS_REGISTER_INDIRECT,
@@ -225,6 +266,7 @@ object M68kIsa {
 
     private val AREG_ONLY = setOf(AddressMode.ADDRESS_REGISTER_DIRECT)
     private val DREG_ONLY = setOf(AddressMode.DATA_REGISTER_DIRECT)
+    private val DREG_AREG = setOf(AddressMode.ADDRESS_REGISTER_DIRECT, AddressMode.DATA_REGISTER_DIRECT)
 
     private val ADD_SUB_MODES = listOf(
         AllowedAdrMode(
@@ -265,7 +307,7 @@ object M68kIsa {
         )
     )
 
-    private val ASD_LSD_MODES = listOf(
+    private val ASL_MODES = listOf(
         AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("*****")),
         AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("*****")),
         AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****")),
@@ -273,6 +315,14 @@ object M68kIsa {
         AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****"))
     )
 
+    private val ASR_LSD_MODES = listOf(
+        AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*")),
+        AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*")),
+        AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*")),
+        // not an official address mode, but supported by assembler (implicit #1)
+        AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"))
+    )
+
     private val ROD_MODES = listOf(
         AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**0*")),
         AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**0*")),
@@ -311,6 +361,9 @@ object M68kIsa {
     private val isaData = listOf(
 
         // Data Movement Instructions
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData(
                 "move", "Move",
                 modes = listOf(
@@ -320,12 +373,16 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "movea", "Move Address", altMnemonics = listOf("move"),
                 modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_SET_OP2_L))
+            )
         ),
+
         IsaData(
             "movem", "Move Multiple Registers",
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.REGISTER_LIST, AddressMode.ADDRESS_REGISTER_DIRECT, AddressMode.DATA_REGISTER_DIRECT),
@@ -382,8 +439,10 @@ object M68kIsa {
                 ),
             )
         ),
+
         IsaData(
             "movep", "Move Peripheral",
+            machine = EnumSet.range(Machine.MC68000, Machine.MC68040),
             modes = listOf(
                 AllowedAdrMode(
                     DREG_ONLY,
@@ -402,11 +461,13 @@ object M68kIsa {
 
         IsaData(
             "moveq", "Move Quick",
+            machine = ALL_MACHINES,
             modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, OP_SIZE_L, modInfo = RWM_SET_OP2_L, affectedCc = cc("-**00")))
         ),
 
         IsaData(
             "exg", "Exchange Registers",
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.DATA_REGISTER_DIRECT, AddressMode.ADDRESS_REGISTER_DIRECT),
@@ -416,6 +477,10 @@ object M68kIsa {
                 )
             )
         ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData(
                 "lea", "Load Effective Address",
                 modes = listOf(
@@ -434,6 +499,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "pea", "Push Effective Address",
                 modes = listOf(
@@ -451,22 +517,32 @@ object M68kIsa {
                         modInfo = RWM_MODIFY_STACK
                     )
                 )
+            )
         ),
+
         IsaData(
             "link", "Link and Allocate",
+            machine = ALL_MACHINES,
             modes = listOf(AllowedAdrMode(AREG_ONLY, setOf(AddressMode.IMMEDIATE_DATA), OP_SIZE_W, modInfo = RWM_SET_OP1_L or RWM_MODIFY_STACK))
         ),
+
         IsaData(
             "unlk", "Unlink",
+            machine = ALL_MACHINES,
             modes = listOf(AllowedAdrMode(AREG_ONLY, null, OP_UNSIZED, modInfo = RWM_SET_OP1_L or RWM_MODIFY_STACK))
         ),
 
         // Integer Arithmetic Instructions
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData("add", "Add", modes = ADD_SUB_MODES),
+
             IsaData(
                 "adda", "Add Address", altMnemonics = listOf("add"),
                 modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_L))
             ),
+
             IsaData(
                 "addi", "Add Immediate", altMnemonics = listOf("add"),
                 modes = listOf(
@@ -475,14 +551,22 @@ object M68kIsa {
                     )
                 )
             ),
-        IsaData("addq", "Add Quick", modes = ADDQ_SUBQ_MODES),
+
-        IsaData("addx", "Add with Extend", modes = ADDX_SUBX_MODES),
+            IsaData("addq", "Add Quick", modes = ADDQ_SUBQ_MODES)
+        ),
+
+        IsaData("addx", "Add with Extend", machine = ALL_MACHINES, modes = ADDX_SUBX_MODES),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
 
             IsaData("sub", "Subtract", modes = ADD_SUB_MODES),
+
             IsaData(
                 "suba", "Subtract Address", altMnemonics = listOf("sub"),
                 modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_L))
             ),
+
             IsaData(
                 "subi", "Subtract Immediate", altMnemonics = listOf("sub"),
                 modes = listOf(
@@ -491,8 +575,14 @@ object M68kIsa {
                     )
                 )
             ),
-        IsaData("subq", "Subtract Quick", modes = ADDQ_SUBQ_MODES),
+
-        IsaData("subx", "Subtract with Extend", modes = ADDX_SUBX_MODES),
+            IsaData("subq", "Subtract Quick", modes = ADDQ_SUBQ_MODES)
+        ),
+
+        IsaData("subx", "Subtract with Extend", machine = ALL_MACHINES, modes = ADDX_SUBX_MODES),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
 
             IsaData(
                 "neg", "Negate", modes = listOf(
@@ -502,6 +592,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "negx", "Negate with Extend", modes = listOf(
                     AllowedAdrMode(
@@ -534,10 +625,20 @@ object M68kIsa {
                     ),
                 )
             ),
+
             IsaData(
                 "cmpa", "Compare Address", altMnemonics = listOf("cmp"),
-            modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_READ_OP2_L, affectedCc = cc("-****")))
+                modes = listOf(
+                    AllowedAdrMode(
+                        ALL_68000_MODES,
+                        AREG_ONLY,
+                        OP_SIZE_WL,
+                        modInfo = RWM_READ_OP1_OPSIZE or RWM_READ_OP2_L,
+                        affectedCc = cc("-****")
+                    )
+                )
             ),
+
             IsaData(
                 "cmpi", "Compare Immediate", altMnemonics = listOf("cmp"),
                 modes = listOf(
@@ -546,9 +647,12 @@ object M68kIsa {
                         affectedCc = cc("-****")
                     )
                 )
+            )
         ),
+
         IsaData(
             "cmpm", "Compare Memory to Memory", altMnemonics = listOf("cmp"),
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC),
@@ -559,26 +663,41 @@ object M68kIsa {
             )
         ),
 
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData(
                 "muls", "Signed Multiply",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_W or RWM_MODIFY_OP2_L, affectedCc = cc("-**00")))
             ),
+
             IsaData(
                 "mulu", "Unsigned Multiply",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_W or RWM_MODIFY_OP2_L, affectedCc = cc("-**00")))
             ),
+
             IsaData(
                 "divs", "Signed Divide",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_L or RWM_MODIFY_OP2_L, affectedCc = cc("-***0")))
             ),
+
             IsaData(
                 "divu", "Unsigned Divide",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_L or RWM_MODIFY_OP2_L, affectedCc = cc("-***0")))
             ),
+        ),
 
-        IsaData("ext", "Sign Extend", modes = listOf(AllowedAdrMode(DREG_ONLY, null, OP_SIZE_WL, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**00")))),
+        IsaData(
+            "ext",
+            "Sign Extend",
+            machine = ALL_MACHINES,
+            modes = listOf(AllowedAdrMode(DREG_ONLY, null, OP_SIZE_WL, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**00")))
+        ),
 
         // Logical Instructions
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData(
                 "and", "Logical AND",
                 modes = listOf(
@@ -586,6 +705,7 @@ object M68kIsa {
                     AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**00"))
                 )
             ),
+
             IsaData(
                 "andi", "Logical AND Immediate",
                 altMnemonics = listOf("and"),
@@ -598,6 +718,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "eor", "Logical Exclusive-OR",
                 modes = listOf(
@@ -609,6 +730,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "eori", "Logical Exclusive-OR Immediate", altMnemonics = listOf("eor"),
                 modes = listOf(
@@ -620,6 +742,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "or", "Logical Inclusive-OR",
                 modes = listOf(
@@ -627,6 +750,7 @@ object M68kIsa {
                     AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**00"))
                 )
             ),
+
             IsaData(
                 "ori", "Logical Inclusive-OR Immediate", altMnemonics = listOf("or"),
                 modes = listOf(
@@ -638,20 +762,23 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "not", "Logical Complement",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**00")))
             ),
 
             // Shift and Rotate Instructions
-        IsaData("asl", "Arithmetic Shift Left", modes = ASD_LSD_MODES),
+            IsaData("asl", "Arithmetic Shift Left", modes = ASL_MODES),
-        IsaData("asr", "Arithmetic Shift Right", modes = ASD_LSD_MODES),
+            IsaData("asr", "Arithmetic Shift Right", modes = ASR_LSD_MODES),
-        IsaData("lsl", "Logical Shift Left", modes = ASD_LSD_MODES),
+            IsaData("lsl", "Logical Shift Left", modes = ASR_LSD_MODES),
-        IsaData("lsr", "Logical Shift Right", modes = ASD_LSD_MODES),
+            IsaData("lsr", "Logical Shift Right", modes = ASR_LSD_MODES),
             IsaData("rol", "Rotate Left", modes = ROD_MODES),
             IsaData("ror", "Rotate Right", modes = ROD_MODES),
             IsaData("roxl", "Rotate with Extend Left", modes = ROXD_MODES),
             IsaData("roxr", "Rotate with Extend Right", modes = ROXD_MODES),
+        ),
+
         IsaData(
             "swap",
             "Swap Register Words",
@@ -659,14 +786,19 @@ object M68kIsa {
         ),
 
         // Bit Manipulation Instructions
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData("bchg", "Test Bit and Change", modes = BCHG_BCLR_BSET_MODES),
             IsaData("bclr", "Test Bit and Clear", modes = BCHG_BCLR_BSET_MODES),
             IsaData("bset", "Test Bit and Set", modes = BCHG_BCLR_BSET_MODES),
             IsaData("btst", "Test Bit", modes = BTST_MODES),
+        ),
 
         // Binary-Coded Decimal Instructions
         IsaData(
             "abcd", "Add Decimal with Extend",
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     DREG_ONLY, DREG_ONLY, OP_SIZE_B, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE,
@@ -683,6 +815,7 @@ object M68kIsa {
         ),
         IsaData(
             "sbcd", "Subtract Decimal with Extend",
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     DREG_ONLY, DREG_ONLY, OP_SIZE_B, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE,
@@ -697,6 +830,9 @@ object M68kIsa {
                 )
             )
         ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData(
                 "nbcd", "Negate Decimal with Extend",
                 modes = listOf(
@@ -705,6 +841,7 @@ object M68kIsa {
                         affectedCc = cc("CUAU*"), testedCc = cc("?-?--")
                     )
                 )
+            )
         ),
 
         // Program Control Instructions
@@ -733,6 +870,10 @@ object M68kIsa {
             modes = listOf(AllowedAdrMode(DREG_ONLY, setOf(AddressMode.ABSOLUTE_ADDRESS), OP_SIZE_W, modInfo = RWM_MODIFY_OP1_W, testedCc = cc("-????"))),
             changesControlFlow = true
         ),
+
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData(
                 "sCC", "Set Conditionally", conditionCodes = conditionCodes,
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL, null, OP_SIZE_B, modInfo = RWM_SET_OP2_B, testedCc = cc("-????")))
@@ -769,24 +910,30 @@ object M68kIsa {
                     )
                 ),
                 changesControlFlow = true
+            )
         ),
-        IsaData("nop", "No Operation", hasOps = false, modes = NO_OPS_UNSIZED),
+
+        IsaData("nop", "No Operation", machine = ALL_MACHINES, hasOps = false, modes = NO_OPS_UNSIZED),
 
         IsaData(
             "rtr",
             "Return and Restore",
+            machine = ALL_MACHINES,
             hasOps = false,
             modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK, affectedCc = cc("*****"))),
             changesControlFlow = true
         ),
         IsaData(
             "rts", "Return from Subroutine", hasOps = false,
+            machine = ALL_MACHINES,
             modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK)),
             changesControlFlow = true
         ),
 
         IsaData(
-            "tst", "Test Operand", modes = listOf(
+            "tst", "Test Operand",
+            machine = MC68000_ONLY,
+            modes = listOf(
                 AllowedAdrMode(
                     ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL, null, modInfo = RWM_READ_OP1_OPSIZE,
                     affectedCc = cc("-**00")
@@ -794,9 +941,25 @@ object M68kIsa {
             )
         ),
 
+        IsaData(
+            "tst", "Test Operand",
+            machine = MC68020_PLUS,
+            modes = listOf(
+                AllowedAdrMode(
+                    ALL_68020_MODES.minus(AddressMode.ADDRESS_REGISTER_DIRECT), null, modInfo = RWM_READ_OP1_OPSIZE,
+                    affectedCc = cc("-**00")
+                ),
+                AllowedAdrMode(
+                    setOf(AddressMode.ADDRESS_REGISTER_DIRECT), null, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE,
+                    affectedCc = cc("-**00")
+                ),
+            )
+        ),
+
         // System Control Instructions
         IsaData(
             "andi", "AND Immediate to Status Register", id = "andi to SR", altMnemonics = listOf("and"), isPrivileged = true,
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.IMMEDIATE_DATA), setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "sr",
@@ -806,6 +969,7 @@ object M68kIsa {
         ),
         IsaData(
             "eori", "Exclusive-OR Immediate to Status Register", id = "eori to SR", altMnemonics = listOf("eor"), isPrivileged = true,
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.IMMEDIATE_DATA), setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "sr",
@@ -815,6 +979,7 @@ object M68kIsa {
         ),
         IsaData(
             "ori", "Inclusive-OR Immediate to Status Register", id = "ori to SR", altMnemonics = listOf("or"), isPrivileged = true,
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.IMMEDIATE_DATA), setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "sr",
@@ -822,8 +987,10 @@ object M68kIsa {
                 )
             )
         ),
+
         IsaData(
             "move", "Move from Status Register", id = "move from SR",
+            machine = MC68000_ONLY,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
@@ -835,6 +1002,25 @@ object M68kIsa {
                 )
             )
         ),
+
+        IsaData(
+            "move", "Move from Status Register", id = "move from SR", isPrivileged = true,
+            machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
+            modes = listOf(
+                AllowedAdrMode(
+                    setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
+                    ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL,
+                    OP_SIZE_W,
+                    "sr",
+                    modInfo = RWM_SET_OP2_W,
+                    testedCc = cc("?????")
+                )
+            )
+        ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData(
                 "move", "Move to Status Register", id = "move to SR", isPrivileged = true,
                 modes = listOf(
@@ -843,34 +1029,85 @@ object M68kIsa {
                         affectedCc = cc("*****")
                     )
                 )
+            )
         ),
+
         IsaData(
             "move", "Move User Stack Pointer", id = "move USP", isPrivileged = true,
+            machine = ALL_MACHINES,
             modes = listOf(
                 AllowedAdrMode(setOf(AddressMode.SPECIAL_REGISTER_DIRECT), AREG_ONLY, OP_SIZE_L, "usp", modInfo = RWM_SET_OP2_L),
                 AllowedAdrMode(AREG_ONLY, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_L, "usp", modInfo = RWM_READ_OP1_L),
             )
         ),
 
-        IsaData("reset", "Reset External Devices", isPrivileged = true, hasOps = false, modes = NO_OPS_UNSIZED),
         IsaData(
-            "rte", "Return from Exception", isPrivileged = true, hasOps = false,
+            "movec", "Move Control Register", isPrivileged = true,
-            modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK)),
+            machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
-            changesControlFlow = true
+            modes = listOf(
-        ),
+                AllowedAdrMode(setOf(AddressMode.SPECIAL_REGISTER_DIRECT), DREG_AREG, OP_SIZE_L, "sfc|dfc|usp|vbr", modInfo = RWM_SET_OP2_L),
-        IsaData(
+                AllowedAdrMode(DREG_AREG, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_L, "sfc|dfc|usp|vbr", modInfo = RWM_READ_OP1_L),
-            "stop", "Stop", isPrivileged = true,
+            )
-            modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED))
         ),
 
+        IsaData(
+            "moves", "Move Address Space", isPrivileged = true,
+            machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
+            modes = listOf(
+                AllowedAdrMode(
+                    ALL_68020_MODES_EXCEPT_IMMEDIATE_AND_PC_REL.minus(
+                        listOf(
+                            AddressMode.DATA_REGISTER_DIRECT,
+                            AddressMode.ADDRESS_REGISTER_DIRECT
+                        )
+                    ), DREG_AREG, modInfo = RWM_SET_OP2_OPSIZE
+                ),
+                AllowedAdrMode(
+                    DREG_AREG, ALL_68020_MODES_EXCEPT_IMMEDIATE_AND_PC_REL.minus(
+                        listOf(
+                            AddressMode.DATA_REGISTER_DIRECT,
+                            AddressMode.ADDRESS_REGISTER_DIRECT
+                        )
+                    ), modInfo = RWM_READ_OP1_OPSIZE
+                )
+            )
+        ),
+
+        IsaData("reset", "Reset External Devices", machine = ALL_MACHINES, isPrivileged = true, hasOps = false, modes = NO_OPS_UNSIZED),
+
+        IsaData(
+            "rte", "Return from Exception",
+            machine = ALL_MACHINES, isPrivileged = true, hasOps = false,
+            modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK)),
+            changesControlFlow = true
+        ),
+
+        IsaData(
+            "stop", "Stop",
+            machine = ALL_MACHINES, isPrivileged = true,
+            modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED))
+        ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData(
                 "chk", "Check Register Against Bound",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_W or RWM_READ_OP2_W, affectedCc = cc("-*UUU")))
+            )
         ),
-        IsaData("illegal", "Take Illegal Instruction Trap", hasOps = false, modes = NO_OPS_UNSIZED, changesControlFlow = true),
+
-        IsaData("trap", "Trap", modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED)), changesControlFlow = true),
+        IsaData("illegal", "Take Illegal Instruction Trap", machine = ALL_MACHINES, hasOps = false, modes = NO_OPS_UNSIZED, changesControlFlow = true),
+
         IsaData(
-            "trapv", "Trap on Overflow", hasOps = false,
+            "trap",
+            "Trap",
+            machine = ALL_MACHINES,
+            modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED)),
+            changesControlFlow = true
+        ),
+        IsaData(
+            "trapv", "Trap on Overflow",
+            machine = ALL_MACHINES, hasOps = false,
             modes = listOf(AllowedAdrMode(size = OP_UNSIZED, testedCc = cc("---?-"))),
             changesControlFlow = true
         ),
@@ -902,19 +1139,72 @@ object M68kIsa {
                 )
             )
         ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
+            IsaData(
+                "move", "Move from Condition Code Register", id = "move from CCR",
+                machine = EnumSet.of(Machine.MC68010),
+                modes = listOf(
+                    AllowedAdrMode(
+                        setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
+                        ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL,
+                        OP_SIZE_W,
+                        "ccr",
+                        modInfo = RWM_SET_OP2_W,
+                        testedCc = cc("?????")
+                    )
+                )
+            ),
+
             IsaData(
                 "move", "Move to Condition Code Register", id = "move to CCR",
                 modes = listOf(
                     AllowedAdrMode(ALL_EXCEPT_AREG, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "ccr", affectedCc = cc("*****")),
                 )
+            )
         ),
 
         // Multiprocessor Instructions
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData(
                 "tas", "Test Operand and Set",
                 modes = listOf(AllowedAdrMode(ALL_EXCEPT_IMMEDIATE_AND_PC_REL, null, OP_SIZE_B, modInfo = RWM_MODIFY_OP1_B, affectedCc = cc("-**00")))
             )
         )
+    )
+
+    private fun autoExpandForOtherCpus(machines: Set<Machine>, vararg isaDatas: IsaData): Array<out IsaData> {
+        val allIsaData = ArrayList<IsaData>()
+        for (isaData in isaDatas) {
+            val newModes = isaData.modes.map { it.copy(op1 = add68020Modes(it.op1), op2 = add68020Modes(it.op2)) }
+            allIsaData.add(isaData.copy(machine = machines, modes = newModes))
+        }
+        return allIsaData.toTypedArray()
+    }
+
+    private fun add68020Modes(oldModes: Set<AddressMode>?) = if (oldModes != null) {
+        val newModes = oldModes.toMutableSet()
+        if (oldModes.contains(AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX)) {
+            newModes.add(AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX)
+            newModes.add(AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT)
+            newModes.add(AddressMode.MEMORY_INDIRECT)
+            newModes.add(AddressMode.MEMORY_INDIRECT_POSTINDEXED)
+            newModes.add(AddressMode.MEMORY_INDIRECT_PREINDEXED)
+        }
+        if (oldModes.contains(AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX)) {
+            newModes.add(AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX)
+            newModes.add(AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT)
+            newModes.add(AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT)
+            newModes.add(AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED)
+            newModes.add(AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED)
+        }
+        newModes
+    } else {
+        null
+    }
 
     private val mnemonicLookupMap = isaData.asSequence()
         .flatMap {
@@ -964,5 +1254,5 @@ object M68kIsa {
     private fun isAddressModeMatching(am: AllowedAdrMode, op1: AddressMode?, op2: AddressMode?, specialReg: String?) =
         ((((op1 == null) && (am.op1 == null)) || am.op1?.contains(op1) ?: false)
                 && (((op2 == null) && (am.op2 == null)) || am.op2?.contains(op2) ?: false)
-                && ((specialReg == null) || (specialReg.equals(am.specialReg, true))))
+                && ((specialReg == null) || (am.specialReg?.split('|')?.any { it.equals(specialReg, true) } ?: false)))
 }

src/main/java/de/platon42/intellij/plugins/m68k/documentation/AbstractM68kDocumentationProvider.kt

@@ -0,0 +1,39 @@
+package de.platon42.intellij.plugins.m68k.documentation
+
+import com.intellij.lang.documentation.AbstractDocumentationProvider
+import com.intellij.lang.documentation.DocumentationMarkup
+import com.intellij.openapi.util.text.HtmlBuilder
+import com.intellij.openapi.util.text.HtmlChunk
+import com.intellij.psi.PsiElement
+import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
+import de.platon42.intellij.plugins.m68k.psi.M68kNamedElement
+import de.platon42.intellij.plugins.m68k.psi.utils.M68kPsiWalkUtil
+import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
+
+abstract class AbstractM68kDocumentationProvider : AbstractDocumentationProvider() {
+
+    fun getSettings(element: PsiElement): M68kLexerPrefs = element.project.getService(M68kProjectSettings::class.java).settings
+
+    fun getComments(element: PsiElement): HtmlChunk {
+        val builder = HtmlBuilder()
+        val comments = M68kPsiWalkUtil.collectRelatedComments(element).map { HtmlChunk.text(it.text) }
+        builder.appendWithSeparators(HtmlChunk.br(), comments)
+        return if (comments.isNotEmpty()) builder.wrapWith(HtmlChunk.span().attr("class", "grayed")) else HtmlChunk.empty()
+    }
+
+    fun getDefinition(element: M68kNamedElement) = getDefinition(HtmlChunk.text(element.name!!).code())
+
+    fun getDefinition(value: String) = getDefinition(HtmlChunk.text(value))
+
+    fun getDefinition(chunk: HtmlChunk) =
+        HtmlBuilder().append(chunk).wrapWith(DocumentationMarkup.DEFINITION_ELEMENT)
+
+    fun getContent(element: PsiElement) =
+        HtmlBuilder().append(HtmlChunk.text(element.text).code()).wrapWith(DocumentationMarkup.CONTENT_ELEMENT)
+
+    fun getContent(chunk: HtmlChunk) =
+        HtmlBuilder().append(chunk).wrapWith(DocumentationMarkup.CONTENT_ELEMENT)
+
+    fun getContent(value: String) =
+        HtmlBuilder().append(value).wrapWith(DocumentationMarkup.CONTENT_ELEMENT)
+}

src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kGlobalLabelDocumentationProvider.kt

@@ -1,47 +0,0 @@
-package de.platon42.intellij.plugins.m68k.documentation
-
-import com.intellij.lang.documentation.AbstractDocumentationProvider
-import com.intellij.lang.documentation.DocumentationMarkup
-import com.intellij.openapi.util.text.StringUtil
-import com.intellij.psi.PsiComment
-import com.intellij.psi.PsiElement
-import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.util.SmartList
-import de.platon42.intellij.plugins.m68k.psi.M68kGlobalLabel
-import de.platon42.intellij.plugins.m68k.psi.M68kStatement
-
-class M68kGlobalLabelDocumentationProvider : AbstractDocumentationProvider() {
-
-    override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
-        return generateDoc(element, originalElement)
-    }
-
-    override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
-        return if (element is M68kGlobalLabel) {
-            // TODO find out how we can generate inner links for more symbol references inside the expression (DocumentationManagerUtil)
-            val statement = element.parent as M68kStatement
-            var preprocessorDirective = statement.preprocessorDirective
-            if ((preprocessorDirective == null) && (statement.asmInstruction == null) && (statement.macroCall == null)) {
-                val nextLineStatement = PsiTreeUtil.skipWhitespacesAndCommentsForward(PsiTreeUtil.skipWhitespacesAndCommentsForward(statement))
-                        as? M68kStatement
-                preprocessorDirective = nextLineStatement?.preprocessorDirective
-            }
-            val content = if (preprocessorDirective != null)
-                DocumentationMarkup.CONTENT_START + StringUtil.escapeXmlEntities(preprocessorDirective.text) + DocumentationMarkup.CONTENT_END
-            else ""
-            val comments = SmartList<String>()
-            var prevToken: PsiElement? = statement
-            do {
-                prevToken = PsiTreeUtil.skipWhitespacesBackward(prevToken)
-                if (prevToken !is PsiComment) break
-                comments.add(prevToken.text)
-            } while (true)
-            val commentpart =
-                if (comments.isNotEmpty()) comments.asReversed().joinToString("<br>", DocumentationMarkup.GRAYED_START, DocumentationMarkup.GRAYED_END) else ""
-
-            commentpart +
-                    DocumentationMarkup.DEFINITION_START + StringUtil.escapeXmlEntities(element.name!!) + DocumentationMarkup.DEFINITION_END +
-                    content
-        } else null
-    }
-}

src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kLabelDefinitionDocumentationProvider.kt

@@ -0,0 +1,34 @@
+package de.platon42.intellij.plugins.m68k.documentation
+
+import com.intellij.openapi.util.text.HtmlBuilder
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import de.platon42.intellij.plugins.m68k.psi.M68kGlobalLabel
+import de.platon42.intellij.plugins.m68k.psi.M68kLocalLabel
+import de.platon42.intellij.plugins.m68k.psi.M68kNamedElement
+import de.platon42.intellij.plugins.m68k.psi.M68kStatement
+
+class M68kLabelDefinitionDocumentationProvider : AbstractM68kDocumentationProvider() {
+
+    override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
+        return generateDoc(element, originalElement)
+    }
+
+    override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
+        return if (element is M68kGlobalLabel || element is M68kLocalLabel) {
+            // TODO find out how we can generate inner links for more symbol references inside the expression (DocumentationManagerUtil)
+            val statement = element.parent as M68kStatement
+            var preprocessorDirective = statement.preprocessorDirective
+            if ((preprocessorDirective == null) && (statement.asmInstruction == null) && (statement.macroCall == null)) {
+                val nextLineStatement = PsiTreeUtil.skipWhitespacesAndCommentsForward(PsiTreeUtil.skipWhitespacesAndCommentsForward(statement))
+                        as? M68kStatement
+                preprocessorDirective = nextLineStatement?.preprocessorDirective
+            }
+            val builder = HtmlBuilder()
+            builder.append(getComments(statement))
+            builder.append(getDefinition(element as M68kNamedElement))
+            if (preprocessorDirective != null) builder.append(getContent(preprocessorDirective))
+            builder.toString()
+        } else null
+    }
+}

src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kMacroDefinitionDocumentationProvider.kt

@@ -0,0 +1,42 @@
+package de.platon42.intellij.plugins.m68k.documentation
+
+import com.intellij.openapi.util.text.HtmlBuilder
+import com.intellij.openapi.util.text.HtmlChunk
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroCall
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
+import de.platon42.intellij.plugins.m68k.psi.utils.M68kMacroExpansionUtil
+
+class M68kMacroDefinitionDocumentationProvider : AbstractM68kDocumentationProvider() {
+
+    override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
+        return generateDoc(element, originalElement)
+    }
+
+    override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
+        return if (element is M68kMacroDefinition) createDoc(element, originalElement, getSettings(element).maxLongDocumentationLines) else null
+    }
+
+    override fun generateHoverDoc(element: PsiElement, originalElement: PsiElement?): String? {
+        return if (element is M68kMacroDefinition) createDoc(element, originalElement, getSettings(element).maxShortDocumentationLines) else null
+    }
+
+    private fun createDoc(macrodef: M68kMacroDefinition, originalElement: PsiElement?, linesLimit: Int): String {
+        val macroCall = PsiTreeUtil.getParentOfType(originalElement, M68kMacroCall::class.java)
+        val expandedMacro = M68kMacroExpansionUtil.expandMacro(macrodef, macroCall)
+        val builder = HtmlBuilder()
+        return builder
+            .append(getComments(macrodef))
+            .append(getDefinition(HtmlChunk.text(macrodef.name!!).code()))
+            .append(
+                getContent(
+                    HtmlBuilder().appendWithSeparators(
+                        HtmlChunk.br(),
+                        expandedMacro.take(linesLimit).map { HtmlChunk.text(it).code() }.toList()
+                    ).toFragment()
+                )
+            )
+            .toString()
+    }
+}

src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kRegisterFlowDocumentationProvider.kt

@@ -1,6 +1,5 @@
 package de.platon42.intellij.plugins.m68k.documentation
 
-import com.intellij.lang.documentation.AbstractDocumentationProvider
 import com.intellij.lang.documentation.DocumentationMarkup
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.text.HtmlBuilder
@@ -19,18 +18,18 @@ import de.platon42.intellij.plugins.m68k.utils.M68kIsaUtil.findExactIsaDataAndAl
 import de.platon42.intellij.plugins.m68k.utils.M68kIsaUtil.getOpSizeOrDefault
 import de.platon42.intellij.plugins.m68k.utils.M68kIsaUtil.modifyRwmWithOpsize
 
-class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
+class M68kRegisterFlowDocumentationProvider : AbstractM68kDocumentationProvider() {
 
     override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
         if (element is M68kDataRegister || element is M68kAddressRegister) {
-            return createDoc(element as M68kRegister, 100) // TODO make this configurable
+            return createDoc(element as M68kRegister, getSettings(element).maxLongDocumentationLines)
         }
         return null
     }
 
     override fun generateHoverDoc(element: PsiElement, originalElement: PsiElement?): String? {
         if (element is M68kDataRegister || element is M68kAddressRegister) {
-            return createDoc(element as M68kRegister, 4) // TODO make this configurable
+            return createDoc(element as M68kRegister, getSettings(element).maxShortDocumentationLines)
         }
         return null
     }
@@ -82,15 +81,16 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
             PsiTreeUtil.getPrevSiblingOfType(it, M68kStatement::class.java)
         })
         backtrace.reverse()
+        val remLines = linesLimit - backtrace.size.coerceAtLeast(1)
         val traceBits = (cursorRwm or (cursorRwm ushr RWM_MODIFY_SHIFT) or (cursorRwm ushr RWM_READ_SHIFT)) and RWM_SIZE_MASK
-        backtrace.addAll(analyseFlow(register, traceBits, false, initialStatement, linesLimit) {
+        backtrace.addAll(analyseFlow(register, traceBits, false, initialStatement, remLines) {
             PsiTreeUtil.getNextSiblingOfType(it, M68kStatement::class.java)
         })
 
         val statementRows = HtmlBuilder()
         backtrace.forEach(statementRows::append)
         val builder = HtmlBuilder()
-        builder.append(HtmlChunk.text(thisInfo).wrapWith(DocumentationMarkup.DEFINITION_ELEMENT))
+        builder.append(getDefinition(thisInfo))
         builder.append(statementRows.wrapWith(DocumentationMarkup.SECTIONS_TABLE.style("padding-left: 8pt; padding-right: 8pt")))
         return builder.toString()
     }

src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kSymbolDefinitionDocumentationProvider.kt

@@ -1,13 +1,11 @@
 package de.platon42.intellij.plugins.m68k.documentation
 
-import com.intellij.lang.documentation.AbstractDocumentationProvider
+import com.intellij.openapi.util.text.HtmlBuilder
-import com.intellij.lang.documentation.DocumentationMarkup
-import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.PsiElement
 import de.platon42.intellij.plugins.m68k.psi.M68kAssignment
 import de.platon42.intellij.plugins.m68k.psi.M68kSymbolDefinition
 
-class M68kSymbolDefinitionDocumentationProvider : AbstractDocumentationProvider() {
+class M68kSymbolDefinitionDocumentationProvider : AbstractM68kDocumentationProvider() {
 
     override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
         return generateDoc(element, originalElement)
@@ -16,9 +14,12 @@ class M68kSymbolDefinitionDocumentationProvider : AbstractDocumentationProvider(
     override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
         return if (element is M68kSymbolDefinition) {
             // TODO find out how we can generate inner links for more symbol references inside the expression (DocumentationManagerUtil)
-            val value = (element.parent as M68kAssignment).expr.text
+            val assignment = element.parent as M68kAssignment
-            DocumentationMarkup.DEFINITION_START + StringUtil.escapeXmlEntities(element.name!!) + DocumentationMarkup.DEFINITION_END +
+            HtmlBuilder()
-                    DocumentationMarkup.CONTENT_START + StringUtil.escapeXmlEntities(value) + DocumentationMarkup.CONTENT_END
+                .append(getComments(assignment.parent))
+                .append(getDefinition(element))
+                .append(getContent(assignment.expr))
+                .toString()
         } else null
     }
 }

src/main/java/de/platon42/intellij/plugins/m68k/inspections/M68kUnresolvedReferenceInspection.kt

@@ -29,7 +29,7 @@ class M68kUnresolvedReferenceInspection : AbstractBaseM68kLocalInspectionTool()
             }
 
             override fun visitSymbolReference(symbolReference: M68kSymbolReference) {
-                val references = symbolReference.references ?: return
+                val references = symbolReference.references
                 if (references.isEmpty()) return
                 val resolve = references.mapNotNull { it as? PsiPolyVariantReference }
                     .firstNotNullOfOrNull { it.multiResolve(false).ifEmpty { null } }

src/main/java/de/platon42/intellij/plugins/m68k/lexer/M68kLexerPrefs.kt

@@ -4,5 +4,8 @@ data class M68kLexerPrefs(
     var spaceIntroducesComment: Boolean = false,
     var maxLinesPerMacro: Int = 250,
     var macroSectionUnparsed: Boolean = false,
-    var macroParametersUnparsed: Boolean = true
+    var macroParametersUnparsed: Boolean = true,
+
+    var maxShortDocumentationLines: Int = 5,
+    var maxLongDocumentationLines: Int = 100,
 )

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

@@ -118,9 +118,9 @@ PLAIN_MACRO_LINE=[^;\r\n]+
                         if(isAsmMnemonicWithSize(yytext())) { yybegin(ASMINSTR); yypushback(2); return MNEMONIC; }
                         if(isAsmMnemonic(yytext())) { yybegin(ASMINSTR); return MNEMONIC; }
                         //if(isEndDirective(yytext())) { yybegin(YYINITIAL); zzAtEOF = true; return null; }
-                        if(isDataDirective(yytext())) { startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
+                        if(isDataDirective(yytext())) { eatOneWhitespace = true; startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
-                        if(isPlainDirective(yytext())) { yybegin(PLAINPARAMS); return OTHER_DIRECTIVE; }
+                        if(isPlainDirective(yytext())) { eatOneWhitespace = true; yybegin(PLAINPARAMS); return OTHER_DIRECTIVE; }
-                        if(isOtherDirective(yytext())) { startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
+                        if(isOtherDirective(yytext())) { eatOneWhitespace = true; startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
                         return handleMacroMode(this);
                       }
   {MACRONAME}         { return handleMacroMode(this); }
@@ -168,7 +168,6 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   "+"                 { return OP_PLUS; }
   "-"                 { return OP_MINUS; }
   "*"                 { yybegin(exprOpState); return CURRENT_PC_SYMBOL; }
-
 }
 
 <EXPR> {
@@ -216,8 +215,12 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   "sr"                { yybegin(exprOpState); return REG_SR; }
   "usp"               { yybegin(exprOpState); return REG_USP; }
   "vbr"               { yybegin(exprOpState); return REG_VBR; }
+  "dfc"               { yybegin(exprOpState); return REG_DFC; }
+  "sfc"               { yybegin(exprOpState); return REG_SFC; }
 
   "#"                 { return HASH; }
+  "\["                { return SQUARE_L; }
+//  "\]"                { return SQUARE_R; }
 
   {SYMBOL}            { yybegin(exprOpState); return SYMBOL; }
 }
@@ -226,6 +229,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>

src/main/java/de/platon42/intellij/plugins/m68k/m68k.bnf

@@ -164,6 +164,7 @@ OperandSize ::= (OPSIZE_BS|OPSIZE_W|OPSIZE_L) {
     name = ".s|.b|.w|.l"
     methods = [getSize]
 }
+
 AddressSize ::= (OPSIZE_W|OPSIZE_L) { name = ".w|.l" }
 DataWidth ::= (OPSIZE_W|OPSIZE_L) { name = ".w|.l" }
 
@@ -227,7 +228,7 @@ AddressRegister ::= AREG | REG_SP {
     extends = Register
 }
 
-SpecialRegister ::= REG_CCR | REG_SR | REG_USP | REG_VBR {
+SpecialRegister ::= REG_CCR | REG_SR | REG_USP | REG_VBR | REG_SFC | REG_DFC {
     name = "special register"
     extends = Register
 }
@@ -236,14 +237,26 @@ Register ::= DataRegister | AddressRegister | SpecialRegister
 
 private DataOrAddressRegister ::= DataRegister | AddressRegister { name = "data or address register"}
 
-IndexRegister ::= DataOrAddressRegister DataWidth?
+BaseDisplacement ::= expr DataWidth?
+OuterDisplacement ::= expr DataWidth?
+
+IndexRegister ::= DataOrAddressRegister DataWidth? (OP_AR_MUL IndexScale)?
 {
     name = "index register"
     methods = [
+        indexRegister = "DataOrAddressRegister"
         isLongWidth
     ]
 }
 
+IndexScale ::= expr
+{
+    name = "scale value"
+    methods = [
+        indexScale = "expr"
+    ]
+}
+
 AddressingMode ::= ImmediateData
                 | AddressRegisterIndirectPreDecAddressingMode
                 | AddressRegisterIndirectPostIncAddressingMode
@@ -256,6 +269,14 @@ AddressingMode ::= ImmediateData
                 | ProgramCounterIndirectWithDisplacementOldAddressingMode
                 | AddressRegisterIndirectWithIndexOldAddressingMode
                 | ProgramCounterIndirectWithIndexOldAddressingMode
+                | AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode
+                | ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode
+                | MemoryIndirectAddressingMode
+                | ProgramCounterMemoryIndirectAddressingMode
+                | MemoryIndirectPostIndexedAddressingMode
+                | ProgramCounterMemoryIndirectPostIndexedAddressingMode
+                | MemoryIndirectPreIndexedAddressingMode
+                | ProgramCounterMemoryIndirectPreIndexedAddressingMode
                 | SpecialRegisterDirectAddressingMode
                 | DataRegisterDirectAddressingMode
                 | AddressRegisterDirectAddressingMode
@@ -268,6 +289,7 @@ AddressRegisterDirectAddressingMode ::= AddressRegister !(OP_MINUS|OP_AR_DIV)
 AddressRegisterIndirectAddressingMode ::= ROUND_L AddressRegister ROUND_R !OP_PLUS { implements = "de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect" }
 AddressRegisterIndirectPostIncAddressingMode ::= ROUND_L AddressRegister ROUND_R OP_PLUS { implements = "de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect" }
 AddressRegisterIndirectPreDecAddressingMode ::= OP_MINUS ROUND_L AddressRegister ROUND_R { implements = "de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect" }
+
 AddressRegisterIndirectWithDisplacementOldAddressingMode ::= expr ROUND_L AddressRegister ROUND_R
 {
     implements = [
@@ -278,6 +300,7 @@ AddressRegisterIndirectWithDisplacementOldAddressingMode ::= expr ROUND_L Addres
         displacement = "expr"
     ]
 }
+
 AddressRegisterIndirectWithDisplacementNewAddressingMode ::= ROUND_L expr SEPARATOR AddressRegister ROUND_R
 {
     implements = [
@@ -313,6 +336,77 @@ AddressRegisterIndirectWithIndexNewAddressingMode ::= ROUND_L (expr SEPARATOR)?
     ]
 }
 
+private internalBaseDisplacementOption1 ::= (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister
+private internalBaseDisplacementOption2 ::= (BaseDisplacement SEPARATOR)? AddressRegister (SEPARATOR IndexRegister)?
+private internalBaseDisplacementOption3 ::= BaseDisplacement (SEPARATOR AddressRegister)? (SEPARATOR IndexRegister)?
+
+AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode ::= ROUND_L (internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3)? ROUND_R
+{
+    implements = [
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalAddressRegisterIndirect"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalIndexRegister"
+    ]
+    methods = [
+        baseDisplacement = "BaseDisplacement"
+    ]
+}
+
+ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode ::= ROUND_L (BaseDisplacement SEPARATOR)? PC (SEPARATOR IndexRegister)? ROUND_R
+{
+    implements = [
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalIndexRegister"
+    ]
+    methods = [
+        baseDisplacement = "BaseDisplacement"
+    ]
+}
+
+MemoryIndirectAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? AddressRegister SQUARE_R (SEPARATOR OuterDisplacement)? 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 = "BaseDisplacement"
+        outerDisplacement = "OuterDisplacement"
+    ]
+}
+
+private internalMemoryIndirectPostIndexedOption1 ::= (BaseDisplacement SEPARATOR)? AddressRegister
+private internalMemoryIndirectPostIndexedOption2 ::= BaseDisplacement (SEPARATOR AddressRegister)?
+
+MemoryIndirectPostIndexedAddressingMode ::= ROUND_L (SQUARE_L (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? ROUND_R
+{
+    implements = [
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalAddressRegisterIndirect"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
+    ]
+    methods = [
+        baseDisplacement = "BaseDisplacement"
+        outerDisplacement = "OuterDisplacement"
+    ]
+}
+
+MemoryIndirectPreIndexedAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
+{
+    implements = [
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalAddressRegisterIndirect"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
+    ]
+    methods = [
+        baseDisplacement = "BaseDisplacement"
+        outerDisplacement = "OuterDisplacement"
+    ]
+}
+
 ProgramCounterIndirectWithDisplacementOldAddressingMode ::= (ROUND_L PC ROUND_R) | (expr ROUND_L PC ROUND_R)
 {
     implements = ["de.platon42.intellij.plugins.m68k.psi.M68kWithDisplacement"]
@@ -351,6 +445,44 @@ ProgramCounterIndirectWithIndexNewAddressingMode ::= ROUND_L (expr SEPARATOR)? P
     ]
 }
 
+ProgramCounterMemoryIndirectAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
+{
+    implements = [
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
+        "de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
+    ]
+    methods = [
+        baseDisplacement = "BaseDisplacement"
+        outerDisplacement = "OuterDisplacement"
+    ]
+}
+
+ProgramCounterMemoryIndirectPostIndexedAddressingMode ::= ROUND_L (SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? 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 = "BaseDisplacement"
+        outerDisplacement = "OuterDisplacement"
+    ]
+}
+
+ProgramCounterMemoryIndirectPreIndexedAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SEPARATOR IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? 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 = "BaseDisplacement"
+        outerDisplacement = "OuterDisplacement"
+    ]
+}
+
 AbsoluteAddressAddressingMode ::= expr AddressSize? !ROUND_L
 
 RegisterRange ::= (DataRegister OP_MINUS DataRegister) | (AddressRegister OP_MINUS AddressRegister) | (DataRegister OP_MINUS AddressRegister) {

src/main/java/de/platon42/intellij/plugins/m68k/parser/M68kParserDefinition.kt

@@ -10,15 +10,14 @@ import de.platon42.intellij.plugins.m68k.lexer.M68kLexer
 import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
 import de.platon42.intellij.plugins.m68k.psi.M68kFile
 import de.platon42.intellij.plugins.m68k.psi.M68kTypes
+import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
 import de.platon42.intellij.plugins.m68k.stubs.M68kElementTypes
 
 class M68kParserDefinition : ParserDefinition {
 
-    val lexerPrefs = M68kLexerPrefs() // TODO make this configurable
-
     override fun createLexer(project: Project): Lexer {
-        // TODO take prefs from project somehow
+        val settings = project.getService(M68kProjectSettings::class.java)
-        return M68kLexer(lexerPrefs)
+        return M68kLexer(settings?.settings ?: M68kLexerPrefs())
     }
 
     override fun createParser(project: Project) = M68kParser()

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

@@ -12,12 +12,20 @@ object M68kAddressModeUtil {
             is M68kAddressRegisterIndirectPreDecAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_PRE_DEC
             is M68kAddressRegisterIndirectWithDisplacementNewAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT
             is M68kAddressRegisterIndirectWithDisplacementOldAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT
-            is M68kAddressRegisterIndirectWithIndexNewAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
+            is M68kAddressRegisterIndirectWithIndexNewAddressingMode -> if (hasScale(addressingMode)) AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
-            is M68kAddressRegisterIndirectWithIndexOldAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
+            is M68kAddressRegisterIndirectWithIndexOldAddressingMode -> if (hasScale(addressingMode)) AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
+            is M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT
             is M68kProgramCounterIndirectWithDisplacementNewAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT
             is M68kProgramCounterIndirectWithDisplacementOldAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT
-            is M68kProgramCounterIndirectWithIndexNewAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
+            is M68kProgramCounterIndirectWithIndexNewAddressingMode -> if (hasScale(addressingMode)) AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
-            is M68kProgramCounterIndirectWithIndexOldAddressingMode -> 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 M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT
+            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 +35,9 @@ 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>> {
         if (rwm and RWM_MODIFY_STACK > 0) {
             return listOf(Register.A7 to RWM_MODIFY_L)
@@ -37,29 +48,20 @@ object M68kAddressModeUtil {
     fun getReadWriteModifyRegisters(addressingMode: M68kAddressingMode?, rwm: Int): List<Pair<Register, Int>> {
         if (addressingMode == null) return emptyList()
         return when (addressingMode) {
-            is M68kImmediateData,
-            is M68kSpecialRegisterDirectAddressingMode,
-            is M68kProgramCounterIndirectWithDisplacementNewAddressingMode,
-            is M68kProgramCounterIndirectWithDisplacementOldAddressingMode,
-            is M68kAbsoluteAddressAddressingMode -> emptyList()
-
             is M68kAddressRegisterIndirectPostIncAddressingMode -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to (RWM_READ_L or RWM_MODIFY_L))
             is M68kAddressRegisterIndirectPreDecAddressingMode -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to (RWM_READ_L or RWM_MODIFY_L))
-            is M68kWithAddressRegisterIndirect -> {
+            is M68kWithAddressRegisterIndirect -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to RWM_READ_L)
-                if (addressingMode is M68kWithIndexRegister) {
+            is M68kWithOptionalAddressRegisterIndirect -> if (addressingMode.addressRegister != null) listOf(Register.getRegFromName(addressingMode.addressRegister!!.text) to RWM_READ_L) else emptyList()
-                    listOf(
-                        Register.getRegFromName(addressingMode.addressRegister.text) to RWM_READ_L,
-                        Register.getRegFromName(addressingMode.indexRegister.register.text) to if (addressingMode.indexRegister.isLongWidth) RWM_READ_L else RWM_READ_W
-                    )
-                } else {
-                    listOf(Register.getRegFromName(addressingMode.addressRegister.text) to RWM_READ_L)
-                }
-            }
-            is M68kWithIndexRegister -> listOf(Register.getRegFromName(addressingMode.indexRegister.register.text) to if (addressingMode.indexRegister.isLongWidth) RWM_READ_L else RWM_READ_W)
             is M68kDataRegisterDirectAddressingMode -> listOf(Register.getRegFromName(addressingMode.dataRegister.text) to rwm)
             is M68kAddressRegisterDirectAddressingMode -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to rwm)
             is M68kRegisterListAddressingMode -> addressingMode.registers.map { it to rwm }
-            else -> throw IllegalArgumentException("Unknown addressing mode $addressingMode")
+            else -> emptyList()
-        }
+        }.plus(
+            when (addressingMode) {
+                is M68kWithIndexRegister -> listOf(Register.getRegFromName(addressingMode.indexRegister.register.text) to if (addressingMode.indexRegister.isLongWidth) RWM_READ_L else RWM_READ_W)
+                is M68kWithOptionalIndexRegister -> if (addressingMode.indexRegister != null) listOf(Register.getRegFromName(addressingMode.indexRegister!!.register.text) to if (addressingMode.indexRegister!!.isLongWidth) RWM_READ_L else RWM_READ_W) else emptyList()
+                else -> emptyList()
+            }
+        )
     }
 }

src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kPsiImplUtil.kt

@@ -105,7 +105,7 @@ object M68kPsiImplUtil {
     // OperandSize
     @JvmStatic
     fun getSize(element: M68kOperandSize): Int =
-        when (element.text) {
+        when (element.text?.lowercase()) {
             null -> OP_UNSIZED
             ".w" -> OP_SIZE_W
             ".l" -> OP_SIZE_L

src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithBaseDisplacement.kt

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

src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOptionalAddressRegisterIndirect.kt

@@ -0,0 +1,6 @@
+package de.platon42.intellij.plugins.m68k.psi
+
+interface M68kWithOptionalAddressRegisterIndirect : M68kAddressingMode {
+
+    val addressRegister: M68kAddressRegister?
+}

src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOptionalIndexRegister.kt

@@ -0,0 +1,6 @@
+package de.platon42.intellij.plugins.m68k.psi
+
+interface M68kWithOptionalIndexRegister : M68kAddressingMode {
+
+    val indexRegister: M68kIndexRegister?
+}

src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOuterDisplacement.kt

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

src/main/java/de/platon42/intellij/plugins/m68k/psi/utils/M68kLookupUtil.kt

@@ -1,9 +1,10 @@
-package de.platon42.intellij.plugins.m68k.psi
+package de.platon42.intellij.plugins.m68k.psi.utils
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StubIndex
 import com.intellij.psi.util.PsiTreeUtil
+import de.platon42.intellij.plugins.m68k.psi.*
 import de.platon42.intellij.plugins.m68k.stubs.M68kGlobalLabelStubIndex
 import de.platon42.intellij.plugins.m68k.stubs.M68kMacroDefinitionStubIndex
 import de.platon42.intellij.plugins.m68k.stubs.M68kSymbolDefinitionStubIndex

src/main/java/de/platon42/intellij/plugins/m68k/psi/utils/M68kMacroExpansionUtil.kt

@@ -0,0 +1,25 @@
+package de.platon42.intellij.plugins.m68k.psi.utils
+
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroCall
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
+
+object M68kMacroExpansionUtil {
+
+    fun expandMacro(macroDefinition: M68kMacroDefinition, macroCall: M68kMacroCall?): List<String> {
+        val params = macroCall?.exprList?.map { it.text }?.toTypedArray() ?: emptyArray()
+
+        if (params.isEmpty()) return macroDefinition.macroPlainLineList.map { it.text }
+
+        val originalContent = macroDefinition.macroPlainLineList.joinToString("\n", transform = { it.text })
+        var modifiedContent = originalContent
+        for (param in params.withIndex()) {
+            val paramRef = when (param.index) {
+                in 0..8 -> "\\" + (param.index + 1)
+                in 9..34 -> "\\" + ('a' + (param.index - 9))
+                else -> "seriously?"
+            }
+            modifiedContent = modifiedContent.replace(paramRef, param.value)
+        }
+        return modifiedContent.split("\n")
+    }
+}

src/main/java/de/platon42/intellij/plugins/m68k/psi/utils/M68kPsiWalkUtil.kt

@@ -0,0 +1,31 @@
+package de.platon42.intellij.plugins.m68k.psi.utils
+
+import com.intellij.psi.PsiComment
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.SmartList
+import com.intellij.util.containers.addIfNotNull
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
+
+object M68kPsiWalkUtil {
+
+    fun collectRelatedComments(element: PsiElement): List<PsiComment> {
+        val comments = SmartList<PsiComment>()
+        val eolComment = if (element is M68kMacroDefinition) {
+            // macro definition needs special handling of EOL comments
+            PsiTreeUtil.findChildOfType(element, PsiComment::class.java)
+        } else {
+            PsiTreeUtil.skipWhitespacesForward(element) as? PsiComment
+        }
+
+        comments.addIfNotNull(eolComment)
+        var prevToken: PsiElement? = element
+        do {
+            prevToken = PsiTreeUtil.skipWhitespacesBackward(prevToken)
+            if (prevToken !is PsiComment) break
+            comments.add(prevToken)
+        } while (true)
+
+        return comments.reversed()
+    }
+}

src/main/java/de/platon42/intellij/plugins/m68k/refs/M68kGlobalLabelSymbolCompletionContributor.kt

@@ -6,8 +6,8 @@ import com.intellij.codeInsight.lookup.LookupElementBuilder
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.util.ProcessingContext
 import de.platon42.intellij.plugins.m68k.M68kIcons
-import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil
 import de.platon42.intellij.plugins.m68k.psi.M68kTypes
+import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil
 
 class M68kGlobalLabelSymbolCompletionContributor : CompletionContributor() {
 

src/main/java/de/platon42/intellij/plugins/m68k/refs/M68kMacroCallCompletionContributor.kt

@@ -4,8 +4,8 @@ import com.intellij.codeInsight.completion.*
 import com.intellij.codeInsight.lookup.LookupElementBuilder
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.util.ProcessingContext
-import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil
 import de.platon42.intellij.plugins.m68k.psi.M68kTypes
+import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil
 
 class M68kMacroCallCompletionContributor : CompletionContributor() {
 

src/main/java/de/platon42/intellij/plugins/m68k/settings/M68kProjectSettings.kt

@@ -0,0 +1,19 @@
+package de.platon42.intellij.plugins.m68k.settings
+
+import com.intellij.openapi.components.PersistentStateComponent
+import com.intellij.openapi.components.State
+import com.intellij.openapi.components.Storage
+import com.intellij.openapi.components.StoragePathMacros
+import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
+
+@State(name = "M68k.Settings", storages = [Storage(StoragePathMacros.WORKSPACE_FILE)])
+class M68kProjectSettings : PersistentStateComponent<M68kLexerPrefs> {
+
+    var settings: M68kLexerPrefs = M68kLexerPrefs()
+
+    override fun getState() = settings
+
+    override fun loadState(state: M68kLexerPrefs) {
+        settings = state
+    }
+}

src/main/java/de/platon42/intellij/plugins/m68k/settings/M68kProjectSettingsConfigurable.kt

@@ -0,0 +1,91 @@
+package de.platon42.intellij.plugins.m68k.settings
+
+import com.intellij.openapi.options.Configurable
+import com.intellij.openapi.options.ConfigurationException
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.NlsContexts.ConfigurableName
+import com.intellij.ui.components.JBCheckBox
+import com.intellij.uiDesigner.core.Spacer
+import com.intellij.util.ui.FormBuilder
+import com.intellij.util.ui.UIUtil
+import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
+import java.text.NumberFormat
+import java.text.ParseException
+import javax.swing.JComponent
+import javax.swing.JFormattedTextField
+import javax.swing.JLabel
+import javax.swing.text.DefaultFormatterFactory
+import javax.swing.text.NumberFormatter
+
+class M68kProjectSettingsConfigurable(project: Project?) : Configurable {
+
+    private val settings = project?.getService(M68kProjectSettings::class.java)
+
+    private val spacesOptionField = JBCheckBox("Space introduces comment (-spaces)", settings?.settings?.spaceIntroducesComment ?: false)
+
+    private val maxLinesPerMacroField = createNumberField(settings?.settings?.maxLinesPerMacro)
+    private val maxShortDocumentationLinesField = createNumberField(settings?.settings?.maxShortDocumentationLines)
+    private val maxLongDocumentationLinesField = createNumberField(settings?.settings?.maxLongDocumentationLines)
+
+    override fun getDisplayName(): @ConfigurableName String = "M68k"
+
+    override fun createComponent(): JComponent? {
+        return FormBuilder.createFormBuilder()
+            .setAlignLabelOnRight(false)
+            .setHorizontalGap(UIUtil.DEFAULT_HGAP)
+            .setVerticalGap(UIUtil.DEFAULT_VGAP)
+            .addComponent(spacesOptionField)
+            .addLabeledComponent(JLabel("Maximum lines parsed inside macro"), maxLinesPerMacroField)
+            .addSeparator()
+            .addLabeledComponent(JLabel("Lines of code in hovered documentation"), maxShortDocumentationLinesField)
+            .addLabeledComponent(JLabel("Lines of code in full documentation"), maxLongDocumentationLinesField)
+            .addComponentFillVertically(Spacer(), 0)
+            .panel
+    }
+
+    private fun createNumberField(value: Any?): JFormattedTextField {
+        val valueField = JFormattedTextField()
+        valueField.columns = 4
+        val formatter = NumberFormat.getIntegerInstance()
+        formatter.isParseIntegerOnly = true
+        valueField.formatterFactory = DefaultFormatterFactory(NumberFormatter(formatter))
+        valueField.value = value
+        return valueField
+    }
+
+    override fun isModified(): Boolean {
+        val prefs = settings?.settings ?: return false
+
+        return prefs.spaceIntroducesComment != spacesOptionField.isSelected
+                || fieldDiffers(maxLinesPerMacroField, prefs.maxLinesPerMacro)
+                || fieldDiffers(maxShortDocumentationLinesField, prefs.maxShortDocumentationLines)
+                || fieldDiffers(maxLongDocumentationLinesField, prefs.maxLongDocumentationLines)
+    }
+
+    @Throws(ConfigurationException::class)
+    override fun apply() {
+        val prefs = settings?.settings ?: return
+        prefs.spaceIntroducesComment = spacesOptionField.isSelected
+        getFieldValue(maxLinesPerMacroField).let { if (it != null) prefs.maxLinesPerMacro = it }
+        getFieldValue(maxShortDocumentationLinesField).let { if (it != null) prefs.maxShortDocumentationLines = it }
+        getFieldValue(maxLongDocumentationLinesField).let { if (it != null) prefs.maxLongDocumentationLines = it }
+    }
+
+    private fun fieldDiffers(field: JFormattedTextField, value: Int?): Boolean {
+        val fieldValue = getFieldValue(field)
+        return (fieldValue != null) && (value != null) && (fieldValue != value)
+    }
+
+    private fun getFieldValue(field: JFormattedTextField): Int? {
+        return try {
+            val value = field.value
+            (value as Number).toInt()
+        } catch (ex: ParseException) {
+            null
+        }
+    }
+
+    override fun reset() {
+        settings?.settings = M68kLexerPrefs()
+    }
+}

src/main/java/de/platon42/intellij/plugins/m68k/structureview/M68kStructureViewElement.kt

@@ -6,8 +6,8 @@ import com.intellij.navigation.ItemPresentation
 import com.intellij.psi.NavigatablePsiElement
 import de.platon42.intellij.plugins.m68k.psi.M68kFile
 import de.platon42.intellij.plugins.m68k.psi.M68kGlobalLabel
-import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil
+import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil
-import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil.findAllLocalLabels
+import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil.findAllLocalLabels
 
 class M68kStructureViewElement(private val myElement: NavigatablePsiElement) : StructureViewTreeElement {
     override fun getValue(): Any = myElement

src/main/java/de/platon42/intellij/plugins/m68k/syntax/M68kSyntaxHighlighter.kt

@@ -11,15 +11,13 @@ import com.intellij.psi.tree.IElementType
 import de.platon42.intellij.plugins.m68k.lexer.M68kLexer
 import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
 import de.platon42.intellij.plugins.m68k.psi.M68kTypes
+import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
 
 class M68kSyntaxHighlighter(val project: Project?) : SyntaxHighlighterBase() {
+    private val settings = project?.getService(M68kProjectSettings::class.java)
+
     override fun getHighlightingLexer(): Lexer {
-        if (project == null) {
+        return M68kLexer(settings?.settings ?: M68kLexerPrefs()) // Use some defaults
-            return M68kLexer(M68kLexerPrefs()) // Use some defaults
-        } else {
-            // FIXME Where do we get the prefs from?
-            return M68kLexer(M68kLexerPrefs())
-        }
     }
 
     override fun getTokenHighlights(tokenType: IElementType): Array<TextAttributesKey> {
@@ -44,7 +42,7 @@ class M68kSyntaxHighlighter(val project: Project?) : SyntaxHighlighterBase() {
             M68kTypes.AREG -> arrayOf(AREG)
             M68kTypes.REG_SP -> arrayOf(STACK_POINTER)
             M68kTypes.DREG -> arrayOf(DREG)
-            M68kTypes.REG_USP, M68kTypes.REG_SR, M68kTypes.REG_CCR, M68kTypes.REG_VBR -> arrayOf(SPECIAL_REG)
+            M68kTypes.REG_USP, M68kTypes.REG_SR, M68kTypes.REG_CCR, M68kTypes.REG_VBR, M68kTypes.REG_SFC, M68kTypes.REG_DFC -> arrayOf(SPECIAL_REG)
             M68kTypes.COMMENT -> arrayOf(COMMENT)
             M68kTypes.DECIMAL, M68kTypes.HEXADECIMAL, M68kTypes.OCTAL -> arrayOf(NUMBER)
             M68kTypes.STRINGLIT -> arrayOf(STRING)

src/main/resources/META-INF/plugin.xml

@@ -40,7 +40,9 @@
         <lang.documentationProvider language="MC68000"
                                     implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kSymbolDefinitionDocumentationProvider"/>
         <lang.documentationProvider language="MC68000"
-                                    implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kGlobalLabelDocumentationProvider"/>
+                                    implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kLabelDefinitionDocumentationProvider"/>
+        <lang.documentationProvider language="MC68000"
+                                    implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kMacroDefinitionDocumentationProvider"/>
         <lang.documentationProvider language="MC68000"
                                     implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kRegisterFlowDocumentationProvider"/>
         <lang.documentationProvider language="MC68000"
@@ -66,6 +68,12 @@
         <localInspection implementationClass="de.platon42.intellij.plugins.m68k.inspections.M68kUnresolvedReferenceInspection"
                          displayName="Unresolved label/symbol/macro reference" groupName="M68k"
                          enabledByDefault="true" level="WARNING"/>
+
+        <projectService serviceImplementation="de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings"/>
+
+        <projectConfigurable parentId="language" instance="de.platon42.intellij.plugins.m68k.settings.M68kProjectSettingsConfigurable"
+                             id="de.platon42.intellij.plugins.m68k.settings.M68kProjectSettingsConfigurable" displayName="M68k"
+                             nonDefaultProject="true"/>
     </extensions>
 
     <actions>

src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java

@@ -12,6 +12,7 @@ import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.extension.*;
 import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
 import org.junit.jupiter.api.extension.ExtensionContext.Store;
+import org.junit.runner.Description;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
@@ -34,8 +35,11 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
     public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
         LightCodeInsightFixtureTestCaseWrapper testCase = getWrapper(extensionContext);
         Parameter parameter = parameterContext.getParameter();
-        if (parameter.isAnnotationPresent(MyFixture.class)) return testCase.getMyFixture();
+        if (parameter.isAnnotationPresent(MyFixture.class)) {
-        else if (parameter.isAnnotationPresent(MyTestCase.class)) return testCase;
+            return testCase.getMyFixture();
+        } else if (parameter.isAnnotationPresent(MyTestCase.class)) {
+            return testCase;
+        }
         return null;
     }
 
@@ -68,14 +72,15 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
     @Override
     public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
         Throwable[] throwables = new Throwable[1];
+        Description testDescription = Description.createTestDescription(extensionContext.getRequiredTestClass(), getWrapper(extensionContext).getName());
 
         Runnable runnable = () -> {
             try {
                 TestLoggerFactory.onTestStarted();
                 invocation.proceed();
-                TestLoggerFactory.onTestFinished(true);
+                TestLoggerFactory.onTestFinished(true, testDescription);
             } catch (Throwable e) {
-                TestLoggerFactory.onTestFinished(false);
+                TestLoggerFactory.onTestFinished(false, testDescription);
                 throwables[0] = e;
             }
         };

src/test/java/de/platon42/intellij/jupiter/ParsingTestExtension.java

@@ -2,17 +2,17 @@ package de.platon42.intellij.jupiter;
 
 
 import com.intellij.lang.ParserDefinition;
+import com.intellij.mock.MockProjectEx;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.psi.PsiFile;
-import com.intellij.testFramework.EdtTestUtilKt;
 import com.intellij.testFramework.ParsingTestCase;
 import com.intellij.testFramework.TestLoggerFactory;
-import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
 import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.extension.*;
 import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
 import org.junit.jupiter.api.extension.ExtensionContext.Store;
+import org.junit.runner.Description;
 
 import java.io.IOException;
 import java.lang.annotation.Annotation;
@@ -80,39 +80,26 @@ public class ParsingTestExtension implements ParameterResolver, AfterTestExecuti
     @Override
     public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
         Throwable[] throwables = new Throwable[1];
+        Description testDescription = Description.createTestDescription(extensionContext.getRequiredTestClass(), getWrapper(extensionContext).getName());
 
-        Runnable runnable = () -> {
         try {
             TestLoggerFactory.onTestStarted();
             invocation.proceed();
-                TestLoggerFactory.onTestFinished(true);
+            TestLoggerFactory.onTestFinished(true, testDescription);
         } catch (Throwable e) {
-                TestLoggerFactory.onTestFinished(false);
+            TestLoggerFactory.onTestFinished(false, testDescription);
             throwables[0] = e;
         }
-        };
-
-        invokeTestRunnable(runnable);
 
         if (throwables[0] != null) {
             throw throwables[0];
         }
     }
 
-    private static void invokeTestRunnable(@NotNull Runnable runnable) {
-        IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
-        if (policy != null && !policy.runInDispatchThread()) {
-            runnable.run();
-        } else {
-            EdtTestUtilKt.runInEdtAndWait(() -> {
-                runnable.run();
-                return null;
-            });
-        }
-    }
-
     public interface IParsingTestCase {
 
+        MockProjectEx getProject();
+
         ParserDefinition getParserDefinition();
 
         void ensureNoErrorElements();

src/test/java/de/platon42/intellij/plugins/m68k/asm/M68kMnemonicCompletionContributorTest.kt

@@ -13,27 +13,33 @@ internal class M68kMnemonicCompletionContributorTest : AbstractM68kTest() {
 
     @Test
     internal fun completion_shows_all_move_mnemonics_after_first_letters(@MyFixture myFixture: CodeInsightTestFixture) {
-        myFixture.configureByText("completeme.asm", """
+        myFixture.configureByText(
+            "completeme.asm", """
  mo<caret>
-        """)
+        """
+        )
         myFixture.completeBasic()
-        assertThat(myFixture.lookupElementStrings).containsExactlyInAnyOrder("move", "moveq", "movea", "movem", "movep")
+        assertThat(myFixture.lookupElementStrings).containsExactlyInAnyOrder("move", "moveq", "movea", "movem", "movep", "movec", "moves")
     }
 
     @Test
     internal fun completion_shows_all_mnemonics_after_label(@MyFixture myFixture: CodeInsightTestFixture) {
-        myFixture.configureByText("completeme.asm", """
+        myFixture.configureByText(
+            "completeme.asm", """
 label: <caret>
-        """)
+        """
+        )
         myFixture.completeBasic()
         assertThat(myFixture.lookupElementStrings).hasSameElementsAs(M68kIsa.mnemonics)
     }
 
     @Test
     internal fun completion_shows_all_mnemonics_after_space(@MyFixture myFixture: CodeInsightTestFixture) {
-        myFixture.configureByText("completeme.asm", """
+        myFixture.configureByText(
+            "completeme.asm", """
  <caret>
-        """)
+        """
+        )
         myFixture.completeBasic()
         assertThat(myFixture.lookupElementStrings).hasSameElementsAs(M68kIsa.mnemonics)
     }

src/test/java/de/platon42/intellij/plugins/m68k/documentation/AbstractDocumentationProviderTest.kt

@@ -12,6 +12,7 @@ import org.junit.jupiter.api.extension.ExtendWith
 abstract class AbstractDocumentationProviderTest : AbstractM68kTest() {
 
     fun generateDocumentation(myFixture: CodeInsightTestFixture): String? {
+        // FIXME migrate to DocumentationTarget
         val docElement = DocumentationManager.getInstance(myFixture.project).findTargetElement(myFixture.editor, myFixture.file)
         val provider = DocumentationManager.getProviderFromElement(docElement)
 

src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kLabelDocumentationProviderTest.kt

@@ -8,7 +8,7 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 
 @ExtendWith(LightCodeInsightExtension::class)
-internal class M68kGlobalLabelDocumentationProviderTest : AbstractDocumentationProviderTest() {
+internal class M68kLabelDocumentationProviderTest : AbstractDocumentationProviderTest() {
 
     @Test
     internal fun check_documentation_for_a_label_definition(@MyFixture myFixture: CodeInsightTestFixture) {
@@ -18,13 +18,13 @@ internal class M68kGlobalLabelDocumentationProviderTest : AbstractDocumentationP
 ; inputs: d0 = number
 
 ; output: d0 = square
-squareme: include "fancysquarecode.asm"
+squareme: include "fancysquarecode.asm" ; code -> cool!
  rts
  bsr square<caret>me
         """
         )
         assertThat(generateDocumentation(myFixture))
-            .isEqualTo("<span class='grayed'>; inputs: d0 = number<br>; output: d0 = square</span><div class='definition'><pre>squareme</pre></div><div class='content'>include &quot;fancysquarecode.asm&quot;</div>")
+            .isEqualTo("<span class=\"grayed\">; inputs: d0 = number<br/>; output: d0 = square<br/>; code -&gt; cool!</span><div class=\"definition\"><code>squareme</code></div><div class=\"content\"><code>include &quot;fancysquarecode.asm&quot;</code></div>")
     }
 
     @Test
@@ -32,12 +32,12 @@ squareme: include "fancysquarecode.asm"
         myFixture.configureByText(
             "documentme.asm", """
 ; output: d0 = square
-square<caret>me:
+.square<caret>me:
 ; oh man
  include "fancysquarecode.asm"
         """
         )
         assertThat(generateDocumentation(myFixture))
-            .isEqualTo("<span class='grayed'>; output: d0 = square</span><div class='definition'><pre>squareme</pre></div><div class='content'>include &quot;fancysquarecode.asm&quot;</div>")
+            .isEqualTo("<span class=\"grayed\">; output: d0 = square</span><div class=\"definition\"><code>.squareme</code></div><div class=\"content\"><code>include &quot;fancysquarecode.asm&quot;</code></div>")
     }
 }

src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kMacroDefinitionDocumentationProviderTest.kt

@@ -0,0 +1,58 @@
+package de.platon42.intellij.plugins.m68k.documentation
+
+import com.intellij.testFramework.fixtures.CodeInsightTestFixture
+import de.platon42.intellij.jupiter.LightCodeInsightExtension
+import de.platon42.intellij.jupiter.MyFixture
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(LightCodeInsightExtension::class)
+internal class M68kMacroDefinitionDocumentationProviderTest : AbstractDocumentationProviderTest() {
+
+    @Test
+    internal fun check_expanded_documentation_for_a_macro_definition(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+MOLV<caret>ANIA MACRO ; the bestest macro
+ move.l \1,d0
+ mulu   d0,d0
+ ENDM
+        """
+        )
+        assertThat(generateDocumentation(myFixture))
+            .isEqualTo("<span class=\"grayed\">; the bestest macro</span><div class=\"definition\"><code>MOLVANIA</code></div><div class=\"content\"><code> move.l \\1,d0</code><br/><code> mulu   d0,d0</code></div>")
+    }
+
+    @Test
+    internal fun check_expanded_documentation_for_a_macro_invocation(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+MOLVANIA MACRO ; the bestest macro
+ move.l \1,d0
+ mulu   d0,d0
+ ENDM
+
+ MOLV<caret>ANIA d1
+        """
+        )
+        assertThat(generateDocumentation(myFixture))
+            .isEqualTo("<span class=\"grayed\">; the bestest macro</span><div class=\"definition\"><code>MOLVANIA</code></div><div class=\"content\"><code> move.l d1,d0</code><br/><code> mulu   d0,d0</code></div>")
+    }
+
+    @Test
+    internal fun check_expanded_documentation_for_a_macro_invocation_with_lots_of_params(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+; compress nibbles
+DTW MACRO
+ dc.b ((\1)<<4)|(\2),((\3)<<4)|(\4),((\5)<<4)|(\6),((\7)<<4)|(\8),((\9)<<4)|(\a),((\b)<<4)|(\c),((\d)<<4)|(\e),((\f)<<4)|(\g)
+ ENDM
+
+ DTW<caret> 15,14,14,10,1,2,3,4,10,11,10,12,5,3,9,10
+        """
+        )
+        assertThat(generateDocumentation(myFixture))
+            .isEqualTo("<span class=\"grayed\">; compress nibbles</span><div class=\"definition\"><code>DTW</code></div><div class=\"content\"><code> dc.b ((15)&lt;&lt;4)|(14),((14)&lt;&lt;4)|(10),((1)&lt;&lt;4)|(2),((3)&lt;&lt;4)|(4),((10)&lt;&lt;4)|(11),((10)&lt;&lt;4)|(12),((5)&lt;&lt;4)|(3),((9)&lt;&lt;4)|(10)</code></div>")
+    }
+}

src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kRegisterFlowDocumentationProviderTest.kt

@@ -100,7 +100,6 @@ nextlabel
             )
     }
 
-
     @Test
     internal fun check_documentation_for_a_written_register_in_code_flow(@MyFixture myFixture: CodeInsightTestFixture) {
         myFixture.configureByText(
@@ -177,6 +176,42 @@ nextlabel
         <td valign="top"> ; <font color="#00ff00">sets d1.l</font></td>
     </tr>
 </table>
+"""
+            )
+    }
+
+    @Test
+    internal fun check_documentation_for_68020_address_modes(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+    moveq.l #0,d0
+    lea     foobar(pc),a0
+    move.l  ([100.w,a0,a0.w*4],124.w),($42.w,a0,d0.l*4)
+    move.l  a<caret>0,a1
+"""
+        )
+        assertThat(generateDocumentation(myFixture))
+            .isEqualToIgnoringWhitespace(
+                """
+<div class="definition">movea instruction uses a0.l</div>
+<table class="sections" style="padding-left: 8pt; padding-right: 8pt">
+    <tr>
+        <td valign="top">        </td>
+        <td valign="top"><code>lea foobar(pc),<font color="#ffc800">a0</font></code></td>
+        <td valign="top"> ; <font color="#00ff00">sets a0.l</font></td>
+    </tr>
+    <tr>
+        <td valign="top">        </td>
+        <td valign="top"><code>move.l ([100.w,<font color="#ffc800">a0</font>,<font color="#ffc800">a0</font>.w*4],124.w),(${'$'}42.w,<font color="#ffc800">a0</font>,d0.l*4)</code>
+        </td>
+        <td valign="top"> ; uses a0.l, uses a0.w</td>
+    </tr>
+    <tr>
+        <td valign="top">--&gt;</td>
+        <td valign="top"><b><code>move.l <font color="#ffc800">a0</font>,a1</code></b></td>
+        <td valign="top"> ; &lt;--</td>
+    </tr>
+</table>
 """
             )
     }

src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kSymbolDefinitionDocumentationProviderTest.kt

@@ -14,11 +14,11 @@ internal class M68kSymbolDefinitionDocumentationProviderTest : AbstractDocumenta
     internal fun check_documentation_for_a_symbol_definition(@MyFixture myFixture: CodeInsightTestFixture) {
         myFixture.configureByText(
             "documentme.asm", """
-PIC_WIDTH = 320
+PIC_WIDTH = 320 ; width of picture
  move.w #PIC_WIDT<caret>H,d0
         """
         )
         assertThat(generateDocumentation(myFixture))
-            .isEqualTo("<div class='definition'><pre>PIC_WIDTH</pre></div><div class='content'>320</div>")
+            .isEqualTo("<span class=\"grayed\">; width of picture</span><div class=\"definition\"><code>PIC_WIDTH</code></div><div class=\"content\"><code>320</code></div>")
     }
 }

src/test/java/de/platon42/intellij/plugins/m68k/inspections/M68kInspectionSuppressorTest.kt

@@ -63,7 +63,7 @@ internal class M68kInspectionSuppressorTest : AbstractInspectionTest() {
         val quickFixPair = highlightInfos[0].quickFixActionRanges[0]
         val intentionActionDescriptor = quickFixPair.first
         val element = myFixture.file.findElementAt(quickFixPair.second.startOffset)!!
-        val suppressQuickFix = intentionActionDescriptor.getOptions(element, myFixture.editor)!!
+        val suppressQuickFix = intentionActionDescriptor.getOptions(element, myFixture.editor)
             .first { it.text == suppressAction }
         myFixture.launchAction(suppressQuickFix)
     }

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

@@ -14,7 +14,7 @@ internal class AddressingModesTest : AbstractParsingTest() {
 
     @Test
     internal fun register_direct(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        testGoodSyntax(testCase, " move.l d0,a7\n")
+        testGoodSyntax(testCase, " MOVE.L d0,a7\n")
     }
 
     @Test
@@ -52,6 +52,16 @@ internal class AddressingModesTest : AbstractParsingTest() {
         testGoodSyntax(testCase, " move.l (sp,d0.w),(a1,a3)\n")
     }
 
+    @Test
+    internal fun register_indirect_with_scaled_index_and_offset_old_syntax(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l -4+foo(sp,d0.w*8),(10*20+4)(a1,a3*4)\n")
+    }
+
+    @Test
+    internal fun register_indirect_with_scaled_index_and_offset_new_syntax(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (-4+foo,sp,a0*1),((10*20+4),a1,d5.l*2)\n")
+    }
+
     @Test
     internal fun pc_indirect_with_offset_old_syntax(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
         testGoodSyntax(testCase, " move.l -4*4(pc),+4(pc)\n")
@@ -82,6 +92,181 @@ 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.w,a1],124),([-12.w,a0],-120)\n")
+    }
+
+    @Test
+    internal fun memory_indirect_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([a1],124.l),([a0],-120.w)\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.w,a1],a0.w*4,124),([-12,a0],d0.l*8,-120.w)\n")
+    }
+
+    @Test
+    internal fun memory_indirect_post_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([a1],a0,124.l),([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.l,a1],a0),([-12,a0],d0.l*8)\n")
+    }
+
+    @Test
+    internal fun memory_indirect_post_indexed_without_address_register(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([1234.l],a0),([-12],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.w)\n")
+    }
+
+    @Test
+    internal fun memory_indirect_pre_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([1234.l,a1,a0]),([-12,a0,d0.l*8])\n")
+    }
+
+    @Test
+    internal fun memory_indirect_pre_indexed_without_address_register(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([1234.l,a0*4]),([-12,d0.l*8])\n")
+    }
+
+    @Test
+    internal fun memory_indirect_pre_indexed_only_with_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([a0*4]),([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.w,pc],124),d0\n")
+    }
+
+    @Test
+    internal fun pc_memory_indirect_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l ([pc],124.l),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.l,pc],a0.w*4,124.w),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.w,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.l),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 register_indirect_with_index_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (100.w,a0,a0.l*4),d0\n")
+    }
+
+    @Test
+    internal fun register_indirect_with_index_base_displacement_without_areg(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (100.w,a0.l*4),d0\n")
+    }
+
+    @Test
+    internal fun register_indirect_with_index_base_displacement_without_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (100.l,a0),d0\n")
+    }
+
+    @Test
+    internal fun register_indirect_with_index_base_displacement_with_dreg_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (d0),(d0.w*4)\n")
+    }
+
+    @Test
+    internal fun register_indirect_with_index_base_displacement_only(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (100.l),d0\n")
+    }
+
+    @Test
+    internal fun register_indirect_with_index_base_displacement_zero(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (),d0\n")
+    }
+
+    @Test
+    internal fun pc_indirect_with_index_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (100.w,pc,a0.l*4),d0\n")
+    }
+
+    @Test
+    internal fun pc_indirect_with_index_base_displacement_without_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " move.l (100.l,pc),d0\n")
+    }
+
     @Test
     internal fun absolute_address(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
         testGoodSyntax(testCase, " move.l 4.w,a6\n")

src/test/java/de/platon42/intellij/plugins/m68k/parser/CommentsTest.kt

@@ -3,6 +3,7 @@ package de.platon42.intellij.plugins.m68k.parser
 import de.platon42.intellij.jupiter.MyTestCase
 import de.platon42.intellij.jupiter.ParsingTestExtension
 import de.platon42.intellij.jupiter.TestDataSubPath
+import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
 import org.junit.jupiter.api.Test
 
 @TestDataSubPath("comments")
@@ -50,37 +51,51 @@ internal class CommentsTest : AbstractParsingTest() {
 
     @Test
     internal fun comment_after_instruction_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        (testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = true
+        setSpacesSetting(testCase, true)
         testGoodSyntax(testCase, " add.w d0,d0 hey comment\n")
     }
 
     @Test
     internal fun comment_after_assignment_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        (testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = true
+        setSpacesSetting(testCase, true)
+
         testGoodSyntax(testCase, "FOO = 123+23 hey comment\n")
     }
 
+    @Test
+    internal fun comment_after_data_directive_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        setSpacesSetting(testCase, true)
+
+        testGoodSyntax(testCase, " dc.w $1234,$2345 hey comment\n")
+    }
+
     @Test
     internal fun comment_after_macro_call_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        (testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = true
+        setSpacesSetting(testCase, true)
         testGoodSyntax(testCase, " PUSHM d0,d0 hey comment\n")
     }
 
     @Test
     internal fun space_does_not_start_comment_within_instruction_without_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        (testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = false
+        setSpacesSetting(testCase, false)
         testGoodSyntax(testCase, " add.w # 234, d0 ; hey comment\n")
     }
 
     @Test
     internal fun space_does_not_start_comment_within_assignment_without_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        (testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = false
+        setSpacesSetting(testCase, false)
         testGoodSyntax(testCase, "FOO = 123 + 23 ; hey comment\n")
     }
 
     @Test
     internal fun space_does_not_start_comment_within_macro_call_without_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
-        (testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = false
+        setSpacesSetting(testCase, false)
         testGoodSyntax(testCase, " PUSHM d0, d0 ; hey comment\n")
     }
+
+    private fun setSpacesSetting(testCase: ParsingTestExtension.IParsingTestCase, spacesOption: Boolean) {
+        val settings = M68kProjectSettings()
+        settings.settings.spaceIntroducesComment = spacesOption
+        testCase.project.registerService(M68kProjectSettings::class.java, settings)
+    }
 }

src/test/java/de/platon42/intellij/plugins/m68k/refs/M68kReferenceContributorTest.kt

@@ -103,7 +103,7 @@ internal class M68kReferenceContributorTest : AbstractM68kTest() {
         assertThat(otherfile.text).isEqualTo("; oh no!")
 
         myFixture.renameElementAtCaret("foobar.asm")
-        val files = FilenameIndex.getFilesByName(myFixture.project, "foobar.asm", GlobalSearchScope.allScope(myFixture.project))
+        val files = FilenameIndex.getVirtualFilesByName("foobar.asm", GlobalSearchScope.allScope(myFixture.project))
         assertThat(files).hasSize(1)
 
         assertThat(file.text).isEqualToIgnoringWhitespace("include \"foobar.asm\"")
@@ -123,7 +123,7 @@ internal class M68kReferenceContributorTest : AbstractM68kTest() {
         assertThat(otherfile.text).isEqualTo("; oh no!")
 
         myFixture.renameElementAtCaret("foobar.asm")
-        val files = FilenameIndex.getFilesByName(myFixture.project, "foobar.asm", GlobalSearchScope.allScope(myFixture.project))
+        val files = FilenameIndex.getVirtualFilesByName("foobar.asm", GlobalSearchScope.allScope(myFixture.project))
         assertThat(files).hasSize(1)
 
         assertThat(file.text).isEqualToIgnoringWhitespace("include \"foobar/foobar.asm\"")

src/test/resources/parser/addressingmodes/memory_indirect_minimal.txt

@@ -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')

src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_minimal.txt

@@ -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')

src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_with_all_params.txt

@@ -0,0 +1,69 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('120')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_address_register.txt

@@ -0,0 +1,45 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('12')
+        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')

src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_base_displacement.txt

@@ -0,0 +1,51 @@
+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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('124')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('120')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_outer_displacement.txt

@@ -0,0 +1,51 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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')

src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_minimal.txt

@@ -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')

src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_only_with_index.txt

@@ -0,0 +1,37 @@
+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)('[')
+        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.ROUND_R)(')')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
+        PsiElement(M68kTokenType.ROUND_L)('(')
+        PsiElement(M68kTokenType.SQUARE_L)('[')
+        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')

src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_with_all_params.txt

@@ -0,0 +1,65 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('120')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_address_register.txt

@@ -0,0 +1,49 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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.ROUND_R)(')')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
+        PsiElement(M68kTokenType.ROUND_L)('(')
+        PsiElement(M68kTokenType.SQUARE_L)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('12')
+        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')

src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_base_displacement.txt

@@ -0,0 +1,51 @@
+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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('120')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_outer_displacement.txt

@@ -0,0 +1,51 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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')

src/test/resources/parser/addressingmodes/memory_indirect_with_all_params.txt

@@ -0,0 +1,49 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        PsiElement(M68kTokenType.SEPARATOR)(',')
+        M68kAddressRegisterImpl(ADDRESS_REGISTER)
+          PsiElement(M68kTokenType.AREG)('a1')
+        PsiElement(M68kTokenType.SQUARE_R)(']')
+        PsiElement(M68kTokenType.SEPARATOR)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('12')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        PsiElement(M68kTokenType.SEPARATOR)(',')
+        M68kAddressRegisterImpl(ADDRESS_REGISTER)
+          PsiElement(M68kTokenType.AREG)('a0')
+        PsiElement(M68kTokenType.SQUARE_R)(']')
+        PsiElement(M68kTokenType.SEPARATOR)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('120')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/memory_indirect_without_base_displacement.txt

@@ -0,0 +1,39 @@
+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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('124')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
+            PsiElement(M68kTokenType.OP_MINUS)('-')
+            M68kLiteralExprImpl(LITERAL_EXPR)
+              PsiElement(M68kTokenType.DECIMAL)('120')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/memory_indirect_without_outer_displacement.txt

@@ -0,0 +1,35 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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')

src/test/resources/parser/addressingmodes/pc_indirect_with_index_base_displacement.txt

@@ -0,0 +1,34 @@
+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(' ')
+      M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE)
+        PsiElement(M68kTokenType.ROUND_L)('(')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('100')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        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_L)('.l')
+          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')

src/test/resources/parser/addressingmodes/pc_indirect_with_index_base_displacement_without_index.txt

@@ -0,0 +1,24 @@
+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(' ')
+      M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE)
+        PsiElement(M68kTokenType.ROUND_L)('(')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('100')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        PsiElement(M68kTokenType.SEPARATOR)(',')
+        PsiElement(M68kTokenType.PC)('pc')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
+        M68kDataRegisterImpl(DATA_REGISTER)
+          PsiElement(M68kTokenType.DREG)('d0')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/pc_memory_indirect_minimal.txt

@@ -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')

src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_minimal.txt

@@ -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')

src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_with_all_params.txt

@@ -0,0 +1,42 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('124')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
+        M68kDataRegisterImpl(DATA_REGISTER)
+          PsiElement(M68kTokenType.DREG)('d0')
+  PsiElement(M68kTokenType.EOL)('\n')

src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_without_base_displacement.txt

@@ -0,0 +1,34 @@
+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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          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')

src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_without_outer_displacement.txt

@@ -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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          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')

src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_minimal.txt

@@ -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')

src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_with_all_params.txt

@@ -0,0 +1,40 @@
+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)('[')
+        M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('1234')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_W)('.w')
+        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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          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')

src/test/resources/parser/addressingmodes/pc_memory_indirect_pre_indexed_without_base_displacement.txt

@@ -0,0 +1,34 @@
+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)(',')
+        M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
+          M68kLiteralExprImpl(LITERAL_EXPR)
+            PsiElement(M68kTokenType.DECIMAL)('124')
+          M68kDataWidthImpl(DATA_WIDTH)
+            PsiElement(M68kTokenType.OPSIZE_L)('.l')
+        PsiElement(M68kTokenType.ROUND_R)(')')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
+        M68kDataRegisterImpl(DATA_REGISTER)
+          PsiElement(M68kTokenType.DREG)('d0')
+  PsiElement(M68kTokenType.EOL)('\n')