eyeprolog 1.2.35 → 1.2.37

package/package.json

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

package/src/iso.js

@@ -9,7 +9,9 @@ import { sameNumberValue } from './number-value.js';
 import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
-import { characterCodeConstantEnd, quotedEscapeEnd } from './syntax-scan.js';
+import {
+  characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
+} from './syntax-scan.js';
 
 let isoFresh = 0;
 
@@ -1072,20 +1074,6 @@ function* nlBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function isTerminatingFullStop(source, index) {
-  const previous = source[index - 1] ?? '';
-  const next = source[index + 1] ?? '';
-  if (previous === '.' || next === '.') return false;
-  if (/\d/.test(previous) && /\d/.test(next)) return false;
-  if (/[A-Za-z0-9_]/.test(previous) && /[A-Za-z0-9_]/.test(next)) return false;
-  return true;
-}
-
-const termGraphicCharacters = new Set('#$&*+-./<=>?@^~\\:');
-function continuesGraphicToken(source, index) {
-  return index > 0 && termGraphicCharacters.has(source[index - 1]);
-}
-
 function* termTextCandidates(stream) {
   const source = String(stream.content);
   let quote = null, lineComment = false, blockComment = false;

package/src/parser.js

@@ -1,6 +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';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
@@ -369,12 +370,11 @@ class Parser {
       this.pos += 2;
       return { type: TOK.ATOM, text: '?-', line };
     }
-    if (ch === '.' && this.peek(1) &&
-        !isWhitespaceCode(this.peek(1).charCodeAt(0)) &&
-        this.peek(1) !== '%' && !(this.peek(1) === '/' && this.peek(2) === '*')) {
+    if (ch === '.' && !isTerminatingFullStop(this.source, this.pos)) {
       const start = this.pos;
       this.take();
-      while (isGraphicAtomCode(this.peek().charCodeAt(0))) this.take();
+      while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
+             !isTerminatingFullStop(this.source, this.pos)) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
     if (ch === '!') {
@@ -543,7 +543,8 @@ class Parser {
     if (isGraphicAtomCode(ch.charCodeAt(0))) {
       const start = this.pos;
       this.take();
-      while (isGraphicAtomCode(this.peek().charCodeAt(0))) this.take();
+      while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
+             !isTerminatingFullStop(this.source, this.pos)) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
 

package/src/repl.js

@@ -4,7 +4,9 @@ import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { formalErrorTerm } from './iso.js';
-import { characterCodeConstantEnd, quotedEscapeEnd } from './syntax-scan.js';
+import {
+  characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
+} from './syntax-scan.js';
 
 const ANSWER_HELP = `
 SPACE, "n" or ";": next solution, if any
@@ -389,7 +391,7 @@ function terminalFullStop(source) {
       lineComment = true;
       continue;
     }
-    if (ch === '/' && next === '*') {
+    if (ch === '/' && next === '*' && !continuesGraphicToken(source, i)) {
       blockComment = true;
       i++;
       continue;
@@ -400,7 +402,8 @@ function terminalFullStop(source) {
     }
     if ('([{'.includes(ch)) depth++;
     else if (')]}'.includes(ch)) depth = Math.max(0, depth - 1);
-    else if (ch === '.' && depth === 0 && onlyLayoutAndComments(source.slice(i + 1))) return i;
+    else if (ch === '.' && depth === 0 && isTerminatingFullStop(source, i) &&
+             onlyLayoutAndComments(source.slice(i + 1))) return i;
   }
   return -1;
 }
@@ -614,6 +617,7 @@ function formatAnswer(engine, state, variables, env) {
       // current operator atoms in argument and list-element positions without
       // quotes, just as writeq/1 already prints them.
       operatorAtomsAsArgs: true,
+      dottedGraphicAtoms: true,
       doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
     })}`);
   }

package/src/syntax-scan.js

@@ -2,6 +2,26 @@
 // readers. These locate token boundaries only; parser.js remains responsible
 // for accepting or rejecting the token itself.
 
+const graphicTokenCharacters = new Set('#$&*+-./<=>?@^~\\:');
+
+export function continuesGraphicToken(source, index) {
+  return index > 0 && graphicTokenCharacters.has(source[index - 1]);
+}
+
+export function isTerminatingFullStop(source, index) {
+  if (source[index] !== '.') return false;
+  const next = source[index + 1] ?? '';
+  // At a line boundary, after a single-line comment marker, or at end of
+  // input, the dot is the read-term end char. Before horizontal layout it is
+  // instead part of an already-started graphic token: `./*. .` is the atom
+  // `./*.` followed by its separate end char. A directly following /* also
+  // stays in the current graphic token; bracketed comments are recognized
+  // only when /* begins a token.
+  if (next === '' || next === '%' || next === '\n' || next === '\r') return true;
+  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return !continuesGraphicToken(source, index);
+  return false;
+}
+
 export function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;

package/src/write.js

@@ -5,6 +5,7 @@ import {
 } from './term.js';
 
 const graphicAtomCharacters = new Set('!#$&*+-/<=>?@^~\\'.split(''));
+const dottedGraphicAtomCharacters = new Set([...graphicAtomCharacters, '.']);
 const compactInfixOperators = new Set([':', '..']);
 
 function quotedControlEscape(ch) {
@@ -48,6 +49,11 @@ function writeAtom(name) {
   return atomNeedsQuotes(name) ? quoteAtom(name) : name;
 }
 
+function isDottedGraphicAtom(name) {
+  return name.includes('.') && [...name].some((ch) => ch !== '.') && !name.startsWith('/*') &&
+    [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
+}
+
 function legacyVariableToIso(name) {
   if (name === '?') return '_';
   const tail = name.slice(1);
@@ -172,6 +178,10 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   if (resolved.type === STRING) return writeString(resolved.name);
   if (resolved.type === ATOM) {
     if (!options.quoted) return resolved.name;
+    // Top-level bindings are already delimited by their answer punctuation.
+    // Keep valid dotted graphic tokens readable there without weakening the
+    // ISO writeq/1 policy tested by WG17 #308.
+    if (options.dottedGraphicAtoms && isDottedGraphicAtom(resolved.name)) return resolved.name;
     // ISO 6.3.3.1 gives functional arguments and list elements a special
     // `arg` production: an atom that is a current operator is valid there
     // without quoting. Keep lexical exceptions such as `|` quoted.
@@ -269,6 +279,7 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     variableNames: printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
+    dottedGraphicAtoms: options.dottedGraphicAtoms === true,
   };
   const maxPriority = Number.isInteger(options.maxPriority)
     ? Math.max(0, Math.min(1200, options.maxPriority))

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

@@ -5,7 +5,7 @@ text_roundtrip(Term, Peek, Code, Mode, Alias) :-
     open('/tmp/eyeprolog-iso-text.txt', write, Output, [alias(iso_text_output), type(text)]),
     writeq(iso_text_output, sample(42)),
     put_char(iso_text_output, '.'),
-    put_char(iso_text_output, 'Z'),
+    put_char(iso_text_output, ' '),
     close(Output),
     open('/tmp/eyeprolog-iso-text.txt', read, Input, [alias(iso_text_input), eof_action(eof_code)]),
     stream_property(Input, mode(Mode)),

package/test/conformance/expected/iso/streams_and_term_io.pl

@@ -1,4 +1,4 @@
-text_roundtrip(sample(42), 'Z', 90, read, iso_text_input).
+text_roundtrip(sample(42), ' ', 32, read, iso_text_input).
 binary_roundtrip(65, 65, -1).
 read_term_metadata(ok).
 default_streams(ok).

package/test/conformance/expected-errors/syntax/extra_double_period_rejected.txt

@@ -1 +1 @@
-parse line 1: expected ., got ..
+parse line 1: expected ., got .

package/test/run-regression.mjs

@@ -733,6 +733,44 @@ c4 ?- call((!;1)).
         assertIncludes(upstreamResult.stdout, '46 true.', 'WG17 #367 output');
       },
     },
+    {
+      name: 'readers distinguish graphic tokens, comments, and full stops (issue #41)',
+      run: () => {
+        const parsed = parseProgramText('./*.');
+        assertEqual(parsed.length, 1, 'graphic atom clause count');
+        assertEqual(parsed[0].head.name, './*', 'comment opener stays inside graphic atom');
+
+        const read = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: './*.' },
+        });
+        assertEqual(read.stdout, "read('./*').\n", 'graphic atom writeq readback');
+
+        const consecutive = runEyeProlog('answer(A, B) :- read(A), read(B).\n', {
+          goal: 'answer(A, B)',
+          ioOptions: { input: './*. .\nok.\n' },
+        });
+        assertEqual(consecutive.stdout, "answer('./*.', ok).\n", 'following read starts after the complete term');
+
+        let error = null;
+        try {
+          runEyeProlog('', { goal: 'read(T)', ioOptions: { input: '!.!.' } });
+        } catch (caught) {
+          error = caught;
+        }
+        assertEqual(error?.message, 'error(syntax_error(read_term))', 'solo-token sequence rejection');
+
+        const repl = runCli([], {
+          input: 'read(T).\n./*. .\nread(T).\nok.\nread(T).\n!.!.\nhalt.\n',
+        });
+        assertEqual(repl.status, 0, 'REPL exit status');
+        assertIncludes(repl.stdout, 'T = ./*..', 'REPL dotted graphic atom answer');
+        assertNotIncludes(repl.stdout, "T = './*.'", 'REPL dotted graphic atom has no spurious quotes');
+        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');
+      },
+    },
     {
       name: 'question mark is a graphic character and writeq keeps graphic atoms unquoted',
       run: () => {
@@ -2781,20 +2819,22 @@ open(X) :- candidate(X), \\+ closed(X).
           const goal = parseGoalText('trial(Chars)');
           let count = 0;
           for (const _ of solver.solve([goal], new Env(), 0)) {
-            if (++count === 500000) break;
+            if (++count === 50000) break;
           }
-          if (count !== 500000) throw new Error('unexpected answer count: ' + count);
+          if (count !== 50000) throw new Error('unexpected answer count: ' + count);
           process.stdout.write(String(count));
         `;
         const result = spawnSync(process.execPath, [
-          '--max-old-space-size=64',
+          // A smaller heap preserves the original false-exhaustion signal
+          // without requiring half a million transient conversion attempts.
+          '--max-old-space-size=32',
           '--input-type=module',
           '--eval',
           script,
-        ], { cwd: packageRoot, encoding: 'utf8', timeout: 45000 });
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
         if (result.error) throw result.error;
         assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
-        assertEqual(result.stdout, '500000', 'distinct number syntax attempts');
+        assertEqual(result.stdout, '50000', 'distinct number syntax attempts');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -5369,9 +5369,16 @@ comment continues to the end of its line. Doubling the active delimiter is
 also accepted inside either quoted form, so `""` inside double-quoted notation
 denotes one literal double quote character.
 
-Graphic atoms may contain `#$&*+-/<=>@^~\;`. A colon is the Part 2 module
-qualification operator in `Module:Goal`; quote an atom whose name itself
-contains a colon. Unquoted angle-bracket IRIs are not syntax.
+Graphic tokens use the characters `#$&*+-./<=>?@^~\`; `!` and `;` are solo
+atoms. A colon is the Part 2 module qualification operator in `Module:Goal`;
+quote an atom whose name itself contains a colon. Unquoted angle-bracket IRIs
+are not syntax.
+
+A `/*` sequence opens a block comment only when it begins a token; inside a
+maximal graphic token the slash and star remain atom characters. A period ends
+a term only when it is recognized as the terminating full stop. Consequently,
+`./*.` at the end of a line reads the atom `./*`, whereas `./*. .` reads the
+atom `./*.` and consumes the second period as the terminator.
 
 In the grammar below, `{ x }` means zero or more repetitions of `x`, `[ x ]`
 means that `x` is optional, and parentheses group alternatives. These marks