eyeprolog 1.2.37 → 1.2.39

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.37",
+  "version": "1.2.39",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/iso.js

@@ -1178,6 +1178,31 @@ function scopeReadTerm(term) {
   return { term: copy(term), variables };
 }
 
+function parseReadTermText(text, solver) {
+  const converted = convertedTermText(text, solver);
+  const operatorState = createParserOperatorState(solver.program.operators.values(), false);
+  const clauses = parseClauses(converted, {
+    sourceMetadata: false,
+    operatorState,
+    isoStrict: solver.isoStrict,
+    doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    // The stream scanner supplies one candidate ending at this full stop.
+    // Earlier ambiguous dots must remain available to maximal graphic tokens.
+    readTermEnd: converted.length - 1,
+  });
+  if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
+  return clauses[0].head;
+}
+
+export function isCompleteReadTermText(text, solver) {
+  try {
+    parseReadTermText(text, solver);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
 function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
@@ -1189,16 +1214,9 @@ function readTermFromStream(stream, solver) {
         throw new PrologError('syntax_error(read_term)');
       }
       try {
-        const operatorState = createParserOperatorState(solver.program.operators.values(), false);
-        const clauses = parseClauses(convertedTermText(candidate.text, solver), {
-          sourceMetadata: false,
-          operatorState,
-          isoStrict: solver.isoStrict,
-          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
-        });
-        if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
+        const term = parseReadTermText(candidate.text, solver);
         stream.position = candidate.end;
-        return scopeReadTerm(clauses[0].head);
+        return scopeReadTerm(term);
       } catch (_) {
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.

package/src/parser.js

@@ -1,7 +1,7 @@
 // Tokenizer and recursive-descent parser for the EyeProlog source language.
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
-import { isTerminatingFullStop } from './syntax-scan.js';
+import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
@@ -196,9 +196,25 @@ class Parser {
     this.infixOperators = operatorState.infixOperators;
     this.prefixOperators = operatorState.prefixOperators;
     this.postfixOperators = operatorState.postfixOperators;
+    this.readTermEnd = Number.isInteger(options.readTermEnd) ? options.readTermEnd : null;
     this.previousToken = null;
     this.token = this.nextToken();
   }
+  terminatingFullStop(index = this.pos) {
+    // read/1 tries each possible full stop in turn.  While parsing a later
+    // candidate, a preceding dot after a graphic character belongs to that
+    // maximal graphic token; the candidate's final dot is the end char.  Keep
+    // ordinary program parsing context-free by enabling this only for a
+    // designated read-term candidate.
+    if (this.readTermEnd != null) {
+      if (index === this.readTermEnd) return true;
+      if (index < this.readTermEnd && continuesGraphicToken(this.source, index)) {
+        const next = this.source[index + 1] ?? '';
+        if (next === '%' || /^[\u0009-\u000d\u0020]$/.test(next)) return false;
+      }
+    }
+    return isTerminatingFullStop(this.source, index);
+  }
   defineOperator(priority, specifier, name) {
     defineParserOperator(this, priority, specifier, name);
   }
@@ -366,15 +382,16 @@ class Parser {
       this.pos += 3;
       return { type: TOK.ATOM, text: '...', line };
     }
-    if (ch === '?' && this.peek(1) === '-') {
+    if (ch === '?' && this.peek(1) === '-' &&
+        !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
       this.pos += 2;
       return { type: TOK.ATOM, text: '?-', line };
     }
-    if (ch === '.' && !isTerminatingFullStop(this.source, this.pos)) {
+    if (ch === '.' && !this.terminatingFullStop()) {
       const start = this.pos;
       this.take();
       while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
-             !isTerminatingFullStop(this.source, this.pos)) this.take();
+             !this.terminatingFullStop()) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
     if (ch === '!') {
@@ -394,11 +411,13 @@ class Parser {
       this.take();
       return { type: punct[ch], text: ch, line, precededByLayout };
     }
-    if (ch === ':' && this.peek(1) === '-') {
+    if (ch === ':' && this.peek(1) === '-' &&
+        !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
       this.pos += 2;
       return { type: TOK.IF, text: ':-', line };
     }
-    if (ch === ':') {
+    if (ch === ':' &&
+        !(isGraphicAtomCode(this.peek(1).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 1))) {
       this.take();
       return { type: TOK.ATOM, text: ':', line };
     }
@@ -544,7 +563,7 @@ class Parser {
       const start = this.pos;
       this.take();
       while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
-             !isTerminatingFullStop(this.source, this.pos)) this.take();
+             !this.terminatingFullStop()) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
 
@@ -606,7 +625,9 @@ class Parser {
       this.advance();
       return atom('{}');
     }
-    const term = this.parseTerm(0, true);
+    // As with a parenthesized term, a current operator atom may be the entire
+    // curly-bracket content: `{*}` denotes {}(*), not an incomplete infix use.
+    const term = this.parseTerm(0, true, true, true);
     this.expect(TOK.RBRACE, '}');
     this.advance();
     return compound('{}', [term]);
@@ -732,7 +753,7 @@ class Parser {
       // an argument delimiter there is no operand for prefix syntax, so keep
       // the operator as an atom instead of reporting a misleading bad-term
       // error.
-      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.BAR, TOK.DOT].includes(this.token.type)) {
+      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.RBRACE, TOK.BAR, TOK.DOT].includes(this.token.type)) {
         if (!allowOperatorAtom && this.token.type !== TOK.DOT) {
           throw new Error(`parse line ${this.token.line}: operator atom ${op} requires argument context or parentheses`);
         }
@@ -1032,7 +1053,7 @@ export function parseClauses(source, options = {}) {
   const parserOptions = ownsParserFlagState
     ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes } }
     : options;
-  if (options.sourceMetadata === false) {
+  if (options.sourceMetadata === false && options.readTermEnd == null) {
     const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
     if (ownsParserFlagState) parserOptions.parserFlagState.doubleQuotes = initialDoubleQuotes;

package/src/repl.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
-import { formalErrorTerm } from './iso.js';
+import { formalErrorTerm, isCompleteReadTermText } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -162,7 +162,7 @@ class LineReader {
     return this.terminal && Number.isInteger(this.input.fd);
   }
 
-  readInteractiveTermSync() {
+  readInteractiveTermSync(solver = null) {
     if (!this.canReadTermSynchronously()) return null;
     let source = '';
     let prompt = '|: ';
@@ -172,7 +172,9 @@ class LineReader {
       if (line == null) return source.trim() ? source : null;
       source += `${line}\n`;
       const end = terminalFullStop(source);
-      if (end >= 0) return source.slice(0, end + 1) + '\n';
+      if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+        return source.slice(0, end + 1) + '\n';
+      }
       prompt = '|    ';
     }
   }
@@ -256,7 +258,7 @@ function makeState(engine, sources, output, options = {}, previousState = null,
     // let ISO term input request a complete terminal term exactly when read/1-2
     // or read_term/2-3 actually executes.  This also works inside conjunctions
     // and user predicates instead of only when read/* is the whole REPL goal.
-    userInput.interactiveReadTerm = () => reader.readInteractiveTermSync();
+    userInput.interactiveReadTerm = () => reader.readInteractiveTermSync(solver);
   }
   const flagOverrides = new Map(previousState?.flagOverrides ?? []);
   for (const [name, value] of flagOverrides) {
@@ -300,7 +302,7 @@ async function prepareInteractiveTermInput(state, goal, reader) {
   const stream = interactiveTermInputStream(state, goal);
   if (stream == null || terminalFullStop(String(stream.content).slice(stream.position)) >= 0) return;
 
-  const text = await readInteractiveTerm(reader);
+  const text = await readInteractiveTerm(reader, state.solver);
   if (text == null) return;
   stream.content += text;
   stream.pastEnd = false;
@@ -334,7 +336,7 @@ function explicitInputReference(term) {
   return null;
 }
 
-async function readInteractiveTerm(reader) {
+async function readInteractiveTerm(reader, solver = null) {
   let source = '';
   let prompt = '|: ';
   while (true) {
@@ -342,11 +344,22 @@ async function readInteractiveTerm(reader) {
     if (line == null) return source.trim() ? source : null;
     source += `${line}\n`;
     const end = terminalFullStop(source);
-    if (end >= 0) return source.slice(0, end + 1) + '\n';
+    if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+      return source.slice(0, end + 1) + '\n';
+    }
     prompt = '|    ';
   }
 }
 
+function acceptsReadTermBoundary(source, end, solver) {
+  // A dot after a graphic character has two possible readings.  Stop at once
+  // when the candidate is already a complete term (for example `./*.`);
+  // otherwise keep reading so a later end char can make it part of an atom
+  // (for example the first dot in `!,*.\n.`).
+  return !continuesGraphicToken(source, end) || solver == null ||
+    isCompleteReadTermText(source.slice(0, end + 1), solver);
+}
+
 function terminalFullStop(source) {
   let quote = null;
   let lineComment = false;

package/src/write.js

@@ -227,7 +227,9 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   }
 
   if (!options.ignoreOps && resolved.name === '{}' && resolved.arity === 1) {
-    return `{${format(resolved.args[0], env, options, table, 1200)}}`;
+    // A current operator atom is valid as the complete curly-bracket content,
+    // just as it is in a functional argument or list element.
+    return `{${format(resolved.args[0], env, options, table, 1200, 'argument')}}`;
   }
 
   if (!options.ignoreOps) {

package/test/conformance/cases/iso/lexical_and_curly_terms.pl

@@ -9,6 +9,7 @@ answer(Binary, Octal, Hex, Character, Escaped, Curly, EmptyCurly, IntegerPart, F
     =(Character, 0'\n),
     =(Escaped, 'A\x42\\101\'),
     =(Curly, {pair(a, b)}),
+    {*} = {}(*),
     =(EmptyCurly, {}),
     IntegerPart is float_integer_part(-3.75),
     FractionalPart is float_fractional_part(-3.75).

package/test/run-regression.mjs

@@ -38,7 +38,7 @@ import {
   variantTerms,
   parseProgramText,
 } from '../src/index.js';
-import { parseGoalText, parseNumberTokenText } from '../src/parser.js';
+import { ISO_OPERATOR_DEFINITIONS, parseGoalText, parseNumberTokenText } from '../src/parser.js';
 import { compareTerms } from '../src/term.js';
 import { formatTermForWrite } from '../src/write.js';
 import { selectClauseCandidates } from '../src/program.js';
@@ -752,6 +752,31 @@ c4 ?- call((!;1)).
         });
         assertEqual(consecutive.stdout, "answer('./*.', ok).\n", 'following read starts after the complete term');
 
+        // A possible full stop can fail to complete the term while still
+        // extending a current graphic operator into an ordinary atom.  The
+        // later standalone full stop then completes the read term.  Exercise
+        // every predefined graphic operator, including the tokenizer's
+        // special :- and ?- cases, so they cannot diverge from * again.
+        const graphicOperator = /^[#$&*+\-./<=>?@^~\\:]+$/;
+        const graphicOperators = [...new Set(ISO_OPERATOR_DEFINITIONS.map(([, , name]) => name))]
+          .filter((name) => graphicOperator.test(name));
+        for (const name of graphicOperators) {
+          const program = Program.parse('');
+          const solver = new Solver(program, {
+            registry: getEyePrologRegistry(),
+            ioOptions: { input: `!,${name}.\n.\n` },
+          });
+          const readGoal = parseGoalText('read(T)', {
+            operatorDefinitions: [...program.operators.values()],
+          });
+          const answers = [...solver.solve([readGoal], new Env(), 0)];
+          assertEqual(answers.length, 1, `graphic operator read answer for ${name}`);
+          const term = copyResolved(readGoal.args[0], answers[0]);
+          assertEqual(term.name, ',', `graphic operator conjunction for ${name}`);
+          assertEqual(term.args[0].name, '!', `graphic operator left operand for ${name}`);
+          assertEqual(term.args[1].name, `${name}.`, `graphic operator atom for ${name}`);
+        }
+
         let error = null;
         try {
           runEyeProlog('', { goal: 'read(T)', ioOptions: { input: '!.!.' } });
@@ -769,6 +794,15 @@ c4 ?- call((!;1)).
         assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
         assertIncludes(repl.stdout, 'error(syntax_error(read_term), eyeprolog)', 'REPL syntax error');
         assertEqual(repl.stderr, '', 'REPL stderr');
+
+        const continuedGraphic = runCli([], {
+          input: 'read(T).\n!,*.\n.\nread(T).\na\n.\nhalt.\n',
+        });
+        assertEqual(continuedGraphic.status, 0, 'continued graphic operator REPL status');
+        assertIncludes(continuedGraphic.stdout, 'T = (!, *.).', 'continued graphic operator answer');
+        assertIncludes(continuedGraphic.stdout, 'T = a.', 'read after continued graphic operator');
+        assertNotIncludes(continuedGraphic.stdout, 'syntax_error', 'continued graphic operator syntax');
+        assertEqual(continuedGraphic.stderr, '', 'continued graphic operator REPL stderr');
       },
     },
     {
@@ -782,6 +816,38 @@ c4 ?- call((!;1)).
         assertNotIncludes(result.stdout, "'?-'", 'writeq(?-) has no quotes');
       },
     },
+    {
+      name: 'curly brackets accept ISO and custom operator atoms (issue #41)',
+      run: () => {
+        const operatorNames = [...new Set(ISO_OPERATOR_DEFINITIONS.map(([, , name]) => name))]
+          .filter((name) => name !== ',');
+        for (const name of operatorNames) {
+          const holder = parseGoalText(`holder({${name}})`);
+          const curly = holder.args[0];
+          assertEqual(curly.name, '{}', `curly functor for ${name}`);
+          assertEqual(curly.args[0].name, name, `curly operator atom ${name}`);
+        }
+
+        const customProgram = parseProgramText([
+          ':- op(100, fx, pre).',
+          ':- op(100, xf, post).',
+          ':- op(100, xfx, infix).',
+          'custom({pre}, {post}, {infix}).',
+          '',
+        ].join('\n'));
+        const custom = customProgram.find((clause) => clause.head.name === 'custom').head;
+        assertEqual(
+          custom.args.map((curly) => curly.args[0].name).join(','),
+          'pre,post,infix',
+          'custom prefix, postfix, and infix operator atoms',
+        );
+
+        const repl = runCli([], { input: 'read(T).\n{*}.\nhalt.\n' });
+        assertEqual(repl.status, 0, 'curly operator REPL status');
+        assertIncludes(repl.stdout, 'T = {*}.', 'curly operator REPL answer');
+        assertNotIncludes(repl.stdout, '{(*)}', 'curly operator has no unnecessary parentheses');
+      },
+    },
     {
       name: 'normal parser rejects non-conforming bare operator operands',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5197,12 +5197,14 @@ parsing of subsequent text, place them before their first use. ISO argument
 syntax also permits an atom that is currently an operator to appear directly
 as a functional argument or list element, so forms such as
 `current_op(Priority, Specifier, :-)` and `[:-,-]` are valid without quoting
-or parenthesizing those operator atoms. Term output observes the same `arg`
-rule: with `quoted(true)`, an operator atom is not quoted merely because it is
-an operator when it occurs as a functional argument or list element. Thus
-`writeq([:-,-])` emits `[:-,-]`, and `writeq(f(;,'|',';;'))` emits
-`f(;,'|',';;')`; the bar stays quoted because ISO treats the unquoted `|`
-token as a list separator rather than an atom. The ISO initial operator table also
+or parenthesizing those operator atoms. A current operator atom may likewise
+be the complete content of parentheses or curly brackets: `(+)` denotes the
+atom `+`, and `{*}` denotes the curly term `{}(*)`. Term output observes the
+same context rules: with `quoted(true)`, an operator atom is not quoted merely
+because it occurs as a functional argument, list element, or sole curly-bracket
+content. Thus `writeq({*})` emits `{*}`, `writeq([:-,-])` emits `[:-,-]`, and
+`writeq(f(;,'|',';;'))` emits `f(;,'|',';;')`; the bar stays quoted because
+ISO treats the unquoted `|` token as a list separator rather than an atom. The ISO initial operator table also
 contains `?-` at priority 1200 with specifier `fx`, so
 `current_op(1200, fx, ?-)` succeeds. EyeProlog's embedded quad syntax permits
 an optional label before the query marker (`Label ?- Query.`), so while quad