C Ret.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: C Ret
file_extensions:
  - c
  - h
first_line_match: '-[*]-( Mode:)? C -[*]-'
scope: source.c1y

variables:
  _basic_types: 'void|signed|unsigned|char|short|int|long|float|double|signed|unsigned|_Bool|_Complex|_Imaginary'
  _aggregate_types: 'struct|union|enum'
  _simple_types: '{{_basic_types}}|{{_aggregate_types}}'

  _storage_classes: 'static|extern|auto|register|_Thread_local'
  _type_qualifiers: 'const|restrict|volatile|_Atomic'
  _compiler_directives: 'inline|__restrict__|__restrict|_Noreturn'
  _type_modifiers: '{{_storage_classes}}|{{_type_qualifiers}}|{{_compiler_directives}}'

  _control_keywords: 'return|if|else|switch|case|default|goto|for|do|while|break|continue'

  _word_operators: 'sizeof'

  _other_keywords: '{{_word_operators}}|typedef'

  identifier: '\b[[:alpha:]_][[:alnum:]_]*\b'

  invalid_names: '\b(?:{{_simple_types}}|{{_type_modifiers}}|{{_control_keywords}}|{{_other_keywords}})\b'
  valid_names: '(?!{{invalid_names}}){{identifier}}'

  type_modifiers: '\b(?:{{_type_modifiers}})\b'
  basic_types: '\b(?:{{_basic_types}})\b'
  struct: '\b(?:struct)\b'
  union: '\b(?:union)\b'
  struct_like: '\b(?:struct|union)\b'

  declarations_lookahead: '(?={{__test_declarations_simple}}|{{__test_custom_type_passive}})'

  __test_declarations_simple: '{{type_modifiers}}|{{basic_types}}|{{struct_like}}'
  __test_custom_type_passive: '{{valid_names}}(?:[\s\*])*(?:{{type_modifiers}}|{{valid_names}})'

  __test_unary_expression: '\b(?:sizeof)\b|\+\+|\!|\~|\*|\&|\+|\-'
  __test_primary_expression: '\d|{{valid_names}}|[\(\{\[]|"|'''

  integer_suffix: '(?i:U(?:LL|L)|(?:LL|L)U|U|LL|L)'

contexts:
  prototype:
    - include: line_continuations
    - include: comments
    - include: preprocessors

  main:
    - include: global

  global:
    - include: statements # test

  statements:
    - include: statement_labels
    - include: control_statements
    - include: typedef_declarations
    - include: declarations
    - include: statement_groups
    - include: statement_terminators
    - include: expressions

