Assembly-6809.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
# http://www.sublimetext.com/docs/3/scope_naming.html

name: Assembly 6809/6309

file_extensions:
  - asm
  - src
  - s

scope: source.mc6809

variables:
  num_bin: (?:[01][01]*)
  num_oct: (?:[0-7][0-7]*)
  num_dec: (?:\d\d*)
  num_hex: (?:\h\h*)
  symbol_id: (?:[A-Za-z\.\@\_!\?][A-Za-z0-9\.\@\$\_\?]*)|([0-9](?!\S))
  filename_id: (?:\S+(?!\S))
  all_registers: (?i)cc|dp|pc|[0abdefsuvwxy]
  pragma_options:  '(?ix:
                      (no)?(
                        dollar(not)?local|
                        index0tonone|
                        undefextern|
                        cescapes|
                        (importundef)?export|
                        pcaspcr|
                        shadow|
                        list|
                        autobranchlength|
                        symbol(no)?case|
                        condundefzero|
                        6800compat|
                        forwardrefmax|
                        testmode|
                        c[cdt]?|
                        qrts|
                        m80ext|
                        6[83]09(conv)?|
                        newsource|
                        oldsource|
                        operandsizewarning|
                        emuext|
                        output|
                        expandcond
                      )
                    )'
  edtasm_id: ^(\d{5})\s
  lwasm_list_id: ^[\s\h\?s]{22}\([\s\w\-\.\/]*\):\d{5}[\s\d\(\)\+\?\[\]]{9}([\s\d]{8})?
  lwasm_list_data_id: ^\s{5}\h{2,16}$
  lwasm_list_symbol_header_id: ^Symbol Table:$
  lwasm_list_symbol_id: ^\[[S\s][GL]\][\s\w\W]{34}\h{4,8}$
  lwasm_list_warnings: '^Warning: Operand size larger than required$'

