Added some more settings for maximum parsed lines inside a macro and maximum displayed lines of code for documentation.

RegisterFlow line counting fixed.

README.md

@@ -6,30 +6,31 @@ _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, and the lack of a plugin for M68k was the motivation to write one. Also, diving deep into custom language plugins has a steep
+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
-learning curve.
+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.
 
-My plugin, on the other hand, is still pretty basic and is the result of a few weeks of work. I released a really early first version it because I think it's "
+My plugin, on the other hand, is still pretty basic and is the result of a few weeks of work. I released the first versions because I think it's "good enough"
-good enough" to get started, and I can return to demo coding with its current state.
+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
-- Inspection for validating the syntax of 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
+- Symbols / labels / macros code completion
-- References / Refactoring support for local and global labels, symbol assignments, and macros.
+- References / refactoring support for local and global labels, symbol assignments, and macros.
 - Simple register usage flow (hover over register or press F1 for full flow)
 - Brace matching
 - Quote handler
@@ -39,7 +40,10 @@ good enough" to get started, and I can return to demo coding with its current st
 
 ### Inspections
 
-#### M68kSyntaxInspection - Assembly instruction validity
+The plugin provides a few inspections for code analysis. An error or warning can be suppressed by placing a `; suppress <InspectionName>` comment either on an
+end of line comment behind the statement or in a full line comment above the statement.
+
+#### M68kSyntax - Assembly instruction validity
 
 Checks the validity of the current instruction. If an instruction is not recognized, you may get one of the following errors:
 
@@ -54,7 +58,7 @@ Checks the validity of the current instruction. If an instruction is not recogni
 - Operation size _(.b,.w,.l)_ unsupported for _mnemonic_
 - Operation size _(.b,.w,.l)_ unsupported (should be _(.b,.w,.l)_)
 
-#### M68kDeadWriteInspection - Dead writes to registers
+#### M68kDeadWrite - Dead writes to registers
 
 This inspection looks at register writes and tries to find instructions that renders a write moot because it was overwritten by another instruction before
 anything useful was done with it.
@@ -65,7 +69,7 @@ Analysis is aborted at global labels, flow control instructions, directives
 The inspection tries to take condition code changing into account and puts out a weak warning if the statement merely changes condition codes before the
 contents of the register are overwritten. In this case, it is sometimes better to replace `move` by `tst`.
 
-#### M68kUnexpectedConditionalInstructionInspection - Unaffected condition codes before conditional instruction
+#### M68kUnexpectedConditionalInstruction - Unaffected condition codes before conditional instruction
 
 Especially for novice coders, it is not clear that some instructions do not affect the condition codes for a subsequent condition branch or `scc` instruction.
 `movea`, `adda` and `suba` come to my mind.
@@ -75,13 +79,27 @@ The inspection will report such suspicious instruction sequences.
 However, this does not need to be a programming error. Advanced coders sometimes make use of the fact that instructions do not change condition codes and thus
 optimize the order of execution.
 
+#### M68kUnresolvedReference - Unresolved label/symbol/macro reference
+
+Points out unresolved references such for global and local labels, macros or symbols. Right now, missing symbol and global label references are shown only as
+weak warnings as missing macro evaluation will not resolve symbols defined via `STRUCT` macros.
+
 ### Documentation provider
 
-#### M68kSymbolDefinitionDocumentationProvider
+#### M68kSymbolDefinition
 
 Provides the assigned value of a `=`, `set` or `equ` symbol definition when hovering over a symbol.
 
-#### M68kRegisterFlowDocumentationProvider
+#### M68kMacroDefinition
+
+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
 
 When hovering over or placing the cursor at a data or address register, the documentation will scan through the instructions backwards and forwards and will
 show all read, changes of the register contents. It does this until an instruction is found that defines (sets) the contents of the register
@@ -92,7 +110,7 @@ The analysis ignores all code flow instructions and might be inaccurate for bran
 The documentation will search up to 100 instructions in each direction, but only four when hovering over the register
 (so if you need the whole analysis, use the documentation window).
 
-#### M68kInstructionDocumentationProvider
+#### M68kInstruction
 
 When hovering over a mnemonic, it will show a short description of the assembly instruction.
 
@@ -104,13 +122,17 @@ If the current statement has no valid syntax, the instruction details of all mat
 ## Known issues
 
 - `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`).
-- No support for includes. Scoping is 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).
-- `opt` keyword needs special treatment and will currently show a parsing error.
 - Missing but planned features:
     - Macro evaluation on invocation
     - Folding