# declarations

  declarations:
    # - include: declar_function_definitions
    - match: '{{declarations_lookahead}}'
      push: [_declar_name_and_continue, _meta_declarations_specifier, _declar_before_type]

  _declar_list_continue:
    - scope: punctuation.separator.c
      match: ','
      set: [_declar_name_and_continue, _declar_after_type_and_modifiers]
    - include: _pop_nonspace


  typedef_declarations:
    - scope: keyword.other.typedef.c
      match: '\b(?:typedef)\b'
      push: [_typedef_declar_list_continue, _declar_after_name, _declar_typedef_name, _meta_declarations_typedef_specifier, _declar_before_type]

  _typedef_declar_list_continue:
    - scope: punctuation.separator.c
      match: ','
      set: [_typedef_declar_list_continue, _declar_after_name, _declar_typedef_name, _declar_after_type_and_modifiers]
    - include: _pop_nonspace


  _declar_before_type:
    - include: type_modifiers
    - include: __declar_basic_types
    - include: __declar_struct_like
    - include: __declar_custom_types
    - include: _pop_nonspace

  _declar_after_basic_type:
    - include: type_modifiers
    - include: __declar_basic_types
    - include: __declar_pointer
    - match: '(?=\s*(?!\*|{{type_modifiers}}|{{basic_types}})\S)'
      pop: true
    - include: _pop_nonspace

  _declar_after_type:
    - include: type_modifiers
    - include: __declar_pointer
    - match: '(?=\s*(?!\*|{{type_modifiers}})\S)'
      pop: true
    - include: _pop_nonspace

  _declar_after_type_continue:
    - include: type_modifiers
    - include: __declar_pointer_continue
    - match: '(?=\s*(?!\*|{{type_modifiers}})\S)'
      pop: true
    - include: _pop_nonspace

  _declar_after_type_and_modifiers:
    - include: __declar_pointer_continue
    - match: '(?=\s*(?!\*)\S)'
      pop: true
    - include: _pop_nonspace

  __declar_basic_types:
    - match: '(?={{basic_types}})'
      set:
        - include: basic_types
        - match: ''
          set: _declar_after_basic_type

  __declar_struct_like:
    - match: '(?={{struct}})'
      set:
        - include: struct
        - match: ''
          set: [_declar_after_type, _struct_like_body, _struct_tag]
    - match: '(?={{union}})'
      set:
        - include: union
        - match: ''
          set: [_declar_after_type, _struct_like_body, _union_tag]

  _struct_tag:
    - match: '(?={{valid_names}})'
      set:
        - include: struct_tags
        - match: ''
          pop: true
    - include: _pop_nonspace

  _union_tag:
    - match: '(?={{valid_names}})'
      set:
        - include: union_tags
        - match: ''
          pop: true
    - include: _pop_nonspace

  _struct_like_body:
    - scope: punctuation.section.brace.begin.c
      match: '\{'
      push:
        - include: declarations
        - include: statement_terminators
        - include: simple_braces
        - scope: punctuation.section.brace.end.c
          match: '\}'
          pop: true
    - match: '(?=\s*(?!\{)\S)'
      pop: true
    - include: _pop_nonspace

  __declar_custom_types:
    - match: '(?={{valid_names}})'
      set:
        - include: custom_types
        - match: ''
          set: _declar_after_type

  __declar_pointer:
    - scope: storage.modifier.pointer
      match: '\*'
      set: _declar_after_type

  __declar_pointer_continue:
    - scope: storage.modifier.pointer
      match: '\*'
      set: _declar_after_type_continue

  _meta_declarations_specifier:
    - meta_scope: meta.declarations.specifier.c
    - include: _pop_immediate

  _meta_declarations_typedef_specifier:
    - meta_scope: meta.declarations.typedef.specifier.c
    - include: _pop_immediate


  _declar_name_and_continue:
    - include: __declar_name_function_definition
    - match: '(?={{valid_names}}|\()'
      set: [_declar_list_continue, _declar_initializer, _declar_after_name, _declar_name]
    - include: _pop_nonspace

  __declar_name_function_definition:
    - match: '(?=(?:\(\s*(?:\*\s*)*)*{{valid_names}}\s*\()'
      set: [_declar_function_definition_body, _declar_after_name, _declar_name]

  _declar_function_definition_body:
    - scope: punctuation.section.brace.begin.c
      match: '\{'
      set:
        - include: statements
        - scope: punctuation.section.brace.end.c
          match: '\}'
          pop: true
    - match: '(?=\S)'
      set: [_declar_list_continue, _declar_initializer]


  _declar_name:
    - match: '(?={{valid_names}})'
      set:
        - include: declar_names
        - include: _pop_immediate
    - include: __declar_name_paren
    - include: _pop_nonspace

  __declar_name_paren:
    - scope: punctuation.section.paren.begin
      match: '\('
      set:
        - match: '(?={{valid_names}})'
          push:
            - include: declar_names
            - include: _pop_immediate
        - match: '(?=\*)'
          push: [_declar_after_name, _declar_name, _declar_after_type_and_modifiers]
        - match: '(?=\()'
          push: _declar_name_paren
        - scope: punctuation.section.paren.end
          match: '\)'
          pop: true

  _declar_name_paren:
    - include: __declar_name_paren
    - include: _pop_nonspace


  _declar_typedef_name:
    - match: '(?={{valid_names}})'
      set:
        - include: declar_typedef_names
        - include: _pop_immediate
    - include: __declar_typedef_name_paren
    - include: _pop_nonspace

  __declar_typedef_name_paren:
    - scope: punctuation.section.paren.begin
      match: '\('
      set:
        - match: '(?={{valid_names}})'
          push:
            - include: declar_typedef_names
            - include: _pop_immediate
        - match: '(?=\*)'
          push: [_declar_after_name, _declar_typedef_name, _declar_after_type_and_modifiers]
        - match: '(?=\()'
          push: _declar_typedef_name_paren
        - scope: punctuation.section.paren.end
          match: '\)'
          pop: true

  _declar_typedef_name_paren:
    - include: __declar_typedef_name_paren
    - include: _pop_nonspace


  _declar_after_name:
    - include: __declar_parameters
    - scope: punctuation.section.bracket.begin.c
      match: '\['
      set:
        - include: expressions
        - include: simple_brackets
        - scope: punctuation.section.bracket.end.c
          match: '\]'
          set: [_declar_after_name]
    - include: _pop_nonspace

  _declar_initializer:
    - scope: punctuation
      match: '\='
      push:
        - include: expressions_no_comma
        - match: '(?=[,;)])'
          pop: true
    - include: _pop_nonspace

  __declar_parameters:
    - match: '(?=\(\s*{{valid_names}}\s*(,\s*{{valid_names}}\s*)*\))'
      set:
        - scope: variable.parameter.c
          match: '{{valid_names}}'
        - scope: punctuation.separator.c
          match: ','
        - scope: punctuation.section.simple-param.begin.c
          match: '\('
        - scope: punctuation.section.simple-param.end.c
          match: '\)'
          pop: true
    - scope: punctuation.section.param.begin.c
      match: '\('
      set:
        - scope: punctuation.separator.c
          match: ','
        - include: declar_parameter_contents
        - scope: punctuation.section.param.end.c
          match: '\)'
          pop: true

  declar_parameter_contents:
    - match: '{{declarations_lookahead}}'
      push: [_declar_after_name, _declar_parameter_name, _meta_declarations_specifier, _declar_before_type]

  _declar_parameter_name:
    - match: '(?={{valid_names}})'
      set:
        - include: declar_parameter_names
        - include: _pop_immediate
    - include: __declar_parameter_name_paren
    - include: _pop_nonspace

  __declar_parameter_name_paren:
    - scope: punctuation.section.paren.begin
      match: '\('
      set:
        - match: '(?={{valid_names}})'
          push:
            - include: declar_parameter_names
            - include: _pop_immediate
        - match: '(?=\*)'
          push: [_declar_after_name, _declar_parameter_name, _declar_after_type_and_modifiers]
        - match: '(?=\()'
          push: _declar_parameter_name_paren
        - scope: punctuation.section.paren.end
          match: '\)'
          pop: true

  _declar_parameter_name_paren:
    - include: __declar_parameter_name_paren
    - include: _pop_nonspace

