Bumped to IntelliJ/CLion 2021.2.2

'END' detection was breaking parsing, causing havoc.
Added documentation provider info for global labels. Shows directives and comments above.
2021-09-25 21:29:17 +02:00 · 2021-09-25 17:20:45 +02:00 · 2021-09-25 15:19:05 +02:00 · 2021-09-05 18:42:20 +02:00 · 2021-09-04 14:23:15 +02:00 · 2021-09-04 14:08:10 +02:00
63 changed files with 1401 additions and 405 deletions
@@ -10,8 +10,8 @@ This plugin delivers support for MC68000 assembly language files ([VAsm](http://

 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
-learning curve.
+I'm an Amiga retro democoder (among other things), and the lack of a plugin for M68k was the motivation to write one. Also, diving deep into custom language
+plugins has a steep learning curve.

 When I started the plugin in July 2021, I was not aware of the [M68k plugin efforts by Jetbrains employee Yann Cébron](https://github.com/YannCebron/m68kplugin)
 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
@@ -19,17 +19,17 @@ awesome features and is pretty advanced. Check it out. You can install both plug

 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 "
-good enough" to get started, and I can return to demo coding with its current state.
+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"
+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
- Inspection for validating the syntax of the 68000 ISA.
+- Validates the assembly syntax against the 68000 ISA.
 - Syntax highlighting and Color Settings Page (you should really modify the color settings to your likings!)
 - Mnemonics code completion
- Symbols / Labels / Macros code completion
- References / Refactoring support for local and global labels, symbol assignments, and macros.
+- Symbols / labels / macros code completion
+- 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 +39,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 +57,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 +68,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 +78,22 @@ 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
+#### M68kGlobalLabel
+
+Shows the comments above the label and if the first statement after the label is a directive like `include` or `dc.b`, shows it, too.
+
+#### 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 +104,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 +116,13 @@ 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 and labels 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, FPU or 68020+ address modes.
 - 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 +145,36 @@ 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
- support `include` directive
- support `opt` directive
- suppression support via comments
- inspection: Unresolved local label
- inspection: Unresolved macro
+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.
+
+Feedback and [rating](https://plugins.jetbrains.com/plugin/17268-mc68000-assembly-language-support/reviews)
+are appreciated. It really is keeping me motivated to continue development.

 ## Changelog

+### 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 +206,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.
@@ -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.7'
 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.junit.jupiter:junit-jupiter-api:5.8.0-M1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
+    testImplementation "org.assertj:assertj-core:3.21.0"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+    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,32 @@ 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.5284.40", // 2020.3 - 2021.2.2
                   "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
-    downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea"
+                   "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/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.7 (26-Sep-21)</h4>
    <ul>
-      <li>Bugfix: movem ISA was wrong regarding movem.w <ea>,<registerlist> (sign extends registers).
-      <li>Cosmetics: Changed Register Flow Documentation wording from 'reads' to 'uses' and from 'modifies' to 'changes'.
-      <li>Bugfix: Minor fix for `andi/eori/ori to ccr` which were not byte sized in ISA.
-      <li>Bugfix: Added alternate condition code tests HS (=CC) and LO (=CS).
-      <li>Performance: Optimized mnemonic lookup.
-      <li>Enhancement: Reworked Instruction Documentation provider, now shows condition codes.
-      <li>Bugfix: In ISA exg is no longer treated as setting a definitive value.
-      <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!
+      <li>Bugfix: 'btst' with pc-relative and weird immediate mode was missing (courtesy of Yann).
+      <li>Bugfix: 'movem' with pc-relative mode was missing for weird immediate mode (courtesy of Yann).
+      <li>Bugfix: Special registers for address mode matching only worked with lower case register names (courtesy of Yann).
+      <li>Enhancement: Assembler syntax with implicit immediate 1 for shifts and rotations no longer cause syntax errors (courtesy of Yann).
+      <li>Enhancement: Documentation for instruction with special register shows specific register expected.
+      <li>New: Added documentation provider info for global labels. Shows directives and comments above.
+      <li>Bugfix: Fixed BNF for labels with preprocessor statements.
+      <li>Disabled: 'END' detection was breaking parsing, causing havoc.
    </ul>
  <p>Full changelog available at <a href="https://github.com/chrisly42/mc68000-asm-plugin#changelog">Github project site</a>.</p>
 """)
@@ -40,7 +40,7 @@ public class _M68kLexer implements FlexLexer {
    public static final int ASSIGNMENT = 12;
    public static final int EXPR = 14;
    public static final int EXPR_OP = 16;
-    public static final int MACROCALL = 18;
+    public static final int PLAINPARAMS = 18;
    public static final int WAITEOL = 20;
    public static final int MACRODEF = 22;
    public static final int MACROLINE = 24;
@@ -194,23 +194,23 @@ public class _M68kLexer implements FlexLexer {
    private static final int[] ZZ_ACTION = zzUnpackAction();

    private static final String ZZ_ACTION_PACKED_0 =
-            "\17\0\1\1\2\2\1\3\1\4\1\1\1\5\1\6" +
-                    "\1\7\1\10\1\1\1\7\2\11\1\7\1\10\1\12" +
-                    "\1\13\1\14\1\1\1\15\1\16\1\17\4\16\1\1" +
-                    "\1\16\5\1\1\20\1\21\1\22\1\23\1\24\1\25" +
-                    "\1\26\1\27\1\30\1\31\2\16\1\32\1\33\1\34" +
-                    "\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44" +
-                    "\1\45\1\46\1\47\1\42\1\50\2\1\1\51\1\16" +
-                    "\1\52\1\11\4\52\1\53\1\11\2\54\2\55\1\56" +
-                    "\1\57\3\60\1\57\1\60\1\0\1\4\1\61\2\62" +
-                    "\1\63\3\0\1\7\1\64\1\65\1\66\1\67\1\70" +
-                    "\1\71\1\16\1\72\1\73\1\16\1\74\1\75\2\0" +
-                    "\1\76\4\0\1\77\1\16\1\32\1\100\1\101\1\102" +
-                    "\1\103\1\104\1\105\1\106\3\0\1\52\1\0\1\52" +
-                    "\1\0\1\52\1\0\1\52\1\55\1\57\3\0\1\4" +
-                    "\1\62\1\63\1\7\1\107\1\7\1\110\1\111\1\112" +
-                    "\1\113\1\0\1\52\3\0\1\55\1\57\3\0\1\7" +
-                    "\1\55\1\57\2\0\1\114\1\115\1\116\1\0\1\117";
+            "\17\0\1\1\2\2\1\3\1\4\1\5\1\6\1\7" +
+                    "\1\10\1\11\1\1\1\10\2\12\1\10\1\11\1\13" +
+                    "\1\14\1\15\1\1\1\16\1\17\1\20\4\17\1\1" +
+                    "\1\17\5\1\1\21\1\22\1\23\1\24\1\25\1\26" +
+                    "\1\27\1\30\1\31\1\32\2\17\1\33\1\34\1\35" +
+                    "\1\36\1\37\1\40\1\41\1\42\1\43\1\44\1\45" +
+                    "\1\46\1\47\1\50\1\43\1\51\2\1\1\52\1\17" +
+                    "\1\53\1\12\4\53\1\54\1\12\2\55\2\56\1\57" +
+                    "\1\60\3\61\1\60\1\61\1\0\1\4\1\62\2\63" +
+                    "\1\64\3\0\1\10\1\65\1\66\1\67\1\70\1\71" +
+                    "\1\72\1\17\1\73\1\74\1\17\1\75\1\76\2\0" +
+                    "\1\77\4\0\1\100\1\17\1\33\1\101\1\102\1\103" +
+                    "\1\104\1\105\1\106\1\107\3\0\1\53\1\0\1\53" +
+                    "\1\0\1\53\1\0\1\53\1\56\1\60\3\0\1\4" +
+                    "\1\63\1\64\1\10\1\110\1\10\1\111\1\112\1\113" +
+                    "\1\114\1\0\1\53\3\0\1\56\1\60\3\0\1\10" +
+                    "\1\56\1\60\2\0\1\115\1\116\1\117\1\0\1\120";

    private static int[] zzUnpackAction() {
        int[] result = new int[184];
@@ -624,11 +624,11 @@ public class _M68kLexer implements FlexLexer {
    /**
     * Refills the input buffer.
     *
-     * @return {@code false}, iff there was new input.
+     * @return {@code false}, iff there was NO new input.
     * @throws java.io.IOException if any I/O-Error occurs
     */
    private boolean zzRefill() throws java.io.IOException {
-        return true;
+        return !zzAtEOF;
    }


@@ -814,14 +814,14 @@ public class _M68kLexer implements FlexLexer {
                        return BAD_CHARACTER;
                    }
                    // fall through
-                    case 80:
+                    case 81:
                        break;
                    case 2: {
                        yybegin(YYINITIAL);
                        return WHITE_SPACE;
                    }
                    // fall through
-                    case 81:
+                    case 82:
                        break;
                    case 3: {
                        yybegin(NOSOL);
@@ -829,7 +829,7 @@ public class _M68kLexer implements FlexLexer {
                        return WHITE_SPACE;
                    }
                    // fall through
-                    case 82:
+                    case 83:
                        break;
                    case 4: {
                        yybegin(INSTRPART);
@@ -838,22 +838,30 @@ public class _M68kLexer implements FlexLexer {
                        return GLOBAL_LABEL_DEF;
                    }
                    // fall through
-                    case 83:
-                        break;
-                    case 5: {
-                        yybegin(YYINITIAL);
-                        return COMMENT;
-                    }
-                    // fall through
                    case 84:
                        break;
-                    case 6: {
-                        return WHITE_SPACE;
+                    case 5: {
+                        yybegin(INSTRPART);
+                        eatOneWhitespace = false;
+                        return LOCAL_LABEL_DEF;
                    }
                    // fall through
                    case 85:
                        break;
+                    case 6: {
+                        yybegin(YYINITIAL);
+                        return COMMENT;
+                    }
+                    // fall through
+                    case 86:
+                        break;
                    case 7: {
+                        return WHITE_SPACE;
+                    }
+                    // fall through
+                    case 87:
+                        break;
+                    case 8: {
                        if (isAsmMnemonicWithSize(yytext())) {
                            yybegin(ASMINSTR);
                            yypushback(2);
@@ -863,10 +871,15 @@ public class _M68kLexer implements FlexLexer {
                            yybegin(ASMINSTR);
                            return MNEMONIC;
                        }
+                        //if(isEndDirective(yytext())) { yybegin(YYINITIAL); zzAtEOF = true; return null; }
                        if (isDataDirective(yytext())) {
                            startExpr(EXPR, EXPR_OP);
                            return DATA_DIRECTIVE;
                        }
+                        if (isPlainDirective(yytext())) {
+                            yybegin(PLAINPARAMS);
+                            return OTHER_DIRECTIVE;
+                        }
                        if (isOtherDirective(yytext())) {
                            startExpr(EXPR, EXPR_OP);
                            return OTHER_DIRECTIVE;
@@ -874,498 +887,498 @@ public class _M68kLexer implements FlexLexer {
                        return handleMacroMode(this);
                    }
                    // fall through
-                    case 86:
-                        break;
-                    case 8: {
-                        return handleMacroMode(this);
-                    }
-                    // fall through
-                    case 87:
-                        break;
-                    case 9: {
-                        yybegin(YYINITIAL);
-                        return EOL;
-                    }
-                    // fall through
                    case 88:
                        break;
-                    case 10: {
-                        return COLON;
+                    case 9: {
+                        return handleMacroMode(this);
                    }
                    // fall through
                    case 89:
                        break;
-                    case 11: {
-                        yybegin(WAITEOL);
-                        return COMMENT;
+                    case 10: {
+                        yybegin(YYINITIAL);
+                        return EOL;
                    }
                    // fall through
                    case 90:
                        break;
-                    case 12: {
-                        startExpr(ASMOPS, ASMOPS_OP);
-                        return WHITE_SPACE;
+                    case 11: {
+                        return COLON;
                    }
                    // fall through
                    case 91:
                        break;
-                    case 13: {
-                        return handleEolCommentWhitespace(this);
+                    case 12: {
+                        yybegin(WAITEOL);
+                        return COMMENT;
                    }
                    // fall through
                    case 92:
                        break;
-                    case 14: {
-                        yybegin(exprOpState);
-                        return SYMBOL;
+                    case 13: {
+                        startExpr(ASMOPS, ASMOPS_OP);
+                        return WHITE_SPACE;
                    }
                    // fall through
                    case 93:
                        break;
-                    case 15: {
-                        yybegin(exprOpState);
-                        return DECIMAL;
+                    case 14: {
+                        return handleEolCommentWhitespace(this);
                    }
                    // fall through
                    case 94:
                        break;
-                    case 16: {
-                        return SEPARATOR;
+                    case 15: {
+                        yybegin(exprOpState);
+                        return SYMBOL;
                    }
                    // fall through
                    case 95:
                        break;
-                    case 17: {
-                        return HASH;
+                    case 16: {
+                        yybegin(exprOpState);
+                        return DECIMAL;
                    }
                    // fall through
                    case 96:
                        break;
-                    case 18: {
-                        return OP_BITWISE_XOR;
+                    case 17: {
+                        return SEPARATOR;
                    }
                    // fall through
                    case 97:
                        break;
-                    case 19: {
-                        return ROUND_L;
+                    case 18: {
+                        return HASH;
                    }
                    // fall through
                    case 98:
                        break;
-                    case 20: {
-                        yybegin(exprOpState);
-                        return ROUND_R;
+                    case 19: {
+                        return OP_BITWISE_XOR;
                    }
                    // fall through
                    case 99:
                        break;
-                    case 21: {
-                        return OP_UNARY_NOT;
+                    case 20: {
+                        return ROUND_L;
                    }
                    // fall through
                    case 100:
                        break;
-                    case 22: {
-                        return OP_UNARY_COMPL;
+                    case 21: {
+                        yybegin(exprOpState);
+                        return ROUND_R;
                    }
                    // fall through
                    case 101:
                        break;
-                    case 23: {
-                        return OP_PLUS;
+                    case 22: {
+                        return OP_UNARY_NOT;
                    }
                    // fall through
                    case 102:
                        break;
-                    case 24: {
-                        return OP_MINUS;
+                    case 23: {
+                        return OP_UNARY_COMPL;
                    }
                    // fall through
                    case 103:
                        break;
-                    case 25: {
-                        yybegin(exprOpState);
-                        return CURRENT_PC_SYMBOL;
+                    case 24: {
+                        return OP_PLUS;
                    }
                    // fall through
                    case 104:
                        break;
-                    case 26: {
-                        yybegin(exprState);
-                        return OP_CMP_EQ;
+                    case 25: {
+                        return OP_MINUS;
                    }
                    // fall through
                    case 105:
                        break;
-                    case 27: {
-                        yybegin(exprState);
-                        return OP_AR_MOD;
+                    case 26: {
+                        yybegin(exprOpState);
+                        return CURRENT_PC_SYMBOL;
                    }
                    // fall through
                    case 106:
                        break;
-                    case 28: {
+                    case 27: {
                        yybegin(exprState);
-                        return OP_CMP_LT;
+                        return OP_CMP_EQ;
                    }
                    // fall through
                    case 107:
                        break;
-                    case 29: {
+                    case 28: {
                        yybegin(exprState);
-                        return OP_CMP_GT;
+                        return OP_AR_MOD;
                    }
                    // fall through
                    case 108:
                        break;
-                    case 30: {
+                    case 29: {
                        yybegin(exprState);
-                        return SEPARATOR;
+                        return OP_CMP_LT;
                    }
                    // fall through
                    case 109:
                        break;
-                    case 31: {
+                    case 30: {
                        yybegin(exprState);
-                        return OP_BITWISE_XOR;
+                        return OP_CMP_GT;
                    }
                    // fall through
                    case 110:
                        break;
-                    case 32: {
+                    case 31: {
                        yybegin(exprState);
-                        return ROUND_L;
+                        return SEPARATOR;
                    }
                    // fall through
                    case 111:
                        break;
-                    case 33: {
-                        return ROUND_R;
+                    case 32: {
+                        yybegin(exprState);
+                        return OP_BITWISE_XOR;
                    }
                    // fall through
                    case 112:
                        break;
-                    case 34: {
+                    case 33: {
                        yybegin(exprState);
-                        return OP_BITWISE_OR;
+                        return ROUND_L;
                    }
                    // fall through
                    case 113:
                        break;
-                    case 35: {
-                        yybegin(exprState);
-                        return OP_UNARY_COMPL;
+                    case 34: {
+                        return ROUND_R;
                    }
                    // fall through
                    case 114:
                        break;
-                    case 36: {
+                    case 35: {
                        yybegin(exprState);
-                        return OP_PLUS;
+                        return OP_BITWISE_OR;
                    }
                    // fall through
                    case 115:
                        break;
-                    case 37: {
+                    case 36: {
                        yybegin(exprState);
-                        return OP_MINUS;
+                        return OP_UNARY_COMPL;
                    }
                    // fall through
                    case 116:
                        break;
-                    case 38: {
+                    case 37: {
                        yybegin(exprState);
-                        return OP_AR_MUL;
+                        return OP_PLUS;
                    }
                    // fall through
                    case 117:
                        break;
-                    case 39: {
+                    case 38: {
                        yybegin(exprState);
-                        return OP_BITWISE_AND;
+                        return OP_MINUS;
                    }
                    // fall through
                    case 118:
                        break;
-                    case 40: {
+                    case 39: {
                        yybegin(exprState);
-                        return OP_AR_DIV;
+                        return OP_AR_MUL;
                    }
                    // fall through
                    case 119:
                        break;
-                    case 41: {
-                        startExpr(EXPR, EXPR_OP);
-                        return OP_ASSIGN;
+                    case 40: {
+                        yybegin(exprState);
+                        return OP_BITWISE_AND;
                    }
                    // fall through
                    case 120:
                        break;
-                    case 42: {
-                        return STRINGLIT;
+                    case 41: {
+                        yybegin(exprState);
+                        return OP_AR_DIV;
                    }
                    // fall through
                    case 121:
                        break;
-                    case 43: {
-                        return COMMENT;
+                    case 42: {
+                        startExpr(EXPR, EXPR_OP);
+                        return OP_ASSIGN;
                    }
                    // fall through
                    case 122:
                        break;
+                    case 43: {
+                        return STRINGLIT;
+                    }
+                    // fall through
+                    case 123:
+                        break;
                    case 44: {
+                        return COMMENT;
+                    }
+                    // fall through
+                    case 124:
+                        break;
+                    case 45: {
                        yybegin(MACROLINE);
                        macroLines = 0;
                        return WHITE_SPACE;
                    }
                    // fall through
-                    case 123:
-                        break;
-                    case 45: {
-                        return MACRO_NAME;
-                    }
-                    // fall through
-                    case 124:
-                        break;
-                    case 46: {
-                        yybegin(MACROWAITEOL);
-                        return COMMENT;
-                    }
-                    // fall through
                    case 125:
                        break;
-                    case 47: {
-                        return MACRO_LINE;
+                    case 46: {
+                        return MACRO_NAME;
                    }
                    // fall through
                    case 126:
                        break;
-                    case 48: {
-                        return handleMacroLineEol(this);
+                    case 47: {
+                        yybegin(MACROWAITEOL);
+                        return COMMENT;
                    }
                    // fall through
                    case 127:
                        break;
+                    case 48: {
+                        return MACRO_LINE;
+                    }
+                    // fall through
+                    case 128:
+                        break;
                    case 49: {
+                        return handleMacroLineEol(this);
+                    }
+                    // fall through
+                    case 129:
+                        break;
+                    case 50: {
                        yybegin(ASSIGNMENT);
                        eatOneWhitespace = true;
                        yypushback(pushbackAssignment(yytext()));
                        return SYMBOLDEF;
                    }
                    // fall through
-                    case 128:
+                    case 130:
                        break;
-                    case 50: {
+                    case 51: {
                        yybegin(INSTRPART);
                        eatOneWhitespace = false;
                        yypushback(pushbackLabelColons(yytext()));
                        return LOCAL_LABEL_DEF;
                    }
                    // fall through
-                    case 129:
+                    case 131:
                        break;
-                    case 51: {
+                    case 52: {
                        yybegin(INSTRPART);
                        yypushback(pushbackLabelColons(yytext()));
                        return GLOBAL_LABEL_DEF;
                    }
                    // fall through
-                    case 130:
-                        break;
-                    case 52: {
-                        return OPSIZE_BS;
-                    }
-                    // fall through
-                    case 131:
-                        break;
-                    case 53: {
-                        return OPSIZE_W;
-                    }
-                    // fall through
                    case 132:
                        break;
-                    case 54: {
-                        return OPSIZE_L;
+                    case 53: {
+                        return OPSIZE_BS;
                    }
                    // fall through
                    case 133:
                        break;
-                    case 55: {
-                        yybegin(exprOpState);
-                        return AREG;
+                    case 54: {
+                        return OPSIZE_W;
                    }
                    // fall through
                    case 134:
                        break;
-                    case 56: {
-                        yybegin(exprOpState);
-                        return REG_SP;
+                    case 55: {
+                        return OPSIZE_L;
                    }
                    // fall through
                    case 135:
                        break;
-                    case 57: {
+                    case 56: {
                        yybegin(exprOpState);
-                        return DREG;
+                        return AREG;
                    }
                    // fall through
                    case 136:
                        break;
-                    case 58: {
+                    case 57: {
                        yybegin(exprOpState);
-                        return REG_SR;
+                        return REG_SP;
                    }
                    // fall through
                    case 137:
                        break;
-                    case 59: {
+                    case 58: {
                        yybegin(exprOpState);
-                        return HEXADECIMAL;
+                        return DREG;
                    }
                    // fall through
                    case 138:
                        break;
-                    case 60: {
+                    case 59: {
                        yybegin(exprOpState);
-                        return BINARY;
+                        return REG_SR;
                    }
                    // fall through
                    case 139:
                        break;
-                    case 61: {
+                    case 60: {
                        yybegin(exprOpState);
-                        return OCTAL;
+                        return HEXADECIMAL;
                    }
                    // fall through
                    case 140:
                        break;
-                    case 62: {
+                    case 61: {
                        yybegin(exprOpState);
-                        return STRINGLIT;
+                        return BINARY;
                    }
                    // fall through
                    case 141:
                        break;
-                    case 63: {
+                    case 62: {
                        yybegin(exprOpState);
-                        return PC;
+                        return OCTAL;
                    }
                    // fall through
                    case 142:
                        break;
-                    case 64: {
-                        yybegin(exprState);
-                        return OP_CMP_LT_EQ;
+                    case 63: {
+                        yybegin(exprOpState);
+                        return STRINGLIT;
                    }
                    // fall through
                    case 143:
                        break;
-                    case 65: {
-                        yybegin(exprState);
-                        return OP_AR_SHIFT_L;
+                    case 64: {
+                        yybegin(exprOpState);
+                        return PC;
                    }
                    // fall through
                    case 144:
                        break;
-                    case 66: {
+                    case 65: {
                        yybegin(exprState);
-                        return OP_CMP_NOT_EQ;
+                        return OP_CMP_LT_EQ;
                    }
                    // fall through
                    case 145:
                        break;
-                    case 67: {
+                    case 66: {
                        yybegin(exprState);
-                        return OP_CMP_GT_EQ;
+                        return OP_AR_SHIFT_L;
                    }
                    // fall through
                    case 146:
                        break;
-                    case 68: {
+                    case 67: {
                        yybegin(exprState);
-                        return OP_AR_SHIFT_R;
+                        return OP_CMP_NOT_EQ;
                    }
                    // fall through
                    case 147:
                        break;
-                    case 69: {
+                    case 68: {
                        yybegin(exprState);
-                        return OP_LOGICAL_AND;
+                        return OP_CMP_GT_EQ;
                    }
                    // fall through
                    case 148:
                        break;
-                    case 70: {
+                    case 69: {
                        yybegin(exprState);
-                        return OP_LOGICAL_OR;
+                        return OP_AR_SHIFT_R;
                    }
                    // fall through
                    case 149:
                        break;
+                    case 70: {
+                        yybegin(exprState);
+                        return OP_LOGICAL_AND;
+                    }
+                    // fall through
+                    case 150:
+                        break;
                    case 71: {
+                        yybegin(exprState);
+                        return OP_LOGICAL_OR;
+                    }
+                    // fall through
+                    case 151:
+                        break;
+                    case 72: {
                        yybegin(INSTRPART);
                        yypushback(pushbackLabelColons(yytext()));
                        return LOCAL_LABEL_DEF;
                    }
                    // fall through
-                    case 150:
+                    case 152:
                        break;
-                    case 72: {
+                    case 73: {
                        yybegin(exprOpState);
                        return REG_USP;
                    }
                    // fall through
-                    case 151:
+                    case 153:
                        break;
-                    case 73: {
+                    case 74: {
                        yybegin(exprOpState);
                        return REG_CCR;
                    }
                    // fall through
-                    case 152:
+                    case 154:
                        break;
-                    case 74: {
+                    case 75: {
                        yybegin(exprOpState);
                        return REG_VBR;
                    }
                    // fall through
-                    case 153:
+                    case 155:
                        break;
-                    case 75: {
+                    case 76: {
                        startExpr(EXPR, EXPR_OP);
                        return EQU;
                    }
                    // fall through
-                    case 154:
+                    case 156:
                        break;
-                    case 76: {
+                    case 77: {
                        yybegin(MACRODEF);
                        return MACRO_TAG;
                    }
                    // fall through
-                    case 155:
+                    case 157:
                        break;
-                    case 77: {
+                    case 78: {
                        return MACRO_TAG;
                    }
                    // fall through
-                    case 156:
+                    case 158:
                        break;
-                    case 78: {
+                    case 79: {
                        yybegin(MACROTERMINATION);
                        return MACRO_END_TAG;
                    }
                    // fall through
-                    case 157:
+                    case 159:
                        break;
-                    case 79: {
+                    case 80: {
                        yybegin(MACRODEF);
                        yypushback(pushbackAfterFirstToken(yytext()));
                        return MACRO_NAME;
                    }
                    // fall through
-                    case 158:
+                    case 160:
                        break;
                    default:
                        zzScanError(ZZ_NO_MATCH);
@@ -562,9 +562,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 +600,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) {
@@ -817,42 +830,38 @@ public class M68kParser implements PsiParser, LightPsiParser {
    }

    /* ********************************************************** */
-    // Label? (DATA_DIRECTIVE | OTHER_DIRECTIVE)
-    //         PreprocessorOperands?
+    // PreprocessorKeyword 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?
-    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
+    // PreprocessorOperands?
    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) {
@@ -1217,14 +1226,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 +1243,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:
@@ -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
-    M68kGlobalLabel getGlobalLabel();
-
-    @Nullable
-    M68kLocalLabel getLocalLabel();
+    @NotNull
+    M68kPreprocessorKeyword getPreprocessorKeyword();

    @NotNull
    List<M68kExpr> getExprList();
@@ -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 {
+
+}
@@ -58,6 +58,7 @@ public interface M68kTypes {
    IElementType OPERAND_SIZE = new M68kElementType("OPERAND_SIZE");
    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_NEW_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE");
@@ -233,6 +234,8 @@ public interface M68kTypes {
                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) {
@@ -131,6 +131,10 @@ public class M68kVisitor extends PsiElementVisitor {
        visitPsiElement(o);
    }

+    public void visitPreprocessorKeyword(@NotNull M68kPreprocessorKeyword o) {
+        visitPsiElement(o);
+    }
+
    public void visitProgramCounterIndirectWithDisplacementNewAddressingMode(@NotNull M68kProgramCounterIndirectWithDisplacementNewAddressingMode o) {
        visitAddressingMode(o);
        // visitWithDisplacement(o);
@@ -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
-    public M68kGlobalLabel getGlobalLabel() {
-        return PsiTreeUtil.getChildOfType(this, M68kGlobalLabel.class);
-    }
-
-    @Override
-    @Nullable
-    public M68kLocalLabel getLocalLabel() {
-        return PsiTreeUtil.getChildOfType(this, M68kLocalLabel.class);
+    @NotNull
+    public M68kPreprocessorKeyword getPreprocessorKeyword() {
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kPreprocessorKeyword.class));
    }

    @Override
@@ -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);
+    }
+
+}
@@ -10,7 +10,7 @@ class M68kFileElementType private constructor() : ILightStubFileElementType<PsiF
        @JvmField
        val INSTANCE = M68kFileElementType()

-        const val STUB_VERSION = 5
+        const val STUB_VERSION = 6
        const val STUB_EXTERNAL_ID_PREFIX = "MC68000."
        const val EXTERNAL_ID = STUB_EXTERNAL_ID_PREFIX + "FILE"
    }
@@ -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"
    )
 }
@@ -44,7 +44,7 @@ enum class AddressMode(val description: String, val syntax: String) {
    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)"),
    PROGRAM_COUNTER_INDIRECT_WITH_INDEX("program counter indirect with index", "(d8,PC,Xn)"),
-    SPECIAL_REGISTER_DIRECT("special register", "ccr|usp|vbr"),
+    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")
@@ -202,6 +202,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,
@@ -256,33 +268,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 =
@@ -354,7 +372,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,
@@ -944,5 +964,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) || (specialReg.equals(am.specialReg, true))))
 }
@@ -0,0 +1,47 @@
+package de.platon42.intellij.plugins.m68k.documentation
+
+import com.intellij.lang.documentation.AbstractDocumentationProvider
+import com.intellij.lang.documentation.DocumentationMarkup
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.psi.PsiComment
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.SmartList
+import de.platon42.intellij.plugins.m68k.psi.M68kGlobalLabel
+import de.platon42.intellij.plugins.m68k.psi.M68kStatement
+
+class M68kGlobalLabelDocumentationProvider : AbstractDocumentationProvider() {
+
+    override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
+        return generateDoc(element, originalElement)
+    }
+
+    override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
+        return if (element is M68kGlobalLabel) {
+            // TODO find out how we can generate inner links for more symbol references inside the expression (DocumentationManagerUtil)
+            val statement = element.parent as M68kStatement
+            var preprocessorDirective = statement.preprocessorDirective
+            if ((preprocessorDirective == null) && (statement.asmInstruction == null) && (statement.macroCall == null)) {
+                val nextLineStatement = PsiTreeUtil.skipWhitespacesAndCommentsForward(PsiTreeUtil.skipWhitespacesAndCommentsForward(statement))
+                        as? M68kStatement
+                preprocessorDirective = nextLineStatement?.preprocessorDirective
+            }
+            val content = if (preprocessorDirective != null)
+                DocumentationMarkup.CONTENT_START + StringUtil.escapeXmlEntities(preprocessorDirective.text) + DocumentationMarkup.CONTENT_END
+            else ""
+            val comments = SmartList<String>()
+            var prevToken: PsiElement? = statement
+            do {
+                prevToken = PsiTreeUtil.skipWhitespacesBackward(prevToken)
+                if (prevToken !is PsiComment) break
+                comments.add(prevToken.text)
+            } while (true)
+            val commentpart =
+                if (comments.isNotEmpty()) comments.asReversed().joinToString("<br>", DocumentationMarkup.GRAYED_START, DocumentationMarkup.GRAYED_END) else ""
+
+            commentpart +
+                    DocumentationMarkup.DEFINITION_START + StringUtil.escapeXmlEntities(element.name!!) + DocumentationMarkup.DEFINITION_END +
+                    content
+        } else null
+    }
+}
@@ -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.op2))
+                if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op1, allowedAdrMode.specialReg))
+                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()
    }

@@ -79,18 +79,12 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
        )

        backtrace.addAll(analyseFlow(register, missingBits, true, initialStatement, linesLimit) {
-            PsiTreeUtil.getPrevSiblingOfType(
-                it,
-                M68kStatement::class.java
-            )
+            PsiTreeUtil.getPrevSiblingOfType(it, M68kStatement::class.java)
        })
        backtrace.reverse()
        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) {
-            PsiTreeUtil.getNextSiblingOfType(
-                it,
-                M68kStatement::class.java
-            )
+            PsiTreeUtil.getNextSiblingOfType(it, M68kStatement::class.java)
        })

        val statementRows = HtmlBuilder()
@@ -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
@@ -16,7 +16,7 @@ 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 value = (element.parent as M68kAssignment).expr.text
            DocumentationMarkup.DEFINITION_START + StringUtil.escapeXmlEntities(element.name!!) + DocumentationMarkup.DEFINITION_END +
                    DocumentationMarkup.CONTENT_START + StringUtil.escapeXmlEntities(value) + DocumentationMarkup.CONTENT_END
        } else null
@@ -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
+    }
+}
@@ -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())
+                    }
+                }
+            }
+        }
+    }
+}
@@ -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
+        }
+    }
 }
@@ -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,7 +117,9 @@ PLAIN_MACRO_LINE=[^;\r\n]+
  {DIRECTIVE_KEYWORD} {
                        if(isAsmMnemonicWithSize(yytext())) { yybegin(ASMINSTR); yypushback(2); return MNEMONIC; }
                        if(isAsmMnemonic(yytext())) { yybegin(ASMINSTR); return MNEMONIC; }
+                        //if(isEndDirective(yytext())) { yybegin(YYINITIAL); zzAtEOF = true; return null; }
                        if(isDataDirective(yytext())) { startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
+                        if(isPlainDirective(yytext())) { yybegin(PLAINPARAMS); return OTHER_DIRECTIVE; }
                        if(isOtherDirective(yytext())) { startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
                        return handleMacroMode(this);
                      }
@@ -136,7 +139,7 @@ PLAIN_MACRO_LINE=[^;\r\n]+
  {OPSIZE_L}          { return OPSIZE_L; }
 }

-<MACROCALL> {
+<PLAINPARAMS> {
  ","                 { return SEPARATOR; }

  {PLAINPARAM}        { return STRINGLIT; }
@@ -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 InstructionOnly ::= Instruction
+private LabelWithInstruction ::= Label (Instruction|PreprocessorDirective)
+private InstructionOnly ::= (Instruction|PreprocessorDirective)

 LocalLabel ::= LOCAL_LABEL_DEF COLON? {
    name = "local label"
@@ -173,8 +172,11 @@ AsmOp ::= MNEMONIC OperandSize? {
    methods = [getMnemonic getOpSize]
 }

-PreprocessorDirective ::= Label? (DATA_DIRECTIVE | OTHER_DIRECTIVE)
-        PreprocessorOperands?
+PreprocessorKeyword ::= (DATA_DIRECTIVE | OTHER_DIRECTIVE)
+
+PreprocessorDirective ::= PreprocessorKeyword PreprocessorOperands? {
+    mixin = "de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirectiveMixin"
+}

 MacroPlainLine ::= MACRO_LINE
 MacroNameDefinition ::= MACRO_NAME
@@ -62,11 +62,4 @@ object M68kAddressModeUtil {
            else -> throw IllegalArgumentException("Unknown addressing mode $addressingMode")
        }
    }
-
-    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()
-    }
 }
@@ -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
    }
@@ -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 -> {
-                return text.run {
-                    when {
-                        startsWith('"') -> removeSurrounding("\"")
-                        startsWith('\'') -> removeSurrounding("'")
-                        startsWith('<') -> removeSurrounding(">")
-                        else -> this
-                    }
-                }
-            }
+            M68kTypes.STRINGLIT -> LexerUtil.unquoteString(childNode.text)
            M68kTypes.DECIMAL -> {
                try {
                    return childNode.text.toInt()
@@ -46,6 +38,6 @@ abstract class M68kLiteralExprMixin(node: ASTNode) : ASTWrapperPsiElement(node),
                }
            }
        }
-        return text
+        return childNode.text
    }
 }
@@ -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)
    }
@@ -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)
+    }
+}
@@ -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 {
@@ -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)
    }
@@ -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
+//        )
+//    }
+}
@@ -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)
+                            )
+                        }
+                    }
+                }
+            })
+    }
+}
@@ -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
@@ -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
@@ -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
+        }
+    }
+}
@@ -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()
+            }
+        }
+    }
 }
@@ -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
@@ -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()
+    }
+}
@@ -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,23 @@
        <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.M68kGlobalLabelDocumentationProvider"/>
        <lang.documentationProvider language="MC68000"
                                    implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kRegisterFlowDocumentationProvider"/>
        <lang.documentationProvider language="MC68000"
@@ -43,9 +49,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 +63,9 @@
        <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"/>
    </extensions>

    <actions>
@@ -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>
@@ -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 M68kGlobalLabelDocumentationProviderTest : 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"
+ rts
+ bsr square<caret>me
+        """
+        )
+        assertThat(generateDocumentation(myFixture))
+            .isEqualTo("<span class='grayed'>; inputs: d0 = number<br>; output: d0 = square</span><div class='definition'><pre>squareme</pre></div><div class='content'>include &quot;fancysquarecode.asm&quot;</div>")
+    }
+
+    @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'><pre>squareme</pre></div><div class='content'>include &quot;fancysquarecode.asm&quot;</div>")
+    }
+}
@@ -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(
@@ -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
+    }
 }