@@ -133,17 +155,46 @@ It is probably the only plugin (besides [Cajon](https://github.com/chrisly42/caj
 far (or at least the only one I'm aware of ;) ). The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to
 make it work with JUnit 5. Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
 
-## Private TODO list
+## Feedback
 
-- code completion suggestion for unresolved local labels, global labels and symbols
+I guess there are currently over 500 users of this plugin and while I wrote this mainly for myself, I'm only doing this in my spare time.
-- support `include` directive
+
-- support `opt` directive
+Feedback and [rating](https://plugins.jetbrains.com/plugin/17268-mc68000-assembly-language-support/reviews)
-- suppression support via comments
+are appreciated. It really is keeping me motivated to continue development.
-- inspection: Unresolved local label
-- inspection: Unresolved macro
 
 ## Changelog
 
+### 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).
+- Bugfix: `movem` with pc-relative mode was missing for weird immediate mode (courtesy of Yann).
+- Bugfix: Special registers for address mode matching only worked with lower case register names (courtesy of Yann).
+- Enhancement: Assembler syntax with implicit immediate 1 for shifts and rotations no longer cause syntax errors (courtesy of Yann).
+- Enhancement: Documentation for instruction with special register shows specific register expected.
+- New: Added documentation provider info for global labels. Shows directives and comments above.
+- Bugfix: Fixed BNF for labels with preprocessor statements.
+- Disabled: `END` detection was breaking parsing, causing havoc.
+
+### V0.6 (09-Aug-21)
+
+- Enhancement: `opt` and several other directives (`printt`, `fail` etc.) no longer causes a syntax error when unquoted.
+- Enhancement: `include`, `incdir` and `incbin` and `output` with `<pathname>` quotes no longer cause syntax error.
+- New: Files in `include` directives can be referenced and renamed/refactored.
+- New: Code completion for local label definitions, suggesting undefined labels already referenced.
+- New: Added inspection suppression possibility and quickfix.
+- New: Added inspection for unresolved symbols, macros and labels.
+- Enhancement: 'END' directive stops parsing.
+
 ### V0.5 (06-Aug-21)
 
 - Bugfix: `movem` ISA was wrong regarding the `movem.w <ea>,<registerlist>` (sign extends registers).
@@ -175,7 +226,7 @@ make it work with JUnit 5. Feel free to use the code (in package ```de.platon42.
 - Enhancement: Macro definitions are now word and stub indexed, macro calls reference to definition.
 - New: Macro definition refactoring and find usages support.
 - Enhancement: Structural View also shows macro definitions.
-- Bugfix: Missing REPT and ENDR assembler directives added.
+- Bugfix: Missing `REPT` and `ENDR` assembler directives added.
 - Cosmetics: Changed or added some icons at various places.
 - Performance: Reference search for global labels and symbols now uses stub index.
 - Compatibility: Restored compatibility with IDE versions < 2021.1.

build.gradle

@@ -1,13 +1,13 @@
 plugins {
     id 'java'
-    id 'org.jetbrains.intellij' version '1.1.3'
+    id 'org.jetbrains.intellij' version '1.1.6'
     id 'org.jetbrains.kotlin.jvm' version '1.5.21'
     id 'jacoco'
-    id 'com.github.kt3k.coveralls' version '2.11.0'
+    id 'com.github.kt3k.coveralls' version '2.12.0'
 }
 
 group = 'de.platon42'
-version = '0.5'
+version = '0.8'
 sourceCompatibility = "1.8"
 targetCompatibility = "1.8"
 
@@ -22,9 +22,9 @@ repositories {
 
 dependencies {
     implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
-    testImplementation "org.assertj:assertj-core:3.20.2"
+    testImplementation "org.assertj:assertj-core:3.21.0"
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
     testImplementation "org.jetbrains.kotlin:kotlin-test"
     testImplementation "org.jetbrains.kotlin:kotlin-reflect"
 //    testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
@@ -42,45 +42,31 @@ compileTestKotlin {
 }
 
 intellij {
-    setVersion("2021.2") // LATEST-EAP-SNAPSHOT
+    setVersion("2021.2.2") // LATEST-EAP-SNAPSHOT
     setUpdateSinceUntilBuild(false)
 //    setPlugins(["com.intellij.java"])
 }
 
 runPluginVerifier {
-    ideVersions = ["IC-203.6682.168", "IC-212.4746.92", // 2020.3 - 2021.2
+    ideVersions = ["IC-203.6682.168", "IC-212.5457.46", // 2020.3 - 2021.2.3
                    "CL-203.5981.166", "CL-203.8084.11", // 2020.3
                    "CL-211.6693.114", "CL-211.7628.27", // 2021.1
-                   "CL-212.4746.93"] // 2021.2
+                   "CL-212.4746.93", "CL-212.5284.51"] // 2021.2 - 2021.2.2
-    downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea"
+    downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
 }
 
 patchPluginXml {
     setChangeNotes("""
-  <h4>V0.5 (06-Aug-21)</h4>
+  <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.8 (15-Oct-21)</h4>
     <ul>
-      <li>Bugfix: movem ISA was wrong regarding movem.w <ea>,<registerlist> (sign extends registers).
+      <li>New: Support for MC68020+ addressing modes! However, MC68020+ specific instructions have not been added yet.
-      <li>Cosmetics: Changed Register Flow Documentation wording from 'reads' to 'uses' and from 'modifies' to 'changes'.
+      <li>New: Full support for MC68010 ISA ('movec', 'moves' and new special registers 'SFC' and 'DFC').
-      <li>Bugfix: Minor fix for `andi/eori/ori to ccr` which were not byte sized in ISA.
+      <li>Enhancement: Label documentation now also works for local labels and includes end-of-line comment for label, too.
-      <li>Bugfix: Added alternate condition code tests HS (=CC) and LO (=CS).
+      <li>Enhancement: Symbol definition documentation now also includes comments in the same way as the label documentation does.
-      <li>Performance: Optimized mnemonic lookup.
+      <li>New: Macro definition / invocation documentation provider that even tries to expand macros.
-      <li>Enhancement: Reworked Instruction Documentation provider, now shows condition codes.
+      <li>New: Added Language settings page with one option so far (-spaces option).
-      <li>Bugfix: In ISA exg is no longer treated as setting a definitive value.
+      <li>New: Added some more settings for maximum parsed lines inside a macro and maximum displayed lines of code for documentation.
-      <li>New: Added inspection to find dead writes to registers!
-      <li>New: Added inspection to warn about unexpected condition code unaffecting instructions before conditional instructions.
-    </ul>
-  <h4>V0.4 (03-Aug-21)</h4>
-    <ul>
-      <li>Notice: Due to major new API use, this plugin no longer works on IDEs >=2019.3.1, but rather requires >=2020.3.
-      <li>Enhancement: Added Structure View filters.
-      <li>New: Added inspection to validate the correctness of a MC68000 instruction regarding operation size and address modes.
-      <li>Bugfix: Added several missing assembler directives (opt, machine, etc.).
-      <li>Bugfix: Uppercase hexadecimal literals were not parsed (JFlex bug?).
-      <li>Bugfix: Interpretation of register lists was wrong in BNF.
-      <li>New: Added Documentation Provider for symbol definitions (shows assigned declaration).
-      <li>New: Added Documentation Provider for mnemonics (simple version, generated out of ISA information).
-      <li>Bugfix: Macro definitions with colons and without space supported (as found in P61a source).
-      <li>New: When asking for documentation on registers, a code flow analysis is done. Cool stuff!
     </ul>
   <p>Full changelog available at <a href="https://github.com/chrisly42/mc68000-asm-plugin#changelog">Github project site</a>.</p>
 """)

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) {
@@ -562,9 +660,13 @@ public class M68kParser implements PsiParser, LightPsiParser {
     }
 
     /* ********************************************************** */
-    // Instruction
+    // Instruction|PreprocessorDirective
     static boolean InstructionOnly(PsiBuilder b, int l) {
-        return Instruction(b, l + 1);
+        if (!recursion_guard_(b, l, "InstructionOnly")) return false;
+        boolean r;
+        r = Instruction(b, l + 1);
+        if (!r) r = PreprocessorDirective(b, l + 1);
+        return r;
     }
 
     /* ********************************************************** */
@@ -596,18 +698,27 @@ public class M68kParser implements PsiParser, LightPsiParser {
     }
 
     /* ********************************************************** */
-    // Label Instruction
+    // Label (Instruction|PreprocessorDirective)
     static boolean LabelWithInstruction(PsiBuilder b, int l) {
         if (!recursion_guard_(b, l, "LabelWithInstruction")) return false;
         if (!nextTokenIs(b, "", GLOBAL_LABEL_DEF, LOCAL_LABEL_DEF)) return false;
         boolean r;
         Marker m = enter_section_(b);
         r = Label(b, l + 1);
-        r = r && Instruction(b, l + 1);
+        r = r && LabelWithInstruction_1(b, l + 1);
         exit_section_(b, m, null, r);
         return r;
     }
 
+    // Instruction|PreprocessorDirective
+    private static boolean LabelWithInstruction_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "LabelWithInstruction_1")) return false;
+        boolean r;
+        r = Instruction(b, l + 1);
+        if (!r) r = PreprocessorDirective(b, l + 1);
+        return r;
+    }
+
     /* ********************************************************** */
     // LOCAL_LABEL_DEF COLON?
     public static boolean LocalLabel(PsiBuilder b, int l) {
@@ -751,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) {
@@ -764,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) {
@@ -817,42 +1134,38 @@ public class M68kParser implements PsiParser, LightPsiParser {
     }
 
     /* ********************************************************** */
-    // Label? (DATA_DIRECTIVE | OTHER_DIRECTIVE)
+    // PreprocessorKeyword PreprocessorOperands?
-    //         PreprocessorOperands?
     public static boolean PreprocessorDirective(PsiBuilder b, int l) {
         if (!recursion_guard_(b, l, "PreprocessorDirective")) return false;
+        if (!nextTokenIs(b, "<preprocessor directive>", DATA_DIRECTIVE, OTHER_DIRECTIVE)) return false;
         boolean r;
         Marker m = enter_section_(b, l, _NONE_, PREPROCESSOR_DIRECTIVE, "<preprocessor directive>");
-        r = PreprocessorDirective_0(b, l + 1);
+        r = PreprocessorKeyword(b, l + 1);
         r = r && PreprocessorDirective_1(b, l + 1);
-        r = r && PreprocessorDirective_2(b, l + 1);
         exit_section_(b, l, m, r, false, null);
         return r;
     }
 
-    // Label?
+    // PreprocessorOperands?
-    private static boolean PreprocessorDirective_0(PsiBuilder b, int l) {
-        if (!recursion_guard_(b, l, "PreprocessorDirective_0")) return false;
-        Label(b, l + 1);
-        return true;
-    }
-
-    // DATA_DIRECTIVE | OTHER_DIRECTIVE
     private static boolean PreprocessorDirective_1(PsiBuilder b, int l) {
         if (!recursion_guard_(b, l, "PreprocessorDirective_1")) return false;
-        boolean r;
-        r = consumeToken(b, DATA_DIRECTIVE);
-        if (!r) r = consumeToken(b, OTHER_DIRECTIVE);
-        return r;
-    }
-
-    // PreprocessorOperands?
-    private static boolean PreprocessorDirective_2(PsiBuilder b, int l) {
-        if (!recursion_guard_(b, l, "PreprocessorDirective_2")) return false;
         PreprocessorOperands(b, l + 1);
         return true;
     }
 
+    /* ********************************************************** */
+    // DATA_DIRECTIVE | OTHER_DIRECTIVE
+    public static boolean PreprocessorKeyword(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "PreprocessorKeyword")) return false;
+        if (!nextTokenIs(b, "<preprocessor keyword>", DATA_DIRECTIVE, OTHER_DIRECTIVE)) return false;
+        boolean r;
+        Marker m = enter_section_(b, l, _NONE_, PREPROCESSOR_KEYWORD, "<preprocessor keyword>");
+        r = consumeToken(b, DATA_DIRECTIVE);
+        if (!r) r = consumeToken(b, OTHER_DIRECTIVE);
+        exit_section_(b, l, m, r, false, null);
+        return r;
+    }
+
     /* ********************************************************** */
     // expr
     static boolean PreprocessorOperand(PsiBuilder b, int l) {
@@ -940,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) {
@@ -995,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) {
@@ -1122,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;
@@ -1131,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;
     }
@@ -1170,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) {
@@ -1217,14 +1968,12 @@ public class M68kParser implements PsiParser, LightPsiParser {
 
     /* ********************************************************** */
     // Assignment
-    //             | PreprocessorDirective
     //             | LabelInsts
     public static boolean statement(PsiBuilder b, int l) {
         if (!recursion_guard_(b, l, "statement")) return false;
         boolean r;
         Marker m = enter_section_(b, l, _NONE_, STATEMENT, "<statement>");
         r = Assignment(b, l + 1);
-        if (!r) r = PreprocessorDirective(b, l + 1);
         if (!r) r = LabelInsts(b, l + 1);
         exit_section_(b, l, m, r, false, M68kParser::statement_recover);
         return r;
@@ -1236,11 +1985,21 @@ public class M68kParser implements PsiParser, LightPsiParser {
         if (!recursion_guard_(b, l, "statement_recover")) return false;
         boolean r;
         Marker m = enter_section_(b, l, _NOT_);
-        r = !consumeToken(b, EOL);
+        r = !statement_recover_0(b, l + 1);
         exit_section_(b, l, m, r, false, null);
         return r;
     }
 
+    // (EOL)
+    private static boolean statement_recover_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "statement_recover_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeTokenFast(b, EOL);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
     /* ********************************************************** */
     // Expression root: expr
     // Operator priority table:

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/M68kPreprocessorDirective.java

@@ -2,17 +2,13 @@
 package de.platon42.intellij.plugins.m68k.psi;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
 public interface M68kPreprocessorDirective extends M68kPsiElement {
 
-    @Nullable
+    @NotNull
-    M68kGlobalLabel getGlobalLabel();
+    M68kPreprocessorKeyword getPreprocessorKeyword();
-
-    @Nullable
-    M68kLocalLabel getLocalLabel();
 
     @NotNull
     List<M68kExpr> getExprList();

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

@@ -0,0 +1,6 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+public interface M68kPreprocessorKeyword extends M68kPsiElement {
+
+}

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,19 +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");
@@ -125,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");
@@ -132,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");
@@ -155,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) {
@@ -167,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) {
@@ -215,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) {
@@ -227,20 +249,38 @@ 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) {
                 return new M68kPreprocessorDirectiveImpl(node);
+            } else if (type == PREPROCESSOR_KEYWORD) {
+                return new M68kPreprocessorKeywordImpl(node);
             } else if (type == PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE) {
                 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,14 +138,45 @@ 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);
     }
 
+    public void visitPreprocessorKeyword(@NotNull M68kPreprocessorKeyword o) {
+        visitPsiElement(o);
+    }
+
     public void visitProgramCounterIndirectWithDisplacementNewAddressingMode(@NotNull M68kProgramCounterIndirectWithDisplacementNewAddressingMode o) {
         visitAddressingMode(o);
         // visitWithDisplacement(o);
@@ -141,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);
@@ -153,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/M68kPreprocessorDirectiveImpl.java

@@ -1,17 +1,15 @@
 // 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.*;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public class M68kPreprocessorDirectiveImpl extends ASTWrapperPsiElement implements M68kPreprocessorDirective {
+public class M68kPreprocessorDirectiveImpl extends M68kPreprocessorDirectiveMixin implements M68kPreprocessorDirective {
 
     public M68kPreprocessorDirectiveImpl(@NotNull ASTNode node) {
         super(node);
@@ -28,15 +26,9 @@ public class M68kPreprocessorDirectiveImpl extends ASTWrapperPsiElement implemen
     }
 
     @Override
-    @Nullable
+    @NotNull
-    public M68kGlobalLabel getGlobalLabel() {
+    public M68kPreprocessorKeyword getPreprocessorKeyword() {
-        return PsiTreeUtil.getChildOfType(this, M68kGlobalLabel.class);
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kPreprocessorKeyword.class));
-    }
-
-    @Override
-    @Nullable
-    public M68kLocalLabel getLocalLabel() {
-        return PsiTreeUtil.getChildOfType(this, M68kLocalLabel.class);
     }
 
     @Override

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

@@ -0,0 +1,27 @@
+// 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 de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorKeyword;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+
+public class M68kPreprocessorKeywordImpl extends ASTWrapperPsiElement implements M68kPreprocessorKeyword {
+
+    public M68kPreprocessorKeywordImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitPreprocessorKeyword(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+}

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 = 5
+        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/AssemblerDirectives.kt

@@ -22,7 +22,15 @@ object AssemblerDirectives {
         "rsset", "clrfo", "clrso", "setfo", "setso"
     )
 
-    val otherDirective: Set<String> = setOf(
+    val plainDirectives: Set<String> = setOf(
+        "incdir", "include", "incbin", "output", "idnt",
+
+        "printt", "echo", "fail",
+
+        "opt"
+    )
+
+    val otherDirectives: Set<String> = setOf(
         "if",
         "ifeq", "ifne", "ifgt", "ifge", "iflt", "ifle", "ifb", "ifnb", "ifc", "ifnc",
         "ifd", "ifnd", "ifmacrod", "ifmacrond",
@@ -38,12 +46,10 @@ object AssemblerDirectives {
         "reg", "equr", "equrl",
         "freg", "fequr", "fequrl",
 
-        "incdir", "include", "incbin", "output",
-
         "list", "nlist", "nolist", "llen", "nopage", "page", "spc",
         "org",
 
-        "assert", "fail", "print", "printt", "printv", "echo",
+        "assert", "printv",
 
         "inline", "einline",
         "rem", "erem",
@@ -53,6 +59,6 @@ object AssemblerDirectives {
 
         "basereg", "endb", "far", "near", "initnear",
 
-        "opt"
+        "end"
     )
 }

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,8 +49,18 @@ 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)"),
-    SPECIAL_REGISTER_DIRECT("special register", "ccr|usp|vbr"),
+    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>"),
     ABSOLUTE_ADDRESS("absolute short/long", "(xxx).w|l")
@@ -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,
@@ -202,6 +243,18 @@ object M68kIsa {
         AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX,
     )
 
+    private val ALL_EXCEPT_AREG_AND_DREG = setOf(
+        AddressMode.ADDRESS_REGISTER_INDIRECT,
+        AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC,
+        AddressMode.ADDRESS_REGISTER_INDIRECT_PRE_DEC,
+        AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT,
+        AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX,
+        AddressMode.ABSOLUTE_ADDRESS,
+        AddressMode.IMMEDIATE_DATA,
+        AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT,
+        AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX,
+    )
+
     private val INDIRECT_MODES = setOf(
         AddressMode.ADDRESS_REGISTER_INDIRECT,
         AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC,
@@ -213,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(
@@ -256,33 +310,39 @@ object M68kIsa {
     private val ASD_LSD_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, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****")),
+        AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****")),
+        // not an official address mode, but supported by assembler (implicit #1)
+        AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****"))
     )
 
     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*")),
-        AllowedAdrMode(INDIRECT_MODES, null, modInfo = RWM_MODIFY_OP1_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 ROXD_MODES = listOf(
         AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
         AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
-        AllowedAdrMode(INDIRECT_MODES, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
+        AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
+        // not an official address mode, but supported by assembler (implicit #1)
+        AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
     )
 
     private val BCHG_BCLR_BSET_MODES = listOf(
         AllowedAdrMode(DREG_ONLY, DREG_ONLY, OP_SIZE_L, modInfo = RWM_READ_OP1_B or RWM_MODIFY_OP2_L, affectedCc = cc("--*--")),
         AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_READ_OP1_B or RWM_MODIFY_OP2_B, affectedCc = cc("--*--")),
         AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, OP_SIZE_L, modInfo = RWM_MODIFY_OP2_L, affectedCc = cc("--*--")),
-        AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_MODIFY_OP2_B, affectedCc = cc("--*--")),
+        AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), ALL_EXCEPT_AREG_AND_DREG, OP_SIZE_B, modInfo = RWM_MODIFY_OP2_B, affectedCc = cc("--*--")),
     )
 
     private val BTST_MODES = listOf(
         AllowedAdrMode(DREG_ONLY, DREG_ONLY, OP_SIZE_L, modInfo = RWM_READ_OP1_B or RWM_READ_OP2_L, affectedCc = cc("--*--")),
-        AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_READ_OP1_B or RWM_READ_OP2_B, affectedCc = cc("--*--")),
+        AllowedAdrMode(DREG_ONLY, ALL_EXCEPT_AREG_AND_DREG, OP_SIZE_B, modInfo = RWM_READ_OP1_B or RWM_READ_OP2_B, affectedCc = cc("--*--")),
         AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, OP_SIZE_L, modInfo = RWM_READ_OP2_L, affectedCc = cc("--*--")),
-        AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_READ_OP2_B, affectedCc = cc("--*--")),
+        AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), ALL_EXCEPT_AREG_AND_DREG, OP_SIZE_B, modInfo = RWM_READ_OP2_B, affectedCc = cc("--*--")),
     )
 
     private val conditionCodes =
@@ -293,6 +353,9 @@ object M68kIsa {
     private val isaData = listOf(
 
         // Data Movement Instructions
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData(
                 "move", "Move",
                 modes = listOf(
@@ -302,12 +365,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),
@@ -354,7 +421,9 @@ object M68kIsa {
                         AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC,
                         AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT,
                         AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX,
-                        AddressMode.ABSOLUTE_ADDRESS
+                        AddressMode.ABSOLUTE_ADDRESS,
+                        AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT,
+                        AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
                     ),
                     setOf(AddressMode.IMMEDIATE_DATA),
                     OP_SIZE_WL,
@@ -362,8 +431,10 @@ object M68kIsa {
                 ),
             )
         ),
+
         IsaData(
             "movep", "Move Peripheral",
+            machine = EnumSet.range(Machine.MC68000, Machine.MC68040),
             modes = listOf(
                 AllowedAdrMode(
                     DREG_ONLY,
@@ -382,11 +453,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),
@@ -396,6 +469,10 @@ object M68kIsa {
                 )
             )
         ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
+
             IsaData(
                 "lea", "Load Effective Address",
                 modes = listOf(
@@ -414,6 +491,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "pea", "Push Effective Address",
                 modes = listOf(
@@ -431,22 +509,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(
@@ -455,14 +543,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(
@@ -471,8 +567,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(
@@ -482,6 +584,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "negx", "Negate with Extend", modes = listOf(
                     AllowedAdrMode(
@@ -514,10 +617,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(
@@ -526,9 +639,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),
@@ -539,26 +655,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(
@@ -566,6 +697,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"),
@@ -578,6 +710,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "eor", "Logical Exclusive-OR",
                 modes = listOf(
@@ -589,6 +722,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "eori", "Logical Exclusive-OR Immediate", altMnemonics = listOf("eor"),
                 modes = listOf(
@@ -600,6 +734,7 @@ object M68kIsa {
                     )
                 )
             ),
+
             IsaData(
                 "or", "Logical Inclusive-OR",
                 modes = listOf(
@@ -607,6 +742,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(
@@ -618,6 +754,7 @@ 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")))
@@ -632,6 +769,8 @@ object M68kIsa {
             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",
@@ -639,14 +778,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,
@@ -663,6 +807,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,
@@ -677,6 +822,9 @@ object M68kIsa {
                 )
             )
         ),
+
+        *autoExpandForOtherCpus(
+            MC68020_PLUS,
             IsaData(
                 "nbcd", "Negate Decimal with Extend",
                 modes = listOf(
@@ -685,6 +833,7 @@ object M68kIsa {
                         affectedCc = cc("CUAU*"), testedCc = cc("?-?--")
                     )
                 )
+            )
         ),
 
         // Program Control Instructions
@@ -713,6 +862,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("-????")))
@@ -749,24 +902,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")
@@ -774,9 +933,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",
@@ -786,6 +961,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",
@@ -795,6 +971,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",
@@ -802,8 +979,10 @@ object M68kIsa {
                 )
             )
         ),
+
         IsaData(
             "move", "Move from Status Register", id = "move from SR",
+            machine = MC68000_ONLY,
             modes = listOf(
                 AllowedAdrMode(
                     setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
@@ -815,6 +994,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(
@@ -823,34 +1021,82 @@ 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,
+            machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
+            modes = listOf(
+                AllowedAdrMode(setOf(AddressMode.SPECIAL_REGISTER_DIRECT), DREG_AREG, OP_SIZE_L, "sfc|dfc|usp|vbr", modInfo = RWM_SET_OP2_L),
+                AllowedAdrMode(DREG_AREG, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_L, "sfc|dfc|usp|vbr", modInfo = RWM_READ_OP1_L),
+            )
+        ),
+
+        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", isPrivileged = true,
+            "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
         ),
@@ -882,21 +1128,75 @@ 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 val mnemonicLookupMap = isaData.asSequence()
+    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 {
             (if (it.conditionCodes.isEmpty()) it.altMnemonics.plus(it.mnemonic) else it.altMnemonics.plus(it.conditionCodes
                 .map { cc ->
@@ -944,5 +1244,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 == am.specialReg)))
+                && ((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/M68kInstructionDocumentationProvider.kt

@@ -92,8 +92,8 @@ class M68kInstructionDocumentationProvider : AbstractDocumentationProvider() {
                 val cellsPerRow = ArrayList<HtmlChunk>(3)
                 cellsPerRow.add(contentBuilder.toFragment())
 
-                if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op1))
+                if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op1, allowedAdrMode.specialReg))
-                if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op2))
+                if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op2, allowedAdrMode.specialReg))
 
                 addressModeInfoRows.append(HtmlChunk.tag("tr").children(cellsPerRow.map { it.wrapWith(DocumentationMarkup.SECTION_CONTENT_CELL) }))
                 addressModeInfoRows.toFragment()
@@ -126,11 +126,12 @@ class M68kInstructionDocumentationProvider : AbstractDocumentationProvider() {
         return defBuilder
     }
 
-    private fun collectAddressModes(addressModes: Set<AddressMode>?): HtmlChunk {
+    private fun collectAddressModes(addressModes: Set<AddressMode>?, specialReg: String?): HtmlChunk {
         if (addressModes == null) return HtmlChunk.text("")
         val modes = HtmlBuilder()
         addressModes.sortedBy(AddressMode::ordinal)
-            .forEach { modes.append(HtmlChunk.text(it.syntax).wrapWith(HtmlChunk.div())) }
+            .map { if (it == AddressMode.SPECIAL_REGISTER_DIRECT) specialReg!! else it.syntax }
+            .forEach { modes.append(HtmlChunk.text(it).wrapWith(HtmlChunk.div())) }
         return modes.toFragment()
     }
 

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
     }
@@ -79,24 +78,19 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
         )
 
         backtrace.addAll(analyseFlow(register, missingBits, true, initialStatement, linesLimit) {
-            PsiTreeUtil.getPrevSiblingOfType(
+            PsiTreeUtil.getPrevSiblingOfType(it, M68kStatement::class.java)
-                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(
+            PsiTreeUtil.getNextSiblingOfType(it, M68kStatement::class.java)
-                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()
     }
@@ -113,7 +107,7 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
         var currStatement = startingStatement
         val statementLines = ArrayList<HtmlChunk>()
         val rn = register.regname
-        var addAbrevDots = false
+        var addAbbrevDots = false
         var lines = 0
         while (missingBits > 0) {
             val globalLabel = PsiTreeUtil.findChildOfType(currStatement, M68kGlobalLabel::class.java)
@@ -127,17 +121,17 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
             currStatement = direction.invoke(currStatement) ?: break
             val currAsmInstruction = PsiTreeUtil.getChildOfType(currStatement, M68kAsmInstruction::class.java) ?: continue
             if (checkIfInstructionUsesRegister(currAsmInstruction, register)) {
-                if (addAbrevDots) {
+                if (addAbbrevDots) {
                     ++lines
                     statementLines.add(createAbbreviationDots())
                 }
                 if (++lines > linesLimit) {
-                    if (!addAbrevDots) {
+                    if (!addAbbrevDots) {
                         statementLines.add(createAbbreviationDots())
                     }
                     break
                 }
-                addAbrevDots = false
+                addAbbrevDots = false
                 val (_, currAdrMode) = findExactIsaDataAndAllowedAdrModeForInstruction(currAsmInstruction) ?: continue
 
                 val localLabelName = PsiTreeUtil.findChildOfType(currStatement, M68kLocalLabel::class.java)?.name ?: "        "
@@ -163,7 +157,7 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
                         .children(lineBuilder.wrapWith(DocumentationMarkup.SECTION_CONTENT_CELL))
                 )
             } else {
-                addAbrevDots = true
+                addAbbrevDots = true
             }
         }
         return statementLines

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.getParent() 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/M68kInspectionSuppressor.kt

@@ -0,0 +1,83 @@
+package de.platon42.intellij.plugins.m68k.inspections
+
+import com.intellij.codeInspection.InspectionSuppressor
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.codeInspection.SuppressQuickFix
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiComment
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import de.platon42.intellij.plugins.m68k.psi.M68kPsiElement
+import de.platon42.intellij.plugins.m68k.psi.M68kStatement
+
+class M68kInspectionSuppressor : InspectionSuppressor {
+
+    companion object {
+        const val MARKER = "suppress "
+    }
+
+    override fun isSuppressedFor(element: PsiElement, toolId: String): Boolean {
+        if (element !is M68kPsiElement) return false
+        val statement = PsiTreeUtil.getParentOfType(element, M68kStatement::class.java) ?: return false
+        val nextToken = PsiTreeUtil.skipWhitespacesForward(statement)
+        return isSuppressedWithComment(nextToken, toolId) || isSuppressedWithComment(PsiTreeUtil.skipWhitespacesBackward(statement), toolId)
+    }
+
+    override fun getSuppressActions(element: PsiElement?, toolId: String): Array<SuppressQuickFix> {
+        return arrayOf(LineSuppressQuickFix(toolId))
+    }
+
+    private fun isSuppressedWithComment(nextToken: PsiElement?, toolId: String): Boolean {
+        return if (nextToken is PsiComment) {
+            val comment = nextToken.text
+            comment.contains(MARKER) && comment.contains(toolId)
+        } else {
+            false
+        }
+    }
+
+    class LineSuppressQuickFix(private val toolId: String) : SuppressQuickFix {
+
+        override fun getFamilyName() = "Suppress for statement"
+
+        override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
+            val statement = PsiTreeUtil.getParentOfType(descriptor.startElement, M68kStatement::class.java) ?: return
+
+            val document = PsiDocumentManager.getInstance(project).getDocument(statement.containingFile) ?: return
+            val lineNumber = document.getLineNumber(statement.textOffset)
+            var usePrevLine = false
+            val nextToken = PsiTreeUtil.skipWhitespacesForward(statement)
+            if (nextToken is PsiComment) {
+                val comment = nextToken.text
+                if (comment.contains(MARKER)) {
+                    if (!comment.contains(toolId)) {
+                        document.insertString(document.getLineEndOffset(lineNumber), " $toolId")
+                    }
+                    return
+                } else {
+                    usePrevLine = true
+                }
+            }
+            val prevToken = PsiTreeUtil.skipWhitespacesBackward(statement)
+            if (prevToken is PsiComment) {
+                val comment = prevToken.text
+                if (comment.contains(MARKER)) {
+                    if (!comment.contains(toolId)) {
+                        document.insertString(document.getLineEndOffset(document.getLineNumber(prevToken.textOffset)), " $toolId")
+                    }
+                    return
+                }
+            }
+            if (usePrevLine) {
+                document.insertString(document.getLineStartOffset(lineNumber), "; $MARKER$toolId\n")
+            } else {
+                document.insertString(document.getLineEndOffset(lineNumber), "\t; $MARKER$toolId")
+            }
+        }
+
+        override fun isAvailable(project: Project, context: PsiElement) = true
+
+        override fun isSuppressAll() = false
+    }
+}

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

@@ -0,0 +1,48 @@
+package de.platon42.intellij.plugins.m68k.inspections
+
+import com.intellij.codeInspection.LocalInspectionToolSession
+import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiPolyVariantReference
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroCall
+import de.platon42.intellij.plugins.m68k.psi.M68kSymbolReference
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor
+import de.platon42.intellij.plugins.m68k.refs.M68kGlobalLabelSymbolReference
+
+class M68kUnresolvedReferenceInspection : AbstractBaseM68kLocalInspectionTool() {
+
+    companion object {
+        private const val DISPLAY_NAME = "Unresolved label/symbol/macro reference"
+    }
+
+    override fun getDisplayName() = DISPLAY_NAME
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
+        return object : M68kVisitor() {
+            override fun visitMacroCall(macroCall: M68kMacroCall) {
+                val reference = macroCall.reference as? PsiPolyVariantReference ?: return
+                val resolve = reference.multiResolve(false)
+                if (resolve.isEmpty()) {
+                    holder.registerProblem(reference)
+                }
+            }
+
+            override fun visitSymbolReference(symbolReference: M68kSymbolReference) {
+                val references = symbolReference.references ?: return
+                if (references.isEmpty()) return
+                val resolve = references.mapNotNull { it as? PsiPolyVariantReference }
+                    .firstNotNullOfOrNull { it.multiResolve(false).ifEmpty { null } }
+                if (resolve == null) {
+                    // TODO currently, because macro invocations are not evaluated, mark missing symbols only as weak warning
+                    val makeWeak = references.any { it is M68kGlobalLabelSymbolReference }
+                    if (makeWeak) {
+                        holder.registerProblem(references.first(), ProblemHighlightType.WEAK_WARNING)
+                    } else {
+                        holder.registerProblem(references.first())
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -19,11 +19,17 @@ object LexerUtil {
             && text.dropLast(1).endsWith('.')
             && mnemonics.contains(text.dropLast(2).toString().lowercase())
 
+    @JvmStatic
+    fun isEndDirective(text: CharSequence) = text.contentEquals("end", ignoreCase = true)
+
     @JvmStatic
     fun isDataDirective(text: CharSequence) = AssemblerDirectives.dataDirectives.contains(text.toString().lowercase())
 
     @JvmStatic
-    fun isOtherDirective(text: CharSequence) = AssemblerDirectives.otherDirective.contains(text.toString().lowercase())
+    fun isPlainDirective(text: CharSequence) = AssemblerDirectives.plainDirectives.contains(text.toString().lowercase())
+
+    @JvmStatic
+    fun isOtherDirective(text: CharSequence) = AssemblerDirectives.otherDirectives.contains(text.toString().lowercase())
 
     @JvmStatic
     fun pushbackAssignment(text: CharSequence): Int {
@@ -52,7 +58,7 @@ object LexerUtil {
     @JvmStatic
     fun handleMacroMode(lexer: _M68kLexer): IElementType {
         if (lexer.lexerPrefs.macroParametersUnparsed) {
-            lexer.yybegin(_M68kLexer.MACROCALL)
+            lexer.yybegin(_M68kLexer.PLAINPARAMS)
         } else {
             lexer.yybegin(_M68kLexer.ASMOPS)
         }
@@ -69,4 +75,13 @@ object LexerUtil {
         lexer.yybegin(_M68kLexer.MACROLINE)
         return TokenType.WHITE_SPACE
     }
+
+    fun unquoteString(string: String) = string.run {
+        when {
+            startsWith('"') -> removeSurrounding("\"")
+            startsWith('\'') -> removeSurrounding("'")
+            startsWith('<') -> removeSurrounding("<", ">")
+            else -> this
+        }
+    }
 }

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

@@ -72,7 +72,7 @@ HASH_COMMENT=([#;*].*+)
 SKIP_TO_EOL=[^\r\n]+
 PLAIN_MACRO_LINE=[^;\r\n]+
 
-%state NOSOL,INSTRPART,ASMINSTR,ASMOPS,ASMOPS_OP,ASSIGNMENT,EXPR,EXPR_OP,MACROCALL,WAITEOL,MACRODEF,MACROLINE,MACROTERMINATION,MACROWAITEOL
+%state NOSOL,INSTRPART,ASMINSTR,ASMOPS,ASMOPS_OP,ASSIGNMENT,EXPR,EXPR_OP,PLAINPARAMS,WAITEOL,MACRODEF,MACROLINE,MACROTERMINATION,MACROWAITEOL
 
 %%
 <YYINITIAL, NOSOL>
@@ -81,7 +81,7 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   {HASH_COMMENT}      { yybegin(YYINITIAL); return COMMENT; }
 }
 
-<INSTRPART,ASMINSTR,MACROCALL,ASSIGNMENT,EXPR,EXPR_OP,ASMOPS,ASMOPS_OP>
+<INSTRPART,ASMINSTR,PLAINPARAMS,ASSIGNMENT,EXPR,EXPR_OP,ASMOPS,ASMOPS_OP>
 {
   {EOL}               { yybegin(YYINITIAL); return EOL; }
   {COMMENT}           { yybegin(WAITEOL); return COMMENT; }
@@ -92,7 +92,7 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   {WHITE_SPACE}       { return WHITE_SPACE; }
 }
 
-<MACROCALL, EXPR, EXPR_OP, ASMOPS, ASMOPS_OP> {
+<PLAINPARAMS, EXPR, EXPR_OP, ASMOPS, ASMOPS_OP> {
   {WHITE_SPACE}       { return handleEolCommentWhitespace(this); }
 }
 
@@ -102,6 +102,7 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   {MACRO_DEF_LEFT}    { yybegin(MACRODEF); yypushback(pushbackAfterFirstToken(yytext())); return MACRO_NAME; }
   {LOCAL_LABEL}       { yybegin(INSTRPART); eatOneWhitespace = false; yypushback(pushbackLabelColons(yytext())); return LOCAL_LABEL_DEF; }
   {GLOBAL_LABEL}      { yybegin(INSTRPART); eatOneWhitespace = false; yypushback(pushbackLabelColons(yytext())); return GLOBAL_LABEL_DEF; }
+  "."                 { yybegin(INSTRPART); eatOneWhitespace = false; return LOCAL_LABEL_DEF; }
 }
 
 <NOSOL> {
@@ -116,8 +117,10 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   {DIRECTIVE_KEYWORD} {
                         if(isAsmMnemonicWithSize(yytext())) { yybegin(ASMINSTR); yypushback(2); return MNEMONIC; }
                         if(isAsmMnemonic(yytext())) { yybegin(ASMINSTR); return MNEMONIC; }
-                        if(isDataDirective(yytext())) { startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
+                        //if(isEndDirective(yytext())) { yybegin(YYINITIAL); zzAtEOF = true; return null; }
-                        if(isOtherDirective(yytext())) { startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
+                        if(isDataDirective(yytext())) { eatOneWhitespace = true; startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
+                        if(isPlainDirective(yytext())) { eatOneWhitespace = true; yybegin(PLAINPARAMS); return OTHER_DIRECTIVE; }
+                        if(isOtherDirective(yytext())) { eatOneWhitespace = true; startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
                         return handleMacroMode(this);
                       }
   {MACRONAME}         { return handleMacroMode(this); }
@@ -136,7 +139,7 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   {OPSIZE_L}          { return OPSIZE_L; }
 }
 
-<MACROCALL> {
+<PLAINPARAMS> {
   ","                 { return SEPARATOR; }
 
   {PLAINPARAM}        { return STRINGLIT; }
@@ -165,7 +168,6 @@ PLAIN_MACRO_LINE=[^;\r\n]+
   "+"                 { return OP_PLUS; }
   "-"                 { return OP_MINUS; }
   "*"                 { yybegin(exprOpState); return CURRENT_PC_SYMBOL; }
-
 }
 
 <EXPR> {
@@ -213,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; }
 }
@@ -223,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

@@ -121,11 +121,10 @@ M68kFile ::= line*
 private line ::= !<<eof>> (MacroDefinition | statement) (<<eof>>|EOL)
 
 statement ::= (Assignment
-            | PreprocessorDirective
             | LabelInsts)
-            {pin=1 recoverWhile=statement_recover};
+            {pin = 1 recoverWhile = statement_recover}
 
-private statement_recover ::= !(EOL)
+private statement_recover ::= !(EOL) { consumeTokenMethod = "consumeTokenFast" }
 
 SymbolDefinition ::= SYMBOLDEF {
     implements = "de.platon42.intellij.plugins.m68k.psi.M68kNamedElement"
@@ -140,8 +139,8 @@ Assignment ::= SymbolDefinition COLON? (OP_ASSIGN|EQU) expr
 private LabelInsts ::= LabelWithInstruction | LabelOnly | InstructionOnly
 
 private LabelOnly ::= Label
-private LabelWithInstruction ::= Label Instruction
+private LabelWithInstruction ::= Label (Instruction|PreprocessorDirective)
-private InstructionOnly ::= Instruction
+private InstructionOnly ::= (Instruction|PreprocessorDirective)
 
 LocalLabel ::= LOCAL_LABEL_DEF COLON? {
     name = "local label"
@@ -165,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" }
 
@@ -173,8 +173,11 @@ AsmOp ::= MNEMONIC OperandSize? {
     methods = [getMnemonic getOpSize]
 }
 
-PreprocessorDirective ::= Label? (DATA_DIRECTIVE | OTHER_DIRECTIVE)
+PreprocessorKeyword ::= (DATA_DIRECTIVE | OTHER_DIRECTIVE)
-        PreprocessorOperands?
+
+PreprocessorDirective ::= PreprocessorKeyword PreprocessorOperands? {
+    mixin = "de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirectiveMixin"
+}
 
 MacroPlainLine ::= MACRO_LINE
 MacroNameDefinition ::= MACRO_NAME
@@ -225,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
 }
@@ -234,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
@@ -254,6 +269,14 @@ AddressingMode ::= ImmediateData
                 | ProgramCounterIndirectWithDisplacementOldAddressingMode
                 | AddressRegisterIndirectWithIndexOldAddressingMode
                 | ProgramCounterIndirectWithIndexOldAddressingMode
+                | AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode
+                | ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode
+                | MemoryIndirectAddressingMode
+                | ProgramCounterMemoryIndirectAddressingMode
+                | MemoryIndirectPostIndexedAddressingMode
+                | ProgramCounterMemoryIndirectPostIndexedAddressingMode
+                | MemoryIndirectPreIndexedAddressingMode
+                | ProgramCounterMemoryIndirectPreIndexedAddressingMode
                 | SpecialRegisterDirectAddressingMode
                 | DataRegisterDirectAddressingMode
                 | AddressRegisterDirectAddressingMode
@@ -266,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 = [
@@ -276,6 +300,7 @@ AddressRegisterIndirectWithDisplacementOldAddressingMode ::= expr ROUND_L Addres
         displacement = "expr"
     ]
 }
+
 AddressRegisterIndirectWithDisplacementNewAddressingMode ::= ROUND_L expr SEPARATOR AddressRegister ROUND_R
 {
     implements = [
@@ -311,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"]
@@ -349,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,36 +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()
             }
-    }
+        )
-
-    fun mergeReadWriteModifyRegisters(regset: Set<Pair<Register, Int>>): Set<Pair<Register, Int>> {
-        if (regset.size <= 1) return regset
-        return regset.groupBy({ it.first }) { it.second }
-            .map { it.key to if (it.value.size == 1) it.value.single() else it.value.reduce(Int::or) }
-            .toSet()
     }
 }

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

@@ -37,6 +37,11 @@ object M68kElementFactory {
         return PsiTreeUtil.findChildOfType(file, M68kMacroCall::class.java)!!
     }
 
+    fun createIncludeStatement(project: Project, path: String): M68kPreprocessorDirective {
+        val file = createFile(project, " include \"$path\"\n")
+        return PsiTreeUtil.findChildOfType(file, M68kPreprocessorDirective::class.java)!!
+    }
+
     fun createFile(project: Project, content: String): M68kFile {
         return PsiFileFactory.getInstance(project).createFileFromText("dummy.m68k", INSTANCE, content) as M68kFile
     }

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

@@ -2,21 +2,13 @@ package de.platon42.intellij.plugins.m68k.psi
 
 import com.intellij.extapi.psi.ASTWrapperPsiElement
 import com.intellij.lang.ASTNode
+import de.platon42.intellij.plugins.m68k.lexer.LexerUtil
 
 abstract class M68kLiteralExprMixin(node: ASTNode) : ASTWrapperPsiElement(node), M68kLiteralExpr {
     override fun getValue(): Any? {
         val childNode = firstChild.node
         when (childNode.elementType) {
-            M68kTypes.STRINGLIT -> {
+            M68kTypes.STRINGLIT -> LexerUtil.unquoteString(childNode.text)
-                return text.run {
-                    when {
-                        startsWith('"') -> removeSurrounding("\"")
-                        startsWith('\'') -> removeSurrounding("'")
-                        startsWith('<') -> removeSurrounding(">")
-                        else -> this
-                    }
-                }
-            }
             M68kTypes.DECIMAL -> {
                 try {
                     return childNode.text.toInt()
@@ -46,6 +38,6 @@ abstract class M68kLiteralExprMixin(node: ASTNode) : ASTWrapperPsiElement(node),
                 }
             }
         }
-        return text
+        return childNode.text
     }
 }

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

@@ -7,6 +7,10 @@ import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry
 
 abstract class M68kMacroCallMixin(node: ASTNode) : ASTWrapperPsiElement(node), M68kMacroCall {
 
+    override fun getReference(): PsiReference? {
+        return references.firstOrNull()
+    }
+
     override fun getReferences(): Array<PsiReference> {
         return ReferenceProvidersRegistry.getReferencesFromProviders(this)
     }

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

@@ -0,0 +1,17 @@
+package de.platon42.intellij.plugins.m68k.psi
+
+import com.intellij.extapi.psi.ASTWrapperPsiElement
+import com.intellij.lang.ASTNode
+import com.intellij.psi.PsiReference
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry
+
+abstract class M68kPreprocessorDirectiveMixin(node: ASTNode) : ASTWrapperPsiElement(node), M68kPreprocessorDirective {
+
+    override fun getReference(): PsiReference? {
+        return references.firstOrNull()
+    }
+
+    override fun getReferences(): Array<PsiReference> {
+        return ReferenceProvidersRegistry.getReferencesFromProviders(this)
+    }
+}

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

@@ -29,7 +29,7 @@ object M68kPsiImplUtil {
 
     // Local Label
     @JvmStatic
-    fun getName(element: M68kLocalLabel): String? = element.firstChild.text
+    fun getName(element: M68kLocalLabel): String? = element.firstChild?.text
 
     @JvmStatic
     fun setName(element: M68kLocalLabel, name: String): PsiElement {

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

@@ -7,6 +7,10 @@ import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry
 
 abstract class M68kSymbolReferenceMixin(node: ASTNode) : ASTWrapperPsiElement(node), M68kSymbolReference {
 
+    override fun getReference(): PsiReference? {
+        return references.firstOrNull()
+    }
+
     override fun getReferences(): Array<PsiReference> {
         return ReferenceProvidersRegistry.getReferencesFromProviders(this)
     }

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/M68kIncludeFileReference.kt

@@ -0,0 +1,46 @@
+package de.platon42.intellij.plugins.m68k.refs
+
+import com.intellij.psi.*
+import com.intellij.psi.impl.source.resolve.ResolveCache
+import com.intellij.psi.search.FileTypeIndex
+import com.intellij.psi.search.GlobalSearchScope
+import de.platon42.intellij.plugins.m68k.M68kFileType
+import de.platon42.intellij.plugins.m68k.lexer.LexerUtil
+import de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirective
+
+class M68kIncludeFileReference(element: M68kPreprocessorDirective) : PsiPolyVariantReferenceBase<M68kPreprocessorDirective>(element, true) {
+
+    companion object {
+        val INSTANCE = Resolver()
+    }
+
+    class Resolver : ResolveCache.PolyVariantResolver<M68kIncludeFileReference> {
+        override fun resolve(ref: M68kIncludeFileReference, incompleteCode: Boolean): Array<ResolveResult> {
+            val project = ref.element.project
+            val allFiles = FileTypeIndex.getFiles(M68kFileType.INSTANCE, GlobalSearchScope.allScope(project))
+
+            val pathName = LexerUtil.unquoteString(ref.element.exprList.first().text).replace('\\', '/')
+            val fileMatched = ((allFiles.firstOrNull { it.path.equals(pathName, ignoreCase = true) }
+                ?: allFiles.firstOrNull { it.path.endsWith(pathName.removePrefix("../"), ignoreCase = true) })
+                ?: allFiles.firstOrNull { it.path.endsWith(pathName.substringAfterLast('/'), ignoreCase = true) }) ?: return emptyArray()
+            return PsiElementResolveResult.createResults(PsiManager.getInstance(project).findFile(fileMatched))
+        }
+    }
+
+    override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> =
+        ResolveCache.getInstance(element.project)
+            .resolveWithCaching(this, INSTANCE, false, incompleteCode)
+
+    override fun resolve(): PsiElement? = multiResolve(false).singleOrNull()?.element
+
+    override fun getVariants(): Array<Any> = emptyArray()
+
+//    override fun getRangeInElement(): TextRange {
+//        val unquoted = LexerUtil.unquoteString(element.text)
+//
+//        val path = element.exprList.first()
+//        return TextRange.from(
+//            path.textRange.startOffset + path.text.indexOf(unquoted), unquoted.length
+//        )
+//    }
+}

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

@@ -0,0 +1,68 @@
+package de.platon42.intellij.plugins.m68k.refs
+
+import com.intellij.codeInsight.completion.*
+import com.intellij.codeInsight.lookup.LookupElementBuilder
+import com.intellij.patterns.PlatformPatterns
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.ProcessingContext
+import de.platon42.intellij.plugins.m68k.psi.*
+
+class M68kLocalLabelDefCompletionContributor : CompletionContributor() {
+
+    init {
+        extend(
+            CompletionType.BASIC,
+            PlatformPatterns.or(PlatformPatterns.psiElement(M68kTypes.LOCAL_LABEL_DEF), PlatformPatterns.psiElement(M68kTypes.GLOBAL_LABEL_DEF)),
+            object : CompletionProvider<CompletionParameters>() {
+                override fun addCompletions(parameters: CompletionParameters, context: ProcessingContext, resultSet: CompletionResultSet) {
+                    var topLevelElement = parameters.originalFile.findElementAt(parameters.offset)
+                    while (topLevelElement?.parent !is M68kFile) {
+                        topLevelElement = topLevelElement?.parent ?: return
+                    }
+                    // TODO find out if we can cache this somehow
+                    val affectedStatements = ArrayList<M68kStatement>()
+                    val definedLocalLabels = HashSet<String>()
+                    val referencedLocalLabels = HashSet<String>()
+                    findUndefinedLocalLabels(topLevelElement, affectedStatements, definedLocalLabels, referencedLocalLabels) {
+                        PsiTreeUtil.getNextSiblingOfType(it, M68kStatement::class.java)
+                    }
+                    findUndefinedLocalLabels(topLevelElement, affectedStatements, definedLocalLabels, referencedLocalLabels) {
+                        PsiTreeUtil.getPrevSiblingOfType(it, M68kStatement::class.java)
+                    }
+                    referencedLocalLabels.removeAll(definedLocalLabels)
+                    resultSet.addAllElements(
+                        if (parameters.originalPosition?.text == ".") {
+                            referencedLocalLabels.map { LookupElementBuilder.create(it.removePrefix(".")) }
+                        } else {
+                            referencedLocalLabels.map(LookupElementBuilder::create)
+                        }
+                    )
+                }
+
+                private fun findUndefinedLocalLabels(
+                    topLevelElement: PsiElement,
+                    affectedStatements: MutableList<M68kStatement>,
+                    definedLocalLabels: MutableSet<String>,
+                    referencedLocalLabels: MutableSet<String>,
+                    direction: (topLevelElement: PsiElement) -> M68kStatement?
+                ) {
+                    var currStatement = topLevelElement
+                    while (true) {
+                        currStatement = direction.invoke(currStatement) ?: break
+                        val globalLabel = PsiTreeUtil.findChildOfType(currStatement, M68kGlobalLabel::class.java)
+                        if (globalLabel != null) break
+                        affectedStatements.add(currStatement)
+                        val localLabel = PsiTreeUtil.findChildOfType(currStatement, M68kLocalLabel::class.java)
+                        if (localLabel != null) definedLocalLabels.add(localLabel.name!!)
+                        val symbolReferences = PsiTreeUtil.findChildrenOfAnyType(currStatement, M68kSymbolReference::class.java)
+                        if (symbolReferences.isNotEmpty()) {
+                            referencedLocalLabels.addAll(
+                                symbolReferences.filter(M68kSymbolReference::isLocalLabelRef).map(M68kSymbolReference::getSymbolName)
+                            )
+                        }
+                    }
+                }
+            })
+    }
+}

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

@@ -1,5 +1,6 @@
 package de.platon42.intellij.plugins.m68k.refs
 
+import com.intellij.codeInsight.daemon.EmptyResolveMessageProvider
 import com.intellij.codeInsight.lookup.LookupElementBuilder
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
@@ -14,11 +15,15 @@ import de.platon42.intellij.plugins.m68k.psi.M68kLocalLabel
 import de.platon42.intellij.plugins.m68k.psi.M68kStatement
 import de.platon42.intellij.plugins.m68k.psi.M68kSymbolReference
 
-class M68kLocalLabelReference(element: M68kSymbolReference) : PsiPolyVariantReferenceBase<M68kSymbolReference>(element, TextRange(0, element.textLength)) {
+class M68kLocalLabelReference(element: M68kSymbolReference) :
+    PsiPolyVariantReferenceBase<M68kSymbolReference>(element, TextRange(0, element.textLength)),
+    EmptyResolveMessageProvider {
 
     companion object {
         val INSTANCE = Resolver()
 
+        private const val UNRESOLVED_MESSAGE_PATTERN = "Cannot resolve local label ''{0}''"
+
         fun findLocalLabels(element: M68kSymbolReference, predicate: (M68kLocalLabel) -> Boolean): List<M68kLocalLabel> {
             val statement = PsiTreeUtil.getStubOrPsiParentOfType(element, M68kStatement::class.java)!!
             val results = SmartList<M68kLocalLabel>()
@@ -42,6 +47,8 @@ class M68kLocalLabelReference(element: M68kSymbolReference) : PsiPolyVariantRefe
         }
     }
 
+    override fun getUnresolvedMessagePattern() = UNRESOLVED_MESSAGE_PATTERN
+
     class Resolver : ResolveCache.PolyVariantResolver<M68kLocalLabelReference> {
         override fun resolve(ref: M68kLocalLabelReference, incompleteCode: Boolean): Array<ResolveResult> {
             val refName = ref.element.symbolName

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/refs/M68kMacroReference.kt

@@ -1,5 +1,6 @@
 package de.platon42.intellij.plugins.m68k.refs
 
+import com.intellij.codeInsight.daemon.EmptyResolveMessageProvider
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementResolveResult
@@ -14,12 +15,16 @@ import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
 import de.platon42.intellij.plugins.m68k.stubs.M68kMacroDefinitionStubIndex
 
 class M68kMacroReference(element: M68kMacroCall) :
-    PsiPolyVariantReferenceBase<M68kMacroCall>(element, TextRange(0, element.macroName.length)) {
+    PsiPolyVariantReferenceBase<M68kMacroCall>(element, TextRange(0, element.macroName.length)), EmptyResolveMessageProvider {
 
     companion object {
         val INSTANCE = Resolver()
+
+        private const val UNRESOLVED_MESSAGE_PATTERN = "Cannot resolve macro ''{0}''"
     }
 
+    override fun getUnresolvedMessagePattern() = UNRESOLVED_MESSAGE_PATTERN
+
     class Resolver : ResolveCache.PolyVariantResolver<M68kMacroReference> {
         override fun resolve(ref: M68kMacroReference, incompleteCode: Boolean): Array<ResolveResult> {
             val macroName = ref.element.macroName

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

@@ -0,0 +1,34 @@
+package de.platon42.intellij.plugins.m68k.refs
+
+import com.intellij.history.core.Paths
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.AbstractElementManipulator
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.IncorrectOperationException
+import de.platon42.intellij.plugins.m68k.lexer.LexerUtil
+import de.platon42.intellij.plugins.m68k.psi.M68kElementFactory
+import de.platon42.intellij.plugins.m68k.psi.M68kLiteralExpr
+import de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirective
+
+class M68kPreprocessorDirectiveElementManipulator : AbstractElementManipulator<M68kPreprocessorDirective>() {
+
+    @Throws(IncorrectOperationException::class)
+    override fun handleContentChange(element: M68kPreprocessorDirective, range: TextRange, newContent: String): M68kPreprocessorDirective {
+        val oldPath = LexerUtil.unquoteString(element.exprList.first().text)
+            .replace('\\', '/')
+            .substringBeforeLast('/', missingDelimiterValue = "")
+        val newIncludeStatement = M68kElementFactory.createIncludeStatement(element.project, Paths.appended(oldPath, newContent))
+        PsiTreeUtil.findChildOfType(element, M68kLiteralExpr::class.java)!!.replace(newIncludeStatement.exprList.first())
+        return element
+    }
+
+    override fun getRangeInElement(element: M68kPreprocessorDirective): TextRange {
+        val pathExpr = element.exprList.first()
+        val unquotedPath = LexerUtil.unquoteString(pathExpr.text)
+        return if (unquotedPath.length < pathExpr.textLength) {
+            TextRange.from(pathExpr.startOffsetInParent + 1, unquotedPath.length)
+        } else {
+            pathExpr.textRangeInParent
+        }
+    }
+}

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

@@ -3,7 +3,9 @@ package de.platon42.intellij.plugins.m68k.refs
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.psi.*
 import com.intellij.util.ProcessingContext
+import de.platon42.intellij.plugins.m68k.psi.M68kLiteralExpr
 import de.platon42.intellij.plugins.m68k.psi.M68kMacroCall
+import de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirective
 import de.platon42.intellij.plugins.m68k.psi.M68kSymbolReference
 
 class M68kReferenceContributor : PsiReferenceContributor() {
@@ -12,12 +14,14 @@ class M68kReferenceContributor : PsiReferenceContributor() {
         val localLabelReferenceProvider = LocalLabelReferenceProvider()
         val globalLabelReferenceProvider = GlobalLabelSymbolReferenceProvider()
         val macroReferenceProvider = MacroReferenceProvider()
+        val includeFileReferenceProvider = IncludeFileReferenceProvider()
     }
 
     override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
         registrar.registerReferenceProvider(PlatformPatterns.psiElement(M68kSymbolReference::class.java), localLabelReferenceProvider)
         registrar.registerReferenceProvider(PlatformPatterns.psiElement(M68kSymbolReference::class.java), globalLabelReferenceProvider)
         registrar.registerReferenceProvider(PlatformPatterns.psiElement(M68kMacroCall::class.java), macroReferenceProvider)
+        registrar.registerReferenceProvider(PlatformPatterns.psiElement(M68kPreprocessorDirective::class.java), includeFileReferenceProvider)
     }
 
     class LocalLabelReferenceProvider : PsiReferenceProvider() {
@@ -40,4 +44,16 @@ class M68kReferenceContributor : PsiReferenceContributor() {
         override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> =
             arrayOf(M68kMacroReference(element as M68kMacroCall))
     }
+
+    class IncludeFileReferenceProvider : PsiReferenceProvider() {
+        override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+            val directive = element as M68kPreprocessorDirective
+            if (directive.exprList.firstOrNull() !is M68kLiteralExpr) return emptyArray()
+            return if (directive.preprocessorKeyword.text.equals("include", ignoreCase = true)) {
+                arrayOf(M68kIncludeFileReference(directive))
+            } else {
+                emptyArray()
+            }
+        }
+    }
 }

src/main/java/de/platon42/intellij/plugins/m68k/scanner/M68kFindUsagesProvider.kt

@@ -1,5 +1,6 @@
 package de.platon42.intellij.plugins.m68k.scanner
 
+import com.intellij.lang.HelpID
 import com.intellij.lang.cacheBuilder.DefaultWordsScanner
 import com.intellij.lang.cacheBuilder.WordsScanner
 import com.intellij.lang.findUsages.FindUsagesProvider
@@ -22,14 +23,19 @@ class M68kFindUsagesProvider : FindUsagesProvider {
             TokenSet.EMPTY
         )
 
-    override fun canFindUsagesFor(psiElement: PsiElement): Boolean = psiElement is M68kNamedElement
+    override fun canFindUsagesFor(psiElement: PsiElement): Boolean =
+        when (psiElement) {
+            is M68kNamedElement, is M68kSymbolReference, is M68kMacroCall, is M68kFile, is M68kRegister -> true
+            else -> false
+        }
 
-    override fun getHelpId(psiElement: PsiElement): @NonNls String? = null
+    override fun getHelpId(psiElement: PsiElement): @NonNls String = HelpID.FIND_OTHER_USAGES
 
     override fun getType(element: PsiElement): @Nls String {
         return when (element) {
             is M68kGlobalLabel -> "global label"
             is M68kLocalLabel -> "local label"
+            is M68kPreprocessorDirective -> "preprocessor directive"
             is M68kSymbolDefinition -> "symbol definition"
             is M68kSymbolReference -> "symbol reference"
             is M68kMacroDefinition -> "macro definition"
@@ -44,6 +50,7 @@ class M68kFindUsagesProvider : FindUsagesProvider {
         return when (element) {
             is M68kGlobalLabel -> element.name!!
             is M68kLocalLabel -> element.name!!
+            is M68kPreprocessorDirective -> element.text
             is M68kSymbolDefinition -> element.parent.text
             is M68kSymbolReference -> element.symbolName
             is M68kMacroDefinition -> element.macroNameDefinition.text

src/main/java/de/platon42/intellij/plugins/m68k/scanner/M68kIncludeFileProvider.kt

@@ -0,0 +1,59 @@
+package de.platon42.intellij.plugins.m68k.scanner
+
+import com.intellij.openapi.fileTypes.FileType
+import com.intellij.openapi.fileTypes.FileTypeRegistry
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.impl.include.FileIncludeInfo
+import com.intellij.psi.impl.include.FileIncludeProvider
+import com.intellij.psi.impl.source.tree.LightTreeUtil
+import com.intellij.util.Consumer
+import com.intellij.util.PathUtilRt
+import com.intellij.util.indexing.FileContent
+import com.intellij.util.indexing.PsiDependentFileContent
+import de.platon42.intellij.plugins.m68k.M68kFileType.Companion.INSTANCE
+import de.platon42.intellij.plugins.m68k.lexer.LexerUtil
+import de.platon42.intellij.plugins.m68k.psi.M68kTypes
+
+class M68kIncludeFileProvider : FileIncludeProvider() {
+
+    override fun getId(): String {
+        return "mc68000_include"
+    }
+
+    override fun acceptFile(file: VirtualFile): Boolean {
+        return FileTypeRegistry.getInstance().isFileOfType(file, INSTANCE)
+    }
+
+    override fun registerFileTypesUsedForIndexing(fileTypeSink: Consumer<in FileType?>) {
+        fileTypeSink.consume(INSTANCE)
+    }
+
+    override fun getIncludeInfos(content: FileContent): Array<FileIncludeInfo> {
+        if (content.contentAsText.indexOfAny(listOf("include", "incbin"), ignoreCase = true) < 0) return emptyArray()
+
+        val tree = (content as PsiDependentFileContent).lighterAST
+        val statements = LightTreeUtil.getChildrenOfType(tree, tree.root, M68kTypes.STATEMENT).asSequence()
+            .mapNotNull { LightTreeUtil.firstChildOfType(tree, it, M68kTypes.PREPROCESSOR_DIRECTIVE) }
+            .mapNotNull {
+                val keywordNode = LightTreeUtil.firstChildOfType(tree, it, M68kTypes.PREPROCESSOR_KEYWORD) ?: return@mapNotNull null
+                val keyword = LightTreeUtil.toFilteredString(tree, keywordNode, null)
+                if (keyword.equals("include", true) || keyword.equals("incbin", true)) {
+                    keyword to it
+                } else {
+                    null
+                }
+            }
+            .mapNotNull {
+                val pathNode = LightTreeUtil.firstChildOfType(tree, it.second, M68kTypes.LITERAL_EXPR) ?: return@mapNotNull null
+                val path = LexerUtil.unquoteString(LightTreeUtil.toFilteredString(tree, pathNode, null)).replace('\\', '/')
+                if (it.first.equals("include", true)) {
+                    FileIncludeInfo(path)
+                } else {
+                    FileIncludeInfo(PathUtilRt.getFileName(path), path, 0, true)
+                }
+            }
+            .toList()
+
+        return statements.toTypedArray()
+    }
+}

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

@@ -16,7 +16,7 @@
 
     <extensions defaultExtensionNs="com.intellij">
         <fileType name="MC68000 Assembler" implementationClass="de.platon42.intellij.plugins.m68k.M68kFileType"
-                  fieldName="INSTANCE" language="MC68000" extensions="asm;ASM;s;S;i"/>
+                  fieldName="INSTANCE" language="MC68000" extensions="asm;s;i"/>
         <lang.parserDefinition language="MC68000"
                                implementationClass="de.platon42.intellij.plugins.m68k.parser.M68kParserDefinition"/>
         <lang.syntaxHighlighterFactory language="MC68000"
@@ -24,17 +24,25 @@
         <colorSettingsPage implementation="de.platon42.intellij.plugins.m68k.syntax.M68kColorSettingsPage"/>
         <completion.contributor language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.asm.M68kMnemonicCompletionContributor"/>
         <completion.contributor language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kGlobalLabelSymbolCompletionContributor"/>
+        <completion.contributor language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kLocalLabelDefCompletionContributor"/>
         <completion.contributor language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kMacroCallCompletionContributor"/>
         <lang.braceMatcher language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.syntax.M68kPairedBraceMatcher"/>
         <lang.quoteHandler language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.M68kStringQuoteHandler"/>
         <lang.findUsagesProvider language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.scanner.M68kFindUsagesProvider"/>
         <lang.psiStructureViewFactory language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.structureview.M68kStructureViewFactory"/>
+        <lang.inspectionSuppressor language="MC68000" implementationClass="de.platon42.intellij.plugins.m68k.inspections.M68kInspectionSuppressor"/>
         <lang.elementManipulator forClass="de.platon42.intellij.plugins.m68k.psi.M68kSymbolReference"
                                  implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kSymbolReferenceElementManipulator"/>
         <lang.elementManipulator forClass="de.platon42.intellij.plugins.m68k.psi.M68kMacroCall"
                                  implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kMacroCallElementManipulator"/>
+        <lang.elementManipulator forClass="de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirective"
+                                 implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kPreprocessorDirectiveElementManipulator"/>
         <lang.documentationProvider language="MC68000"
                                     implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kSymbolDefinitionDocumentationProvider"/>
+        <lang.documentationProvider language="MC68000"
+                                    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"
@@ -43,9 +51,10 @@
         <stubIndex implementation="de.platon42.intellij.plugins.m68k.stubs.M68kGlobalLabelStubIndex"/>
         <stubIndex implementation="de.platon42.intellij.plugins.m68k.stubs.M68kSymbolDefinitionStubIndex"/>
         <stubIndex implementation="de.platon42.intellij.plugins.m68k.stubs.M68kMacroDefinitionStubIndex"/>
-        <psi.referenceContributor implementation="de.platon42.intellij.plugins.m68k.refs.M68kReferenceContributor"/>
+        <psi.referenceContributor language="MC68000" implementation="de.platon42.intellij.plugins.m68k.refs.M68kReferenceContributor"/>
         <gotoSymbolContributor implementation="de.platon42.intellij.plugins.m68k.refs.M68kChooseByNameContributor"/>
         <renameInputValidator implementation="de.platon42.intellij.plugins.m68k.psi.M68kRenameInputValidator"/>
+        <include.provider implementation="de.platon42.intellij.plugins.m68k.scanner.M68kIncludeFileProvider"/>
 
         <localInspection implementationClass="de.platon42.intellij.plugins.m68k.inspections.M68kSyntaxInspection"
                          displayName="Assembly instruction validity" groupName="M68k"
@@ -56,6 +65,15 @@
         <localInspection implementationClass="de.platon42.intellij.plugins.m68k.inspections.M68kUnexpectedConditionalInstructionInspection"
                          displayName="Unaffected condition codes before conditional instruction" groupName="M68k"
                          enabledByDefault="true" level="WARNING"/>
+        <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/main/resources/inspectionDescriptions/M68kUnresolvedReference.html

@@ -0,0 +1,8 @@
+<html>
+<body>
+Checks if references to symbols, macros, global and local labels are resolvable.
+<!-- tooltip end -->
+<p>Currently, issues a weak warning for global labels or symbols as those
+    can be defined via macros, which are not evaluated right now</p>
+</body>
+</html>

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

@@ -2,6 +2,7 @@ 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;
@@ -113,6 +114,8 @@ public class ParsingTestExtension implements ParameterResolver, AfterTestExecuti
 
     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/M68kInstructionDocumentationProviderTest.kt

@@ -108,6 +108,16 @@ internal class M68kInstructionDocumentationProviderTest : AbstractDocumentationP
         assertThat(generateDocumentation(myFixture)).contains("Reset External Devices", "(privileged)")
     }
 
+    @Test
+    internal fun check_documentation_for_instruction_with_special_register(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+ <caret>move.l usp,a0
+        """
+        )
+        assertThat(generateDocumentation(myFixture)).contains("<div>usp</div>")
+    }
+
     @Test
     internal fun check_documentation_if_there_is_no_concrete_match(@MyFixture myFixture: CodeInsightTestFixture) {
         myFixture.configureByText(

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

@@ -0,0 +1,43 @@
+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 M68kLabelDocumentationProviderTest : AbstractDocumentationProviderTest() {
+
+    @Test
+    internal fun check_documentation_for_a_label_definition(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+ rts
+; inputs: d0 = number
+
+; output: d0 = square
+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<br/>; code -&gt; cool!</span><div class=\"definition\"><code>squareme</code></div><div class=\"content\"><code>include &quot;fancysquarecode.asm&quot;</code></div>")
+    }
+
+    @Test
+    internal fun check_documentation_for_a_label_definition_next_line(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "documentme.asm", """
+; output: d0 = square
+.square<caret>me:
+; oh man
+ include "fancysquarecode.asm"
+        """
+        )
+        assertThat(generateDocumentation(myFixture))
+            .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/AbstractInspectionTest.kt

@@ -1,5 +1,6 @@
 package de.platon42.intellij.plugins.m68k.inspections
 
+import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.testFramework.fixtures.CodeInsightTestFixture
 import de.platon42.intellij.jupiter.LightCodeInsightExtension
 import de.platon42.intellij.jupiter.TestDataPath
@@ -16,4 +17,16 @@ abstract class AbstractInspectionTest : AbstractM68kTest() {
         assertThat(myFixture.doHighlighting())
             .areExactly(count, Condition({ it.description?.contains(snippet) ?: false }, "containing"))
     }
+
+    protected fun executeQuickFixes(myFixture: CodeInsightTestFixture, regex: Regex, expectedFixes: Int) {
+        val quickfixes = getQuickFixes(myFixture, regex, expectedFixes)
+        assertThat(quickfixes.groupBy { it.familyName }).hasSize(1)
+        quickfixes.forEach(myFixture::launchAction)
+    }
+
+    protected fun getQuickFixes(myFixture: CodeInsightTestFixture, regex: Regex, expectedFixes: Int): List<IntentionAction> {
+        val quickfixes = myFixture.getAllQuickFixes().filter { it.text.matches(regex) }
+        assertThat(quickfixes).`as`("Fixes matched by $regex: ${myFixture.getAllQuickFixes().map { it.text }}").hasSize(expectedFixes)
+        return quickfixes
+    }
 }

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

@@ -0,0 +1,70 @@
+package de.platon42.intellij.plugins.m68k.inspections
+
+import com.intellij.testFramework.fixtures.CodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class M68kInspectionSuppressorTest : AbstractInspectionTest() {
+
+    companion object {
+        private const val SUPPRESS_FOR_STATEMENT = "Suppress for statement"
+    }
+
+    @Test
+    internal fun suppresses_inspection_with_end_of_line_comment(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kSyntaxInspection::class.java)
+        myFixture.configureByText("syntax.asm", " rts d0 ; suppress M68kSyntax")
+        assertThat(myFixture.doHighlighting()).isEmpty()
+    }
+
+    @Test
+    internal fun suppresses_inspection_with_full_line_comment_on_line_before(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kSyntaxInspection::class.java)
+        myFixture.configureByText("syntax.asm", "; suppress M68kSyntax\n rts d0")
+        assertThat(myFixture.doHighlighting()).isEmpty()
+    }
+
+    @Test
+    internal fun suppression_works_without_prior_comment(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kSyntaxInspection::class.java)
+        myFixture.configureByText("syntax.asm", " rts<caret> d0")
+        executeSuppressAction(myFixture, SUPPRESS_FOR_STATEMENT)
+        myFixture.checkResult(" rts d0\t; suppress M68kSyntax")
+    }
+
+    @Test
+    internal fun suppression_works_with_prior_suppression_comment(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kSyntaxInspection::class.java)
+        myFixture.configureByText("syntax.asm", " rts<caret> d0; suppress foobar")
+        executeSuppressAction(myFixture, SUPPRESS_FOR_STATEMENT)
+        myFixture.checkResult(" rts d0; suppress foobar M68kSyntax")
+    }
+
+    @Test
+    internal fun suppression_works_with_prior_suppression_comment_in_line_above(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kSyntaxInspection::class.java)
+        myFixture.configureByText("syntax.asm", "; suppress foobar\n rts<caret> d0")
+        executeSuppressAction(myFixture, SUPPRESS_FOR_STATEMENT)
+        myFixture.checkResult("; suppress foobar M68kSyntax\n rts d0")
+    }
+
+    @Test
+    internal fun suppression_works_by_adding_suppression_comment_in_line_above(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kSyntaxInspection::class.java)
+        myFixture.configureByText("syntax.asm", " rts<caret> d0 ; unrelated comment")
+        executeSuppressAction(myFixture, SUPPRESS_FOR_STATEMENT)
+        myFixture.checkResult("; suppress M68kSyntax\n rts d0 ; unrelated comment")
+    }
+
+    private fun executeSuppressAction(myFixture: CodeInsightTestFixture, suppressAction: String) {
+        val highlightInfos = myFixture.doHighlighting()
+        assertThat(highlightInfos).hasSize(1)
+        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)!!
+            .first { it.text == suppressAction }
+        myFixture.launchAction(suppressQuickFix)
+    }
+}

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

@@ -0,0 +1,29 @@
+package de.platon42.intellij.plugins.m68k.inspections
+
+import com.intellij.testFramework.fixtures.CodeInsightTestFixture
+import de.platon42.intellij.jupiter.MyFixture
+import org.junit.jupiter.api.Test
+
+internal class M68kUnresolvedReferenceInspectionTest : AbstractInspectionTest() {
+
+    @Test
+    internal fun shows_warning_on_undefined_symbol_label(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kUnresolvedReferenceInspection::class.java)
+        myFixture.configureByText("unresolvedref.asm", " bra foobar")
+        assertHighlightings(myFixture, 1, "Cannot resolve symbol 'foobar'")
+    }
+
+    @Test
+    internal fun shows_warning_on_undefined_local_label(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kUnresolvedReferenceInspection::class.java)
+        myFixture.configureByText("unresolvedref.asm", " bra .foobar")
+        assertHighlightings(myFixture, 1, "Cannot resolve local label '.foobar'")
+    }
+
+    @Test
+    internal fun shows_warning_on_undefined_macro(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.enableInspections(M68kUnresolvedReferenceInspection::class.java)
+        myFixture.configureByText("unresolvedref.asm", " foobar")
+        assertHighlightings(myFixture, 1, "Cannot resolve macro 'foobar'")
+    }
+}

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

@@ -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,11 +92,191 @@ 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")
     }
 
+    @Test
+    internal fun btst_quirk(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " btst #5,#42\n btst d0,#42")
+    }
+
     @Test
     internal fun movem_register_list(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
         testGoodSyntax(testCase, " movem.l d0-d2/d4/a0/a2-a3/a5,-(sp)\n")
@@ -118,7 +308,7 @@ internal class AddressingModesTest : AbstractParsingTest() {
     internal fun special_register_move(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
         testGoodSyntax(
             testCase, " move.l usp,a0\n"
-                    + " move.l a5,usp\n"
+                    + " move.l a5,USP\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/parser/EndDirectiveTest.kt

@@ -0,0 +1,24 @@
+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 org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+
+@TestDataSubPath("directives")
+internal class EndDirectiveTest : AbstractParsingTest() {
+
+    @Test
+    @Disabled("END directive detection breaks stuff, need to find a different solution")
+    internal fun end_directive(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(
+            testCase, """
+ moveq.l #0,d0
+ rts
+ END narf
+ äöö#öä235r2352ou485742q3535p3ü
+"""
+        )
+    }
+}

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

@@ -22,4 +22,14 @@ internal class OtherDirectivesTest : AbstractParsingTest() {
     internal fun if_defined_block(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
         testGoodSyntax(testCase, "\tIFD DEBUG ; cause a crash\n illegal\n ENDC\n")
     }
+
+    @Test
+    internal fun kalms_include_file_special_quote(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " include\t<Engine/A500/System/Copper.i>")
+    }
+
+    @Test
+    internal fun opt_directive(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
+        testGoodSyntax(testCase, " opt o+,w-")
+    }
 }

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

@@ -0,0 +1,57 @@
+package de.platon42.intellij.plugins.m68k.refs
+
+import com.intellij.testFramework.fixtures.CodeInsightTestFixture
+import de.platon42.intellij.jupiter.LightCodeInsightExtension
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.jupiter.TestDataPath
+import de.platon42.intellij.jupiter.TestDataSubPath
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@TestDataPath("src/test/resources/references")
+@TestDataSubPath("completion")
+@ExtendWith(LightCodeInsightExtension::class)
+internal class M68kLocalLabelDefCompletionContributorTest {
+
+    @Test
+    internal fun completion_shows_undefined_local_labels_without_dot_prefix(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "completeme.asm", """
+main
+.loop
+        dbra    d0,.loop
+        dbra    d1,.loop2
+.<caret>
+        bra.s   .foo
+        rts
+
+coolsubroutine
+        bra.s   .narf
+        """
+        )
+        myFixture.completeBasic()
+        assertThat(myFixture.lookupElementStrings).containsExactlyInAnyOrder("loop2", "foo")
+    }
+
+    @Test
+    internal fun completion_shows_undefined_local_labels_even_without_dot(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.configureByText(
+            "completeme.asm", """
+main
+.loop
+        dbra    d0,.loop
+        dbra    d1,.loop2
+<caret>
+        bra.s   .foo
+        bra.s   bar$
+        rts
+
+coolsubroutine
+        bra.s   .narf
+        """
+        )
+        myFixture.completeBasic()
+        assertThat(myFixture.lookupElementStrings).containsExactlyInAnyOrder(".loop2", ".foo", "bar$")
+    }
+}

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

@@ -2,6 +2,8 @@ package de.platon42.intellij.plugins.m68k.refs
 
 import com.intellij.codeInsight.lookup.LookupElementBuilder
 import com.intellij.psi.PsiElement
+import com.intellij.psi.search.FilenameIndex
+import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.fixtures.CodeInsightTestFixture
 import de.platon42.intellij.jupiter.LightCodeInsightExtension
 import de.platon42.intellij.jupiter.MyFixture
@@ -86,4 +88,44 @@ internal class M68kReferenceContributorTest : AbstractM68kTest() {
 
         myFixture.checkResultByFile("macros_after_rename.asm")
     }
+
+    @Test
+    internal fun reference_to_file_can_be_renamed(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.addFileToProject("otherfile.asm", "; oh no!")
+        val file = myFixture.configureByText(
+            "fileref.asm", """
+ include "otherfil<caret>e.asm"
+        """
+        )
+        val reference = file.findReferenceAt(myFixture.editor.caretModel.offset)
+        assertThat(reference).isInstanceOf(M68kIncludeFileReference::class.java)
+        val otherfile = reference!!.resolve() as M68kFile
+        assertThat(otherfile.text).isEqualTo("; oh no!")
+
+        myFixture.renameElementAtCaret("foobar.asm")
+        val files = FilenameIndex.getFilesByName(myFixture.project, "foobar.asm", GlobalSearchScope.allScope(myFixture.project))
+        assertThat(files).hasSize(1)
+
+        assertThat(file.text).isEqualToIgnoringWhitespace("include \"foobar.asm\"")
+    }
+
+    @Test
+    internal fun reference_to_file_in_a_subdirectory_can_be_renamed(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.addFileToProject("foobar/otherfile.asm", "; oh no!")
+        val file = myFixture.configureByText(
+            "fileref.asm", """
+ include "foobar/otherfil<caret>e.asm"
+        """
+        )
+        val reference = file.findReferenceAt(myFixture.editor.caretModel.offset)
+        assertThat(reference).isInstanceOf(M68kIncludeFileReference::class.java)
+        val otherfile = reference!!.resolve() as M68kFile
+        assertThat(otherfile.text).isEqualTo("; oh no!")
+
+        myFixture.renameElementAtCaret("foobar.asm")
+        val files = FilenameIndex.getFilesByName(myFixture.project, "foobar.asm", GlobalSearchScope.allScope(myFixture.project))
+        assertThat(files).hasSize(1)
+
+        assertThat(file.text).isEqualToIgnoringWhitespace("include \"foobar/foobar.asm\"")
+    }
 }

src/test/java/de/platon42/intellij/plugins/m68k/scanner/M68kIncludeFileProviderTest.kt

@@ -0,0 +1,37 @@
+package de.platon42.intellij.plugins.m68k.scanner
+
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.impl.include.FileIncludeManager
+import com.intellij.testFramework.fixtures.CodeInsightTestFixture
+import de.platon42.intellij.jupiter.LightCodeInsightExtension
+import de.platon42.intellij.jupiter.MyFixture
+import de.platon42.intellij.plugins.m68k.AbstractM68kTest
+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 M68kIncludeFileProviderTest : AbstractM68kTest() {
+
+    @Test
+    internal fun accepts_a_couple_of_include_statements(@MyFixture myFixture: CodeInsightTestFixture) {
+        myFixture.addFileToProject("macros.i", "PUSHM MACRO\n ENDM")
+        myFixture.addFileToProject("exec/execbase.i", "; Commodore include")
+        myFixture.addFileToProject("exec/exec.i", " include execbase.i")
+        myFixture.addFileToProject("includes/hardware/custom.i", "; Another Commodore include")
+        myFixture.addFileToProject("data/ease_x.bin", "binary file")
+        myFixture.addFileToProject("fx/fx_angle_only.S", "; Nosfe!!")
+        myFixture.configureByText(
+            "completeme.asm", """
+ include macros.i
+ include "exec/exec.i"
+ include <../src/includes/hardware/custom.i>
+ incbin "data/ease_x.bin"
+ include fx\fx_angle_only.S
+        """
+        )
+        val includedFiles = FileIncludeManager.getManager(myFixture.project).getIncludedFiles(myFixture.file.virtualFile, true, true)
+        assertThat(includedFiles).extracting<String>(VirtualFile::getName)
+            .containsExactlyInAnyOrder("completeme.asm", "macros.i", "fx_angle_only.S", "custom.i", "exec.i", "execbase.i")
+    }
+}