# statements

  statement_labels:
    - scope: entity.name.label.c
      match: '{{valid_names}}(?=\s*:)'
      push:
        - scope: punctuation.separator.c
          match: ':'
          pop: true
    - include: switch_labels


  control_statements:
    - scope: keyword.control.return.c
      match: '\b(?:return)\b'
      push: _expressions
    - scope: keyword.control.continue.c
      match: '\b(?:continue)\b'
    - scope: keyword.control.break.c
      match: '\b(?:break)\b'
    - scope: keyword.control.goto.c
      match: '\b(?:goto)\b'
      push:
        - scope: meta.goto.label
          match: '{{valid_names}}'
        - include: _pop_nonspace
    - scope: keyword.control.if.c
      match: '\b(?:if)\b'
      push: [_else_statement, _single_statement_or_group, _statement_expression_paran]
    - scope: keyword.control.switch.c
      match: '\b(?:switch)\b'
      push: [_swicth_continue, _statement_expression_paran]
    - scope: keyword.control.do.c
      match: '\b(?:do)\b'
      push: [_do_continue, _single_statement_or_group]
    - scope: keyword.control.while.c
      match: '\b(?:while)\b'
      push: [_single_statement_or_group, _statement_expression_paran]
    - scope: keyword.control.for.c
      match: '\b(?:for)\b'
      push:
        - scope: punctuation.section.paren.begin.c
          match: '\('
          set:
            - match: '{{declarations_lookahead}}'
              push:
                - include: declarations
                - include: _for_continue
            - scope: punctuation.section.paren.end.c
              match: '\)'
              pop: true
            - match: '(?=\S)'
              push: [_for_continue, _expressions]
        - include: _pop_nonspace

  _statement_expression_paran:
    - scope: punctuation.section.paren.begin.c
      match: '\('
      set:
        - scope: punctuation.section.paren.end.c
          match: '\)'
          pop: true
        - include: expressions
    - include: _pop_nonspace

  _single_statement_or_group:
    - scope: punctuation.terminator.c
      match: '(?<=\})|;'
      pop: true
    - match: '(?=\})'
      pop: true
    - include: statements

  _else_statement:
    - scope: keyword.control.else.c
      match: '\b(?:else)\b'
      set: _single_statement_or_group
    - include: _pop_nonspace

  _swicth_continue:
    - scope: punctuation.section.switch.c
      match: '\{'
      set:
        - include: switch_labels
        - scope: punctuation.section.switch.c
          match: '\}'
          pop: true
    - include: _pop_nonspace


  switch_labels:
    - scope: keyword.control.default.c
      match: '\b(?:case)\b'
      push: [_switch_label_content, _case_expression]
    - scope: keyword.control.default.c
      match: '\b(?:default)\b'
      push: _switch_label_content

  _case_expression:
    - match: '(?=:)'
      pop: true
    - include: expressions
    - include: _pop_nonspace

  _switch_label_content:
    - scope: punctuation.separator.c
      match: ':'
      set:
        - match: '(?=\}|\b(?:case|default)\b)'
          pop: true
        - include: statements
    - include: _pop_nonspace

  _do_continue:
    - scope: keyword.control.do-while.c
      match: '\b(?:while)\b'
      set: _statement_expression_paran
    - include: _pop_nonspace

  _for_continue:
    - scope: punctuation.terminator.c
      match: ';'
      set:
        - include: expressions
        - scope: punctuation.terminator.c
          match: ';'
          set:
            - include: expressions
            - match: '(?=\))'
              pop: true
        - include: _pop_nonspace
    - include: _pop_nonspace

  statement_groups:
    - scope: punctuation.section.statements.begin.c
      match: '\{'
      push:
        - include: statements
        - scope: punctuation.section.statements.end.c
          match: '\}'
          pop: true

