tads3.YAML-tmLanguage

# [PackageDev] target_format: plist, ext: tmLanguage
---
name: TADS 3 Source File
scopeName: source.tads3
fileTypes: [t]
uuid: 5171c4a6-0129-4dc0-88a9-7aa4127d6b5d
patterns: 
- include: '#top'

repository:
  top:
    patterns:
    - include: '#preprocessor'
    - include: '#tokens'

  preprocessor:
    patterns:
    - name: meta.preprocessor.charset.tads3
      match: ^\s*#\s*(charset)\s*("[^"]*")$
      captures:
        '1': {name: keyword.other.preprocessor.charset.tads3}
        '2': {name: string.quoted.double.charset.tads3}
    - name: meta.preprocessor.define.function.tads3
      begin: |
        (?x)
        ^\s*\#\s*(define)\s+ ([A-Za-z_][A-Za-z0-9_]*)
        \((?:
          (?:\s*  ([A-Za-z][A-Za-z0-9_]*)  )\s*
          (?:,\s* ([A-Za-z_][A-Za-z0-9_]*) \s*)*
        )?\)
      beginCaptures:
        '1': {name: keyword.other.preprocessor.define.tads3}
        '2': {name: entity.name.function.preprocessor.tads3}
        '3': {name: variable.parameter.preprocessor.tads3}
        '4': {name: variable.parameter.preprocessor.tads3}
      end: $
      patterns:
      - include: '#tokens'
    - name: meta.preprocessor.define.simple.tads3
      begin: ^\s*#\s*(define)\s+([A-Za-z_][A-Za-z0-9_]*)\b
      beginCaptures:
        '1': {name: keyword.other.preprocessor.define.tads3}
        '2': {name: entity.name.function.preprocessor.tads3}
      end: $
      patterns:
      - include: '#tokens'
    - name: meta.preprocessor.error.tads3
      begin: ^\s*#\s*(error)\s+
      beginCaptures:
        '1': {name: keyword.other.preprocessor.error.tads3}
      end: $
      patterns:
      - include: '#preprocessor-tokens'
    - name: meta.preprocessor.if-block.ifdef.tads3
      begin: ^\s*#\s*(ifdef)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$
      beginCaptures:
        '1': {name: keyword.other.preprocessor.ifdef.tads3}
        '2': {name: entity.other.function.preprocessor.ifdef.tads3}
      end: ^\s*#\s*(endif)\s*$
      endCaptures:
        '1': {name: keyword.other.preprocessor.endif.tads3}
      patterns:
      - include: '#top'
      - include: '#preprocessor-cond'
    - name: meta.preprocessor.if-block.ifndef.tads3
      begin: ^\s*#\s*(ifndef)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$
      beginCaptures:
        '1': {name: keyword.other.preprocessor.ifndef.tads3}
        '2': {name: entity.other.function.preprocessor.ifndef.tads3}
      end: ^\s*#\s*(endif)\s*$
      endCaptures:
        '1': {name: keyword.other.preprocessor.endif.tads3}
      patterns:
      - include: '#top'
      - include: '#preprocessor-cond'
    - name: meta.preprocessor.if-block.if.tads3
      begin: ^\s*#\s*(if)\b
      beginCaptures:
        '1': {name: keyword.other.preprocessor.ifdef.tads3}
        '2': {name: entity.other.function.preprocessor.tads3}
      end: ^\s*#\s*(endif)\s*$
      endCaptures:
        '1': {name: keyword.other.preprocessor.endif.tads3}
      patterns:
      - begin: (?<!if)
        end: (?=^\s*#\s*endif\s*$)
        patterns:
        - include: '#top'
        - include: '#preprocessor-cond'
      - begin: ''
        end: $
        patterns:
        - include: '#preprocessor-tokens'
    - name: meta.preprocessor.include.double.tads3
      match: ^\s*#\s*(include)\s*("[^"]*")\s*$
      captures:
        '1': {name: keyword.other.preprocessor.include.tads3}
        '2': {name: string.quoted.double.include.tads3}
    - name: meta.preprocessor.include.lt-gt.tads3
      match: ^\s*#\s*(include)\s*(<[^"]*>)\s*$
      captures:
        '1': {name: keyword.other.preprocessor.include.tads3}
        '2': {name: string.quoted.other.lt-gt.include.tads3}
    - name: meta.preprocessor.line.tads3
      match: ^\s*#\s*(line)\s+(0|[1-9][0-9]*)\s*('[^']*')\s*$
      captures:
        '1': {name: keyword.other.preprocessor.line.tads3}
        '2': {name: constant.numeric.line.tads3}
        '3': {name: string.quoted.single.line.tads3}
    - name: meta.preprocessor.pragma.tads3.message
      begin: ^\s*#\s*(pragma)\s+(message)\s*\(
      beginCaptures:
        '1': {name: keyword.other.preprocessor.pragma.tads3}
        '2': {name: keyword.other.preprocessor.pragma-message.tads3}
      end: \)\s*$
      patterns:
      - include: '#preprocessor-tokens'
    - name: meta.preprocessor.pragma.tads3.newline-spacing
      match: |
        ^(?x)\s*\#\s* (pragma) \s+ (newline_spacing) \s*\(\s*
          (collapse|delete|preserve|on|off)
        \s*\)\s*$
      captures:
        '1': {name: keyword.other.preprocessor.pragma.tads3}
        '2': {name: keyword.other.preprocessor.pragma-newline-spacing.tads3}
        '3':
          name: keyword.other.preprocessor.pragma-newline-spacing-value.tads3
    - name: meta.preprocessor.pragma.tads3.stg
      match: ^\s*#\s*(pragma)\s+(sourceTextGroup)\s*\(\s*(on|off)\s*\)\s*$
      captures:
        '1': {name: keyword.other.preprocessor.pragma.tads3}
        '2': {name: keyword.other.preprocessor.pragma-stg.tads3}
        '3': {name: keyword.other.preprocessor.pragma-stg-value.tads3}
    - name: meta.preprocessor.pragma.tads3.once
      match: ^\s*#\s*(pragma)\s*(once)\s*$
      captures:
        '1': {name: keyword.other.preprocessor.pragma.tads3}
        '2': {name: keyword.other.preprocessor.pragma-once.tads3}
    - name: meta.preprocessor.pragma.tads3.all-once
      match: ^\s*#\s*(pragma)\s*(all_once)\s*[\+\-]\s*$
      captures:
        '1': {name: keyword.other.preprocessor.pragma.tads3}
        '2': {name: keyword.other.preprocessor.pragma-all-once.tads3}
    - name: meta.preprocessor.undef.tads3
      match: ^\s*#\s*(undef)\s*([A-Za-z_][A-Za-z0-9_]*)\s*$
      captures:
        '1': {name: keyword.other.preprocessor.undef.tads3}
        '2': {name: entity.other.function.preprocessor.undef.tads3}

  preprocessor-cond:
    patterns:
    - name: meta.preprocessor.else.tads3
      match: ^\s*#\s*(else)\s*$
      captures:
        '1': {name: keyword.other.preprocessor.else.tads3}
    - name: meta.preprocessor.elif.tads3
      begin: ^\s*#\s*(elif)
      beginCaptures:
        '1': {name: keyword.other.preprocessor.elif.tads3}
      end: $
      patterns:
      - include: '#preprocessor-tokens'

  preprocessor-tokens:
    patterns:
    - include: '#comments'
    - include: '#symbols'
    - include: '#literals-numeric'
    - include: '#literals-regex'
    - include: '#literals-strings-simple'
    - include: '#operators'

  tokens:
    patterns:
    - include: '#comments'
    - include: '#keywords'
    - include: '#grammar'
    - include: '#symbols'
    - include: '#literals-numeric'
    - include: '#literals-regex'
    - include: '#literals-strings-interpolated'
    - include: '#operators'

  comments:
    patterns:
    - name: comment.line.double-slash.tads3
      match: //.*$
    - name: comment.block.tads3
      begin: /\*
      end: \*/

  keywords:
    patterns:
    - name: storage.type.class.tads3
      match: \bclass\b
    - name: keyword.operator.delegated.tads3
      match: \bdelegated\b
    - name: storage.type.dictionary.tads3
      match: \bdictionary\b
    - name: storage.type.enum.tads3
      match: \benum\b
    - name: storage.modifier.extern.tads3
      match: \bextern\b
    - name: storage.modifier.export.tads3
      match: \bexport\b
    - name: storage.type.function.tads3
      match: \bfunction\b
    - name: keyword.operator.inherited.tads3
      match: \binherited\b
    - name: storage.type.intrinsic.tads3
      match: \bintrinsic\b
    - name: storage.type.local.tads3
      match: \blocal\b
    - name: storage.type.method.tads3
      match: \bmethod\b
    - name: storage.modifier.modify.tads3
      match: \bmodify\b
    - name: storage.modifier.multimethod.tads3
      match: \bmultimethod\b
    - name: keyword.operator.new.tads3
      match: \bnew\b
    - name: constant.other.nil.tads3
      match: \bnil\b
    - name: keyword.other.object.tads3
      match: \bobject\b
    - name: storage.type.operator.tads3
      match: \boperator\b
    - name: storage.type.property.tads3
      match: \bproperty\b
    - name: storage.type.propertyset.tads3
      match: \bpropertyset\b
    - name: storage.modifier.replace.tads3
      match: \breplace\b
    - name: keyword.operator.replaced.tads3
      match: \breplaced\b
    - name: keyword.other.static.tads3
      match: \bstatic\b
    - name: storage.type.template.tads3
      match: \btemplate\b
    - name: storage.modifier.transient.tads3
      match: \btransient\b
    - name: constant.other.true.tads3
      match: \btrue\b

    - name: keyword.control.break.tads3
      match: \bbreak\b
    - name: keyword.control.case.tads3
      match: \bcase\b
    - name: keyword.control.catch.tads3
      match: \bcatch\b
    - name: keyword.control.continue.tads3
      match: \bcontinue\b
    - name: keyword.control.default.tads3
      match: \bdefault\b
    - name: keyword.control.do.tads3
      match: \bdo\b
    - name: keyword.control.if.tads3
      match: \bif\b
    - name: keyword.control.else.tads3
      match: \belse\b
    - name: keyword.control.finally.tads3
      match: \bfinally\b
    - name: keyword.control.for.tads3
      match: \bfor\b
    - name: keyword.control.foreach.tads3
      match: \bforeach\b
    - name: keyword.control.goto.tads3
      match: \bgoto\b
    - name: keyword.control.return.tads3
      match: \breturn\b
    - name: keyword.control.switch.tads3
      match: \bswitch\b
    - name: keyword.control.throw.tads3
      match: \bthrow\b
    - name: keyword.control.try.tads3
      match: \btry\b
    - name: keyword.control.while.tads3
      match: \bwhile\b

    - name: entity.other.argcount.tads3
      match: \bargcount\b
    - name: entity.other.definingobj.tads3
      match: \bdefiningobj\b
    - name: entity.other.self.tads3
      match: \bself\b
    - name: entity.other.targetobj.tads3
      match: \btargetobj\b
    - name: entity.other.targetprop.tads3
      match: \btargetprop\b
    - name: entity.other.invokee.tads3
      match: \binvokee\b

  grammar:
    patterns:
    - match: '([A-Za-z_][A-Za-z0-9_]*)\s*\('
      captures:
        '1': {name: support.function}
    - match: '(?<=\.)([A-Za-z_][A-Za-z0-9_]*)'
      captures:
        '1': {name: variable.other}

  symbols:
    patterns:
    - match: \b[A-Za-z_][A-Za-z0-9_]*\b

  literals-numeric:
    patterns:
    - name: constant.numeric.float.tads3
      match: |
        (?x)
        (?:0|[1-9][0-9]*) (?:(?:\.[0-9]*)? [Ee][+-]? [0-9]+ | \.[0-9]*) |
        \.[0-9]+ (?:[Ee][+-]? [0-9]+)?
    - name: constant.numeric.octal.tads3
      match: 0[0-7]+(?![0-9])
    - name: invalid.illegal.bad-octal.tads3
      match: 0[0-9]+
    - name: constant.numeric.hexadecimal.tads3
      match: 0[Xx][0-9A-Fa-f]+
    - name: constant.numeric.decimal.tads3
      match: 0(?![0-9])|[1-9][0-9]*

  literals-regex:
    patterns:
    - name: string.quoted.triple.double.regex.tads3
      begin: "R\"{3,}"
      end: "\"{3,}"
      patterns:
      - name: constant.character.escape.tads3
        match: "\\\\[\"']+"
      - include: '#string-escapes'
    - name: string.quoted.triple.single.regex.tads3
      begin: "R'{3,}"
      end: "'{3,}"
      patterns:
      - name: constant.character.escape.tads3
        match: "\\\\[\"']+"
      - include: '#string-escapes'
    - name: string.quoted.double.regex.tads3
      begin: 'R"'
      end: '"'
      patterns:
      - include: '#string-escapes'
    - name: string.quoted.single.regex.tads3
      begin: "R'"
      end: "'"
      patterns:
      - include: '#string-escapes'

  literals-strings-simple:
    patterns:
    - name: string.quoted.triple.double.tads3
      begin: "\"{3,}"
      end: "\"{3,}"
      patterns:
      - name: constant.character.escape.tads3
        match: "\\\\[\"']+"
      - include: '#string-escapes'
      - include: '#tags-in-triple-double'
    - name: string.quoted.triple.single.tads3
      begin: "'{3,}"
      end: "'{3,}"
      patterns:
      - name: constant.character.escape.tads3
        match: "\\\\[\"']+"
      - include: '#string-escapes'
      - include: '#tags-in-triple-single'
    - name: string.quoted.double.tads3
      begin: "\""
      end: "\""
      patterns:
      - include: '#string-escapes'
      - include: '#tags-in-double'
    - name: string.quoted.single.tads3
      begin: "'"
      end: "'"
      patterns:
      - include: '#string-escapes'
      - include: '#tags-in-single'

  literals-strings-interpolated:
    patterns:
    - name: string.quoted.triple.double.tads3
      begin: "\"{3,}"
      end: "\"{3,}"
      patterns:
      - name: source.tads3.embedded.source
        begin: '<<'
        end: '>>'
        patterns:
        - include: '#tokens'
      - name: constant.character.escape.tads3
        match: "\\\\[\"']+"
      - include: '#string-escapes'
      - include: '#tags-in-triple-double'
    - name: string.quoted.triple.single.tads3
      begin: "'{3,}"
      end: "'{3,}"
      patterns:
      - name: source.tads3.embedded.source
        begin: '<<'
        end: '>>'
        patterns:
        - include: '#tokens'
      - name: constant.character.escape.tads3
        match: "\\\\[\"']+"
      - include: '#string-escapes'
      - include: '#tags-in-triple-single'
    - name: string.quoted.double.tads3
      begin: "\""
      end: "\""
      patterns:
      - name: source.tads3.embedded.source
        begin: '<<'
        end: '>>'
        patterns:
        - include: '#tokens'
      - include: '#string-escapes'
      - include: '#tags-in-double'
    - name: string.quoted.single.tads3
      begin: "'"
      end: "'"
      captures:
        '0': {name: string.quoted.single.tads3}
      patterns:
      - name: source.tads3.embedded.source
        begin: '<<'
        end: '>>'
        patterns:
        - include: '#tokens'
      - include: '#string-escapes'
      - include: '#tags-in-single'

  string-escapes:
    patterns:
    - name: constant.character.escape.tads3
      match: |
        (?x)
        \\(?:
          [\\<>"'\^v bnrt] | # simple ones
          u[0-9A-Fa-f]{4} |  # 4-digit hex
          x[0-9A-Fa-f]{2} |  # 2-digit hex
          [0-7]{3}           # 3-digit octal
        )
    - name: invalid.illegal.bad-escape.tads3
      match: |
        (?x)
        (\\(?:[^\\<>"'\^v bnrtux0-7] | # not one of valid continuations
          u(?![0-9A-Fa-f]) | u[0-9A-Fa-f] (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{2} (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{3} (?![0-9A-Fa-f]) | # bad 4-digit hex
          [0-7] (?![0-7]) | [0-7]{2} (?![0-7]) | # bad 3-digit octal
          x(?![0-9A-Fa-f]) | x[0-9A-Fa-f] (?![0-9A-Fa-f]) # bad 2-digit hex
        ))

  tags-common:
    patterns:
    - name: meta.tag.html.end.tads3
      match: '<(?:\\.)?/([A-Za-z\\.]+)>'
      captures:
        '1': {name: entity.name.tag.tads3}
    - name: meta.tag.curly.tads3
      match: '\{[A-Za-z0-9/ \-_]*\}'

  tags-in-triple-double:
    patterns:
    - include: '#tags-common'
    - name: meta.tag.html.begin.tads3
      match: |
        (?x)
        <([A-Za-z\.]+)\b(?:             # tag name, followed by...
        [^\\"<>] | "(?!") | ""(?!") |   # a safe char, or a non-closing quote...
        (\\(?:                          # or a good escape...
          [\\<>\^v bnrt]  | # simple ones
          u[0-9A-Fa-f]{4} | # 4-digit hex
          x[0-9A-Fa-f]{2} | # 2-digit hex
          [0-7]{3} |        # 3-digit octal
          ["']+             # special triple-quote escape
        )) |                            # or a bad escape.
        (\\(?:[^\\<>"'\^v bnrtux0-7] | # not one of valid continuations
          u(?![0-9A-Fa-f]) | u[0-9A-Fa-f] (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{2} (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{3} (?![0-9A-Fa-f]) | # bad 4-digit hex
          [0-7] (?![0-7]) | [0-7]{2} (?![0-7]) | # bad 3-digit octal
          x(?![0-9A-Fa-f]) | x[0-9A-Fa-f] (?![0-9A-Fa-f]) # bad 2-digit hex
        )))*>
      captures:
        '1': {name: entity.name.tag.tads3}
        '2': {name: constant.character.escape.tads3}
        '3': {name: invalid.illegal.bad-escape.tads3}

  tags-in-triple-single:
    patterns:
    - include: '#tags-common'
    - name: meta.tag.html.begin.tads3
      match: |
        (?x)
        <([A-Za-z\.]+)\b(?:             # tag name, followed by...
        [^\\'<>] | '(?!') | ''(?!') |   # a safe char, or a non-closing quote...
        (\\(?:                          # or a good escape...
          [\\<>\^v bnrt]  | # simple ones
          u[0-9A-Fa-f]{4} | # 4-digit hex
          x[0-9A-Fa-f]{2} | # 2-digit hex
          [0-7]{3} |        # 3-digit octal
          ["']+             # special triple-quote escape
        )) |                            # or a bad escape.
        (\\(?:[^\\<>"'\^v bnrtux0-7] | # not one of valid continuations
          u(?![0-9A-Fa-f]) | u[0-9A-Fa-f] (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{2} (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{3} (?![0-9A-Fa-f]) | # bad 4-digit hex
          [0-7] (?![0-7]) | [0-7]{2} (?![0-7]) | # bad 3-digit octal
          x(?![0-9A-Fa-f]) | x[0-9A-Fa-f] (?![0-9A-Fa-f]) # bad 2-digit hex
        )))*>
      captures:
        '1': {name: entity.name.tag.tads3}
        '2': {name: constant.character.escape.tads3}
        '3': {name: invalid.illegal.bad-escape.tads3}

  tags-in-double:
    patterns:
    - include: '#tags-common'
    - name: meta.tag.html.begin.tads3
      match: |
        (?x)
        <([A-Za-z\.]+)\b(?:             # tag name, followed by...
        [^\\"<>]                        # a safe char...
        (\\(?:                          # or a good escape...
          [\\<>"'\^v bnrt] | # simple ones
          u[0-9A-Fa-f]{4} |  # 4-digit hex
          x[0-9A-Fa-f]{2} |  # 2-digit hex
          [0-7]{3}           # 3-digit octal
        )) |                            # or a bad escape.
        (\\(?:[^\\<>"'\^v bnrtux0-7] | # not one of valid continuations
          u(?![0-9A-Fa-f]) | u[0-9A-Fa-f] (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{2} (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{3} (?![0-9A-Fa-f]) | # bad 4-digit hex
          [0-7] (?![0-7]) | [0-7]{2} (?![0-7]) | # bad 3-digit octal
          x(?![0-9A-Fa-f]) | x[0-9A-Fa-f] (?![0-9A-Fa-f]) # bad 2-digit hex
        )))*>
      captures:
        '1': {name: entity.name.tag.tads3}
        '2': {name: constant.character.escape.tads3}
        '3': {name: invalid.illegal.bad-escape.tads3}

  tags-in-single:
    patterns:
    - include: '#tags-common'
    - name: meta.tag.html.begin.tads3
      match: |
        (?x)
        <([A-Za-z\.]+)\b(?:             # tag name, followed by...
        [^\\'<>]                        # a safe char...
        (\\(?:                          # or a good escape...
          [\\<>"'\^v bnrt] | # simple ones
          u[0-9A-Fa-f]{4} |  # 4-digit hex
          x[0-9A-Fa-f]{2} |  # 2-digit hex
          [0-7]{3}           # 3-digit octal
        )) |                            # or a bad escape.
        (\\(?:[^\\<>"'\^v bnrtux0-7] | # not one of valid continuations
          u(?![0-9A-Fa-f]) | u[0-9A-Fa-f] (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{2} (?![0-9A-Fa-f]) |
            u[0-9A-Fa-f]{3} (?![0-9A-Fa-f]) | # bad 4-digit hex
          [0-7] (?![0-7]) | [0-7]{2} (?![0-7]) | # bad 3-digit octal
          x(?![0-9A-Fa-f]) | x[0-9A-Fa-f] (?![0-9A-Fa-f]) # bad 2-digit hex
        )))*>
      captures:
        '1': {name: entity.name.tag.tads3}
        '2': {name: constant.character.escape.tads3}
        '3': {name: invalid.illegal.bad-escape.tads3}

  operators:
    patterns:
    - begin: \(
      end: \)
      patterns:
      - include: '#tokens'
    - match: ','
    - match: \.\.\.
    - match: \.\.
    - match: \.
    - match: '\{'
    - match: '\}'
    - match: '\['
    - match: '\]'
    - name: keyword.operator.eq.tads3
      match: ==
    - name: keyword.operator.assign.tads3
      match: '='
    - name: keyword.operator.conditional-short.tads3
      match: '\?\?'
    - name: keyword.operator.conditional.tads3
      match: '\?'
    - match: ':'
    - name: keyword.operator.assign.add.tads3
      match: \+=
    - name: keyword.operator.increment.tads3
      match: \+\+
    - name: keyword.operator.add.tads3
      match: \+
    - name: keyword.operator.assign.subtract.tads3
      match: -=
    - name: keyword.operator.decrement.tads3
      match: --
    - match: ->
    - name: keyword.operator.subtract.tads3
      match: '-'
    - name: keyword.operator.assign.multiply.tads3
      match: \*=
    - name: keyword.operator.multiply.tads3
      match: \*
    - name: keyword.operator.assign.divide.tads3
      match: /=
    - name: keyword.operator.divide.tads3
      match: /
    - name: keyword.operator.assign.modulo.tads3
      match: '%='
    - name: keyword.operator.modulo.tads3
      match: '%'
    - name: keyword.operator.ge.tads3
      match: '>='
    - name: keyword.operator.assign.shift-right.arithmetical.tads3
      match: '>>='
    - name: keyword.operator.assign.shift-right.logical.tads3
      match: '>>>='
    - name: keyword.operator.shift-right.logical.tads3
      match: '>>>'
    - name: keyword.operator.shift-right.arithmetical.tads3
      match: '>>'
    - name: keyword.operator.gt.tads3
      match: '>'
    - name: keyword.operator.le.tads3
      match: '<='
    - name: keyword.operator.assign.shift-left.tads3
      match: '<<='
    - name: keyword.operator.shift-left.tads3
      match: '<<'
    - name: keyword.operator.lt.tads3
      match: '<'
    - match: ';'
    - name: keyword.operator.logical.and.tads3
      match: '&&'
    - name: keyword.operator.assign.and.tads3
      match: '&='
    - name: keyword.operator.bitwise.and.tads3
      match: '&'
    - name: keyword.operator.logical.or.tads3
      match: \|\|
    - name: keyword.operator.assign.or.tads3
      match: \|=
    - name: keyword.operator.bitwise.or.tads3
      match: \|
    - name: keyword.operator.assign.xor.tads3
      match: \^=
    - name: keyword.operator.bitwise.xor.tads3
      match: \^
    - name: keyword.operator.ne.tads3
      match: '!='
    - name: keyword.operator.logical.not.tads3
      match: '!'
    - name: keyword.operator.bitwise.not.tads3
      match: '~'
    - match: '@'
    - name: keyword.operator.preprocessor.token-paste.tads3
      match: '##'
    - name: keyword.operator.preprocessor.stringize.single.tads3
      match: '#@'
    - name: keyword.operator.preprocessor.stringize.double.tads3
      match: '#'
...