tree-sitter-ucode 0.3.0 → 0.4.0

package/markup/src/scanner.c

@@ -0,0 +1,22 @@
+/*
+ * External scanner for the ucode_markup grammar.
+ *
+ * All implementation lives in src/scanner_impl.h (static functions).  This
+ * file only exports the five tree_sitter_ucode_markup_external_scanner_*
+ * entry points — no ucode_* symbols leak into this shared library.
+ */
+
+#include "../../src/scanner_impl.h"
+
+void *tree_sitter_ucode_markup_external_scanner_create(void) { return NULL; }
+void  tree_sitter_ucode_markup_external_scanner_destroy(void *p) { (void)p; }
+unsigned tree_sitter_ucode_markup_external_scanner_serialize(void *p, char *b) { (void)p; (void)b; return 0; }
+void  tree_sitter_ucode_markup_external_scanner_deserialize(void *p, const char *b, unsigned n) {
+    (void)p; (void)b; (void)n;
+}
+
+bool tree_sitter_ucode_markup_external_scanner_scan(
+    void *payload, TSLexer *lexer, const bool *valid_symbols
+) {
+    return ucode_scanner_scan(payload, lexer, valid_symbols);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-ucode",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Ucode grammar for tree-sitter",
   "repository": {
     "type": "git",
@@ -24,9 +24,10 @@
     "bindings/node/*",
     "queries/*",
     "src/**",
-    "tmpl/grammar.js",
-    "tmpl/src/**",
-    "tmpl/queries/*",
+    "markup/grammar.js",
+    "markup/src/**",
+    "markup/queries/*",
+    "scripts/generate-markup-grammar.js",
     "*.wasm"
   ],
   "dependencies": {
@@ -47,7 +48,7 @@
   },
   "scripts": {
     "install": "node-gyp-build",
-    "build": "tree-sitter generate && tree-sitter generate tmpl/grammar.js --output tmpl/src && node-gyp-build && tree-sitter build --output ucode.so . && tree-sitter build --output ucode_tmpl.so ./tmpl",
+    "build": "node scripts/generate-markup-grammar.js && tree-sitter generate && tree-sitter generate markup/grammar.js --output markup/src && node-gyp-build && tree-sitter build --output ucode.so . && tree-sitter build --output ucode_markup.so ./markup",
     "test": "node scripts/run-tests.js",
     "prestart": "tree-sitter build --wasm",
     "start": "tree-sitter playground"

package/queries/locals.scm

@@ -5,6 +5,7 @@
 ; Scopes
 ; -------------------------------------------------------------------------
 
+(program) @local.scope
 (function_declaration) @local.scope
 (function_expression) @local.scope
 (arrow_function) @local.scope

package/scripts/generate-markup-grammar.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Generate markup/grammar.js from grammar.js.
+ *
+ * The main grammar has `program` as the first (start) rule so that `.uc`
+ * files work.  For `.uc.tmpl` files we need `markup` to be the
+ * start rule.  This script produces markup/grammar.js by:
+ *
+ *   1. Changing the grammar name from 'ucode' to 'ucode_markup'
+ *   2. Swapping the `markup` and `program` rule definitions so `markup`
+ *      appears first (tree-sitter uses the first rule as the start rule)
+ *
+ * The generated file is checked in and rebuilt whenever grammar.js changes.
+ * Run via `npm run generate-markup` or as part of `npm run build`.
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const srcPath = path.resolve(__dirname, '..', 'grammar.js');
+const dstPath = path.resolve(__dirname, '..', 'markup', 'grammar.js');
+
+let src = fs.readFileSync(srcPath, 'utf8');
+
+// 1. Rename the grammar
+src = src.replace(/name:\s*'ucode'/, "name: 'ucode_markup'");
+
+// 2. Locate the `program` and `markup` rule definitions inside `rules: { ... }`.
+//    Each top-level rule starts with "\n    <ident>: $ =>".
+//    We need to swap the two so `markup` comes first.
+
+// Find the position of each rule's leading newline+spaces
+const programMatch = src.match(/\n    program: \$/);
+const markupMatch  = src.match(/\n    markup: \$/);
+
+if (!programMatch || !markupMatch) {
+    console.error('Could not locate program or markup rule in grammar.js');
+    process.exit(1);
+}
+
+const programIdx = src.indexOf('\n    program: $');
+const markupIdx  = src.indexOf('\n    markup: $');
+
+if (programIdx === markupIdx) {
+    console.error('program and markup are at the same position?');
+    process.exit(1);
+}
+
+// Determine which comes first in the file
+const firstIdx  = Math.min(programIdx, markupIdx);
+const secondIdx = Math.max(programIdx, markupIdx);
+
+// Extract each rule: from its start up to the start of the next rule (or end-of-rules).
+// A top-level rule starts at "\n    <ident>: $" and ends just before the next "\n    <ident>: $".
+// We need the SPANS of the two rules to swap them.
+
+function findNextRuleStart(text, from) {
+    // Match "\n    <word>: $ =>" — the arrow function syntax uniquely identifies
+    // rule definitions vs. object properties at the same indentation level.
+    const re = /\n    \w+: \$ =>/g;
+    re.lastIndex = from + 1;     // skip the current match
+    const m = re.exec(text);
+    return m ? m.index : text.length;
+}
+
+const firstEnd  = findNextRuleStart(src, firstIdx);
+const secondEnd = findNextRuleStart(src, secondIdx);
+
+const firstRule  = src.slice(firstIdx,  firstEnd);
+const secondRule = src.slice(secondIdx, secondEnd);
+
+// Reconstruct: everything before firstIdx, then the rule that was second,
+// then everything between the two rules, then the rule that was first,
+// then everything after secondEnd.
+const between = src.slice(firstEnd, secondIdx);
+
+const swapped =
+    src.slice(0, firstIdx) +
+    secondRule +
+    between +
+    firstRule +
+    src.slice(secondEnd);
+
+// 3. Add a header comment noting this is generated
+const header = '// GENERATED by scripts/generate-markup-grammar.js — do not edit by hand.\n';
+const output = header + swapped;
+
+fs.mkdirSync(path.dirname(dstPath), { recursive: true });
+fs.writeFileSync(dstPath, output, 'utf8');
+
+console.log(`Wrote ${path.relative(process.cwd(), dstPath)}`);