# expressions

  expressions_no_comma:
    - match: '(?={{__test_unary_expression}}|{{__test_primary_expression}})'
      push: [_expressions]

  expressions:
    - include: expressions_no_comma
    - scope: keyword.operator.comma.c
      match: ','

  _expressions:
    - match: '(?=\S)'
      set: [_meta_expression, _expressions_no_meta]

  _expressions_no_meta:
    - match: '(?={{__test_unary_expression}})'
      set: [_expressions_no_meta, _unary_operators_pre]
    - match: '(?={{__test_primary_expression}})'
      set: [_triple_operator_expressions, _binary_operator_expressions, _call_expressions, _primary_expressions]
    - include: _pop_nonspace

  _unary_operators_pre:
    - scope: keyword.operator.word.sizeof.c
      match: '\b(?:sizeof)\b'
      pop: true
    - scope: keyword.operator.pre-increment.c
      match: '\+\+'
      pop: true
    - scope: keyword.operator.unary-plus.c
      match: '\+'
      pop: true
    - scope: keyword.operator.unary-minus.c
      match: '\-'
      pop: true
    - scope: keyword.operator.not.c
      match: '\!'
      pop: true
    - scope: keyword.operator.bitwise-not.c
      match: '\~'
      pop: true
    - scope: keyword.operator.deref.c
      match: '\*'
      pop: true
    - scope: keyword.operator.address.c
      match: '\&'
      pop: true

  _primary_expressions:
    - include: __numeric_literals
    - include: __strings
    - scope: variable.function.c
      match: '{{valid_names}}(?=\s*\()'
      pop: true
    - include: language_constants
    - scope: variable.other.c
      match: '{{valid_names}}'
      pop: true
    - include: __expression_groups
    - include: __expression_eat_braces_and_brackets
    - include: _pop_immediate

  __numeric_literals:
    - scope: constant.numeric.hex.c
      match: '\b0x[0-9a-fA-F]+{{integer_suffix}}?\b'
      pop: true
    - scope: constant.numeric.octal.c
      match: '\b0[0-7]*{{integer_suffix}}?\b'
      pop: true
    - scope: constant.numeric.decimal.c
      match: '\b[1-9]\d*{{integer_suffix}}?\b'
      pop: true

  __strings:
    - scope: punctuation.definition.string.begin.c
      match: '"'
      set:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.c
        - include: __string_contents
        - scope: punctuation.definition.string.end.c
          match: '"'
          pop: true

    - scope: punctuation.definition.string.begin.c
      match: ''''
      set:
        - meta_include_prototype: false
        - meta_scope: string.quoted.single.c
        - include: __string_contents
        - scope: punctuation.definition.string.end.c
          match: ''''
          pop: true

  __string_contents:
    - scope: constant.character.escape.c
      match: '\\[''"?\\abfnrtv]'
    - scope: constant.character.escape.octal.c
      match: '\\[0-7]{1,3}'
    - scope: constant.character.escape.hex.c
      match: '\\x[0-9a-zA-Z]+'
    - scope: constant.character.escape.unicode.c
      match: '\\[uU][0-9a-zA-Z]+'
    - scope: punctuation.separator.continuation.c
      match: '\\$\n'
    - include: scope:source.c#string_placeholder
    - scope: invalid.illegal.c
      match: '\\[^\n]'
    - scope: invalid.illegal.c
      match: '$\n'
      pop: true


  _call_expressions:
    - scope: keyword.operator.post-increment.c
      match: '\+\+'
      set: _call_expressions
    - match: '(?=\()'
      set: [_call_expressions, _expression_call_arguments]
    - match: '(?=\[)'
      set: [_call_expressions, _expression_subscriptors]
    - include: _pop_nonspace

  _expression_call_arguments:
    - scope: punctuation.section.arguments.begin.c
      match: '\('
      set:
        - scope: punctuation.separator.c
          match: ','
        - include: expressions_no_comma
        - scope: punctuation.section.arguments.end.c
          match: '\)'
          pop: true
    - include: _pop_immediate

  _expression_subscriptors:
    - scope: punctuation.section.subscript.begin.c
      match: '\['
      set:
        - include: expressions
        - scope: punctuation.section.subscript.end.c
          match: '\]'
          pop: true
    - include: _pop_immediate

  _binary_operator_expressions:
    - match: '(?=\+|\-|\*|\/|\%|\^|\&|\||\.|\-\>|\=|<|>|<<|>>|!=)'
      set: [_expressions_no_meta, _binary_operators]
    - include: _pop_nonspace

  _triple_operator_expressions:
    - match: '(?=\?)'
      set: [_expressions_no_meta, _triple_operators]
    - include: _pop_nonspace

  _binary_operators:
    - scope: punctuation.accessor.c
      match: '\.|\-\>'
      pop: true
    - scope: keyword.operator.binary.compound.c
      match: '(?:\+|\-|\*|\/|\%|\^|\&|\||<<|>>)\='
      pop: true
    - scope: keyword.operator.binary.c
      match: '<<|>>'
      pop: true
    - scope: keyword.operator.binary.compare.c
      match: '(?:\>|\<)\=?|(?:\=|\!)\='
      pop: true
    - scope: keyword.operator.binary.c
      match: '\+|\-|\*|\/|\%|\^|\&|\||\,|\='
      pop: true
    - include: _pop_immediate

  _triple_operators:
    - scope: keyword.operator.triple.first.c
      match: '\?'
      set: [_triple_operators_continue, _expressions_no_meta]
    - include: _pop_immediate

  _triple_operators_continue:
    - scope: keyword.operator.triple.second.c
      match: '\:'
      pop: true
    - include: _pop_nonspace

  __expression_groups:
    - scope: punctuation.section.paren.begin.c
      match: '\('
      set:
        - include: expressions
        - scope: punctuation.section.paren.end.c
          match: '\)'
          pop: true

  __expression_eat_braces_and_brackets:
    - match: '\{'
      set:
        - include: expressions
        - match: '\}'
          pop: true
    - match: '\['
      set:
        - include: expressions
        - match: '\]'
          pop: true


  _meta_expression:
    - meta_scope: meta.expression.c
    - include: _pop_immediate

