@bablr/language-en-bablr-vm-instruction 0.3.0

package/lib/grammar.macro.js

@@ -0,0 +1,151 @@
+import { i } from '@bablr/boot/shorthand.macro';
+import { CoveredBy, Node, InjectFrom } from '@bablr/helpers/decorators';
+import * as Space from '@bablr/language-en-blank-space';
+import * as productions from '@bablr/helpers/productions';
+
+export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-vm-instruction';
+
+export const dependencies = { Space };
+
+export function* eatMatchTrivia() {
+  if (yield i`match(/[ \t\n]/)`) {
+    return yield i`eat(<#*Space:Space>)`;
+  }
+  return null;
+}
+
+export const grammar = class BABLRVMInstructionGrammar {
+  @Node
+  *Call() {
+    yield i`eat(<*Identifier> 'callee')`;
+    yield* eatMatchTrivia();
+    yield i`eat(<Tuple> 'arguments')`;
+  }
+
+  *Expression() {
+    yield i`eat(<Any> null [
+        <Array '['>
+        <Object '{'>
+        <Tuple '('>
+        <*Boolean /true|false/>
+        <*Null 'null'>
+        <*Identifier /[a-zA-Z]+/>
+        <Number /[\d]|[+-]?Infinity/>
+      ])`;
+  }
+
+  @CoveredBy('Expression')
+  @Node
+  *Array() {
+    yield i`eat(<~*Punctuator '[' balanced=']'> 'openToken')`;
+    let sp = yield* eatMatchTrivia();
+    let first = true;
+    while ((first || sp) && (yield i`match(/./y)`)) {
+      yield i`eat(<Expression> 'elements[]')`;
+      sp = yield* eatMatchTrivia();
+      first = false;
+    }
+    yield i`eat(<~*Punctuator ']' balancer> 'closeToken')`;
+  }
+
+  @CoveredBy('Expression')
+  @Node
+  *Object() {
+    yield i`eat(<~*Punctuator '{' balanced='}'> 'openToken')`;
+    let sp = yield* eatMatchTrivia();
+    let first = true;
+    while ((first || sp) && (yield i`match(/./y)`)) {
+      yield i`eat(<Property> 'properties[]')`;
+      sp = yield* eatMatchTrivia();
+      first = false;
+    }
+    yield i`eat(<~*Punctuator '}' balancer> 'closeToken')`;
+  }
+
+  @Node
+  *Property() {
+    yield i`eat(<*Identifier> 'key')`;
+    yield* eatMatchTrivia();
+    yield i`eat(<~*Punctuator ':'> 'mapToken')`;
+    yield* eatMatchTrivia();
+    yield i`eat(<Expression> 'value')`;
+  }
+
+  @CoveredBy('Expression')
+  @Node
+  *Tuple() {
+    yield i`eat(<~*Punctuator '(' balanced=')'> 'openToken')`;
+    let sp = yield* eatMatchTrivia();
+    let first = true;
+    while ((first || sp) && (yield i`match(/./y)`)) {
+      yield i`eat(<Expression> 'values[]')`;
+      sp = yield* eatMatchTrivia();
+      first = false;
+    }
+    yield i`eat(<~*Punctuator ')' balancer> 'closeToken')`;
+  }
+
+  @CoveredBy('Expression')
+  @Node
+  *Boolean() {
+    yield i`eat(<~*Keyword /true|false/> 'sigilToken')`;
+  }
+
+  @CoveredBy('Expression')
+  @Node
+  *Null() {
+    yield i`eat(<~*Keyword 'null'> 'sigilToken')`;
+  }
+
+  @CoveredBy('Expression')
+  @Node
+  *Identifier() {
+    yield i`eat(/[a-zA-Z]+/)`;
+  }
+
+  *Number() {
+    yield i`eat(<Any> null [
+      <Integer /-?\d/>
+      <Infinity /[+-]I/>
+    ])`;
+  }
+
+  @Node
+  *UnsignedInteger() {
+    yield i`eat(<Digits> 'digits[]')`;
+  }
+
+  @CoveredBy('Number')
+  @Node
+  *Integer() {
+    yield i`eatMatch(<~*Punctuator '-'> 'negativeToken')`;
+    yield i`eat(<Digits> 'digits[]')`;
+  }
+
+  *Digits() {
+    while (yield i`eatMatch(<*Digit /\d/>)`);
+  }
+
+  @Node
+  *Digit() {
+    yield i`eat(/\d/)`;
+  }
+
+  @CoveredBy('Number')
+  @Node
+  *Infinity() {
+    yield i`eatMatch(<~*Punctuator /[+-]/> 'signToken')`;
+    yield i`eat(<~*Keyword 'Infinity'> 'sigilToken')`;
+  }
+
+  @Node
+  @InjectFrom(productions)
+  *Punctuator() {}
+
+  @Node
+  @InjectFrom(productions)
+  *Keyword() {}
+
+  @InjectFrom(productions)
+  *Any() {}
+};

