@willbooster/tree-sitter-c 1.2.0 → 1.4.0

package/README.md

@@ -57,8 +57,8 @@ const parser = new Parser();
 parser.setLanguage(await Language.load(c));
 ```
 
-The package also ships `grammar.js`, the queries in `queries/`, and the node types in `src/node-types.json` for grammars
-extending C (such as C++).
+The package also ships `grammar.js`, the scanner sources `src/scanner.c` and `src/pragma.h`, the queries in `queries/`,
+and the node types in `src/node-types.json` for grammars extending C (such as C++).
 
 In Rust, depend on the [crate](https://crates.io/crates/willbooster-tree-sitter-c) and on
 [willbooster-tree-sitter](https://crates.io/crates/willbooster-tree-sitter), the runtime this package is tested and

package/grammar.js

@@ -35,19 +35,28 @@ const PREC = {
   SUBSCRIPT: 17,
 };
 
+const LINE_COMMENT = seq('//', /(\\+(.|\r?\n)|[^\\\n])*/);
+const PRAGMA_SPACING = repeat(choice(/\s/, /\\\r?\n/));
+
 // oxlint-disable-next-line unicorn/prefer-module -- This package is CommonJS, so tree-sitter loads grammar.js as CommonJS.
 module.exports = Object.assign(
   grammar({
     name: 'c',
 
     conflicts: ($) => [
+      [$._declaration_modifiers, $._empty_declaration],
+      [$.declaration, $.storage_class_specifier],
+      [$.sized_type_specifier, $.enum_specifier],
       [$.type_specifier, $._declarator],
       [$.type_specifier, $._declarator, $.macro_type_specifier],
       [$.type_specifier, $.expression],
       [$.type_specifier, $.expression, $.macro_type_specifier],
       [$.type_specifier, $.macro_type_specifier],
       [$.type_specifier, $.sized_type_specifier],
+      [$.type_specifier, $._sized_bit_int_specifier],
       [$.sized_type_specifier],
+      [$._sized_bit_int_specifier],
+      [$.sized_type_specifier, $._sized_bit_int_specifier],
       [$.attributed_statement],
       [$._declaration_modifiers, $.attributed_statement],
       [$.enum_specifier],
@@ -58,9 +67,14 @@ module.exports = Object.assign(
       [$._top_level_item, $._top_level_statement],
       [$.type_specifier, $._top_level_expression_statement],
       [$.type_qualifier, $.extension_expression],
+      [$.storage_class_specifier, $.type_specifier],
+      [$._compound_literal_storage_class_specifier, $.type_specifier],
+      [$._compound_literal_constexpr_specifier, $.type_qualifier],
     ],
 
-    extras: ($) => [/\s|\\\r?\n/, $.comment],
+    externals: () => [sym('pragma_operator'), sym('preproc_arg'), sym('_preproc_newline')],
+
+    extras: ($) => [$.pragma_operator, /\s|\\\r?\n/, $.comment],
 
     inline: ($) => [
       $._type_identifier,
@@ -123,6 +137,23 @@ module.exports = Object.assign(
           $.preproc_call
         ),
 
+      // Derived grammars that replace externals still need this lexical fallback. Comment-rich spacing makes the
+      // lexer too large for the pinned Node Wasm optimizer; the external scanner handles those forms.
+      pragma_operator: () =>
+        token(
+          seq(
+            '_Pragma',
+            PRAGMA_SPACING,
+            '(',
+            PRAGMA_SPACING,
+            optional(choice('L', 'u8', 'u', 'U')),
+            '"',
+            repeat(choice(/[^\\"\n]/, seq('\\', choice(/./, /\r?\n/)))),
+            '"',
+            PRAGMA_SPACING,
+            ')'
+          )
+        ),
       // Preprocesser
 
       preproc_include: ($) =>
@@ -137,7 +168,7 @@ module.exports = Object.assign(
               alias($.preproc_call_expression, $.call_expression)
             )
           ),
-          token.immediate(/\r?\n/)
+          sym('_preproc_newline')
         ),
 
       preproc_def: ($) =>
@@ -145,7 +176,7 @@ module.exports = Object.assign(
           preprocessor('define'),
           field('name', $.identifier),
           field('value', optional($.preproc_arg)),
-          token.immediate(/\r?\n/)
+          sym('_preproc_newline')
         ),
 
       preproc_function_def: ($) =>
@@ -154,7 +185,7 @@ module.exports = Object.assign(
           field('name', $.identifier),
           field('parameters', $.preproc_params),
           field('value', optional($.preproc_arg)),
-          token.immediate(/\r?\n/)
+          sym('_preproc_newline')
         ),
 
       preproc_params: ($) => seq(token.immediate('('), commaSep(choice($.identifier, '...')), ')'),
@@ -163,7 +194,7 @@ module.exports = Object.assign(
         seq(
           field('directive', $.preproc_directive),
           field('argument', optional($.preproc_arg)),
-          token.immediate(/\r?\n/)
+          sym('_preproc_newline')
         ),
 
       ...preprocIf('', () => sym('_block_item')),
@@ -171,6 +202,8 @@ module.exports = Object.assign(
       ...preprocIf('_in_enumerator_list', () => seq(sym('enumerator'), ',')),
       ...preprocIf('_in_enumerator_list_no_comma', () => sym('enumerator'), -1),
 
+      _preproc_newline: () => token.immediate(/\r?\n/),
+
       preproc_arg: () => token(prec(-1, /\S([^/\n]|\/[^*]|\\\r?\n)*/)),
       preproc_directive: () => /#[ \t]*[a-zA-Z0-9]\w*/,
 
@@ -203,7 +236,8 @@ module.exports = Object.assign(
           seq(field('function', $.identifier), field('arguments', alias($.preproc_argument_list, $.argument_list)))
         ),
 
-      preproc_argument_list: ($) => seq('(', commaSep($._preproc_expression), ')'),
+      preproc_argument_list: ($) =>
+        seq('(', commaSep(choice($._preproc_expression, $.system_lib_string, $.string_literal)), ')'),
 
       preproc_binary_expression: ($) => {
         /** @type {[string, number][]} */
@@ -264,7 +298,17 @@ module.exports = Object.assign(
 
       declaration: ($) =>
         seq(
-          $._declaration_specifiers,
+          choice(
+            $._declaration_specifiers,
+            prec.dynamic(
+              PREC.PAREN_DECLARATOR - 1,
+              seq(
+                repeat($._declaration_modifiers),
+                alias('auto', $.storage_class_specifier),
+                repeat($._declaration_modifiers)
+              )
+            )
+          ),
           commaSep1(
             field(
               'declarator',
@@ -560,6 +604,7 @@ module.exports = Object.assign(
           '__inline__',
           '__forceinline',
           'thread_local',
+          '_Thread_local',
           '__thread'
         ),
 
@@ -585,26 +630,29 @@ module.exports = Object.assign(
           $.struct_specifier,
           $.union_specifier,
           $.enum_specifier,
+          $.typeof_specifier,
+          $.bit_int_specifier,
           $.macro_type_specifier,
           $.sized_type_specifier,
+          alias($._sized_bit_int_specifier, $.sized_type_specifier),
           $.primitive_type,
-          $._type_identifier
+          $._type_identifier,
+          prec.dynamic(-1, alias('thread_local', sym('type_identifier')))
         ),
 
-      sized_type_specifier: ($) =>
-        choice(
-          seq(
-            repeat(choice('signed', 'unsigned', 'long', 'short')),
-            field('type', optional(choice(prec.dynamic(-1, $._type_identifier), $.primitive_type))),
-            repeat1(choice('signed', 'unsigned', 'long', 'short'))
-          ),
-          seq(
-            repeat1(choice('signed', 'unsigned', 'long', 'short')),
-            repeat($.type_qualifier),
-            field('type', optional(choice(prec.dynamic(-1, $._type_identifier), $.primitive_type))),
-            repeat(choice('signed', 'unsigned', 'long', 'short'))
-          )
+      typeof_specifier: ($) =>
+        seq(
+          choice('typeof', 'typeof_unqual', '__typeof__', '__typeof', '__typeof_unqual', '__typeof_unqual__'),
+          '(',
+          choice($.type_descriptor, $.expression, $.comma_expression),
+          ')'
         ),
+      bit_int_specifier: ($) => seq('_BitInt', '(', $.expression, ')'),
+
+      sized_type_specifier: ($) =>
+        sizedTypeSpecifier(optional(choice(prec.dynamic(-1, $._type_identifier), $.primitive_type))),
+
+      _sized_bit_int_specifier: ($) => sizedTypeSpecifier($.bit_int_specifier),
 
       primitive_type: () =>
         token(
@@ -635,10 +683,29 @@ module.exports = Object.assign(
           choice(
             seq(
               field('name', $._type_identifier),
-              optional(seq(':', field('underlying_type', $.primitive_type))),
+              optional(
+                seq(
+                  ':',
+                  field(
+                    'underlying_type',
+                    choice($.primitive_type, $.sized_type_specifier, $.typeof_specifier, $._type_identifier)
+                  )
+                )
+              ),
               field('body', optional($.enumerator_list))
             ),
-            field('body', $.enumerator_list)
+            seq(
+              optional(
+                seq(
+                  ':',
+                  field(
+                    'underlying_type',
+                    choice($.primitive_type, $.sized_type_specifier, $.typeof_specifier, $._type_identifier)
+                  )
+                )
+              ),
+              field('body', $.enumerator_list)
+            )
           ),
           optional($.attribute_specifier)
         ),
@@ -828,7 +895,15 @@ module.exports = Object.assign(
 
       continue_statement: () => seq('continue', ';'),
 
-      goto_statement: ($) => seq('goto', field('label', $._statement_identifier), ';'),
+      goto_statement: ($) =>
+        seq(
+          'goto',
+          choice(
+            field('label', $._statement_identifier),
+            seq('*', field('label', choice($.expression, $.comma_expression)))
+          ),
+          ';'
+        ),
 
       seh_try_statement: ($) =>
         seq('__try', field('body', $.compound_statement), choice($.seh_except_clause, $.seh_finally_clause)),
@@ -861,6 +936,7 @@ module.exports = Object.assign(
           $.field_expression,
           $.compound_literal_expression,
           $.identifier,
+          alias('thread_local', $.identifier),
           $.number_literal,
           $._string,
           $.true,
@@ -1074,12 +1150,69 @@ module.exports = Object.assign(
         ),
 
       compound_literal_expression: ($) =>
-        seq('(', field('type', $.type_descriptor), ')', field('value', $.initializer_list)),
+        seq(
+          '(',
+          repeat(
+            seq(
+              optional(
+                field('storage_class', alias($._compound_literal_constexpr_specifier, $.storage_class_specifier))
+              ),
+              field('storage_class', alias($._compound_literal_storage_class_specifier, $.storage_class_specifier))
+            )
+          ),
+          field('type', $.type_descriptor),
+          ')',
+          field('value', $.initializer_list)
+        ),
+
+      _compound_literal_constexpr_specifier: () => 'constexpr',
+
+      _compound_literal_storage_class_specifier: () =>
+        choice('static', 'register', 'thread_local', '_Thread_local', '__thread'),
 
       parenthesized_expression: ($) => seq('(', choice($.expression, $.comma_expression, $.compound_statement), ')'),
 
-      initializer_list: ($) =>
-        seq('{', commaSep(choice($.initializer_pair, $.expression, $.initializer_list)), optional(','), '}'),
+      initializer_list: ($) => seq('{', optional($._initializer_sequence), '}'),
+
+      _initializer_sequence: ($) =>
+        choice(
+          seq(
+            $._initializer_element,
+            optional(choice(seq(',', optional($._initializer_sequence)), $._initializer_directives))
+          ),
+          $._initializer_directives
+        ),
+
+      _initializer_directives: ($) =>
+        seq(
+          $._initializer_directive,
+          optional(choice($._initializer_sequence, seq(',', optional($._initializer_sequence))))
+        ),
+
+      _initializer_directive: ($) =>
+        choice(
+          alias(sym('preproc_if_in_initializer_list'), sym('preproc_if')),
+          alias(sym('preproc_ifdef_in_initializer_list'), sym('preproc_ifdef')),
+          $.preproc_def,
+          $.preproc_function_def,
+          alias($._initializer_preproc_call, $.preproc_call)
+        ),
+
+      _initializer_element: ($) => choice($.initializer_pair, $.expression, $.initializer_list),
+
+      _initializer_branch: ($) => choice(seq(',', optional($._initializer_sequence)), $._initializer_sequence),
+
+      _initializer_preproc_call: ($) =>
+        seq(
+          field(
+            'directive',
+            alias(token(/#[ \t]*(embed|include|undef|error|warning|line|pragma)/), $.preproc_directive)
+          ),
+          field('argument', optional($.preproc_arg)),
+          alias(sym('_preproc_newline'), '\n')
+        ),
+
+      ...preprocIf('_in_initializer_list', () => sym('_initializer_branch'), 0, false),
 
       initializer_pair: ($) =>
         choice(
@@ -1153,7 +1286,22 @@ module.exports = Object.assign(
 
       escape_sequence: () =>
         token(
-          prec(1, seq('\\', choice(/[^xuU]/, /\d{2,3}/, /x[0-9a-fA-F]{1,4}/, /u[0-9a-fA-F]{4}/, /U[0-9a-fA-F]{8}/)))
+          prec(
+            1,
+            seq(
+              '\\',
+              choice(
+                /[^xuU]/,
+                /[xu]\{[0-9a-fA-F]+\}/,
+                /o\{[0-7]+\}/,
+                /N\{[^}\n]+\}/,
+                /\d{2,3}/,
+                /x[0-9a-fA-F]{1,4}/,
+                /u[0-9a-fA-F]{4}/,
+                /U[0-9a-fA-F]{8}/
+              )
+            )
+          )
         ),
 
       system_lib_string: () => token(seq('<', repeat(choice(/[^>\n]/, String.raw`\>`)), '>')),
@@ -1169,18 +1317,29 @@ module.exports = Object.assign(
       _field_identifier: ($) => alias($.identifier, sym('field_identifier')),
       _statement_identifier: ($) => alias($.identifier, sym('statement_identifier')),
 
-      _empty_declaration: ($) => seq($.type_specifier, ';'),
+      _empty_declaration: ($) => seq(repeat($.ms_declspec_modifier), $.type_specifier, ';'),
 
       macro_type_specifier: ($) =>
         prec.dynamic(-1, seq(field('name', $.identifier), '(', field('type', $.type_descriptor), ')')),
 
       // http://stackoverflow.com/questions/13014947/regex-to-match-a-c-style-multiline-comment/36328890#36328890
-      comment: () => token(choice(seq('//', /(\\+(.|\r?\n)|[^\\\n])*/), seq('/*', /[^*]*\*+([^/*][^*]*\*+)*/, '/'))),
+      comment: () => token(choice(LINE_COMMENT, seq('/*', /[^*]*\*+([^/*][^*]*\*+)*/, '/'))),
     },
   }),
   { PREC, preprocIf, preprocessor, commaSep, commaSep1 }
 );
 
+/**
+ * @param {import('./types/treeSitterDsl').RuleOrLiteral} type
+ */
+function sizedTypeSpecifier(type) {
+  const modifier = choice('signed', 'unsigned', 'long', 'short', '_Complex', '_Imaginary', '__complex__');
+  return choice(
+    seq(repeat(modifier), field('type', type), repeat1(modifier)),
+    seq(repeat1(modifier), repeat(sym('type_qualifier')), field('type', type), repeat(modifier))
+  );
+}
+
 /**
  *
  * @param {string} suffix
@@ -1188,10 +1347,11 @@ module.exports = Object.assign(
  * @param {import('./types/treeSitterDsl').RuleBuilder<string>} content
  *
  * @param {number} precedence
+ * @param {boolean} repeatContent
  *
  * @returns {import('./types/treeSitterDsl').RuleBuilders<string, string>}
  */
-function preprocIf(suffix, content, precedence = 0) {
+function preprocIf(suffix, content, precedence = 0, repeatContent = true) {
   function alternativeBlock() {
     return choice(
       suffix ? alias(sym('preproc_else' + suffix), sym('preproc_else')) : sym('preproc_else'),
@@ -1207,8 +1367,8 @@ function preprocIf(suffix, content, precedence = 0) {
         seq(
           preprocessor('if'),
           field('condition', sym('_preproc_expression')),
-          '\n',
-          repeat(content($)),
+          alias(sym('_preproc_newline'), '\n'),
+          repeatContent ? repeat(content($)) : optional(content($)),
           field('alternative', optional(alternativeBlock())),
           preprocessor('endif')
         )
@@ -1220,13 +1380,14 @@ function preprocIf(suffix, content, precedence = 0) {
         seq(
           choice(preprocessor('ifdef'), preprocessor('ifndef')),
           field('name', sym('identifier')),
-          repeat(content($)),
+          repeatContent ? repeat(content($)) : optional(content($)),
           field('alternative', optional(alternativeBlock())),
           preprocessor('endif')
         )
       ),
 
-    ['preproc_else' + suffix]: ($) => prec(precedence, seq(preprocessor('else'), repeat(content($)))),
+    ['preproc_else' + suffix]: ($) =>
+      prec(precedence, seq(preprocessor('else'), repeatContent ? repeat(content($)) : optional(content($)))),
 
     ['preproc_elif' + suffix]: ($) =>
       prec(
@@ -1234,8 +1395,8 @@ function preprocIf(suffix, content, precedence = 0) {
         seq(
           preprocessor('elif'),
           field('condition', sym('_preproc_expression')),
-          '\n',
-          repeat(content($)),
+          alias(sym('_preproc_newline'), '\n'),
+          repeatContent ? repeat(content($)) : optional(content($)),
           field('alternative', optional(alternativeBlock()))
         )
       ),
@@ -1246,7 +1407,7 @@ function preprocIf(suffix, content, precedence = 0) {
         seq(
           choice(preprocessor('elifdef'), preprocessor('elifndef')),
           field('name', sym('identifier')),
-          repeat(content($)),
+          repeatContent ? repeat(content($)) : optional(content($)),
           field('alternative', optional(alternativeBlock()))
         )
       ),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-c",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "C grammar for tree-sitter",
   "keywords": [
     "incremental",
@@ -20,7 +20,9 @@
     "queries/*.scm",
     "src/node-types.json",
     "tree-sitter.json",
-    "*.wasm"
+    "*.wasm",
+    "src/pragma.h",
+    "src/scanner.c"
   ],
   "scripts": {
     "build-wasm": "script/tree-sitter build --wasm",

package/queries/highlights.scm

@@ -3,6 +3,9 @@
 ((identifier) @constant
  (#match? @constant "^[A-Z][A-Z\\d_]*$"))
 
+((storage_class_specifier) @keyword
+ (#eq? @keyword "auto"))
+"_Thread_local" @keyword
 "break" @keyword
 "case" @keyword
 "const" @keyword
@@ -79,3 +82,8 @@
   name: (identifier) @function.special)
 
 (comment) @comment
+
+(typeof_specifier
+  ["typeof" "typeof_unqual" "__typeof__" "__typeof" "__typeof_unqual" "__typeof_unqual__"] @keyword)
+(bit_int_specifier "_BitInt" @type)
+(pragma_operator) @keyword

package/src/node-types.json

@@ -303,6 +303,10 @@
     "type": "type_specifier",
     "named": true,
     "subtypes": [
+      {
+        "type": "bit_int_specifier",
+        "named": true
+      },
       {
         "type": "enum_specifier",
         "named": true
@@ -327,6 +331,10 @@
         "type": "type_identifier",
         "named": true
       },
+      {
+        "type": "typeof_specifier",
+        "named": true
+      },
       {
         "type": "union_specifier",
         "named": true
@@ -506,6 +514,10 @@
         {
           "type": "preproc_defined",
           "named": true
+        },
+        {
+          "type": "system_lib_string",
+          "named": true
         }
       ]
     }
@@ -878,6 +890,21 @@
       }
     }
   },
+  {
+    "type": "bit_int_specifier",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "expression",
+          "named": true
+        }
+      ]
+    }
+  },
   {
     "type": "bitfield_clause",
     "named": true,
@@ -1118,6 +1145,16 @@
     "type": "compound_literal_expression",
     "named": true,
     "fields": {
+      "storage_class": {
+        "multiple": true,
+        "required": false,
+        "types": [
+          {
+            "type": "storage_class_specifier",
+            "named": true
+          }
+        ]
+      },
       "type": {
         "multiple": false,
         "required": true,
@@ -1160,6 +1197,10 @@
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -1311,7 +1352,7 @@
       },
       "type": {
         "multiple": false,
-        "required": true,
+        "required": false,
         "types": [
           {
             "type": "type_specifier",
@@ -1367,6 +1408,10 @@
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -1478,6 +1523,18 @@
           {
             "type": "primitive_type",
             "named": true
+          },
+          {
+            "type": "sized_type_specifier",
+            "named": true
+          },
+          {
+            "type": "type_identifier",
+            "named": true
+          },
+          {
+            "type": "typeof_specifier",
+            "named": true
           }
         ]
       }
@@ -2156,6 +2213,14 @@
         "multiple": false,
         "required": true,
         "types": [
+          {
+            "type": "comma_expression",
+            "named": true
+          },
+          {
+            "type": "expression",
+            "named": true
+          },
           {
             "type": "statement_identifier",
             "named": true
@@ -2249,6 +2314,26 @@
         {
           "type": "initializer_pair",
           "named": true
+        },
+        {
+          "type": "preproc_call",
+          "named": true
+        },
+        {
+          "type": "preproc_def",
+          "named": true
+        },
+        {
+          "type": "preproc_function_def",
+          "named": true
+        },
+        {
+          "type": "preproc_if",
+          "named": true
+        },
+        {
+          "type": "preproc_ifdef",
+          "named": true
         }
       ]
     }
@@ -2875,6 +2960,10 @@
           "type": "enumerator",
           "named": true
         },
+        {
+          "type": "expression",
+          "named": true
+        },
         {
           "type": "field_declaration",
           "named": true
@@ -2883,10 +2972,22 @@
           "type": "function_definition",
           "named": true
         },
+        {
+          "type": "initializer_list",
+          "named": true
+        },
+        {
+          "type": "initializer_pair",
+          "named": true
+        },
         {
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -2971,6 +3072,10 @@
           "type": "enumerator",
           "named": true
         },
+        {
+          "type": "expression",
+          "named": true
+        },
         {
           "type": "field_declaration",
           "named": true
@@ -2979,10 +3084,22 @@
           "type": "function_definition",
           "named": true
         },
+        {
+          "type": "initializer_list",
+          "named": true
+        },
+        {
+          "type": "initializer_pair",
+          "named": true
+        },
         {
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -3038,6 +3155,10 @@
           "type": "enumerator",
           "named": true
         },
+        {
+          "type": "expression",
+          "named": true
+        },
         {
           "type": "field_declaration",
           "named": true
@@ -3046,10 +3167,22 @@
           "type": "function_definition",
           "named": true
         },
+        {
+          "type": "initializer_list",
+          "named": true
+        },
+        {
+          "type": "initializer_pair",
+          "named": true
+        },
         {
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -3198,6 +3331,10 @@
           "type": "enumerator",
           "named": true
         },
+        {
+          "type": "expression",
+          "named": true
+        },
         {
           "type": "field_declaration",
           "named": true
@@ -3206,10 +3343,22 @@
           "type": "function_definition",
           "named": true
         },
+        {
+          "type": "initializer_list",
+          "named": true
+        },
+        {
+          "type": "initializer_pair",
+          "named": true
+        },
         {
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -3294,6 +3443,10 @@
           "type": "enumerator",
           "named": true
         },
+        {
+          "type": "expression",
+          "named": true
+        },
         {
           "type": "field_declaration",
           "named": true
@@ -3302,10 +3455,22 @@
           "type": "function_definition",
           "named": true
         },
+        {
+          "type": "initializer_list",
+          "named": true
+        },
+        {
+          "type": "initializer_pair",
+          "named": true
+        },
         {
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -3492,6 +3657,10 @@
         "multiple": false,
         "required": false,
         "types": [
+          {
+            "type": "bit_int_specifier",
+            "named": true
+          },
           {
             "type": "primitive_type",
             "named": true
@@ -3762,6 +3931,10 @@
           "type": "linkage_specification",
           "named": true
         },
+        {
+          "type": "ms_declspec_modifier",
+          "named": true
+        },
         {
           "type": "preproc_call",
           "named": true
@@ -3900,6 +4073,29 @@
       ]
     }
   },
+  {
+    "type": "typeof_specifier",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "comma_expression",
+          "named": true
+        },
+        {
+          "type": "expression",
+          "named": true
+        },
+        {
+          "type": "type_descriptor",
+          "named": true
+        }
+      ]
+    }
+  },
   {
     "type": "unary_expression",
     "named": true,
@@ -4299,10 +4495,22 @@
     "type": "_Atomic",
     "named": false
   },
+  {
+    "type": "_BitInt",
+    "named": false
+  },
+  {
+    "type": "_Complex",
+    "named": false
+  },
   {
     "type": "_Generic",
     "named": false
   },
+  {
+    "type": "_Imaginary",
+    "named": false
+  },
   {
     "type": "_Nonnull",
     "named": false
@@ -4311,6 +4519,10 @@
     "type": "_Noreturn",
     "named": false
   },
+  {
+    "type": "_Thread_local",
+    "named": false
+  },
   {
     "type": "__alignof",
     "named": false
@@ -4351,6 +4563,10 @@
     "type": "__clrcall",
     "named": false
   },
+  {
+    "type": "__complex__",
+    "named": false
+  },
   {
     "type": "__declspec",
     "named": false
@@ -4415,6 +4631,22 @@
     "type": "__try",
     "named": false
   },
+  {
+    "type": "__typeof",
+    "named": false
+  },
+  {
+    "type": "__typeof__",
+    "named": false
+  },
+  {
+    "type": "__typeof_unqual",
+    "named": false
+  },
+  {
+    "type": "__typeof_unqual__",
+    "named": false
+  },
   {
     "type": "__unaligned",
     "named": false
@@ -4568,6 +4800,11 @@
     "type": "offsetof",
     "named": false
   },
+  {
+    "type": "pragma_operator",
+    "named": true,
+    "extra": true
+  },
   {
     "type": "preproc_arg",
     "named": true
@@ -4644,6 +4881,14 @@
     "type": "typedef",
     "named": false
   },
+  {
+    "type": "typeof",
+    "named": false
+  },
+  {
+    "type": "typeof_unqual",
+    "named": false
+  },
   {
     "type": "u\"",
     "named": false

package/src/pragma.h

@@ -0,0 +1,130 @@
+#ifndef TREE_SITTER_C_PRAGMA_H_
+#define TREE_SITTER_C_PRAGMA_H_
+
+#include "tree_sitter/parser.h"
+
+static bool scan_pragma_spacing(TSLexer *lexer);
+static bool pragma_space(int32_t c);
+static bool scan_pragma_word(TSLexer *lexer);
+
+static bool scan_pragma(TSLexer *lexer) {
+    while (pragma_space(lexer->lookahead)) {
+        lexer->advance(lexer, true);
+    }
+    if (!scan_pragma_word(lexer)) return false;
+    if (!scan_pragma_spacing(lexer) || lexer->lookahead != '(') return false;
+    lexer->advance(lexer, false);
+    if (!scan_pragma_spacing(lexer)) return false;
+    if (lexer->lookahead == 'L' || lexer->lookahead == 'u' || lexer->lookahead == 'U') {
+        bool utf8 = lexer->lookahead == 'u';
+        lexer->advance(lexer, false);
+        if (utf8 && lexer->lookahead == '8') lexer->advance(lexer, false);
+    }
+    if (lexer->lookahead != '"') return false;
+    lexer->advance(lexer, false);
+    while (lexer->lookahead != '"') {
+        if (lexer->eof(lexer) || lexer->lookahead == '\n' || lexer->lookahead == '\r') return false;
+        if (lexer->lookahead == '\\') {
+            lexer->advance(lexer, false);
+            if (lexer->eof(lexer)) return false;
+            if (lexer->lookahead == '\r') {
+                lexer->advance(lexer, false);
+                if (lexer->lookahead != '\n') return false;
+            }
+        }
+        lexer->advance(lexer, false);
+    }
+    lexer->advance(lexer, false);
+    if (!scan_pragma_spacing(lexer) || lexer->lookahead != ')') return false;
+    lexer->advance(lexer, false);
+    lexer->mark_end(lexer);
+    return true;
+}
+
+static bool scan_pragma_spacing(TSLexer *lexer) {
+    for (;;) {
+        if (pragma_space(lexer->lookahead)) {
+            lexer->advance(lexer, false);
+        } else if (lexer->lookahead == '\\') {
+            lexer->advance(lexer, false);
+            if (lexer->lookahead == '\r') lexer->advance(lexer, false);
+            if (lexer->lookahead != '\n') return false;
+            lexer->advance(lexer, false);
+        } else if (lexer->lookahead == '/') {
+            lexer->advance(lexer, false);
+            if (lexer->lookahead == '/') {
+                lexer->advance(lexer, false);
+                while (!lexer->eof(lexer) && lexer->lookahead != '\n') {
+                    if (lexer->lookahead == '\\') {
+                        do {
+                            lexer->advance(lexer, false);
+                        } while (lexer->lookahead == '\\');
+                        if (lexer->lookahead == '\r') lexer->advance(lexer, false);
+                        if (lexer->eof(lexer)) return false;
+                    }
+                    lexer->advance(lexer, false);
+                }
+            } else if (lexer->lookahead == '*') {
+                lexer->advance(lexer, false);
+                bool star = false;
+                for (;;) {
+                    if (lexer->eof(lexer)) return false;
+                    if (star && lexer->lookahead == '/') {
+                        lexer->advance(lexer, false);
+                        break;
+                    }
+                    star = lexer->lookahead == '*';
+                    lexer->advance(lexer, false);
+                }
+            } else {
+                return false;
+            }
+        } else {
+            return true;
+        }
+    }
+}
+
+static bool scan_pragma_preproc_arg(TSLexer *lexer) {
+    while (pragma_space(lexer->lookahead) && lexer->lookahead != '\n' && lexer->lookahead != '\r') {
+        lexer->advance(lexer, true);
+    }
+    if (!scan_pragma_word(lexer)) return false;
+    bool backslash = false;
+    lexer->mark_end(lexer);
+    while (!lexer->eof(lexer)) {
+        if (lexer->lookahead == '\n') {
+            if (!backslash) break;
+            lexer->advance(lexer, false);
+            backslash = false;
+        } else if (lexer->lookahead == '/') {
+            lexer->advance(lexer, false);
+            if (lexer->lookahead == '*') break;
+            if (lexer->eof(lexer)) break;
+            backslash = lexer->lookahead == '\\';
+            lexer->advance(lexer, false);
+        } else {
+            if (lexer->lookahead != '\r') backslash = lexer->lookahead == '\\';
+            lexer->advance(lexer, false);
+        }
+        lexer->mark_end(lexer);
+    }
+    return true;
+}
+
+static bool scan_pragma_word(TSLexer *lexer) {
+    const char *word = "_Pragma";
+    for (; *word; word++) {
+        if (lexer->lookahead != *word) return false;
+        lexer->advance(lexer, false);
+    }
+    return true;
+}
+
+static bool pragma_space(int32_t c) {
+    return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f' || c == '\v' ||
+           c == 0x85 || c == 0xA0 || c == 0x1680 || (c >= 0x2000 && c <= 0x200A) ||
+           c == 0x2028 || c == 0x2029 || c == 0x202F || c == 0x205F || c == 0x3000;
+}
+
+#endif

package/src/scanner.c

@@ -0,0 +1,45 @@
+#include "pragma.h"
+
+enum TokenType { PRAGMA_OPERATOR, PREPROC_ARG, PREPROC_NEWLINE };
+
+void *tree_sitter_c_external_scanner_create(void) {
+    return NULL;
+}
+
+void tree_sitter_c_external_scanner_destroy(void *payload) {
+    (void)payload;
+}
+
+unsigned tree_sitter_c_external_scanner_serialize(void *payload, char *buffer) {
+    (void)payload;
+    (void)buffer;
+    return 0;
+}
+
+void tree_sitter_c_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
+    (void)payload;
+    (void)buffer;
+    (void)length;
+}
+
+bool tree_sitter_c_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
+    (void)payload;
+    if (valid_symbols[PREPROC_NEWLINE]) {
+        while (pragma_space(lexer->lookahead) && lexer->lookahead != '\n' && lexer->lookahead != '\r') {
+            lexer->advance(lexer, true);
+        }
+        if (lexer->lookahead == '\r') lexer->advance(lexer, false);
+        if (lexer->lookahead == '\n') {
+            lexer->advance(lexer, false);
+            lexer->mark_end(lexer);
+            lexer->result_symbol = PREPROC_NEWLINE;
+            return true;
+        }
+    }
+    if (valid_symbols[PREPROC_ARG]) {
+        lexer->result_symbol = PREPROC_ARG;
+        return scan_pragma_preproc_arg(lexer);
+    }
+    lexer->result_symbol = PRAGMA_OPERATOR;
+    return valid_symbols[PRAGMA_OPERATOR] && scan_pragma(lexer);
+}

package/tree-sitter.json

@@ -16,7 +16,7 @@
     }
   ],
   "metadata": {
-    "version": "1.2.0",
+    "version": "1.4.0",
     "license": "MIT",
     "description": "C grammar for tree-sitter",
     "authors": [