contexts:
  pop-on-eol:
    - match: $
      pop: true

  skip-white-spaces:
    - match: \s*

  match-comments:
    - match: (\s*)(([*;]).*)$
      captures:
        2: comment.line.mc6809
        3: punctuation.definition.comment.mc6809
      pop: true

  comments-eol:
    - match: (\s*)(([*;]?).*)$
      captures:
        2: comment.line.mc6809
        3: punctuation.definition.comment.mc6809
      pop: true


  main:
    # Edtasm listing
    - match: '{{edtasm_id}}'
      captures:
        1: comment.line.edtasm.mc6809
      push: column_1

    # LWASM assembly listing
    - match: '{{lwasm_list_id}}'
      scope: comment.line.lwasm.mc6809
      push: column_1
    - match: '{{lwasm_list_data_id}}'
      scope: comment.line.lwasm.mc6809
    - match: '{{lwasm_list_symbol_header_id}}'
      scope: comment.line.lwasm.mc6809
    - match: '{{lwasm_list_symbol_id}}'
      scope: comment.line.lwasm.mc6809
    - match: '{{lwasm_list_warnings}}'
      scope: invalid.comment.line.lwasm.mc6809

    # Process normal listing
    - match: ''
      push: column_1


  column_1:
    - match: ''
      pop: true

    # Line begins with a comment
    - match: ([*;#]).*$
      scope: comment.line.mc6809
      captures:
        1: punctuation.definition.comment.mc6809
      pop: true

    # Label
    - match: '({{symbol_id}})(:?)(\s*)'
      captures:
        1: entity.name.type.constant.mc6809
      set:
        - include: match-structures
        - include: match-macros
        - include: column_2

    # Blank column one
    - match: \s+
      set: column_2

    - match: .*$
      scope: invalid.illegal
      pop: true


  column_2:
    - include: match-mnemonics
    - include: match-directives
    - include: match-pragmas
    - include: match-comments
    - include: match-emulator-extensions
    - include: match-os9
    - include: match-macro-label

    # No match in column #2 - skip to next line
    - match: .*$
      pop: true

  match-mnemonics:
    - include: match-mnemonics-6809
    - include: match-mnemonics-6309
    - include: match-mnemonics-convenience
    - include: match-mnemonics-invalid
    - include: match-mnemonics-6800

  match-mnemonics-6809:
    # Addressing mode: Inherent
    - match: |-
        (?ix:
             abx|daa|mul|nop|rti|\??rts|
             s(wi[23]?|exw?|ync)|
             ((as|ls|ro)[lr]|neg)[abd]|
             (clr|com|dec|inc|tst)[abdefw]|
             (p(sh|ul)[su]|ro[lr]|lsr)w
        )(?!\S)
      scope: keyword.operator.mc6809
      set: comments-eol

    # Branch instructions
    - match: (?i)(l?b([cv][cs]|eq|gt|h[is]|l[ost]|r[an]|mi|pl|sr|[gnl]e))(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: \<
          scope: constant.other.mc6809
          set: comments-eol
        - match: \>
          scope: constant.other.mc6809
          set: comments-eol
        - include: match-expr
        - match: ''
          set: comments-eol
        - include: pop-on-eol

    # Jump instructions
    - match: (?i)(jmp|jsr)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - include: match-address-direct
        - include: match-address-index
        - include: match-address-extended
        - include: match-expr
        - match: \S*
          scope: invalid.illegal.variable.language.register.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Addressing modes: Immediate #i8
    - match: (?i)((and|or)cc|(bit|ld)md|cwai)(?!\S)\s*
      scope: keyword.operator.mc6809
      set:
        - include: match-address-immediate
        - include: pop-on-eol

    # Addressing modes: Immediate r0,r1
    - match: (?i)((ad[cd]|and|eor|cmp|or|s(bc|ub)|tf)r|exg)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: (?i)(?:(?={{all_registers}},{{all_registers}}))
          set: highlight-registers
        - match: \S*
          scope: invalid.illegal.variable.language.register.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Addressing modes: Immediate, Direct, Indexed and Extended
    - match: |-
        (?ix:
            (
              (adc|and|bit|e?or|sbc)[abd]|
              (add|sub)[abdefw]|
              (cmp|ld)[abdefsuwxy]|
              div[dq]|
              e?ord|
              ldq|
              muld
            )
        )(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - include: match-address-immediate
        - include: match-address-direct
        - include: match-address-index
        - include: match-address-extended
        - include: match-expr
        - match: ''
          set: comments-eol
        - match: \S*
          scope: invalid.illegal.variable.language.register.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Addressing modes: Direct, Indexed and Extended
    - match: |-
        (?ix:
            (
              (as|ls|ro)[lr]|
              clr|com|dec|inc|neg|tst|
              st[abdefqsuwxy]
            )
        )(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - include: match-address-direct
        - include: match-address-index
        - include: match-address-extended
        - include: match-expr
        - match: ''
          set: comments-eol
        - match: \S*
          scope: invalid.illegal.variable.language.register.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Addressing modes: Indexed
    - match: (?i)(lea[suxy])(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - include: match-address-direct
        - include: match-address-index
        - include: match-address-extended
        - include: match-expr
        - match: ''
          set: comments-eol
        - match: \S*
          scope: invalid.illegal.variable.language.register.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Instructions: PSHS and PULS
    - match: (?i)(p(sh|ul)s)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: \#
          scope: keyword.operator.immediate.mc6809
          set:
            - include: match-expr
            - match: \s
              set: comments-eol
            - include: pop-on-eol
        - match: (?=[\S\w]*s[\S\w]*\s)
          set: highlight-invalid-registers
        - match: ''
          set: validate-stack-registers

    # Instructions: PSHU and PULU
    - match: (?i)(p(sh|ul)u)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: \#
          scope: keyword.operator.immediate.mc6809
          set:
            - include: match-expr
            - match: \s
              set: comments-eol
            - include: pop-on-eol
        - match: (?=[\S\w]*u[\S\w]*\s)
          set: highlight-invalid-registers
        - match: ''
          set: validate-stack-registers


  match-mnemonics-6309:
    # Instruction: TFM
    - match: (?i)(tfm)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: |-
            (?ix:
                (?:
                  (?=[xyusd]\+,[xyusd]\+)|
                  (?=[xyusd]\-,[xyusd]\-)|
                  (?=[xyusd]\+,[xyusd]\b)|
                  (?=[xyusd],[xyusd]\+)
                )
            )
          set: highlight-registers
        - match: '\S*'
          scope: invalid.illegal.variable.language.register.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Addressing mode: Direct r,sBit,dBit,addr
    - match: (?i)(b(i?and|(i?e|i)?or)|(ld|st)bt)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: (?i)(cc|a|b)
          scope: variable.language.register.mc6809
          set:
            - include: match-comma
            - include: match-expr
            - match: ''
              set: comments-eol
            - include: pop-on-eol
        - include: match-address-immediate
        - match: ''
          set: comments-eol

    # Addressing modes: INSTRUCTION #i8;EA
    - match: (?i)([aeot]im)(?!\S)\s*
      captures:
        1: keyword.operator.mc6809
      set:
        - match: \#
          scope: keyword.operator.immediate.mc6809
          set:
            - include: match-expr
            - include: pop-on-eol
            - match: \;
              scope: operator.separator.mc6809
              set:
                - include: match-expr
                - match: \,
                  scope: operator.separator.mc6809
                  set:
                    - match: '(?=u)' #todo
                      set: highlight-registers
                    - include: pop-on-eol
                - include: pop-on-eol
                - match: \s+
                  set: comments-eol
            - match: \s+
              set: comments-eol
        - include: pop-on-eol


  match-mnemonics-convenience:
    - match: (?i)(asr|clr|com|ls[lr]|neg|tst)q|(lsl|neg)[ef]|negw(?!\S)
      scope: keyword.operator.mc6809
      set: comments-eol


  match-mnemonics-6800:
    - match: |-
        (?ix:
           \b(
             [acs]ba|
             (cl|se)([cfiv]|if)|
             cpx|
             (de|in)[sxy]|
             ta[bp]|
             t([bp]a|(sx|xs))|
             wai
           )
        )(?!\S)
      scope: keyword.operator.mc6809
      set: comments-eol


  match-mnemonics-invalid:
    - match: (?i)lslw(?!\S)
      scope: invalid.keyword.operator.mc6809
      set: comments-eol


  match-address-immediate:
    - match: \#
      scope: keyword.operator.immediate.mc6809
      set:
        - include: match-expr
        - include: pop-on-eol
        - match: ''
          set: comments-eol

  match-address-direct:
    # 5-bit offset
    - match: \<\<
      scope: keyword.operator.direct.mc6809
      set:
        - include: match-expr
        - match: (?i)(?=,[suxyw])
          set: highlight-registers
        - include: pop-on-eol
        - match: \S*
          set: comments-eol

    # 8-bit offset
    - match: \<
      scope: keyword.operator.direct.mc6809
      set:
        - include: match-expr
        - match: (?i)(?=,([suxyw]|pcr))
          set: highlight-registers
        - include: pop-on-eol
        - match: \S*
          set: comments-eol


  match-address-extended:
    # 16-bit offset
    - match: \>
      scope: keyword.operator.extended.mc6809
      set:
        - include: match-expr
        - match: (?i)(?=,([suxyw]|pcr))
          set: highlight-registers
        - include: pop-on-eol
        - match: \S*
          set: comments-eol


  match-address-index:
    # Non-indirect
    - match: |-
        (?ix:
            (?=[abdefw],[suxy])|
            (?=,[suxyw])|
            (?=,[suxy]\+)|
            (?=,[suxyw]\+\+)|
            (?=,\-[suxy])|
            (?=,\-\-[suxyw])|
            (?=,pcr)
        )
      set: highlight-registers
    # Indirect
    - match: |-
        (?ix:
            (?=\[,[suxyw]\])|
            (?=\[[abdefw],[suxy]\])|
            (?=\[,[suxyw]\+\+\])|
            (?=\[,\-\-[suxyw]\])
        )
      set: highlight-registers-brackets
    # Extended Indirect
    - match: \[
      scope: meta.brackets.mc6809 punctuation.section.brackets.begin.mc6809
      set:
        - match: (?i)(,)([suxyw]|pcr)
          captures:
            1: operator.separator.mc6809
            2: variable.language.register.mc6809
        - match: \]
          scope: meta.brackets.mc6809 punctuation.section.brackets.end.mc6809
          set: comments-eol
        - include: match-expr
        - include: match-labels
        - include: pop-on-eol


  validate-stack-registers:
    - match: ''
      set: highlight-registers
    - include: pop-on-eol


  highlight-registers:
    - match: '(?i)pcr'
      scope: variable.language.register.mc6809
    - match: '{{all_registers}}'
      scope: variable.language.register.mc6809
    - include: match-comma
    - match: '[\+\-]'
      scope: keyword.operator.arithmetic.mc6809
    - match: \s
      set: comments-eol
    - include: pop-on-eol


  highlight-registers-brackets:
    - meta_scope: meta.brackets.mc6809
    - match: '{{all_registers}}'
      scope: variable.language.register.mc6809
    - include: match-comma
    - match: '[\+\-]'
      scope: keyword.operator.arithmetic.mc6809
    - match: \[
      scope: punctuation.section.brackets.begin.mc6809
    - match: \]
      scope: punctuation.section.brackets.end.mc6809
    - match: \s
      set: comments-eol
    - include: pop-on-eol


  highlight-invalid-registers:
    - match: '[\S\w]'
      scope: invalid.variable.language.register.mc6809
    - match: \s
      set: comments-eol
    - include: pop-on-eol


  match-pragmas:
    - match: (?i)(pragma|opt|\*pragma(push|pop)?)(?!\S)\s*
      captures:
        1: support.function.directive.assembler.mc6809
      set:
        - match: '{{pragma_options}}(?=[,\s])'
          scope: keyword.operator.mc6809
        - include: match-comma
        - match: ''
          set: comments-eol
        - include: pop-on-eol


  match-directives:
    # data directives with expr
    - match: (?i)(f[cdq]b|[zr]m[bdq]|d[bw]|\.(d[bsw]|4?byte|word|quad|blkb|rs))(?!\S)\s*
      captures:
        1: storage.type.mc6809
      set:
        - include: match-expr
        - include: match-comma
        - include: pop-on-eol
        - match: ''
          set: comments-eol

    # data directives with strings
    - match: (?i)(fc[cnsz]|\.(asci[isz]|str[sz]?))(?!\S)\s*
      captures:
        1: storage.type.mc6809
      set: match-strings

    # data directives with reserve zeroed bytes
    - match: (?i)(fill|rzb|zmb|bsz|ds)(?!\S)\s*
      captures:
        1: storage.type.mc6809
      set:
        - include: match-expr
        - include: match-comma
        - include: pop-on-eol
        - match: ''
          set: comments-eol

    # Address Definition
    - match: (?i)((re)?org|equ|set(dp)?|align)(?!\S)\s*
      captures:
        1: support.function.address.mc6809
      set:
        - include: match-expr
        - match: ''
          set: comments-eol
        - include: pop-on-eol

    # Conditional assembly with expr
    - match: (?i)(if(eq|ne|ge|gt|lt|le|def|ndef)?)(?!\S)\s*
      captures:
        1: support.function.conditional.mc6809
      set:
        - include: match-expr
        - match: ''
          set: comments-eol
        - include: pop-on-eol

    # Conditional assembly with pragma
    - match: (?i)(if(pragma|opt))(?!\S)\s*
      captures:
        1: support.function.conditional.mc6809
      set:
        - match: '{{pragma_options}}'
          scope: keyword.operator.mc6809
          set: comments-eol
        - include: pop-on-eol

    # Conditional assembly
    - match: (?i)else|endc(?!\S)
      scope: support.function.conditional.mc6809
      set: comments-eol

    # Conditional assembly (ccasm)
    - match: (?i)(end(if|p)|ifp[12]|cond)(?!\S)
      scope: support.function.conditional.mc6809
      set: comments-eol

    # Filenames
    - match: (?i)(include(bin)?|use)(?!\S)\s*
      captures:
        1: support.function.directive.misc.mc6809
      set:
        - match: '{{filename_id}}'
          scope: constant.other.mc6809
        - include: match-filename
        - match: ''
          set: comments-eol
        - include: pop-on-eol

    # Miscelaneous Directives
    - match: (?i)(end)(?!\S)\s*
      captures:
        1: support.function.directive.misc.mc6809
      set:
        - include: match-expr
        - match: ''
          set: comments-eol
        - include: pop-on-eol

    # Misc directives with string
    - match: (?i)(error|warning)(?!\S)\s*
      captures:
        1: support.function.directive.misc.mc6809
      set: match-strings
    - match: (?i)(.module)(?!\S)\s*
      captures:
        1: support.function.directive.misc.mc6809
      set: match-strings
    - match: (?i)(nam|ttl)(?!\S)\s*
      captures:
        1: support.function.directive.misc.mc6809
      set: match-strings

    # Preprocessor addon directives
    - match: (?i)(repeat)(?!\S)\s*
      captures:
        1: support.function.directive.addon.mc6809
      set:
        - include: match-expr
        - include: comments-eol
    - match: (?i)(endrepeat)(?!\S)
      captures:
        1: support.function.directive.addon.mc6809
      set: comments-eol

    # end statement for macros and structures
    - include: match-end-macros
    - include: match-end-structures


  match-os9:
    - match: (?i)(os9|emod)(?!\S)\s*
      captures:
        1: support.function.directive.mc6809
      set:
        - match: '{{symbol_id}}'
          scope: constant.other.mc6809
        - include: match-expr
        - match: ''
          set: comments-eol
        - include: pop-on-eol
    - match: (?i)(mod)(?!\S)\s*
      captures:
        1: support.function.directive.mc6809
      set:
        - include: match-expr
        - include: match-comma
        - include: pop-on-eol


  match-macro-label:
    - match: ({{symbol_id}})
      scope: constant.other.mc6809
      set: comments-eol


  match-macros:
    - match: (?i)(macro)(?!\S)((\s+)(noexpand)(?!\S))?
      captures:
        1: support.function.directive.macro.mc6809
        4: support.function.directive.macro.mc6809
      set: comments-eol
  match-end-macros:
    - match: (?i)endm(?!\S)
      scope: support.function.directive.macro.mc6809
      set: comments-eol
  match-macro-reference:
    - match: (\\)(\d?)
      captures:
        1: punctuation.definition.macro.mc6809
        2: variable.language.macro.mc6809


  match-structures:
    - match: (?i)struct(?!\S)
      scope: support.function.directive.structure.mc6809
      set: comments-eol
  match-end-structures:
    - match: (?i)ends(truct)?(?!\S)
      scope: support.function.directive.structure.mc6809
      set: comments-eol


  match-emulator-extensions:
    # MAME extensions
    - match: '(?i)break|log(?!\S)'
      scope: support.function.directive.mc6809
      set: comments-eol


  match-expr:
    - include: match-integers
    - include: match-operators
    - include: match-parens
    - include: match-sizeof
    - include: match-labels
    - include: match-macro-reference
    - include: match-characters


  match-integers:
    - include: match-binary-integer
    - include: match-octal-integer
    - include: match-hex-integer
    - include: match-decimal-integer

  match-binary-integer:
    - match: '(\%){{num_bin}}'
      scope: constant.numeric.binary.mc6809
      captures:
        1: punctuation.definition.numeric.binary.mc6809
    - match: '{{num_bin}}([bB])'
      scope: constant.numeric.binary.mc6809
      captures:
        1: punctuation.definition.numeric.binary.mc6809

  match-octal-integer:
    - match: '(\@){{num_oct}}'
      scope: constant.numeric.octal.mc6809
      captures:
        1: punctuation.definition.numeric.octal.mc6809
    - match: '{{num_oct}}([oqOQ])'
      scope: constant.numeric.octal.mc6809
      captures:
        1: punctuation.definition.numeric.octal.mc6809

  match-hex-integer:
    - match: '(\$|0[Xx]){{num_hex}}'
      scope: constant.numeric.hexadecimal.mc6809
      captures:
        1: punctuation.definition.numeric.hexadecimal.mc6809
    - match: '{{num_hex}}([hH])'
      scope: constant.numeric.hexadecimal.mc6809
      captures:
        1: punctuation.definition.numeric.hexadecimal.mc6809

  match-decimal-integer:
    - match: '(\&)?{{num_dec}}'
      scope: constant.numeric.decimal.mc6809
      captures:
        1: punctuation.definition.numeric.decimal.mc6809

  match-operators:
    - match: <<|>>|&&|\|\|
      scope: keyword.operator.arithmetic.mc6809
    - match: \*
      scope: keyword.operator.arithmetic.mc6809
    - match: \+|\-|/|%|\||\^|\~|!|\&
      scope: keyword.operator.arithmetic.mc6809

  match-parens:
    - match: \(
      scope: punctuation.section.parens.begin.mc6809
      push:
        - match: \)
          scope: punctuation.section.parens.end.mc6809
          pop: true
        - include: pop-on-eol
        - include: match-expr

  match-comma:
    - match: \,
      scope: operator.separator.mc6809

  match-characters:
    - match: \'
      scope: punctuation.definition.string.begin.mc6809
      push:
        - meta_scope: string.quoted.single.mc6809
        - match: \S(\'?)
          captures:
            1: punctuation.definition.string.end.mc6809
          pop: true
        - include: pop-on-eol
    - match: \"
      scope: punctuation.definition.string.begin.mc6809
      push:
        - meta_scope: string.quoted.double.mc6809
        - match: \S\S(\"?)
          captures:
            1: punctuation.definition.string.end.mc6809
          pop: true
        - include: pop-on-eol

  match-labels:
    - match: '{{symbol_id}}'
      scope: constant.other.mc6809

  match-sizeof:
    - match: (?i)sizeof(\b)
      scope: support.function.directive.structure.mc6809
      push:
        - match: \{
          scope: punctuation.section.parens.begin.mc6809
          set:
            - match: \}
              scope: punctuation.section.parens.end.mc6809
              pop: true
            - include: match-expr
            - include: pop-on-eol
        - include: pop-on-eol

  match-strings:
    - match: \"
      scope: punctuation.definition.string.begin.mc6809
      set:
        - meta_scope: string.quoted.double.mc6809
        - match: \"
          scope: punctuation.definition.string.end.mc6809
          set: comments-eol
        - include: pop-on-eol
    - match: \'
      scope: punctuation.definition.string.begin.mc6809
      set:
        - meta_scope: string.quoted.single.mc6809
        - match: \'
          scope: punctuation.definition.string.end.mc6809
          set: comments-eol
        - include: pop-on-eol
    - match: .*$
      scope: string.unquoted.mc6809
      pop: true
    - include: pop-on-eol