tree-sitter-scpi 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# tree-sitter-scpi
+
+Tree-sitter grammar for SCPI (Standard Commands for Programmable Instruments).
+
+## Overview
+
+This grammar provides syntax parsing for SCPI commands used in programmable instruments. It supports:
+
+- **Common commands**: Asterisk-prefixed commands like `*IDN?`, `*RST`
+- **Hierarchical commands**: Colon-separated command paths like `:MEASure:VOLTage?`
+- **Query commands**: Commands ending with `?`
+- **Command parameters**: Numeric values, strings, and enumerated values
+- **Command chaining**: Multiple commands separated by semicolons
+
+## Installation
+
+```bash
+npm install
+```
+
+## Building
+
+Generate the parser from the grammar:
+
+```bash
+npm run generate
+```
+
+Or using tree-sitter CLI directly:
+
+```bash
+tree-sitter generate
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+npm test
+```
+
+Or using tree-sitter CLI directly:
+
+```bash
+tree-sitter test
+```
+
+## Grammar Structure
+
+### Command Types
+
+#### Common Commands
+Common commands start with an asterisk (`*`) and may include a query marker (`?`):
+
+```
+*IDN?
+*RST
+*OPC?
+```
+
+#### Hierarchical Commands
+Hierarchical commands use colons (`:`) to separate command nodes. The leading colon is optional:
+
+```
+:MEASure:VOLTage?
+MEASure:VOLTage?
+:SYSTem:COMMunicate:SERial:BAUD 9600
+```
+
+### Parameters
+
+Commands can include parameters separated by commas:
+
+- **Numbers**: `5.0`, `-10`, `1.5e3`, `0.001`
+- **Strings**: `"192.168.1.100"`, `"AUTO"`
+- **Enumerations**: `EXTernal`, `INTernal`, `AUTO`
+
+Example:
+```
+:MEASure:VOLTage:DC? 10,0.001
+:SYSTem:COMMunicate:LAN:IPADdress "192.168.1.100"
+:TRIGger:SOURce EXTernal
+```
+
+### Command Chaining
+
+Multiple commands can be chained on a single line using semicolons:
+
+```
+*IDN?;*RST
+:MEASure:VOLTage?;:SOURce:VOLTage 5.0
+```
+
+## Example Usage
+
+```javascript
+const Parser = require('tree-sitter');
+const SCPI = require('tree-sitter-scpi');
+
+const parser = new Parser();
+parser.setLanguage(SCPI);
+
+const sourceCode = `*IDN?
+:MEASure:VOLTage?
+:SOURce:VOLTage 5.0`;
+
+const tree = parser.parse(sourceCode);
+console.log(tree.rootNode.toString());
+```
+
+## Grammar Rules
+
+The grammar defines the following main rules:
+
+- `program`: Root node containing one or more commands
+- `command`: Individual SCPI command (common or hierarchical)
+- `common_command`: Asterisk-prefixed commands
+- `hierarchical_command`: Colon-separated command path
+- `command_path`: Sequence of command nodes separated by colons
+- `command_node`: Individual node in hierarchical path
+- `query_marker`: Optional `?` at end of commands
+- `parameter_list`: Optional parameters following command
+- `parameter`: Individual parameter (number, string, or enumeration)
+- `number`: Numeric values (integers, floats, scientific notation)
+- `string`: Quoted string parameters
+- `enumeration`: Enumerated values (keywords)
+
+## License
+
+MIT
+

package/binding.gyp

@@ -0,0 +1,19 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_scpi_binding",
+      "include_dirs": [
+        "<!(node -e \"require('nan')\")",
+        "src"
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+        # If your language uses an external scanner, add it here.
+      ],
+      "cflags_c": [
+        "-std=c99",
+      ]
+    }
+  ]
+}

package/bindings/node/binding.cc

@@ -0,0 +1,28 @@
+#include "tree_sitter/parser.h"
+#include <node.h>
+#include "nan.h"
+
+using namespace v8;
+
+extern "C" TSLanguage * tree_sitter_scpi();
+
+namespace {
+
+NAN_METHOD(New) {}
+
+void Init(Local<Object> exports, Local<Object> module) {
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+  tpl->SetClassName(Nan::New("Language").ToLocalChecked());
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
+  Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
+  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_scpi());
+
+  Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("scpi").ToLocalChecked());
+  Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
+}
+
+NODE_MODULE(tree_sitter_scpi_binding, Init)
+
+}  // namespace

package/bindings/node/index.js