package/lib/spamex.grammar.js

@@ -0,0 +1,121 @@
+/* @macrome
+ * @generatedby @bablr/macrome-generator-bablr
+ * @generatedfrom ./spamex.grammar.macro.js#ce862490709aa1bd7b3c70d2e6aa90eeca50971e
+ * This file is autogenerated. Please do not edit it directly.
+ * When editing run `npx macrome watch` then change the file this is generated from.
+ */
+import {
+  interpolateArray as _interpolateArray,
+  interpolateArrayChildren as _interpolateArrayChildren,
+  interpolateString as _interpolateString,
+} from '@bablr/agast-helpers/template';
+import * as _l from '@bablr/agast-vm-helpers/languages';
+import * as _t from '@bablr/agast-helpers/shorthand';
+import * as Spamex from '@bablr/language-en-spamex';
+import * as Instruction from './grammar.js';
+export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-vm-spamex-instruction';
+export const dependencies = {
+  ...Instruction.dependencies,
+  Spamex,
+};
+export const grammar = class BABLRVMSpamexInstructionGrammar extends Instruction.grammar {
+  *Expression() {
+    if (
+      yield _t.node(
+        _l.Instruction,
+        'Call',
+        [_t.ref`verb`, _t.ref`arguments`],
+        {
+          verb: _t.s_node(_l.Instruction, 'Identifier', 'eatMatch'),
+          arguments: _t.node(
+            _l.Instruction,
+            'Tuple',
+            [_t.ref`openToken`, _t.ref`values[]`, _t.ref`closeToken`],
+            {
+              openToken: _t.s_i_node(_l.Instruction, 'Punctuator', '('),
+              values: [
+                _t.node(
+                  _l.Spamex,
+                  'NodeMatcher',
+                  [
+                    _t.ref`openToken`,
+                    _t.ref`flags`,
+                    _t.ref`language`,
+                    _t.ref`namespaceSeparatorToken`,
+                    _t.ref`type`,
+                    _t.embedded(_t.s_t_node(_l.Space, 'Space', [_t.lit(' ')], {}, {})),
+                    _t.ref`intrinsicValue`,
+                    _t.ref`closeToken`,
+                  ],
+                  {
+                    openToken: _t.s_i_node(_l.Spamex, 'Punctuator', '<'),
+                    flags: _t.node(_l.CSTML, 'Flags', [], {}, {}),
+                    language: _t.s_node(_l.Spamex, 'Identifier', 'Spamex'),
+                    namespaceSeparatorToken: _t.s_i_node(_l.Spamex, 'Punctuator', ':'),
+                    type: _t.s_node(_l.Spamex, 'Identifier', 'Matcher'),
+                    intrinsicValue: _t.node(
+                      _l.Regex,
+                      'Pattern',
+                      [_t.ref`openToken`, _t.ref`alternatives[]`, _t.ref`closeToken`],
+                      {
+                        openToken: _t.s_i_node(_l.Regex, 'Punctuator', '/'),
+                        alternatives: [
+                          _t.node(
+                            _l.Regex,
+                            'Alternative',
+                            [_t.ref`elements[]`],
+                            {
+                              elements: [
+                                _t.node(
+                                  _l.Regex,
+                                  'CharacterClass',
+                                  [
+                                    _t.ref`openToken`,
+                                    _t.ref`elements[]`,
+                                    _t.ref`elements[]`,
+                                    _t.ref`elements[]`,
+                                    _t.ref`elements[]`,
+                                    _t.ref`closeToken`,
+                                  ],
+                                  {
+                                    openToken: _t.s_i_node(_l.Regex, 'Punctuator', '['),
+                                    elements: [
+                                      _t.node(_l.Regex, 'Character', [_t.lit('<')], {}, {}),
+                                      _t.node(_l.Regex, 'Character', [_t.lit("'")], {}, {}),
+                                      _t.node(_l.Regex, 'Character', [_t.lit('"')], {}, {}),
+                                      _t.node(_l.Regex, 'Character', [_t.lit('/')], {}, {}),
+                                    ],
+                                    closeToken: _t.s_i_node(_l.Regex, 'Punctuator', ']'),
+                                  },
+                                  {
+                                    negate: false,
+                                  },
+                                ),
+                              ],
+                            },
+                            {},
+                          ),
+                        ],
+                        closeToken: _t.s_i_node(_l.Regex, 'Punctuator', '/'),
+                      },
+                      {},
+                    ),
+                    closeToken: _t.s_i_node(_l.Spamex, 'Punctuator', '>'),
+                  },
+                  {},
+                ),
+              ],
+              closeToken: _t.s_i_node(_l.Instruction, 'Punctuator', ')'),
+            },
+            {},
+          ),
+        },
+        {},
+      )
+    ) {
+      // done
+    } else {
+      yield* super.Expression();
+    }
+  }
+};

