tree-sitter-sed 0.3.0 → 0.4.0

package/CMakeLists.txt

@@ -0,0 +1,121 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(
+  tree-sitter-sed
+  VERSION 0.4.0
+  DESCRIPTION "Tree-sitter grammars for POSIX sed."
+  HOMEPAGE_URL "https://github.com/konomanoasa/tree-sitter-sed"
+  LANGUAGES C
+)
+
+option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
+option(TREE_SITTER_REUSE_ALLOCATOR "Reuse the Tree-sitter allocator" OFF)
+
+file(
+  STRINGS src/parser.c
+  TREE_SITTER_ABI_DEFINITION
+  REGEX "^#define LANGUAGE_VERSION [0-9]+$"
+)
+file(
+  STRINGS sed_ere/src/parser.c
+  TREE_SITTER_ERE_ABI_DEFINITION
+  REGEX "^#define LANGUAGE_VERSION [0-9]+$"
+)
+if(
+  NOT TREE_SITTER_ABI_DEFINITION MATCHES "^#define LANGUAGE_VERSION [0-9]+$"
+  OR NOT TREE_SITTER_ERE_ABI_DEFINITION MATCHES
+    "^#define LANGUAGE_VERSION [0-9]+$"
+)
+  message(FATAL_ERROR "Both parsers must define one LANGUAGE_VERSION")
+endif()
+if(NOT TREE_SITTER_ABI_DEFINITION STREQUAL TREE_SITTER_ERE_ABI_DEFINITION)
+  message(FATAL_ERROR "The sed and sed_ere parsers must use the same ABI")
+endif()
+string(
+  REGEX REPLACE "^#define LANGUAGE_VERSION " ""
+  TREE_SITTER_ABI_VERSION
+  "${TREE_SITTER_ABI_DEFINITION}"
+)
+
+include(GNUInstallDirs)
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  include(CTest)
+endif()
+
+add_library(
+  tree-sitter-sed
+  src/parser.c
+  src/scanner.c
+  sed_ere/src/parser.c
+  sed_ere/src/scanner.c
+)
+set_source_files_properties(
+  src/scanner.c
+  PROPERTIES INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/src"
+)
+set_source_files_properties(
+  sed_ere/src/scanner.c
+  PROPERTIES INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/sed_ere/src"
+)
+target_include_directories(
+  tree-sitter-sed
+  INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/bindings/c>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+target_compile_definitions(
+  tree-sitter-sed
+  PRIVATE
+    $<$<BOOL:${TREE_SITTER_REUSE_ALLOCATOR}>:TREE_SITTER_REUSE_ALLOCATOR>
+    $<$<CONFIG:Debug>:TREE_SITTER_DEBUG>
+)
+set_target_properties(
+  tree-sitter-sed
+  PROPERTIES
+    C_STANDARD 11
+    C_STANDARD_REQUIRED ON
+    DEFINE_SYMBOL ""
+    POSITION_INDEPENDENT_CODE ON
+    SOVERSION "${TREE_SITTER_ABI_VERSION}.${PROJECT_VERSION_MAJOR}"
+)
+
+if(BUILD_TESTING AND CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  add_executable(tree-sitter-sed-binding-test test/binding.test.c)
+  target_link_libraries(tree-sitter-sed-binding-test PRIVATE tree-sitter-sed)
+  add_test(
+    NAME tree-sitter-sed-binding
+    COMMAND tree-sitter-sed-binding-test
+  )
+endif()
+
+configure_file(
+  bindings/c/tree-sitter-sed.pc.in
+  "${CMAKE_CURRENT_BINARY_DIR}/tree-sitter-sed.pc"
+  @ONLY
+)
+
+install(
+  TARGETS tree-sitter-sed
+  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+)
+install(
+  DIRECTORY bindings/c/tree_sitter
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  FILES_MATCHING PATTERN "*.h"
+)
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/tree-sitter-sed.pc"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+)
+install(
+  DIRECTORY queries/
+  DESTINATION "${CMAKE_INSTALL_DATADIR}/tree-sitter/queries/sed"
+  FILES_MATCHING PATTERN "*.scm"
+)
+install(
+  DIRECTORY sed_ere/queries/
+  DESTINATION "${CMAKE_INSTALL_DATADIR}/tree-sitter/queries/sed_ere"
+  FILES_MATCHING PATTERN "*.scm"
+)

package/Makefile

@@ -0,0 +1,145 @@
+LANGUAGE_NAME := tree-sitter-sed
+HOMEPAGE_URL := https://github.com/konomanoasa/tree-sitter-sed
+VERSION := 0.4.0
+DESCRIPTION := Tree-sitter grammars for POSIX sed.
+
+PREFIX ?= /usr/local
+DATADIR ?= $(PREFIX)/share
+INCLUDEDIR ?= $(PREFIX)/include
+LIBDIR ?= $(PREFIX)/lib
+BINDIR ?= $(PREFIX)/bin
+PCLIBDIR ?= $(LIBDIR)/pkgconfig
+
+SOURCES := src/parser.c src/scanner.c \
+  sed_ere/src/parser.c sed_ere/src/scanner.c
+OBJECTS := $(SOURCES:.c=.o)
+MAKE_BUILD_DIR := build/make
+STATIC_LIBRARY := lib$(LANGUAGE_NAME).a
+PKG_CONFIG := $(LANGUAGE_NAME).pc
+TEST := $(MAKE_BUILD_DIR)/binding.test
+
+ARFLAGS := rcs
+override CFLAGS += -std=c11 -fPIC
+
+SONAME_MAJOR := $(shell sed -n 's/\#define LANGUAGE_VERSION //p' src/parser.c)
+SED_ERE_SONAME_MAJOR := $(shell sed -n 's/\#define LANGUAGE_VERSION //p' sed_ere/src/parser.c)
+SONAME_MINOR := $(word 1,$(subst ., ,$(VERSION)))
+
+ifeq ($(SONAME_MAJOR),)
+$(error Both parsers must define LANGUAGE_VERSION)
+endif
+ifneq ($(SONAME_MAJOR),$(SED_ERE_SONAME_MAJOR))
+$(error The sed and sed_ere parsers must use the same ABI)
+endif
+
+MACHINE := $(shell $(CC) -dumpmachine)
+
+ifneq ($(findstring darwin,$(MACHINE)),)
+SOEXT := dylib
+SOEXTVER_MAJOR := $(SONAME_MAJOR).$(SOEXT)
+SOEXTVER := $(SONAME_MAJOR).$(SONAME_MINOR).$(SOEXT)
+LINKSHARED := -dynamiclib -Wl,-install_name,$(LIBDIR)/lib$(LANGUAGE_NAME).$(SOEXTVER)
+else ifneq ($(findstring mingw32,$(MACHINE)),)
+SOEXT := dll
+LINKSHARED := -s -shared -Wl,--out-implib,lib$(LANGUAGE_NAME).dll.a
+TEST := $(MAKE_BUILD_DIR)/binding.test.exe
+else
+SOEXT := so
+SOEXTVER_MAJOR := $(SOEXT).$(SONAME_MAJOR)
+SOEXTVER := $(SOEXT).$(SONAME_MAJOR).$(SONAME_MINOR)
+LINKSHARED := -shared -Wl,-soname,lib$(LANGUAGE_NAME).$(SOEXTVER)
+ifneq ($(filter $(shell uname),FreeBSD NetBSD DragonFly),)
+PCLIBDIR := $(PREFIX)/libdata/pkgconfig
+endif
+endif
+
+SHARED_LIBRARY := lib$(LANGUAGE_NAME).$(SOEXT)
+
+all: $(STATIC_LIBRARY) $(SHARED_LIBRARY) $(PKG_CONFIG)
+
+$(STATIC_LIBRARY): $(OBJECTS)
+	$(AR) $(ARFLAGS) $@ $^
+
+$(SHARED_LIBRARY): $(OBJECTS)
+	$(CC) $(LDFLAGS) $(LINKSHARED) $^ $(LDLIBS) -o $@
+ifneq ($(STRIP),)
+	$(STRIP) $@
+endif
+
+$(PKG_CONFIG): bindings/c/$(LANGUAGE_NAME).pc.in FORCE
+	sed -e 's|@PROJECT_VERSION@|$(VERSION)|' \
+		-e 's|@CMAKE_INSTALL_LIBDIR@|$(LIBDIR:$(PREFIX)/%=%)|' \
+		-e 's|@CMAKE_INSTALL_INCLUDEDIR@|$(INCLUDEDIR:$(PREFIX)/%=%)|' \
+		-e 's|@PROJECT_DESCRIPTION@|$(DESCRIPTION)|' \
+		-e 's|@PROJECT_HOMEPAGE_URL@|$(HOMEPAGE_URL)|' \
+		-e 's|@CMAKE_INSTALL_PREFIX@|$(PREFIX)|' $< > $@
+
+src/parser.o: src/tree_sitter/parser.h
+src/scanner.o: common/scanner.h src/tree_sitter/alloc.h src/tree_sitter/parser.h
+src/scanner.o: CPPFLAGS += -Isrc
+sed_ere/src/parser.o: sed_ere/src/tree_sitter/parser.h
+sed_ere/src/scanner.o: common/scanner.h sed_ere/src/tree_sitter/alloc.h \
+  sed_ere/src/tree_sitter/parser.h
+sed_ere/src/scanner.o: CPPFLAGS += -Ised_ere/src
+
+$(MAKE_BUILD_DIR):
+	mkdir -p $@
+
+$(TEST): test/binding.test.c $(STATIC_LIBRARY) | $(MAKE_BUILD_DIR)
+	$(CC) $(CPPFLAGS) $(CFLAGS) -Ibindings/c $< $(STATIC_LIBRARY) $(LDFLAGS) $(LDLIBS) -o $@
+
+test: $(TEST)
+	./$(TEST)
+
+install: all
+	install -d '$(DESTDIR)$(DATADIR)'/tree-sitter/queries/sed \
+		'$(DESTDIR)$(DATADIR)'/tree-sitter/queries/sed_ere \
+		'$(DESTDIR)$(INCLUDEDIR)'/tree_sitter \
+		'$(DESTDIR)$(PCLIBDIR)' \
+		'$(DESTDIR)$(LIBDIR)'
+	install -m644 bindings/c/tree_sitter/$(LANGUAGE_NAME).h \
+		'$(DESTDIR)$(INCLUDEDIR)'/tree_sitter/$(LANGUAGE_NAME).h
+	install -m644 $(PKG_CONFIG) '$(DESTDIR)$(PCLIBDIR)'/$(PKG_CONFIG)
+	install -m644 $(STATIC_LIBRARY) '$(DESTDIR)$(LIBDIR)'/$(STATIC_LIBRARY)
+ifneq ($(findstring mingw32,$(MACHINE)),)
+	install -d '$(DESTDIR)$(BINDIR)'
+	install -m755 $(SHARED_LIBRARY) '$(DESTDIR)$(BINDIR)'/$(SHARED_LIBRARY)
+	install -m644 lib$(LANGUAGE_NAME).dll.a \
+		'$(DESTDIR)$(LIBDIR)'/lib$(LANGUAGE_NAME).dll.a
+else
+	install -m755 $(SHARED_LIBRARY) \
+		'$(DESTDIR)$(LIBDIR)'/lib$(LANGUAGE_NAME).$(SOEXTVER)
+	cd '$(DESTDIR)$(LIBDIR)' && \
+		ln -sf lib$(LANGUAGE_NAME).$(SOEXTVER) \
+			lib$(LANGUAGE_NAME).$(SOEXTVER_MAJOR)
+	cd '$(DESTDIR)$(LIBDIR)' && \
+		ln -sf lib$(LANGUAGE_NAME).$(SOEXTVER_MAJOR) $(SHARED_LIBRARY)
+endif
+	install -m644 queries/*.scm \
+		'$(DESTDIR)$(DATADIR)'/tree-sitter/queries/sed
+	install -m644 sed_ere/queries/*.scm \
+		'$(DESTDIR)$(DATADIR)'/tree-sitter/queries/sed_ere
+
+uninstall:
+	$(RM) '$(DESTDIR)$(LIBDIR)'/$(STATIC_LIBRARY) \
+		'$(DESTDIR)$(INCLUDEDIR)'/tree_sitter/$(LANGUAGE_NAME).h \
+		'$(DESTDIR)$(PCLIBDIR)'/$(PKG_CONFIG)
+ifneq ($(findstring mingw32,$(MACHINE)),)
+	$(RM) '$(DESTDIR)$(BINDIR)'/$(SHARED_LIBRARY) \
+		'$(DESTDIR)$(LIBDIR)'/lib$(LANGUAGE_NAME).dll.a
+else
+	$(RM) '$(DESTDIR)$(LIBDIR)'/lib$(LANGUAGE_NAME).$(SOEXTVER) \
+		'$(DESTDIR)$(LIBDIR)'/lib$(LANGUAGE_NAME).$(SOEXTVER_MAJOR) \
+		'$(DESTDIR)$(LIBDIR)'/$(SHARED_LIBRARY)
+endif
+	$(RM) -r '$(DESTDIR)$(DATADIR)'/tree-sitter/queries/sed \
+		'$(DESTDIR)$(DATADIR)'/tree-sitter/queries/sed_ere
+
+clean:
+	$(RM) $(OBJECTS) $(STATIC_LIBRARY) $(SHARED_LIBRARY) \
+		lib$(LANGUAGE_NAME).dll.a $(PKG_CONFIG)
+	$(RM) -r $(MAKE_BUILD_DIR)
+
+FORCE:
+
+.PHONY: all clean FORCE install test uninstall

package/README.md

@@ -14,7 +14,12 @@ npm install tree-sitter-sed
 
 ## Grammars
 
-This repository contains two grammars. You can find [`sed_ere`](sed_ere) here.
+This repository contains the following two grammars.
+
+| Grammar   | Regexp | C function              |
+| --------- | ------ | ----------------------- |
+| `sed`     | BRE    | `tree_sitter_sed()`     |
+| `sed_ere` | ERE    | `tree_sitter_sed_ere()` |
 
 ## Specifications
 

package/bindings/c/tree-sitter-sed.pc.in

@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: tree-sitter-sed
+Description: @PROJECT_DESCRIPTION@
+URL: @PROJECT_HOMEPAGE_URL@
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -ltree-sitter-sed
+Cflags: -I${includedir}

package/bindings/c/tree_sitter/tree-sitter-sed.h

@@ -0,0 +1,17 @@
+#ifndef TREE_SITTER_SED_H_
+#define TREE_SITTER_SED_H_
+
+typedef struct TSLanguage TSLanguage;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const TSLanguage *tree_sitter_sed(void);
+const TSLanguage *tree_sitter_sed_ere(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/common/dsl.js

@@ -2,6 +2,28 @@ function issueRuleName(id) {
   return `_${id}_issue`;
 }
 
+function outcomeRuleName(id) {
+  return `_${id}_outcome`;
+}
+
+function reasonRuleName(id) {
+  return `_${id}_reason`;
+}
+
+function defineIssueRules(definitions) {
+  const rules = {};
+
+  for (const definition of definitions) {
+    const { outcome, reason, rule } = definition;
+    const id = definition.id ?? reason;
+    rules[reasonRuleName(id)] = rule;
+    rules[outcomeRuleName(id)] = ($) => alias($[reasonRuleName(id)], $[reason]);
+    rules[issueRuleName(id)] = ($) => alias($[outcomeRuleName(id)], $[outcome]);
+  }
+
+  return rules;
+}
+
 function namedExternal($, external, name) {
   return alias(external, $[name]);
 }
@@ -14,4 +36,4 @@ function issueNode($, id) {
   return alias($[issueRuleName(id)], $.syntax_issue);
 }
 
-module.exports = { issueField, issueNode, issueRuleName, namedExternal };
+module.exports = { defineIssueRules, issueField, issueNode, namedExternal };

package/common/grammar.js

@@ -1,33 +1,11 @@
 const {
+  defineIssueRules,
   issueField,
   issueNode,
-  issueRuleName,
   namedExternal,
 } = require("./dsl");
 const regularExpressionRules = require("./regex");
 
-function outcomeRuleName(id) {
-  return `_${id}_outcome`;
-}
-
-function reasonRuleName(id) {
-  return `_${id}_reason`;
-}
-
-function defineIssueRules(definitions) {
-  const rules = {};
-
-  for (const definition of definitions) {
-    const { outcome, reason, rule } = definition;
-    const id = definition.id ?? reason;
-    rules[reasonRuleName(id)] = rule;
-    rules[outcomeRuleName(id)] = ($) => alias($[reasonRuleName(id)], $[reason]);
-    rules[issueRuleName(id)] = ($) => alias($[outcomeRuleName(id)], $[outcome]);
-  }
-
-  return rules;
-}
-
 function missingAtEndOrBoundary($, reason) {
   return choice(
     issueField($, reason),

package/common/scanner.h

@@ -1,5 +1,5 @@
-#ifndef TREE_SITTER_POSIX_SED_COMMON_SCANNER_H_
-#define TREE_SITTER_POSIX_SED_COMMON_SCANNER_H_
+#ifndef TREE_SITTER_SED_COMMON_SCANNER_H_
+#define TREE_SITTER_SED_COMMON_SCANNER_H_
 
 #ifndef SED_REGEX_EXTENDED
 #error "SED_REGEX_EXTENDED must be defined before including scanner.h"
@@ -246,6 +246,17 @@ enum {
   SCANNER_SERIALIZED_STATE_SIZE = 17,
 };
 
+enum {
+  SERIALIZED_AT_BRANCH_START_FLAG = 1 << 0,
+  SERIALIZED_AFTER_ALTERNATION_FLAG = 1 << 1,
+  SERIALIZED_AFTER_ANCHOR_FLAG = 1 << 2,
+  SERIALIZED_TEXT_STATE_SHIFT = 3,
+  SERIALIZED_MODE_FLAGS_MAXIMUM = 31,
+  SERIALIZED_RANGE_PENDING_FLAG = 1 << 0,
+  SERIALIZED_DUPLICATION_STATE_SHIFT = 1,
+  SERIALIZED_BRACKET_FLAGS_MAXIMUM = 7,
+};
+
 static void reset_bracket_tracking(ScannerState *state) {
   state->regex_bracket_term_state = REGEX_BRACKET_TERM_NONE;
   state->regex_bracket_pending_element = REGEX_BRACKET_PENDING_NONE;
@@ -315,10 +326,11 @@ static unsigned sed_scanner_serialize(void *payload, char *buffer) {
   buffer[0] = SCANNER_SERIALIZATION_VERSION;
   buffer[1] = (char)state->mode;
   buffer[2] = (char)state->regex_state;
-  buffer[3] = (state->regex_at_branch_start ? 1 : 0) |
-    (state->regex_after_alternation ? 2 : 0) |
-    (state->regex_after_anchor ? 4 : 0) |
-    ((unsigned char)state->text_state << 3);
+  buffer[3] =
+    (state->regex_at_branch_start ? SERIALIZED_AT_BRANCH_START_FLAG : 0) |
+    (state->regex_after_alternation ? SERIALIZED_AFTER_ALTERNATION_FLAG : 0) |
+    (state->regex_after_anchor ? SERIALIZED_AFTER_ANCHOR_FLAG : 0) |
+    ((unsigned char)state->text_state << SERIALIZED_TEXT_STATE_SHIFT);
   buffer[4] = (char)(delimiter & UINT32_C(0xff));
   buffer[5] = (char)((delimiter >> 8) & UINT32_C(0xff));
   buffer[6] = (char)((delimiter >> 16) & UINT32_C(0xff));
@@ -330,8 +342,10 @@ static unsigned sed_scanner_serialize(void *payload, char *buffer) {
   buffer[13] = (char)state->regex_bracket_first_element;
   buffer[14] = (char)state->regex_bracket_last_element;
   buffer[15] = (char)state->regex_bracket_element_count;
-  buffer[16] = (state->regex_bracket_range_pending ? 1 : 0) |
-    ((unsigned char)state->regex_duplication_state << 1);
+  buffer[16] =
+    (state->regex_bracket_range_pending ? SERIALIZED_RANGE_PENDING_FLAG : 0) |
+    ((unsigned char)state->regex_duplication_state
+      << SERIALIZED_DUPLICATION_STATE_SHIFT);
   return SCANNER_SERIALIZED_STATE_SIZE;
 }
 
@@ -447,12 +461,16 @@ sed_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
       ((uint32_t)(unsigned char)buffer[7] << 24)),
     .mode = (enum ScannerMode)(unsigned char)buffer[1],
     .regex_state = (enum RegexState)(unsigned char)buffer[2],
-    .regex_at_branch_start = (mode_flags & 1U) != 0,
-    .regex_duplication_state =
-      (enum RegexDuplicationState)((regex_bracket_flags >> 1) & 3U),
-    .regex_after_alternation = (mode_flags & 2U) != 0,
-    .regex_after_anchor = (mode_flags & 4U) != 0,
-    .text_state = (enum TextState)((mode_flags >> 3) & 3U),
+    .regex_at_branch_start =
+      (mode_flags & SERIALIZED_AT_BRANCH_START_FLAG) != 0,
+    .regex_duplication_state = (enum RegexDuplicationState)(
+      (regex_bracket_flags >> SERIALIZED_DUPLICATION_STATE_SHIFT) & 3U
+    ),
+    .regex_after_alternation =
+      (mode_flags & SERIALIZED_AFTER_ALTERNATION_FLAG) != 0,
+    .regex_after_anchor = (mode_flags & SERIALIZED_AFTER_ANCHOR_FLAG) != 0,
+    .text_state =
+      (enum TextState)((mode_flags >> SERIALIZED_TEXT_STATE_SHIFT) & 3U),
     .regex_interval_state = (enum RegexIntervalState)(unsigned char)buffer[10],
     .regex_bracket_term_state =
       (enum RegexBracketTermState)(unsigned char)buffer[11],
@@ -463,7 +481,8 @@ sed_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
     .regex_bracket_last_element =
       (enum RegexBracketPendingElement)(unsigned char)buffer[14],
     .regex_bracket_element_count = (uint8_t)(unsigned char)buffer[15],
-    .regex_bracket_range_pending = (regex_bracket_flags & 1U) != 0,
+    .regex_bracket_range_pending =
+      (regex_bracket_flags & SERIALIZED_RANGE_PENDING_FLAG) != 0,
     .regex_group_depth = deserialize_uint16(buffer, 8),
   };
 
@@ -475,7 +494,7 @@ sed_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
     return;
   }
 
-  if ((mode_flags & (unsigned char)~31U) != 0) {
+  if ((mode_flags & (unsigned char)~SERIALIZED_MODE_FLAGS_MAXIMUM) != 0) {
     return;
   }
   if (candidate.text_state > TEXT_AFTER_ESCAPED_NEWLINE) {
@@ -502,7 +521,7 @@ sed_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
     REGEX_BRACKET_PENDING_COLON ||
     candidate.regex_bracket_element_count >
     3U ||
-    (regex_bracket_flags & (unsigned char)~7U) !=
+    (regex_bracket_flags & (unsigned char)~SERIALIZED_BRACKET_FLAGS_MAXIMUM) !=
     0 ||
 #if SED_REGEX_EXTENDED
     candidate.regex_duplication_state > REGEX_AFTER_REPETITION_MODIFIER
@@ -1095,44 +1114,36 @@ update_bracket_state_after_literal(ScannerState *state, int32_t character) {
 static bool
 regex_literal_boundary(const ScannerState *state, int32_t character) {
   if (state->regex_state == REGEX_OUTSIDE_BRACKET) {
-    return character ==
-      state->delimiter ||
-      character ==
-      '\\' ||
-      character ==
-      '(' ||
-      character ==
-      ')' ||
-      character ==
-      '[' ||
-      character ==
-      '*' ||
-      character ==
-      '+' ||
-      character ==
-      '?' ||
-      character ==
-      '|' ||
-      character ==
-      '{' ||
-      character ==
-      '.' ||
-      character ==
-      '^' ||
-      character == '$';
+    switch (character) {
+    case '\\':
+    case '(':
+    case ')':
+    case '[':
+    case '*':
+    case '+':
+    case '?':
+    case '|':
+    case '{':
+    case '.':
+    case '^':
+    case '$':
+      return true;
+    default:
+      return character == state->delimiter;
+    }
   }
 
-  if (
-    character ==
-    '[' ||
-    (state->regex_state == REGEX_BRACKET_FIRST && character == '^') ||
-    (state->regex_state == REGEX_BRACKET_BODY && character == '-') ||
-    (state->regex_state == REGEX_BRACKET_BODY && character == ']')
-  ) {
+  switch (character) {
+  case '[':
     return true;
+  case '^':
+    return state->regex_state == REGEX_BRACKET_FIRST;
+  case '-':
+  case ']':
+    return state->regex_state == REGEX_BRACKET_BODY;
+  default:
+    return false;
   }
-
-  return false;
 }
 
 static enum LiteralScanResult
@@ -1200,15 +1211,19 @@ static bool scan_regex_bracket_opener(
   lexer->mark_end(lexer);
 
   TSSymbol candidate;
+  enum RegexBracketTermState term_state;
   switch (lexer->lookahead) {
   case ':':
     candidate = REGEX_OPEN_COLON;
+    term_state = REGEX_BRACKET_TERM_COLON;
     break;
   case '.':
     candidate = REGEX_OPEN_DOT;
+    term_state = REGEX_BRACKET_TERM_DOT;
     break;
   case '=':
     candidate = REGEX_OPEN_EQUAL;
+    term_state = REGEX_BRACKET_TERM_EQUAL;
     break;
   default:
     begin_single_bracket_element(state, '[');
@@ -1222,10 +1237,7 @@ static bool scan_regex_bracket_opener(
   consume(lexer);
   begin_compound_bracket_element(state);
   finish_first_bracket_element(state);
-  state->regex_bracket_term_state = candidate == REGEX_OPEN_COLON
-    ? REGEX_BRACKET_TERM_COLON
-    : candidate == REGEX_OPEN_DOT ? REGEX_BRACKET_TERM_DOT
-                                  : REGEX_BRACKET_TERM_EQUAL;
+  state->regex_bracket_term_state = term_state;
   *symbol = candidate;
   return true;
 }
@@ -1247,6 +1259,18 @@ static bool bracket_meta_character(int32_t character) {
   return character == '^' || character == '-' || character == ']';
 }
 
+static int32_t
+bracket_term_close_marker(enum RegexBracketTermState term_state) {
+  switch (term_state) {
+  case REGEX_BRACKET_TERM_COLON:
+    return ':';
+  case REGEX_BRACKET_TERM_DOT:
+    return '.';
+  default:
+    return '=';
+  }
+}
+
 static TSSymbol regex_bracket_term_content_symbol(
   const ScannerState *state,
   uint8_t character_count,
@@ -1599,6 +1623,21 @@ static enum DuplicationContextScan scan_regex_duplication_context_marker(
   return DUPLICATION_CONTEXT_TOKEN;
 }
 
+static bool raw_regex_operator_character(int32_t character) {
+  switch (character) {
+  case '(':
+  case ')':
+  case '*':
+  case '+':
+  case '?':
+  case '|':
+  case '{':
+    return true;
+  default:
+    return false;
+  }
+}
+
 static bool scan_raw_regex_operator(
   TSLexer *lexer,
   ScannerState *state,
@@ -1667,39 +1706,42 @@ static bool scan_raw_regex_operator(
 }
 
 static bool regex_delimiter_is_special(int32_t character) {
+  switch (character) {
 #if SED_REGEX_EXTENDED
-  return character ==
-    '.' ||
-    character ==
-    '[' ||
-    character ==
-    '(' ||
-    character ==
-    ')' ||
-    character ==
-    '*' ||
-    character ==
-    '+' ||
-    character ==
-    '?' ||
-    character ==
-    '{' ||
-    character ==
-    '|' ||
-    character ==
-    '^' ||
-    character == '$';
-#else
-  return character ==
-    '.' ||
-    character ==
-    '[' ||
-    character ==
-    '*' ||
-    character ==
-    '^' ||
-    character == '$';
+  case '(':
+  case ')':
+  case '+':
+  case '?':
+  case '{':
+  case '|':
+#endif
+  case '.':
+  case '[':
+  case '*':
+  case '^':
+  case '$':
+    return true;
+  default:
+    return false;
+  }
+}
+
+static bool escape_quotes_regex_syntax(int32_t character) {
+  switch (character) {
+#if SED_REGEX_EXTENDED
+  case '}':
 #endif
+  case '.':
+  case '*':
+  case '^':
+  case '$':
+  case '[':
+  case '\\':
+  case ']':
+    return true;
+  default:
+    return false;
+  }
 }
 
 static bool scan_regex_escaped_delimiter(
@@ -1815,29 +1857,11 @@ static bool scan_regex_escape_after_backslash(
     return emit_symbol(valid_symbols, REGEX_NEWLINE_ESCAPE, symbol);
   }
 
-  const int32_t character = lexer->lookahead;
-  const bool quotes_regex_syntax = character ==
-    '.' ||
-    character ==
-    '*' ||
-    character ==
-    '^' ||
-    character ==
-    '$' ||
-    character ==
-    '[' ||
-    character ==
-    '\\' ||
-    character ==
-    ']' ||
-    (SED_REGEX_EXTENDED && character == '}');
-  if (!quotes_regex_syntax) {
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_NONPORTABLE_ESCAPE, symbol);
-  }
-
+  const TSSymbol candidate = escape_quotes_regex_syntax(lexer->lookahead)
+    ? REGEX_QUOTED_ESCAPE
+    : REGEX_NONPORTABLE_ESCAPE;
   consume(lexer);
-  return emit_symbol(valid_symbols, REGEX_QUOTED_ESCAPE, symbol);
+  return emit_symbol(valid_symbols, candidate, symbol);
 }
 
 #if !SED_REGEX_EXTENDED
@@ -2069,14 +2093,10 @@ static bool scan_regex_token(
       valid_symbols[REGEX_COLL_ELEM_MULTI] ||
       valid_symbols[REGEX_META_CHAR]
     ) {
-      const int32_t close_marker =
-        state->regex_bracket_term_state == REGEX_BRACKET_TERM_COLON ? ':'
-        : state->regex_bracket_term_state == REGEX_BRACKET_TERM_DOT ? '.'
-                                                                    : '=';
       return scan_regex_bracket_term_content(
         lexer,
         state,
-        close_marker,
+        bracket_term_close_marker(state->regex_bracket_term_state),
         valid_symbols,
         symbol
       );
@@ -2211,21 +2231,7 @@ static bool scan_regex_token(
       );
     }
 
-    if (
-      lexer->lookahead ==
-      '(' ||
-      lexer->lookahead ==
-      ')' ||
-      lexer->lookahead ==
-      '*' ||
-      lexer->lookahead ==
-      '+' ||
-      lexer->lookahead ==
-      '?' ||
-      lexer->lookahead ==
-      '|' ||
-      lexer->lookahead == '{'
-    ) {
+    if (raw_regex_operator_character(lexer->lookahead)) {
       return scan_raw_regex_operator(lexer, state, valid_symbols, symbol);
     }
 
@@ -2646,6 +2652,11 @@ static bool scan_regex_recovery_marker(
   return false;
 }
 
+static TSSymbol missing_text_introducer_symbol(const TSLexer *lexer) {
+  return lexer->eof(lexer) ? MISSING_TEXT_INTRODUCER_MARKER
+                           : NONCONFORMING_MISSING_TEXT_INTRODUCER_MARKER;
+}
+
 static bool scan_command_token(
   TSLexer *lexer,
   ScannerState *state,
@@ -2711,10 +2722,11 @@ static bool scan_command_token(
       *symbol = TEXT_COMMAND_START;
       return true;
     }
-    const TSSymbol introducer_marker = lexer->eof(lexer)
-      ? MISSING_TEXT_INTRODUCER_MARKER
-      : NONCONFORMING_MISSING_TEXT_INTRODUCER_MARKER;
-    return emit_symbol(valid_symbols, introducer_marker, symbol);
+    return emit_symbol(
+      valid_symbols,
+      missing_text_introducer_symbol(lexer),
+      symbol
+    );
   }
 
   if (valid_symbols[DEFAULT_OUTPUT_SUPPRESSION] && lexer->lookahead == 'n') {
@@ -2854,11 +2866,13 @@ static bool scan_command_token(
     }
   }
 
-  const TSSymbol missing_text_introducer = lexer->eof(lexer)
-    ? MISSING_TEXT_INTRODUCER_MARKER
-    : NONCONFORMING_MISSING_TEXT_INTRODUCER_MARKER;
   if (
-    emit_missing_marker(lexer, valid_symbols, missing_text_introducer, symbol)
+    emit_missing_marker(
+      lexer,
+      valid_symbols,
+      missing_text_introducer_symbol(lexer),
+      symbol
+    )
   ) {
     return true;
   }

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "tree-sitter-sed",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Tree-sitter grammars for POSIX sed.",
   "license": "MIT",
   "repository": "git+https://github.com/konomanoasa/tree-sitter-sed.git",
   "files": [
+    "bindings/c",
+    "CMakeLists.txt",
     "common/*.js",
     "common/scanner.h",
     "grammar.js",
+    "Makefile",
     "queries/*.scm",
     "src/*.c",
     "src/*.json",
@@ -17,11 +20,12 @@
     "sed_ere/src/*.c",
     "sed_ere/src/*.json",
     "sed_ere/src/tree_sitter/*.h",
+    "test/binding.test.c",
     "tree-sitter.json"
   ],
   "scripts": {
-    "check": "biome check . && node scripts/check-scanner.js && node scripts/check-generated.js && npm test",
-    "format": "biome check --write . && node scripts/check-scanner.js --write",
+    "check": "biome check . && node scripts/check-c.js && node scripts/check-generated.js && npm test",
+    "format": "biome check --write . && node scripts/check-c.js --write",
     "generate": "npm run tree-sitter -- generate-all",
     "test": "npm run tree-sitter -- test-corpus --rebuild && node --test",
     "test:fuzz": "npm run tree-sitter -- fuzz-all --iterations 100 --edits 5",

package/sed_ere/src/parser.c

@@ -56422,7 +56422,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_sed_ere(void) {
     .max_reserved_word_set_size = 0,
     .metadata = {
       .major_version = 0,
-      .minor_version = 3,
+      .minor_version = 4,
       .patch_version = 0,
     },
   };

package/src/parser.c

@@ -58390,7 +58390,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_sed(void) {
     .max_reserved_word_set_size = 0,
     .metadata = {
       .major_version = 0,
-      .minor_version = 3,
+      .minor_version = 4,
       .patch_version = 0,
     },
   };

package/test/binding.test.c

@@ -0,0 +1,9 @@
+#include <stddef.h>
+#include <tree_sitter/tree-sitter-sed.h>
+
+int main(void) {
+  const TSLanguage *sed = tree_sitter_sed();
+  const TSLanguage *sed_ere = tree_sitter_sed_ere();
+
+  return sed == NULL || sed_ere == NULL || sed == sed_ere;
+}

package/tree-sitter.json

@@ -21,7 +21,7 @@
     }
   ],
   "metadata": {
-    "version": "0.3.0",
+    "version": "0.4.0",
     "license": "MIT",
     "description": "Tree-sitter grammars for POSIX sed.",
     "authors": [
@@ -34,7 +34,7 @@
     }
   },
   "bindings": {
-    "c": false,
+    "c": true,
     "go": false,
     "node": false,
     "python": false,