@@ -0,0 +1,19 @@
+try {
+  module.exports = require("../../build/Release/tree_sitter_scpi_binding");
+} catch (error1) {
+  if (error1.code !== 'MODULE_NOT_FOUND') {
+    throw error1;
+  }
+  try {
+    module.exports = require("../../build/Debug/tree_sitter_scpi_binding");
+  } catch (error2) {
+    if (error2.code !== 'MODULE_NOT_FOUND') {
+      throw error2;
+    }
+    throw error1
+  }
+}
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

package/grammar.js

@@ -0,0 +1,128 @@
+module.exports = grammar({
+  name: 'scpi',
+
+  extras: $ => [
+    /[ \t]/,
+    $.comment
+  ],
+
+  rules: {
+    scpi_command: $ => repeat($._statement),
+
+    _statement: $ => seq(
+      optional($.program_message),
+      $._terminator
+    ),
+
+    _terminator: $ => /[\r\n]+/,
+
+    program_message: $ => seq(
+      $._program_message_unit,
+      repeat(seq(';', $._program_message_unit))
+    ),
+
+    _program_message_unit: $ => seq(
+      choice(
+        $.command_header,
+        $.common_command_header
+      ),
+      optional(seq(
+        alias($._separator, 'separator'),
+        $.parameter_list
+      ))
+    ),
+
+    command_header: $ => seq(
+      optional(':'),
+      $.mnemonic,
+      repeat(seq(':', $.mnemonic)),
+      optional('?')
+    ),
+
+    common_command_header: $ => seq(
+      '*',
+      $.mnemonic,
+      optional('?')
+    ),
+
+    mnemonic: $ => /[a-zA-Z][a-zA-Z0-9_]*/,
+
+    parameter_list: $ => seq(
+      $._parameter,
+      repeat(seq(',', $._parameter))
+    ),
+
+    _parameter: $ => choice(
+      $._numeric_entry,
+      $.string_literal,
+      $.boolean_literal,
+      $.character_data,
+      $.channel_list
+      // $.block_data
+    ),
+
+    _numeric_entry: $ => seq(
+      $.numeric_literal,
+      optional($.suffix)
+    ),
+
+    suffix: $ => /[a-zA-Z]+(\/[a-zA-Z]+)*/,
+
+    channel_list: $ => seq(
+      '(@',
+      $._channel_spec_list,
+      ')'
+    ),
+
+    _channel_spec_list: $ => seq(
+      $._channel_item,
+      repeat(seq(',', $._channel_item))
+    ),
+
+    _channel_item: $ => choice(
+      $.channel_range,
+      $.channel_spec
+    ),
+
+    channel_range: $ => seq(
+      $.channel_spec,
+      ':',
+      $.channel_spec
+    ),
+
+    channel_spec: $ => seq(
+      $.integer,
+      repeat(seq('!', $.integer))
+    ),
+
+    integer: $ => /\d+/,
+
+    numeric_literal: $ => token(choice(
+      // Decimal with optional exponent
+      /[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?/,
+      // Hexadecimal
+      /#H[0-9a-fA-F]+/,
+      // Octal
+      /#Q[0-7]+/,
+      // Binary
+      /#B[01]+/
+    )),
+
+    string_literal: $ => choice(
+      seq('"', repeat(choice(/[^"\n]/, '""')), '"'),
+      seq("'", repeat(choice(/[^'\n]/, "''")), "'")
+    ),
+
+    boolean_literal: $ => choice('ON', 'OFF'),
+
+    character_data: $ => /[a-zA-Z][a-zA-Z0-9_]*/,
+
+    comment: $ => token(seq('//', /.*/)),
+    
+    _separator: $ => /[ \t]+/
+  },
+  
+  conflicts: $ => [
+    [$.boolean_literal, $.character_data]
+  ]
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "tree-sitter-scpi",
+  "version": "0.1.0",
+  "description": "Tree-sitter grammar for SCPI (Standard Commands for Programmable Instruments)",
+  "main": "bindings/node",
+  "keywords": [
+    "scpi",
+    "tree-sitter",
+    "parser",
+    "grammar",
+    "instrumentation"
+  ],
+  "author": "Isaac Guo <isaacgy@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/isaacguo/tree-sitter-scpi.git"
+  },
+  "files": [
+    "grammar.js",
+    "src/",
+    "bindings/node/",
+    "binding.gyp",
+    "README.md"
+  ],
+  "dependencies": {
+    "nan": "^2.17.0"
+  },
+  "devDependencies": {
+    "tree-sitter-cli": "^0.20.0"
+  },
+  "scripts": {
+    "generate": "tree-sitter generate",
+    "test": "tree-sitter test"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.scpi",
+      "file-types": [
+        "scpi"
+      ]
+    }
+  ]
+}
+