# comments

  comments:
    - scope: punctuation.definition.comment.line.c
      match: '//'
      push:
        - meta_scope: comment.line.c
        - match: '$'
          pop: true
    - scope: punctuation.definition.comment.block.begin.c
      match: '/\*'
      push:
        - meta_scope: comment.block.c
        - scope: punctuation.definition.comment.block.end.c
          match: '\*/'
          pop: true

# directives

  preprocessors:
    - scope: punctuation.definition.directive.c
      match: '^\s*#'
      push:
        - include: comments
        - include: __preprocessors_incomplete_inc
        - include: __preprocessors_include
        - scope: keyword.control.directive.c
          match: '\b(?:include|define|undef|if|ifdef|ifndef|elif|else|endif|line|error|pragma)\b'
          set: _preprocessors_pop
        - match: '(?=\S)'
          set: _preprocessors_pop
      with_prototype:
        - include: line_continuations
        - include: _preprocessors_pop

  _preprocessors_pop:
    - match: '$\n'
      pop: true

  __preprocessors_incomplete_inc:
    - match: '(?:i(?:nc?)?)\b\s*'
      scope: meta.preprocessor.incomplete.c
      pop: true

  __preprocessors_include:
    - scope: keyword.control.directive.c
      match: '\b(?:include)\b'
      set:
        - include: comments
        - scope: punctuation.definition.string.angle.begin.c
          match: '<'
          set:
            - meta_scope: string.directive.c
            - scope: punctuation.definition.string.angle.end.c
              match: '>'
              pop: true
        - scope: punctuation.definition.string.normal.begin.c
          match: '"'
          set:
            - meta_scope: string.directive.c
            - scope: punctuation.definition.string.normal.end.c
              match: '"'
              pop: true

