C Parse.sublime-syntax

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

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'

  invalid_identifier: '\b(?:{{_simple_types}}|{{_type_modifiers}}|{{_control_keywords}}|{{_word_operators}})\b'

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

  type_modifier: '\b(?:{{_type_modifiers}})\b'
  type_basic: '\b(?:{{_basic_types}})\b'
  struct_like: '\b(?:struct|union)\b'

  test_declar: '{{type_modifier}}|{{type_basic}}|{{struct_like}}'

contexts:
  prototype:
    - include: comments

  main:
    - include: global


  global:
    - include: preprocessors
    - include: test_declar
    - include: fallback



# test expr

  test_expr_context:
    - match: '(?=\S)'
      set:
        - include: expr_literals
        - match: ''
          pop: true

  subscript_context:
    - match: '(?=\S)'
      set:
        - include: subscripts
        - match: ''
          pop: true

  subscripts:
    - scope: punctuation.operator.subscript.begin
      match: '\['
      push:
        - scope: punctuation.operator.subscript.end
          match: '\]'
          pop: true
        - include: expr_fallback

# test declar

  test_declar:
    - match: '(?={{test_declar}})'
      push: [test_declar_after_specifier_context, test_specifier_context]

  parameter_declar_context:
    - match: '(?={{test_declar}})'
      set: [parameter_declarator_context, test_specifier_context]
    - include: fallpop

  parameter2_declar_context:
    - match: '(?={{test_declar}})'
      set: [parameter2_declarator_context, test_specifier_context]
    - include: fallpop


  test_declar_after_specifier_context:
    - match: ''
      set: [test_declar_scope_context, test_declar_declarator_comma_context, test_declar_declarator_context]

  test_declar_scope_context:
    - meta_scope: invalid.illegal.test2.test_declar_scope_context
    - include: fallpop

  test_declar_declarator_comma_context:
    - match: '(?=,)'
      set: [test_declar_declarator_comma_context, test_declar_declarator_context, punctuation_comma_context]
    - include: fallpop



  test_declar_declarator_context:
    - match: '(?=\*)'
      set: [test_declar_declarator_context, pointer_definition_context]
    - match: '(?!{{invalid_identifier}})(?={{identifier}})'
      set: [test_declar_after_declarator_context, test_declar_declarator_identifier_context]
    - match: '(?=\()'
      set: [parameter_after_declarator_context, test_declar_declarator_group_end_context, test_declar_declarator_context, test_declar_declarator_group_context_begin]
    - include: fallpop

  parameter_declarator_context:
    - match: '(?=\*)'
      set: [parameter_declarator_context, pointer_definition_context]
    - match: '(?!{{invalid_identifier}})(?={{identifier}})'
      set: [parameter_after_declarator_context, parameter_identifier_context]
    - match: '(?=\()'
      set: [parameter_after_declarator_context, test_declar_declarator_group_end_context, parameter_declarator_context, test_declar_declarator_group_context_begin]
    - include: fallpop

  parameter2_declarator_context:
    - match: '(?=\*)'
      set: [parameter2_declarator_context, pointer_definition_context]
    - match: '(?!{{invalid_identifier}})(?={{identifier}})'
      set: [parameter_after_declarator_context, parameter2_identifier_context]
    - match: '(?=\()'
      set: [parameter_after_declarator_context, test_declar_declarator_group_end_context, parameter2_declarator_context, test_declar_declarator_group_context_begin]
    - include: fallpop



  test_declar_after_declarator_context:
    - include: assign_initializer_fragment
    - match: '(?=\[)'
      set: [test_declar_after_declarator_context, subscript_context]
    - match: '(?=\()'
      set: [parameter_after_declarator_context, parameter_group_context_end, parameter_list, parameter_group_context_begin]
    - include: fallpop

  parameter_after_declarator_context:
    - include: assign_initializer_fragment
    - match: '(?=\[)'
      set: [parameter_after_declarator_context, subscript_context]
    - match: '(?=\()'
      set: [parameter_after_declarator_context, parameter_group_context_end, parameter2_list, parameter_group_context_begin]
    - include: fallpop



  test_declar_declarator_identifier_context:
    - scope: entity.name.function
      match: '{{identifier}}(?=\s*\()'
      pop: true
    - scope: meta.identifier.declarator
      match: '{{identifier}}'
      pop: true

  parameter_identifier_context:
    - scope: variable.parameter
      match: '{{identifier}}'
      pop: true

  parameter2_identifier_context:
    - scope: meta.variable.parameter
      match: '{{identifier}}'
      pop: true




  test_declar_declarator_group_context_begin:
    - scope: punctuation.section.group.begin
      match: '\('
      pop: true
        
  test_declar_declarator_group_end_context:
    - scope: punctuation.section.group.end
      match: '\)'
      pop: true
    # - include: fallpop




  pointer_definition_context:
    - scope: storage.modifier.pointer
      match: '\*'
      pop: true

  assign_initializer_fragment:
    - scope: keyword.operator.assignment.initializer
      match: '\='
      set: test_initializer_expr_context

  punctuation_comma_context:
    - include: punctuation_commas
    - include: fallpop

  test_initializer_expr_context:
    - match: '(?=\{)'
      set: test_initializer_fragment
    - include: test_expr_context

  test_initializer_fragment:
    - scope: punctuation.definition.initializer.begin
      match: '\{'
      set:
        - scope: punctuation.definition.initializer.end
          match: '\}'
          pop: true
        - include: expr_fallback



  parameter_group_context_begin:
    - scope: punctuation.section.parameters.begin
      match: '\('
      pop: true

  parameter_group_context_end:
    - scope: punctuation.section.parameters.end
      match: '\)'
      pop: true

  parameter_comma_context:
    - scope: punctuation.separator.parameter
      match: ','
      set: parameter_list
    - include: fallpop

  parameter_list:
    - match: ''
      set: [parameter_comma_context, parameter_declar_context]

  parameter2_comma_context:
    - scope: punctuation.separator.parameter2
      match: ','
      set: parameter2_list
    - include: fallpop

  parameter2_list:
    - match: ''
      set: [parameter2_comma_context, parameter2_declar_context]

