Started working on macro support. Macro-Definition are now plain, unparsed lines. Added Syntax-Highlighter options.

2021-07-27 12:42:26 +02:00
parent f006199201
commit 6e683eb6a0
22 changed files with 1117 additions and 462 deletions
@@ -657,6 +657,89 @@ public class M68kParser implements PsiParser, LightPsiParser {
        return true;
    }

+    /* ********************************************************** */
+    // ((MacroNameDefinition MACRO_TAG)|(MACRO_TAG MacroNameDefinition)) MacroPlainLine* MACRO_END_TAG
+    public static boolean MacroDefinition(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroDefinition")) return false;
+        if (!nextTokenIs(b, "<macro definition>", MACRO_NAME, MACRO_TAG)) return false;
+        boolean r, p;
+        Marker m = enter_section_(b, l, _NONE_, MACRO_DEFINITION, "<macro definition>");
+        r = MacroDefinition_0(b, l + 1);
+        p = r; // pin = 1
+        r = r && report_error_(b, MacroDefinition_1(b, l + 1));
+        r = p && consumeToken(b, MACRO_END_TAG) && r;
+        exit_section_(b, l, m, r, p, null);
+        return r || p;
+    }
+
+    // (MacroNameDefinition MACRO_TAG)|(MACRO_TAG MacroNameDefinition)
+    private static boolean MacroDefinition_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroDefinition_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = MacroDefinition_0_0(b, l + 1);
+        if (!r) r = MacroDefinition_0_1(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // MacroNameDefinition MACRO_TAG
+    private static boolean MacroDefinition_0_0(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroDefinition_0_0")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = MacroNameDefinition(b, l + 1);
+        r = r && consumeToken(b, MACRO_TAG);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // MACRO_TAG MacroNameDefinition
+    private static boolean MacroDefinition_0_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroDefinition_0_1")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, MACRO_TAG);
+        r = r && MacroNameDefinition(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
+    // MacroPlainLine*
+    private static boolean MacroDefinition_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroDefinition_1")) return false;
+        while (true) {
+            int c = current_position_(b);
+            if (!MacroPlainLine(b, l + 1)) break;
+            if (!empty_element_parsed_guard_(b, "MacroDefinition_1", c)) break;
+        }
+        return true;
+    }
+
+    /* ********************************************************** */
+    // MACRO_NAME
+    public static boolean MacroNameDefinition(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroNameDefinition")) return false;
+        if (!nextTokenIs(b, MACRO_NAME)) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, MACRO_NAME);
+        exit_section_(b, m, MACRO_NAME_DEFINITION, r);
+        return r;
+    }
+
+    /* ********************************************************** */
+    // MACRO_LINE
+    public static boolean MacroPlainLine(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "MacroPlainLine")) return false;
+        if (!nextTokenIs(b, MACRO_LINE)) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = consumeToken(b, MACRO_LINE);
+        exit_section_(b, m, MACRO_PLAIN_LINE, r);
+        return r;
+    }
+
    /* ********************************************************** */
    // OPSIZE_BS|OPSIZE_W|OPSIZE_L
    public static boolean OperandSize(PsiBuilder b, int l) {
@@ -1048,13 +1131,13 @@ public class M68kParser implements PsiParser, LightPsiParser {
    }

    /* ********************************************************** */
-    // !<<eof>> statement (<<eof>>|EOL)
+    // !<<eof>> (MacroDefinition | statement) (<<eof>>|EOL)
    static boolean line(PsiBuilder b, int l) {
        if (!recursion_guard_(b, l, "line")) return false;
        boolean r;
        Marker m = enter_section_(b);
        r = line_0(b, l + 1);
-        r = r && statement(b, l + 1);
+        r = r && line_1(b, l + 1);
        r = r && line_2(b, l + 1);
        exit_section_(b, m, null, r);
        return r;
@@ -1070,6 +1153,17 @@ public class M68kParser implements PsiParser, LightPsiParser {
        return r;
    }

+    // MacroDefinition | statement
+    private static boolean line_1(PsiBuilder b, int l) {
+        if (!recursion_guard_(b, l, "line_1")) return false;
+        boolean r;
+        Marker m = enter_section_(b);
+        r = MacroDefinition(b, l + 1);
+        if (!r) r = statement(b, l + 1);
+        exit_section_(b, m, null, r);
+        return r;
+    }
+
    // <<eof>>|EOL
    private static boolean line_2(PsiBuilder b, int l) {
        if (!recursion_guard_(b, l, "line_2")) return false;
@@ -0,0 +1,16 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public interface M68kMacroDefinition extends M68kPsiElement {
+
+    @NotNull
+    M68kMacroNameDefinition getMacroNameDefinition();
+
+    @NotNull
+    List<M68kMacroPlainLine> getMacroPlainLineList();
+
+}
@@ -0,0 +1,6 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+public interface M68kMacroNameDefinition extends M68kPsiElement {
+
+}
@@ -0,0 +1,6 @@
+// This is a generated file. Not intended for manual editing.
+package de.platon42.intellij.plugins.m68k.psi;
+
+public interface M68kMacroPlainLine extends M68kPsiElement {
+
+}
@@ -51,6 +51,9 @@ public interface M68kTypes {
    IElementType LITERAL_EXPR = new M68kElementType("LITERAL_EXPR");
    IElementType LOCAL_LABEL = new M68kElementType("LOCAL_LABEL");
    IElementType MACRO_CALL = new M68kElementType("MACRO_CALL");
+    IElementType MACRO_DEFINITION = new M68kElementType("MACRO_DEFINITION");
+    IElementType MACRO_NAME_DEFINITION = new M68kElementType("MACRO_NAME_DEFINITION");
+    IElementType MACRO_PLAIN_LINE = new M68kElementType("MACRO_PLAIN_LINE");
    IElementType OPERAND_SIZE = new M68kElementType("OPERAND_SIZE");
    IElementType PAREN_EXPR = new M68kElementType("PAREN_EXPR");
    IElementType PREPROCESSOR_DIRECTIVE = new M68kElementType("PREPROCESSOR_DIRECTIVE");
@@ -86,7 +89,11 @@ public interface M68kTypes {
    IElementType HASH = new M68kTokenType("HASH");
    IElementType HEXADECIMAL = new M68kTokenType("HEXADECIMAL");
    IElementType LOCAL_LABEL_DEF = new M68kTokenType("LOCAL_LABEL_DEF");
+    IElementType MACRO_END_TAG = new M68kTokenType("MACRO_END_TAG");
    IElementType MACRO_INVOKATION = new M68kTokenType("MACRO_INVOKATION");
+    IElementType MACRO_LINE = new M68kTokenType("MACRO_LINE");
+    IElementType MACRO_NAME = new M68kTokenType("MACRO_NAME");
+    IElementType MACRO_TAG = new M68kTokenType("MACRO_TAG");
    IElementType MNEMONIC = new M68kTokenType("MNEMONIC");
    IElementType OCTAL = new M68kTokenType("OCTAL");
    IElementType OPSIZE_BS = new M68kTokenType("OPSIZE_BS");
@@ -210,6 +217,12 @@ public interface M68kTypes {
                return new M68kLocalLabelImpl(node);
            } else if (type == MACRO_CALL) {
                return new M68kMacroCallImpl(node);
+            } else if (type == MACRO_DEFINITION) {
+                return new M68kMacroDefinitionImpl(node);
+            } else if (type == MACRO_NAME_DEFINITION) {
+                return new M68kMacroNameDefinitionImpl(node);
+            } else if (type == MACRO_PLAIN_LINE) {
+                return new M68kMacroPlainLineImpl(node);
            } else if (type == OPERAND_SIZE) {
                return new M68kOperandSizeImpl(node);
            } else if (type == PAREN_EXPR) {
@@ -94,6 +94,18 @@ public class M68kVisitor extends PsiElementVisitor {
        visitPsiElement(o);
    }

+    public void visitMacroDefinition(@NotNull M68kMacroDefinition o) {
+        visitPsiElement(o);
+    }
+
+    public void visitMacroNameDefinition(@NotNull M68kMacroNameDefinition o) {
+        visitPsiElement(o);
+    }
+
+    public void visitMacroPlainLine(@NotNull M68kMacroPlainLine o) {
+        visitPsiElement(o);
+    }
+
    public void visitOperandSize(@NotNull M68kOperandSize o) {
        visitPsiElement(o);
    }
@@ -0,0 +1,44 @@
+// 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.M68kMacroDefinition;
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroNameDefinition;
+import de.platon42.intellij.plugins.m68k.psi.M68kMacroPlainLine;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class M68kMacroDefinitionImpl extends ASTWrapperPsiElement implements M68kMacroDefinition {
+
+    public M68kMacroDefinitionImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitMacroDefinition(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+    @Override
+    @NotNull
+    public M68kMacroNameDefinition getMacroNameDefinition() {
+        return notNullChild(PsiTreeUtil.getChildOfType(this, M68kMacroNameDefinition.class));
+    }
+
+    @Override
+    @NotNull
+    public List<M68kMacroPlainLine> getMacroPlainLineList() {
+        return PsiTreeUtil.getChildrenOfTypeAsList(this, M68kMacroPlainLine.class);
+    }
+
+}
@@ -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.M68kMacroNameDefinition;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+
+public class M68kMacroNameDefinitionImpl extends ASTWrapperPsiElement implements M68kMacroNameDefinition {
+
+    public M68kMacroNameDefinitionImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitMacroNameDefinition(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+}
@@ -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.M68kMacroPlainLine;
+import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
+import org.jetbrains.annotations.NotNull;
+
+public class M68kMacroPlainLineImpl extends ASTWrapperPsiElement implements M68kMacroPlainLine {
+
+    public M68kMacroPlainLineImpl(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public void accept(@NotNull M68kVisitor visitor) {
+        visitor.visitMacroPlainLine(this);
+    }
+
+    @Override
+    public void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
+        else super.accept(visitor);
+    }
+
+}
@@ -8,6 +8,7 @@ import de.platon42.intellij.plugins.m68k.asm.M68kIsa.mnemonics
 object LexerUtil {

    private val ASSIGNMENT_SEPARATORS = charArrayOf(' ', '\t', '=', ':')
+    private val TOKEN_SEPARATORS = charArrayOf(' ', '\t')

    @JvmStatic
    fun isAsmMnemonic(text: CharSequence) = mnemonics.contains(text.toString().lowercase())
@@ -28,6 +29,11 @@ object LexerUtil {
        return text.length - text.indexOfAny(ASSIGNMENT_SEPARATORS)
    }

+    @JvmStatic
+    fun pushbackAfterFirstToken(text: CharSequence): Int {
+        return text.length - text.indexOfAny(TOKEN_SEPARATORS)
+    }
+
    @JvmStatic
    fun pushbackLabelColons(text: CharSequence): Int {
        return text.count { it == ':' }
@@ -38,7 +44,17 @@ object LexerUtil {
        if (!lexer.eatOneWhitespace && lexer.lexerPrefs.spaceIntroducesComment) {
            lexer.yybegin(_M68kLexer.WAITEOL)
        }
-        lexer.eatOneWhitespace = false;
+        lexer.eatOneWhitespace = false
+        return TokenType.WHITE_SPACE
+    }
+
+    @JvmStatic
+    fun handleMacroLineEol(lexer: _M68kLexer): IElementType {
+        if (++lexer.macroLines > lexer.lexerPrefs.maxLinesPerMacro) {
+            lexer.yybegin(_M68kLexer.YYINITIAL)
+            return TokenType.BAD_CHARACTER
+        }
+        lexer.yybegin(_M68kLexer.MACROLINE)
        return TokenType.WHITE_SPACE
    }
 }
@@ -13,6 +13,7 @@ import static de.platon42.intellij.plugins.m68k.lexer.LexerUtil.*;
 %{
  private M68kLexerPrefs lexerPrefs;
  boolean eatOneWhitespace = false;
+  int macroLines = 0;

  public M68kLexerPrefs getLexerPrefs()
  {
@@ -38,10 +39,12 @@ WHITE_SPACE=\p{Blank}+
 AREG=(a[0-6])
 DREG=(d[0-7])
 ASSIGNMENT=(([:letter:]|_)(([:letter:]|[:digit:])|_)*:?((\p{Blank}+equ\p{Blank}+)|(\p{Blank}+set\p{Blank}+)|\p{Blank}*=\p{Blank}*))
-LOCAL_LABEL=(\.([:letter:]|_)(([:letter:]|[:digit:])|_)*:?)|(([:letter:]|_)(([:letter:]|[:digit:])|_)*\$:?)
-LOCAL_LABEL_WC=(\.([:letter:]|_)(([:letter:]|[:digit:])|_)*:)|(([:letter:]|_)(([:letter:]|[:digit:])|_)*\$:)
-GLOBAL_LABEL=(([:letter:]|_)(([:letter:]|[:digit:])|_)*:?:?)
-GLOBAL_LABEL_WC=(([:letter:]|_)(([:letter:]|[:digit:])|_)*::?)
+LOCAL_LABEL=(\.([:letter:]|_)([:letter:]|[:digit:]|_)*:?)|(([:letter:]|_)([:letter:]|[:digit:]|_)*\$:?)
+LOCAL_LABEL_WC=(\.([:letter:]|_)([:letter:]|[:digit:]|_)*:)|(([:letter:]|_)([:letter:]|[:digit:]|_)*\$:)
+GLOBAL_LABEL=(([:letter:]|_)([:letter:]|[:digit:]|_)*:?:?)
+GLOBAL_LABEL_WC=(([:letter:]|_)([:letter:]|[:digit:]|_)*::?)
+MACRO_DEF_LEFT=(([:letter:]|_)(([:letter:]|[:digit:]|_))*)\p{Blank}+macro\p{Blank}*
+MACRO_END_TAG=\p{Blank}+endm\p{Blank}*[^;\r\n]*
 //MNEMONIC=(([:letter:])+)
 SYMBOL=(([:letter:]|_|\.)(([:letter:]|[:digit:]|[_\$]))*)
 BONUSSYMBOL=(([:letter:]|_|\.)(([:letter:]|[:digit:]|[_\$\.\\]))*)
@@ -59,14 +62,16 @@ PLAINPARAM=(`([^`\\\r\n]|\\.)*`|'([^'\\\r\n]|\\.)*'|\"([^\"\\\r\n]|\\.)*\")|<([^
 COMMENT=([;].*+)
 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
+%state NOSOL,INSTRPART,ASMINSTR,ASMOPS,ASMOPS_OP,ASSIGNMENT,EXPR,EXPR_OP,MACROCALL,WAITEOL,MACRODEF,MACROLINE,MACROTERMINATION,MACROWAITEOL

 %%
 <YYINITIAL> {
  {WHITE_SPACE}       { yybegin(NOSOL); eatOneWhitespace = false; return WHITE_SPACE; }
  {EOL}               { return WHITE_SPACE; }
  {ASSIGNMENT}        { yybegin(ASSIGNMENT); eatOneWhitespace = true; yypushback(pushbackAssignment(yytext())); return SYMBOLDEF; }
+  {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; }

@@ -78,6 +83,7 @@ SKIP_TO_EOL=[^\r\n]+
  {EOL}               { yybegin(YYINITIAL); return WHITE_SPACE; }
  {LOCAL_LABEL_WC}    { yybegin(INSTRPART); yypushback(pushbackLabelColons(yytext())); return LOCAL_LABEL_DEF; }
  {GLOBAL_LABEL_WC}   { yybegin(INSTRPART); yypushback(pushbackLabelColons(yytext())); return GLOBAL_LABEL_DEF; }
+  "macro"             { yybegin(MACRODEF); return MACRO_TAG; }
  {DIRECTIVE_KEYWORD} {
                        if(isAsmMnemonicWithSize(yytext())) { yybegin(ASMINSTR); yypushback(2); return MNEMONIC; }
                        if(isAsmMnemonic(yytext())) { yybegin(ASMINSTR); return MNEMONIC; }
@@ -288,4 +294,35 @@ SKIP_TO_EOL=[^\r\n]+
  {SKIP_TO_EOL}       { return COMMENT; }
 }

+// The macro mess starts here
+
+<MACRODEF> {
+  {WHITE_SPACE}       { return WHITE_SPACE; }
+  {EOL}               { yybegin(MACROLINE); macroLines = 0; return WHITE_SPACE; }
+  "macro"             { return MACRO_TAG; }
+  {MACRONAME}         { return MACRO_NAME; }
+
+  {COMMENT}           { yybegin(MACROWAITEOL); return COMMENT; }
+}
+
+<MACROLINE> {
+  {EOL}               { return handleMacroLineEol(this); }
+  {MACRO_END_TAG}     { yybegin(MACROTERMINATION); return MACRO_END_TAG; }
+
+  {PLAIN_MACRO_LINE}  { return MACRO_LINE; }
+  {COMMENT}           { yybegin(MACROWAITEOL); return COMMENT; }
+}
+
+<MACROTERMINATION> {
+  {WHITE_SPACE}       { return WHITE_SPACE; }
+  {EOL}               { yybegin(YYINITIAL); return EOL; }
+  {COMMENT}           { yybegin(WAITEOL); return COMMENT; }
+}
+
+<MACROWAITEOL>
+{
+  {EOL}               { return handleMacroLineEol(this); }
+  {SKIP_TO_EOL}       { return COMMENT; }
+}
+
 [^] { return BAD_CHARACTER; }
@@ -118,7 +118,7 @@

 M68kFile ::= line*

-private line ::= !<<eof>> statement (<<eof>>|EOL)
+private line ::= !<<eof>> (MacroDefinition | statement) (<<eof>>|EOL)

 statement ::= (Assignment
            | PreprocessorDirective
@@ -170,6 +170,11 @@ AsmOp ::= MNEMONIC OperandSize?
 PreprocessorDirective ::= Label? (DATA_DIRECTIVE | OTHER_DIRECTIVE)
        PreprocessorOperands?

+MacroPlainLine ::= MACRO_LINE
+MacroNameDefinition ::= MACRO_NAME
+
+MacroDefinition ::= ((MacroNameDefinition MACRO_TAG)|(MACRO_TAG MacroNameDefinition)) MacroPlainLine* MACRO_END_TAG {pin=1}
+
 MacroCall ::= MACRO_INVOKATION PlainOperands?
 AsmInstruction ::= AsmOp AsmOperands?
 private Instruction ::= AsmInstruction | MacroCall
@@ -18,6 +18,9 @@ import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.GLOBAL_LABEL
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.LOCAL_LABEL
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.MACRO_CALL
+import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.MACRO_LINE
+import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.MACRO_NAME_DEF
+import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.MACRO_PREPROCESSOR
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.MNEMONIC
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.NUMBER
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.OTHER_PREPROCESSOR
@@ -26,8 +29,8 @@ import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.SPECIAL_REG
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.STACK_POINTER
 import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.STRING
-import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.SYMBOLDEF
-import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.SYMBOLREF
+import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.SYMBOL_DEF
+import de.platon42.intellij.plugins.m68k.syntax.M68kSyntaxHighlighter.Companion.SYMBOL_REF
 import org.jetbrains.annotations.NonNls
 import javax.swing.Icon

@@ -49,7 +52,7 @@ PIC_HEIGHT = 256
        include "../includes/hardware/custom.i"

 BLTHOGON MACRO                  ; macro definition
-        move.w	#DMAF_SETCLR|DMAF_BLITHOG,dmacon(a5)
+        move.w	#DMAF_SETCLR|DMAF_BLITHOG,dmacon(a5) ; hog!
        ENDM

 demo_init                       ; global label
@@ -99,9 +102,12 @@ hello:  dc.b   'Hello World!',10,0
            AttributesDescriptor("Local labels", LOCAL_LABEL),
            AttributesDescriptor("Comma (separator)", SEPARATOR),
            AttributesDescriptor("Colon", COLON),
-            AttributesDescriptor("Symbol definition", SYMBOLDEF),
-            AttributesDescriptor("Symbol reference", SYMBOLREF),
+            AttributesDescriptor("Symbol definition", SYMBOL_DEF),
+            AttributesDescriptor("Symbol reference", SYMBOL_REF),
            AttributesDescriptor("Assembly mnemonic", MNEMONIC),
+            AttributesDescriptor("Macro name definition", MACRO_NAME_DEF),
+            AttributesDescriptor("Macro preprocessor directives", MACRO_PREPROCESSOR),
+            AttributesDescriptor("Macro line", MACRO_LINE),
            AttributesDescriptor("Macro invocation", MACRO_CALL),
            AttributesDescriptor("Data width: Byte/short", DATA_WIDTH_BS),
            AttributesDescriptor("Data width: Word", DATA_WIDTH_W),
@@ -28,11 +28,14 @@ class M68kSyntaxHighlighter(val project: Project?) : SyntaxHighlighterBase() {
            M68kTypes.COLON -> arrayOf(COLON)
            M68kTypes.GLOBAL_LABEL_DEF -> arrayOf(GLOBAL_LABEL)
            M68kTypes.LOCAL_LABEL_DEF -> arrayOf(LOCAL_LABEL)
-            M68kTypes.SYMBOLDEF -> arrayOf(SYMBOLDEF)
-            M68kTypes.SYMBOL -> arrayOf(SYMBOLREF)
+            M68kTypes.SYMBOLDEF -> arrayOf(SYMBOL_DEF)
+            M68kTypes.SYMBOL -> arrayOf(SYMBOL_REF)
            M68kTypes.CURRENT_PC_SYMBOL, M68kTypes.PC -> arrayOf(PROGRAM_COUNTER)
            M68kTypes.MNEMONIC -> arrayOf(MNEMONIC)
+            M68kTypes.MACRO_TAG, M68kTypes.MACRO_END_TAG -> arrayOf(MACRO_PREPROCESSOR)
+            M68kTypes.MACRO_LINE -> arrayOf(MACRO_LINE)
            M68kTypes.MACRO_INVOKATION -> arrayOf(MACRO_CALL)
+            M68kTypes.MACRO_NAME -> arrayOf(MACRO_NAME_DEF)
            M68kTypes.DATA_DIRECTIVE -> arrayOf(DATA_PREPROCESSOR)
            M68kTypes.OTHER_DIRECTIVE, M68kTypes.EQU -> arrayOf(OTHER_PREPROCESSOR)
            M68kTypes.OPSIZE_BS -> arrayOf(DATA_WIDTH_BS)
@@ -55,9 +58,12 @@ class M68kSyntaxHighlighter(val project: Project?) : SyntaxHighlighterBase() {
        val LOCAL_LABEL = TextAttributesKey.createTextAttributesKey("MC68000_GLOBAL_LABEL", DefaultLanguageHighlighterColors.FUNCTION_DECLARATION)
        val SEPARATOR = TextAttributesKey.createTextAttributesKey("MC68000_SEPARATOR", DefaultLanguageHighlighterColors.COMMA)
        val COLON = TextAttributesKey.createTextAttributesKey("MC68000_COLON", DefaultLanguageHighlighterColors.DOT)
-        val SYMBOLDEF = TextAttributesKey.createTextAttributesKey("MC68000_SYMBOLDEF", DefaultLanguageHighlighterColors.CONSTANT)
-        val SYMBOLREF = TextAttributesKey.createTextAttributesKey("MC68000_SYMBOLREF", DefaultLanguageHighlighterColors.IDENTIFIER)
+        val SYMBOL_DEF = TextAttributesKey.createTextAttributesKey("MC68000_SYMBOLDEF", DefaultLanguageHighlighterColors.CONSTANT)
+        val SYMBOL_REF = TextAttributesKey.createTextAttributesKey("MC68000_SYMBOLREF", DefaultLanguageHighlighterColors.IDENTIFIER)
        val MNEMONIC = TextAttributesKey.createTextAttributesKey("MC68000_MNEMONIC", DefaultLanguageHighlighterColors.FUNCTION_CALL)
+        val MACRO_PREPROCESSOR = TextAttributesKey.createTextAttributesKey("MC68000_MACRO_PREPROCESSOR", DefaultLanguageHighlighterColors.INSTANCE_METHOD)
+        val MACRO_NAME_DEF = TextAttributesKey.createTextAttributesKey("MC68000_MACRO_NAME_DEF", DefaultLanguageHighlighterColors.METADATA)
+        val MACRO_LINE = TextAttributesKey.createTextAttributesKey("MC68000_MACRO_LINE", DefaultLanguageHighlighterColors.METADATA)
        val MACRO_CALL = TextAttributesKey.createTextAttributesKey("MC68000_MACRO_CALL", DefaultLanguageHighlighterColors.STATIC_METHOD)
        val DATA_WIDTH_BS = TextAttributesKey.createTextAttributesKey("MC68000_DATA_WIDTH_BS", DefaultLanguageHighlighterColors.DOT)
        val DATA_WIDTH_L = TextAttributesKey.createTextAttributesKey("MC68000_DATA_WIDTH_W", DefaultLanguageHighlighterColors.DOT)