@josd/eyecode 0.1.4 → 0.1.5

package/SPEC.md

@@ -2,7 +2,7 @@
 
 ```text
 Title:      The eyecode Rule Language and Proof Format
-Version:    eyecode 0.1.4
+Version:    eyecode 0.1.5
 Status:     Informational
 Author:     Jos De Roo, KNoWS office of IDLab, Ghent University - imec
 Repository: https://github.com/eyereasoner/eyecode
@@ -22,7 +22,7 @@ command line.
 ## Status of This Memo
 
 This document is not an Internet Standards Track specification. It describes
-the language and formats as implemented by eyecode 0.1.4, for readers who want
+the language and formats as implemented by eyecode 0.1.5, for readers who want
 to write programs, produce or consume proofs and reports, or implement a
 compatible reasoner or checker. Where this document and the implementation
 disagree, that is a defect in one of them.
@@ -827,7 +827,7 @@ conclusions and proof documents in the canonical text, and checks every proof
 it produces as Section 11 describes. A conforming **checker** implements
 Sections 9, 11 and 12 and does not depend on a reasoner. For the same
 program, a conforming reasoner and checker MUST produce the same
-conclusions, proof documents and reports as eyecode 0.1.4, byte for byte,
+conclusions, proof documents and reports as eyecode 0.1.5, byte for byte,
 except for the `Detail` texts of failures (Section 12), the internal names of
 variables where Section 3 says so, and where the host's floating-point
 library functions (`exp`, `log`, the trigonometric and hyperbolic functions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josd/eyecode",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A dependency-free JavaScript rule language with forward and backward reasoning and checkable proofs.",
   "type": "module",
   "main": "./src/index.js",

package/src/lang.js

@@ -137,6 +137,10 @@ function renameAnonymous(term, counter) {
 }
 
 // Collects the clauses a program states, in order.
+// The line of the statement call being run, when the call names it (see
+// markStatements); otherwise statements find it on the stack.
+let statedLine = null;
+
 class Builder {
   constructor(locate) {
     this.sources = [];
@@ -144,7 +148,7 @@ class Builder {
   }
 
   add(kind, head, body, line = null) {
-    if (line === null) line = this.locate();
+    if (line === null) line = statedLine !== null ? statedLine : this.locate();
     const counter = new Anonymous([head, ...body]);
     // In the order the statement writes them: a forward rule, implies(),
     // writes its premise first.
@@ -239,7 +243,10 @@ const LIBRARY = Object.freeze({
 // The names a program is given: the statements and the terms it builds goals
 // with. The statements report to the innermost program being built.
 function exportsFor(io) {
-  const builder = { add: (...args) => active().add(...args), locate: () => active().locate() };
+  const builder = {
+    add: (...args) => active().add(...args),
+    locate: () => (statedLine !== null ? statedLine : active().locate()),
+  };
   const statements = {
     fact: (...terms) => {
       for (const term of terms) builder.add('fact', toTerm(term), []);
@@ -308,6 +315,23 @@ function exportsFor(io) {
     fail: 'fail',
     eyecode: LIBRARY,
   };
+  const named = new Set(STATEMENT_NAMES.map((name) => statements[name]));
+  // A statement call rewritten by markStatements: the statement, run with its
+  // line known.
+  Object.defineProperty(statements, AT, {
+    value: (statement, line) => {
+      if (!named.has(statement)) return statement;
+      return (...args) => {
+        const outer = statedLine;
+        statedLine = line;
+        try {
+          return statement(...args);
+        } finally {
+          statedLine = outer;
+        }
+      };
+    },
+  });
   for (const primitiveKey of PRIMITIVE_KEYS) {
     const name = keyName(primitiveKey);
     const arity = Number(primitiveKey.slice(name.length + 1));
@@ -329,6 +353,9 @@ const KEPT = new Set([
 function programScope(exported) {
   const locals = new Map();
   const predicates = new Map();
+  // Variables are matched by name and each _ is renamed where it occurs, so
+  // one Var per name serves every use.
+  const variables = new Map();
   return new Proxy(Object.create(null), {
     has(target, name) {
       return typeof name === 'string' && !KEPT.has(name);
@@ -337,7 +364,15 @@ function programScope(exported) {
       if (typeof name !== 'string') return undefined;
       if (locals.has(name)) return locals.get(name);
       if (Object.hasOwn(exported, name)) return exported[name];
-      if (/^[A-Z_]/.test(name)) return new Var(name);
+      const first = name.charCodeAt(0);
+      if ((first >= 65 && first <= 90) || first === 95) {
+        let variable = variables.get(name);
+        if (variable === undefined) {
+          variable = new Var(name);
+          variables.set(name, variable);
+        }
+        return variable;
+      }
       let made = predicates.get(name);
       if (made === undefined) {
         made = predicate(name);
@@ -379,6 +414,146 @@ function lineOffset() {
   return firstLine;
 }
 
+const AT = '__eyecode_at__';
+const STATEMENT_NAMES = ['fact', 'implies', 'implied_by', 'query', 'contradiction', 'facts_from'];
+const STATEMENT_SET = new Set(STATEMENT_NAMES);
+const IDENTIFIER = /[A-Za-z0-9_$]/;
+// Words after which a slash starts a regular expression rather than a division.
+const BEFORE_EXPRESSION = new Set(['return', 'typeof', 'case', 'in', 'of', 'new', 'delete', 'void', 'throw', 'else', 'do',
+  'instanceof', 'yield', 'await']);
+
+// The program with each call of a statement, such as fact(...), rewritten to
+// name its own line: __eyecode_at__(fact, 12)(...). Finding the line of a call
+// on the stack costs microseconds, which adds up over a program that states a
+// hundred thousand clauses. The rewriting adds no line breaks, skips strings,
+// comments, template text and regular expressions, and leaves property calls
+// and declarations alone; a call it misses still finds its line on the stack.
+function markStatements(source) {
+  const out = [];
+  const templates = []; // for each open brace: true when it closes a template's ${
+  let from = 0;
+  let line = 1;
+  let i = 0;
+  let previous = ''; // the previous token: an identifier, or one punctuation character
+  const n = source.length;
+  const skipTo = (end) => {
+    for (; i < end; i++) if (source[i] === '\n') line++;
+  };
+  const template = () => {
+    // From inside a template's text to its end, or to a ${ that opens code.
+    while (i < n) {
+      const ch = source[i];
+      if (ch === '\\') skipTo(i + 2);
+      else if (ch === '`') {
+        i++;
+        previous = ')';
+        return;
+      } else if (ch === '$' && source[i + 1] === '{') {
+        i += 2;
+        templates.push(true);
+        previous = '{';
+        return;
+      } else skipTo(i + 1);
+    }
+  };
+  while (i < n) {
+    const ch = source[i];
+    if (ch === '\n') {
+      line++;
+      i++;
+    } else if (ch === ' ' || ch === '\t' || ch === '\r') {
+      i++;
+    } else if (ch === '/' && source[i + 1] === '/') {
+      while (i < n && source[i] !== '\n') i++;
+    } else if (ch === '/' && source[i + 1] === '*') {
+      const end = source.indexOf('*/', i + 2);
+      skipTo(end < 0 ? n : end + 2);
+    } else if (ch === "'" || ch === '"') {
+      i++;
+      while (i < n && source[i] !== ch && source[i] !== '\n') skipTo(source[i] === '\\' ? i + 2 : i + 1);
+      i++;
+      previous = ')';
+    } else if (ch === '`') {
+      i++;
+      template();
+    } else if (ch === '/' && (previous === '' || BEFORE_EXPRESSION.has(previous) || '(,=:[!&|?{};+-*%<>~^'.includes(previous))) {
+      // A regular expression literal.
+      i++;
+      let inClass = false;
+      while (i < n && source[i] !== '\n' && (inClass || source[i] !== '/')) {
+        if (source[i] === '\\') i++;
+        else if (source[i] === '[') inClass = true;
+        else if (source[i] === ']') inClass = false;
+        i++;
+      }
+      i++;
+      while (i < n && IDENTIFIER.test(source[i])) i++;
+      previous = ')';
+    } else if (IDENTIFIER.test(ch)) {
+      const start = i;
+      while (i < n && IDENTIFIER.test(source[i])) i++;
+      const word = source.slice(start, i);
+      if (STATEMENT_SET.has(word) && previous !== '.' && previous !== 'function') {
+        let next = i;
+        while (source[next] === ' ' || source[next] === '\t') next++;
+        if (source[next] === '(') {
+          out.push(source.slice(from, start), `${AT}(${word}, ${line})`);
+          from = i;
+        }
+      }
+      previous = /^[0-9]/.test(word) ? ')' : word;
+    } else if (ch === '{') {
+      templates.push(false);
+      previous = '{';
+      i++;
+    } else if (ch === '}') {
+      i++;
+      if (templates.pop()) template();
+      else previous = '}';
+    } else {
+      previous = ch === ')' || ch === ']' ? ')' : ch;
+      i++;
+    }
+  }
+  out.push(source.slice(from));
+  return out.join('');
+}
+
+// The line of the innermost frame of the script at url, or null when none is
+// on the stack. Where the host gives stack frames as objects (V8), they are
+// read directly, which is many times faster than formatting the stack as
+// text for every statement; elsewhere this returns undefined and the text is
+// searched.
+function innermostLine(url) {
+  if (typeof Error.captureStackTrace !== 'function') return undefined;
+  // A statement is usually called from the program itself, a few frames up,
+  // so a short stack is captured first and the whole one only when needed.
+  for (const limit of [10, Infinity]) {
+    const frames = callSites(limit);
+    if (!Array.isArray(frames)) return undefined;
+    for (const frame of frames) {
+      if (frame.getScriptNameOrSourceURL() === url) return frame.getLineNumber();
+    }
+    if (frames.length < limit) break;
+  }
+  return null;
+}
+
+function callSites(limit) {
+  const prepare = Error.prepareStackTrace;
+  const stackLimit = Error.stackTraceLimit;
+  const holder = {};
+  try {
+    Error.prepareStackTrace = (_, sites) => sites;
+    Error.stackTraceLimit = limit;
+    Error.captureStackTrace(holder, innermostLine);
+    return holder.stack;
+  } finally {
+    Error.prepareStackTrace = prepare;
+    Error.stackTraceLimit = stackLimit;
+  }
+}
+
 function compile(source, url) {
   // eslint-disable-next-line no-new-func
   return new Function('__eyecode_scope__', `with (__eyecode_scope__) {\n${source}\n}\n//# sourceURL=${url}`);
@@ -429,11 +604,18 @@ function execute(source, filename, builder, io) {
   const url = `eyecode-program-${id}.js`;
   let fn;
   try {
-    fn = compile(source, url);
-  } catch (error) {
-    throw new EyecodeError(`${filename}: ${error.name}: ${error.message}`);
+    fn = compile(markStatements(source), url);
+  } catch {
+    // Should the rewriting ever break the program, it runs as written.
+    try {
+      fn = compile(source, url);
+    } catch (error) {
+      throw new EyecodeError(`${filename}: ${error.name}: ${error.message}`);
+    }
   }
   builder.locate = () => {
+    const line = innermostLine(url);
+    if (line !== undefined) return line === null ? null : line - lineOffset() + 1;
     const lines = frameLines(new Error().stack, id);
     return lines.length ? lines[0] - lineOffset() + 1 : null;
   };

package/src/reader.js

@@ -22,77 +22,85 @@ function variableName(text, line) {
 
 // Numbers and names of any length, matched where the scan stands.
 const NUMBER = /(?:([0-9]+)n|((?:[0-9]+\.[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)|([0-9]+))/y;
-const NAME = /[A-Za-z0-9_$]+/y;
 
 const SIMPLE_ESCAPES = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v', 0: '\0', "'": "'", '"': '"', '\\': '\\' };
 
+const isDigit = (code) => code >= 48 && code <= 57;
+const isNameStart = (code) => (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95 || code === 36;
+const isNamePart = (code) => isNameStart(code) || isDigit(code);
+
+// The tokens of a text, read one ahead of the parser as it asks for them, so
+// a large document is never held as tokens all at once.
 class Tokens {
   constructor(text) {
     this.text = text;
     this.pos = 0;
     this.line = 1;
-    this.list = [];
-    this.scan();
-    this.index = 0;
+    this.current = this.read();
   }
 
   error(message, line = this.line) {
     return new EyecodeError(`line ${line}: ${message}`);
   }
 
-  scan() {
+  // The token at this.pos, moving past it.
+  read() {
     const { text } = this;
     const n = text.length;
-    let pos = 0;
-    let line = 1;
-    while (pos < n) {
-      const ch = text[pos];
-      if (ch === '\n') {
-        this.list.push({ kind: 'newline', text: '\n', line });
-        line++;
-        pos++;
-      } else if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '') {
-        pos++;
-      } else if (ch === '/' && text[pos + 1] === '/') {
-        while (pos < n && text[pos] !== '\n') pos++;
-      } else if (ch === '/' && text[pos + 1] === '*') {
-        const end = text.indexOf('*/', pos + 2);
-        if (end < 0) throw this.error('unterminated comment', line);
-        for (let i = pos; i < end; i++) if (text[i] === '\n') line++;
-        pos = end + 2;
-      } else if (ch === "'" || ch === '"') {
-        const [value, next] = this.string(pos, line);
-        this.list.push({ kind: 'string', text: value, line });
-        pos = next;
-      } else if (/[0-9.]/.test(ch) && (ch !== '.' || /[0-9]/.test(text[pos + 1] || ''))) {
-        NUMBER.lastIndex = pos;
-        const match = NUMBER.exec(text);
-        const after = text[pos + match[0].length] || '';
-        if (/[A-Za-z0-9_$.]/.test(after)) throw this.error(`malformed number ${text.slice(pos, pos + match[0].length + 1)}`, line);
-        if (match[1] !== undefined || match[3] !== undefined) {
-          const digits = match[1] !== undefined ? match[1] : match[3];
-          if (digits.length > 1 && digits[0] === '0') throw this.error(`an integer has no leading zero: ${digits}`, line);
-          this.list.push({ kind: 'int', text: digits, line });
+    let { pos, line } = this;
+    try {
+      while (pos < n) {
+        const ch = text[pos];
+        const code = ch.charCodeAt(0);
+        if (ch === '\n') {
+          pos++;
+          line++;
+          return { kind: 'newline', text: '\n', line: line - 1 };
+        } else if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '\ufeff') {
+          pos++;
+        } else if (ch === '/' && text[pos + 1] === '/') {
+          while (pos < n && text[pos] !== '\n') pos++;
+        } else if (ch === '/' && text[pos + 1] === '*') {
+          const end = text.indexOf('*/', pos + 2);
+          if (end < 0) throw this.error('unterminated comment', line);
+          for (let i = pos; i < end; i++) if (text[i] === '\n') line++;
+          pos = end + 2;
+        } else if (ch === "'" || ch === '"') {
+          const [value, next] = this.string(pos, line);
+          pos = next;
+          return { kind: 'string', text: value, line };
+        } else if (isDigit(code) || (ch === '.' && isDigit(text.charCodeAt(pos + 1)))) {
+          NUMBER.lastIndex = pos;
+          const match = NUMBER.exec(text);
+          const after = text.charCodeAt(pos + match[0].length);
+          if (isNamePart(after) || after === 46) throw this.error(`malformed number ${text.slice(pos, pos + match[0].length + 1)}`, line);
+          pos += match[0].length;
+          if (match[1] !== undefined || match[3] !== undefined) {
+            const digits = match[1] !== undefined ? match[1] : match[3];
+            if (digits.length > 1 && digits[0] === '0') throw this.error(`an integer has no leading zero: ${digits}`, line);
+            return { kind: 'int', text: digits, line };
+          }
+          return { kind: 'float', text: match[2], line };
+        } else if (isNameStart(code)) {
+          const start = pos;
+          pos++;
+          while (pos < n && isNamePart(text.charCodeAt(pos))) pos++;
+          return { kind: 'name', text: text.slice(start, pos), line };
+        } else if (ch === '.' && text[pos + 1] === '.' && text[pos + 2] === '.') {
+          pos += 3;
+          return { kind: 'punct', text: '...', line };
+        } else if ('()[]{},:;-'.includes(ch)) {
+          pos++;
+          return { kind: 'punct', text: ch, line };
         } else {
-          this.list.push({ kind: 'float', text: match[2], line });
+          throw this.error(`unexpected character ${JSON.stringify(ch)}`, line);
         }
-        pos += match[0].length;
-      } else if (/[A-Za-z_$]/.test(ch)) {
-        NAME.lastIndex = pos;
-        const match = NAME.exec(text);
-        this.list.push({ kind: 'name', text: match[0], line });
-        pos += match[0].length;
-      } else if (text.startsWith('...', pos)) {
-        this.list.push({ kind: 'punct', text: '...', line });
-        pos += 3;
-      } else if ('()[]{},:;-'.includes(ch)) {
-        this.list.push({ kind: 'punct', text: ch, line });
-        pos++;
-      } else {
-        throw this.error(`unexpected character ${JSON.stringify(ch)}`, line);
       }
+      return { kind: 'end', text: '', line };
+    } finally {
+      this.pos = pos;
+      this.line = line;
     }
-    this.list.push({ kind: 'end', text: '', line });
   }
 
   string(start, line) {
@@ -109,8 +117,15 @@ class Tokens {
       // A document spells control characters as escapes, as the writer does.
       if (ch < ' ' && ch !== '\t') throw this.error('a control character in a string must be escaped', line);
       if (ch !== '\\') {
-        out += ch;
-        pos++;
+        // A run of plain characters at once.
+        let end = pos + 1;
+        while (end < text.length) {
+          const code = text.charCodeAt(end);
+          if (code < 32 || code === 92 || text[end] === quote) break;
+          end++;
+        }
+        out += text.slice(pos, end);
+        pos = end;
         continue;
       }
       const next = text[pos + 1];
@@ -140,20 +155,22 @@ class Tokens {
   }
 
   peek() {
-    return this.list[this.index];
+    return this.current;
   }
 
   next() {
-    return this.list[this.index++];
+    const token = this.current;
+    if (token.kind !== 'end') this.current = this.read();
+    return token;
   }
 
   // Newlines inside brackets are layout.
   skipNewlines() {
-    while (this.list[this.index].kind === 'newline') this.index++;
+    while (this.current.kind === 'newline') this.current = this.read();
   }
 
   at(text) {
-    const token = this.list[this.index];
+    const token = this.current;
     return token.kind === 'punct' && token.text === text;
   }
 

package/src/version.js

@@ -1,2 +1,2 @@
 // The release this checkout is; ./release keeps it in step with package.json.
-export const VERSION = '0.1.4';
+export const VERSION = '0.1.5';