@@ -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)
+    }
+}
@@ -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'")
+    }
+}
@@ -87,6 +87,11 @@ internal class AddressingModesTest : AbstractParsingTest() {
        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 +123,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"
        )
    }

@@ -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ü
+"""
+        )
+    }
+}
@@ -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-")
+    }
 }
@@ -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$")
+    }
+}
@@ -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\"")
+    }
 }
@@ -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")
+    }
+}
@@ -0,0 +1,31 @@
+Assembly File: a.asm
+  PsiWhiteSpace(' ')
+  M68kStatementImpl(STATEMENT)
+    M68kAsmInstructionImpl(ASM_INSTRUCTION)
+      M68kAsmOpImpl(ASM_OP)
+        PsiElement(M68kTokenType.MNEMONIC)('btst')
+      PsiWhiteSpace(' ')
+      M68kImmediateDataImpl(IMMEDIATE_DATA)
+        PsiElement(M68kTokenType.HASH)('#')
+        M68kLiteralExprImpl(LITERAL_EXPR)
+          PsiElement(M68kTokenType.DECIMAL)('5')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kImmediateDataImpl(IMMEDIATE_DATA)
+        PsiElement(M68kTokenType.HASH)('#')
+        M68kLiteralExprImpl(LITERAL_EXPR)
+          PsiElement(M68kTokenType.DECIMAL)('42')
+  PsiElement(M68kTokenType.EOL)('\n')
+  PsiWhiteSpace(' ')
+  M68kStatementImpl(STATEMENT)
+    M68kAsmInstructionImpl(ASM_INSTRUCTION)
+      M68kAsmOpImpl(ASM_OP)
+        PsiElement(M68kTokenType.MNEMONIC)('btst')
+      PsiWhiteSpace(' ')
+      M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
+        M68kDataRegisterImpl(DATA_REGISTER)
+          PsiElement(M68kTokenType.DREG)('d0')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kImmediateDataImpl(IMMEDIATE_DATA)
+        PsiElement(M68kTokenType.HASH)('#')
+        M68kLiteralExprImpl(LITERAL_EXPR)
+          PsiElement(M68kTokenType.DECIMAL)('42')
@@ -29,5 +29,5 @@ Assembly File: a.asm
      PsiElement(M68kTokenType.SEPARATOR)(',')
      M68kSpecialRegisterDirectAddressingModeImpl(SPECIAL_REGISTER_DIRECT_ADDRESSING_MODE)
        M68kSpecialRegisterImpl(SPECIAL_REGISTER)
-          PsiElement(M68kTokenType.REG_USP)('usp')
+          PsiElement(M68kTokenType.REG_USP)('USP')
  PsiElement(M68kTokenType.EOL)('\n')
@@ -1,10 +1,11 @@
 Assembly File: a.asm
  M68kStatementImpl(STATEMENT)
-    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
    M68kGlobalLabelImpl(GLOBAL_LABEL)
      PsiElement(M68kTokenType.GLOBAL_LABEL_DEF)('foo')
      PsiElement(M68kTokenType.COLON)(':')
    PsiWhiteSpace(' ')
+    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.DATA_DIRECTIVE)('dc.b')
      PsiWhiteSpace(' ')
      M68kLiteralExprImpl(LITERAL_EXPR)
@@ -2,6 +2,7 @@ Assembly File: a.asm
  PsiWhiteSpace(' ')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.DATA_DIRECTIVE)('dc.w')
      PsiWhiteSpace(' ')
      M68kLiteralExprImpl(LITERAL_EXPR)
@@ -0,0 +1,26 @@
+Assembly File: a.asm
+  PsiWhiteSpace('\n')
+  PsiWhiteSpace(' ')
+  M68kStatementImpl(STATEMENT)
+    M68kAsmInstructionImpl(ASM_INSTRUCTION)
+      M68kAsmOpImpl(ASM_OP)
+        PsiElement(M68kTokenType.MNEMONIC)('moveq')
+        M68kOperandSizeImpl(OPERAND_SIZE)
+          PsiElement(M68kTokenType.OPSIZE_L)('.l')
+      PsiWhiteSpace(' ')
+      M68kImmediateDataImpl(IMMEDIATE_DATA)
+        PsiElement(M68kTokenType.HASH)('#')
+        M68kLiteralExprImpl(LITERAL_EXPR)
+          PsiElement(M68kTokenType.DECIMAL)('0')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
+        M68kDataRegisterImpl(DATA_REGISTER)
+          PsiElement(M68kTokenType.DREG)('d0')
+  PsiElement(M68kTokenType.EOL)('\n')
+  PsiWhiteSpace(' ')
+  M68kStatementImpl(STATEMENT)
+    M68kAsmInstructionImpl(ASM_INSTRUCTION)
+      M68kAsmOpImpl(ASM_OP)
+        PsiElement(M68kTokenType.MNEMONIC)('rts')
+  PsiElement(M68kTokenType.EOL)('\n')
+  PsiWhiteSpace(' END narf\n äöö#öä235r2352ou485742q3535p3ü\n')
@@ -2,6 +2,7 @@ Assembly File: a.asm
  PsiWhiteSpace('\t')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.DATA_DIRECTIVE)('even')
  PsiWhiteSpace(' ')
  PsiComment(M68kTokenType.COMMENT)('; align to even address')
@@ -2,6 +2,7 @@ Assembly File: a.asm
  PsiWhiteSpace('\t')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('IFD')
      PsiWhiteSpace(' ')
      M68kRefExprImpl(REF_EXPR)
@@ -19,5 +20,6 @@ Assembly File: a.asm
  PsiWhiteSpace(' ')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('ENDC')
  PsiElement(M68kTokenType.EOL)('\n')
@@ -2,6 +2,7 @@ Assembly File: a.asm
  PsiWhiteSpace(' ')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('include')
      PsiWhiteSpace(' ')
      M68kLiteralExprImpl(LITERAL_EXPR)
@@ -1,12 +1,12 @@
 Assembly File: a.asm
  M68kStatementImpl(STATEMENT)
-    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
    M68kGlobalLabelImpl(GLOBAL_LABEL)
      PsiElement(M68kTokenType.GLOBAL_LABEL_DEF)('howto')
      PsiElement(M68kTokenType.COLON)(':')
+    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('incbin')
      PsiWhiteSpace(' ')
-      M68kRefExprImpl(REF_EXPR)
-        M68kSymbolReferenceImpl(SYMBOL_REFERENCE)
-          PsiElement(M68kTokenType.SYMBOL)('Convertedassets\scroller_howto.raw.BPL')
+      M68kLiteralExprImpl(LITERAL_EXPR)
+        PsiElement(M68kTokenType.STRINGLIT)('Convertedassets\scroller_howto.raw.BPL')
  PsiElement(M68kTokenType.EOL)('\n')
@@ -0,0 +1,9 @@
+Assembly File: a.asm
+  PsiWhiteSpace(' ')
+  M68kStatementImpl(STATEMENT)
+    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
+        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('include')
+      PsiWhiteSpace('\t')
+      M68kLiteralExprImpl(LITERAL_EXPR)
+        PsiElement(M68kTokenType.STRINGLIT)('<Engine/A500/System/Copper.i>')
@@ -0,0 +1,12 @@
+Assembly File: a.asm
+  PsiWhiteSpace(' ')
+  M68kStatementImpl(STATEMENT)
+    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
+        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('opt')
+      PsiWhiteSpace(' ')
+      M68kLiteralExprImpl(LITERAL_EXPR)
+        PsiElement(M68kTokenType.STRINGLIT)('o+')
+      PsiElement(M68kTokenType.SEPARATOR)(',')
+      M68kLiteralExprImpl(LITERAL_EXPR)
+        PsiElement(M68kTokenType.STRINGLIT)('w-')
@@ -2,6 +2,7 @@ Assembly File: a.asm
  PsiWhiteSpace(' ')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.DATA_DIRECTIVE)('dc.w')
      PsiWhiteSpace(' ')
      M68kBinarySubExprImpl(BINARY_SUB_EXPR)
@@ -2,6 +2,7 @@ Assembly File: a.asm
  PsiWhiteSpace(' ')
  M68kStatementImpl(STATEMENT)
    M68kPreprocessorDirectiveImpl(PREPROCESSOR_DIRECTIVE)
+      M68kPreprocessorKeywordImpl(PREPROCESSOR_KEYWORD)
        PsiElement(M68kTokenType.OTHER_DIRECTIVE)('IF')
      PsiWhiteSpace(' ')
      M68kBinaryCmpEqExprImpl(BINARY_CMP_EQ_EXPR)
Author	SHA1	Message	Date
chrisly42	62f7f13323	Bumped to IntelliJ/CLion 2021.2.2	2021-09-25 21:29:17 +02:00
chrisly42	c4051a0377	'END' detection was breaking parsing, causing havoc.	2021-09-25 17:20:45 +02:00
chrisly42	a03de6c394	Added documentation provider info for global labels. Shows directives and comments above. Fixed BNF for labels with preprocessor statements. Bumped versions.	2021-09-25 15:19:05 +02:00
chrisly42	1bff1a12c2	Documentation for instruction with special register shows specific register expected.	2021-09-05 18:42:20 +02:00
chrisly42	665947827b	Updated build to latest versions.	2021-09-04 14:23:15 +02:00
chrisly42	3bb6165a58	Courtesy of Yann: Bugfix: Special registers for address mode matching only worked with lower case register names. Bugfix: movem with pc-relative mode was missing for weird immediate mode. Bugfix: btst with pc-relative and weird immediate mode was missing. Enhancement: Assembler syntax with implicit immediate 1 for shifts and rotations no longer cause syntax errors.	2021-09-04 14:08:10 +02:00
chrisly42	89bd964fe7	Minor updates to documentation.	2021-08-09 15:27:12 +02:00
chrisly42	0cb90ff8d7	'END' directive stops parsing. Prepared next release.	2021-08-09 12:14:02 +02:00
chrisly42	431caf64fd	Added inspection for unresolved symbols, macros and labels.	2021-08-09 11:26:13 +02:00
chrisly42	a3f7ddb4f7	New: Added inspection suppression possibility and quickfix.	2021-08-09 10:08:41 +02:00
chrisly42	593719043e	New: Code completion for local label definitions, suggesting undefined labels already referenced.	2021-08-08 13:40:01 +02:00
chrisly42	e0cdfef42b	New: Files in 'include' directives can be referenced and renamed/refactored.	2021-08-06 20:03:47 +02:00
chrisly42	8d7977927f	Added M68kIncludeFileProvider, but dunno what it's actually for.	2021-08-06 19:12:54 +02:00
chrisly42	ddf78ec210	Slightly reworked lexer to for a few directives: 'opt' and several other directives ('printt', 'fail' etc.) no longer causes a syntax error when unquoted. 'include', 'incdir' and 'incbin' and 'output' with '<pathname>' quotes no longer cause syntax error.	2021-08-06 10:06:48 +02:00