# test specifier

  test_specifier_context:
    - include: test_specifier_fragment
    - include: fallpop    

  test_specifier_fragment:
    - match: '(?={{type_modifier}})'
      set: [test_specifier_scope_context_modifier_start, type_basic_and_aggregate_context, type_modifier_context]
    - match: '(?={{type_basic}}|{{struct_like}})'
      set: [test_specifier_scope_context_type_start, type_basic_and_aggregate_context]

  test_specifier_scope_context_modifier_start:
    - meta_scope: meta.test_specifier_modifier
    - include: fallpop

  test_specifier_scope_context_type_start:
    - meta_scope: meta.test_specifier_type
    - include: fallpop

  type_modifier_context:
    - include: type_modifiers
    - include: fallpop

# basic and aggregate

  type_basic_and_aggregate_context:
    - include: type_basic_fragment
    - include: test_struct_like_fragment
    - include: fallpop

  type_basic_context:
    - include: type_basic_fragment
    - include: fallpop

  type_basic_fragment:
    - match: '(?={{type_basic}})'
      set: [modifiers_after_type_basic_context, type_basic_fragment_content]

  type_basic_fragment_content:
    - include: basic_types
    - include: fallpop

  modifiers_after_type_basic_context:
    - match: '(?=\b(?:{{_type_qualifiers}}|{{_compiler_directives}}|{{_type_modifiers}})\b)'
      set: [type_basic_context, type_modifier_context]
    - include: fallpop

# test struct like

  test_struct_like_fragment:
    - match: '(?={{struct_like}})'
      set: [type_modifier_context, test_struct_like_keyword]

  test_struct_like_keyword:
    - scope: storage.type.struct
      match: '\b(?:struct)\b'
      set: test_struct_like_after_keyword
    - scope: storage.type.union
      match: '\b(?:union)\b'
      set: test_struct_like_after_keyword
    - include: fallpop

  test_struct_like_after_keyword:
    - scope: invalid.illegal.identifier
      match: '{{identifier}}'
      set: test_struct_like_after_tag
    - include: test_struct_like_after_tag

  test_struct_like_after_tag:
    - match: '(?=\{)'
      set: [test_struct_like_block_end, test_struct_like_block_content, test_struct_like_block_begin]
    - include: fallpop

  test_struct_like_block_begin:
    - scope: punctuation.section.struct-like.begin
      match: '\{'
      pop: true

  test_struct_like_block_end:
    - scope: punctuation.section.struct-like.end
      match: '\}'
      pop: true

  test_struct_like_block_content:
    - include: test_declar
    - include: punctuation_terminators
    - include: fallpop

# util

  fallback:
    - scope: keyword.control
      match: '\b(?:{{_control_keywords}})\b'

    - include: basic_types
    - include: aggregate_types

    - scope: keyword.typedef
      match: '\b(?:typedef)\b'

    - include: type_modifiers
    - include: expr_fallback

  expr_fallback:
    - scope: keyword.operator.word
      match: '\b(?:{{_word_operators}})\b'

    - include: expr_literals
    
    - scope: punctuation
      match: '[\(\)\[\]\{\}]'
    - scope: punctuation.accessor
      match: '\.|\->'
    - include: punctuation_commas
    - include: punctuation_terminators
    - scope: keyword.operator
      match: '[\+\-\*\/\%\^\&\|\~\=\<\>\!]'

  expr_literals:
    - include: strings
    - include: numbers
    - include: constants

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

  aggregate_types:
    - scope: storage.type.aggregate.c
      match: '\b(?:{{_aggregate_types}})\b'

  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'

  punctuation_commas:
    - scope: punctuation.delimiter
      match: ','

  punctuation_terminators:
    - scope: punctuation.terminator
      match: ';'

  strings:
    - include: scope:source.c11#strings

  numbers:
    - include: scope:source.c11#numbers

  constants:
    - include: scope:source.c11#constants

  preprocessors:
    - include: scope:source.c11#preprocessors

  comments:
    - include: scope:source.c11#comments



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