# util

  _pop_nonspace:
    - match: '(?=\S)'
      pop: true

  _pop_immediate:
    - match: ''
      pop: true

  line_continuations:
    - scope: punctuation.separator.continuation.c
      match: '\\$\n'

  type_modifiers:
    - scope: storage.modifier.storage.c
      match: '\b(?:{{_storage_classes}})\b'
    - scope: storage.modifier.qualifier.c
      match: '\b(?:{{_type_qualifiers}})\b'
    - scope: storage.modifier.directive.c
      match: '\b(?:{{_compiler_directives}})\b'

  basic_types:
    - scope: storage.type.c
      match: '{{basic_types}}'

  struct_like:
    - scope: storage.type.c
      match: '{{struct_like}}'

  struct:
    - scope: storage.type.c
      match: '{{struct}}'

  union:
    - scope: storage.type.c
      match: '{{union}}'

  custom_types:
    - scope: storage.type.custom.c
      match: '{{valid_names}}'

  struct_tags:
    - scope: entity.name.struct.forward-decl.c
      match: '{{valid_names}}(?=[^;{]+;)'
    - scope: entity.name.struct.c
      match: '{{valid_names}}'

  union_tags:
    - scope: entity.name.union.forward-decl.c
      match: '{{valid_names}}(?=[^;{]+;)'
    - scope: entity.name.union.c
      match: '{{valid_names}}'

  declar_names:
    - include: declar_function_names
    - include: declar_variable_names

  declar_function_names:
    - scope: entity.name.function.forward-decl.c
      match: '{{valid_names}}(?=\s*\((?:[^;{]+;|[^\(\)]*\)[^,;{]*[,;]))'
    - scope: entity.name.function.c
      match: '{{valid_names}}(?=\s*\()'

  declar_variable_names:
    - scope: entity.name.variable.c
      match: '{{valid_names}}'

  declar_typedef_names:
    - scope: entity.name.type.c
      match: '{{valid_names}}'

  declar_parameter_names:
    - scope: variable.parameter.c
      match: '{{valid_names}}'

  statement_terminators:
    - scope: punctuation.terminator.c
      match: ';'

  language_constants:
    - scope: constant.language.c
      match: '\b(?:NULL|TRUE|FALSE)\b'

  simple_braces:
    - match: '\{'
      push:
        - match: '\}'
          pop: true

  simple_brackets:
    - match: '\['
      push:
        - match: '\]'
          pop: true

  simple_parens:
    - match: '\('
      push:
        - match: '\)'
          pop: true