package/lib/spamex.grammar.macro.js

@@ -0,0 +1,17 @@
+import { i } from '@bablr/boot/shorthand.macro';
+import * as Spamex from '@bablr/language-en-spamex';
+import * as Instruction from './grammar.js';
+
+export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-vm-spamex-instruction';
+
+export const dependencies = { ...Instruction.dependencies, Spamex };
+
+export const grammar = class BABLRVMSpamexInstructionGrammar extends Instruction.grammar {
+  *Expression() {
+    if (yield i`eatMatch(<Spamex:Matcher /[<'"/]/>)`) {
+      // done
+    } else {
+      yield* super.Expression();
+    }
+  }
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@bablr/language-en-bablr-vm-instruction",
+  "version": "0.3.0",
+  "description": "A BABLR language for BABLR VM instructions",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./lib/grammar.js",
+    "./cstml": "./lib/cstml.grammar.js",
+    "./spamex": "./lib/spamex.grammar.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "macrome build",
+    "watch": "macrome watch",
+    "clean": "macrome clean"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.23.2",
+    "@bablr/agast-helpers": "0.2.0",
+    "@bablr/agast-vm-helpers": "0.2.0",
+    "@bablr/helpers": "0.17.0",
+    "@bablr/language-en-blank-space": "0.2.0",
+    "@bablr/language-en-cstml": "0.4.0",
+    "@bablr/language-en-spamex": "0.3.1"
+  },
+  "devDependencies": {
+    "@bablr/boot": "0.3.0",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/macrome": "0.1.3",
+    "@bablr/macrome-generator-bablr": "0.3.1",
+    "enhanced-resolve": "^5.12.0",
+    "eslint": "^8.47.0",
+    "eslint-import-resolver-enhanced-resolve": "^1.0.5",
+    "eslint-plugin-import": "^2.27.5",
+    "expect": "^29.6.2",
+    "prettier": "^2.0.5"
+  },
+  "keywords": [
+    "bablr-language",
+    "grammar",
+    "english"
+  ],
+  "repository": "git@github.com:bablr-lang/language-en-bablr-vm-instruction.git",
+  "homepage": "https://github.com/bablr-lang/language-en-bablr-vm-instruction",
+  "author": "Conrad Buck <conartist6@gmail.com>",
+  "license": "MIT"
+}