eyeprolog 1.1.7 → 1.1.8

package/package.json

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

package/src/dcg.js

@@ -37,14 +37,14 @@ function terminalItems(term, env = new Env()) {
   const seen = new Set();
   let cursor = deref(term, env);
   while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
-    if (seen.has(cursor)) throw new PrologError('type_error(terminal_sequence)', original);
+    if (seen.has(cursor)) throw new PrologError('type_error(list)', original);
     seen.add(cursor);
     items.push(cursor.args[0]);
     cursor = deref(cursor.args[1], env);
   }
   if (cursor.type === ATOM && cursor.name === '[]') return items;
   if (cursor.type === VAR) throw new PrologError('instantiation_error');
-  throw new PrologError('type_error(terminal_sequence)', original);
+  throw new PrologError('type_error(list)', original);
 }
 
 function terminalsGoal(terminals, input, output, env) {
@@ -155,8 +155,12 @@ export function expandDcgBody(body, input, output, options = {}) {
   // definitions and documents these choices in its conformance profile.
   if (body.type === COMPOUND && body.name === '\\+' && body.arity === 1) {
     const ignored = freshDcgVariable('negated');
+    const negated = body.args[0];
+    const expandedNegated = negated.type === ATOM || negated.type === COMPOUND || negated.type === VAR
+      ? expandDcgBody(negated, input, ignored, options)
+      : negated;
     return conjunction(
-      compound('\\+', [expandDcgBody(body.args[0], input, ignored, options)]),
+      compound('\\+', [expandedNegated]),
       equality(input, output),
     );
   }
@@ -175,6 +179,50 @@ export function expandDcgBody(body, input, output, options = {}) {
   return appendStateArguments(body, input, output, module);
 }
 
+// Embedded goals are validated before the translated grammar is executed.
+// This keeps a non-callable goal visible even when an earlier terminal or
+// branch would otherwise prevent the host goal from being reached.
+export function validateDcgEmbeddedGoals(body, input, output) {
+  const invalidBody = invalidDcgControl(body);
+  if (invalidBody != null) throw new PrologError('type_error(callable)', invalidBody);
+
+  const visit = (term) => {
+    if (term.type !== COMPOUND) return;
+    if (term.name === '{}' && term.arity === 1) {
+      if (invalidControlGoal(term.args[0])) {
+        // Report the translated host-language conjunction, matching the
+        // convention used by Trealla and the ISO Part 3 quad corpus.
+        throw new PrologError('type_error(callable)', conjunction(term.args[0], equality(input, output)));
+      }
+      return;
+    }
+    if ([',', ';', '|', '->', '\\+'].includes(term.name)) {
+      for (const argument of term.args) visit(argument);
+    }
+  };
+  visit(body);
+}
+
+function invalidDcgControl(term) {
+  if (term.type !== ATOM && term.type !== COMPOUND && term.type !== VAR) return term;
+  if (term.type !== COMPOUND || ![',', ';', '|', '->'].includes(term.name)) return null;
+  for (const argument of term.args) {
+    if (argument.type === COMPOUND && argument.name === '{}' && argument.arity === 1) continue;
+    const invalid = invalidDcgControl(argument);
+    if (invalid != null) return invalid;
+  }
+  return null;
+}
+
+function invalidControlGoal(goal) {
+  if (goal.type === VAR) return false;
+  if (goal.type !== ATOM && goal.type !== COMPOUND) return true;
+  if (goal.type === COMPOUND && [',', ';', '->'].includes(goal.name) && goal.arity === 2) {
+    return goal.args.some(invalidControlGoal);
+  }
+  return false;
+}
+
 function splitGrammarHead(head) {
   let terminals = null;
   if (head.type === COMPOUND && head.name === ',' && head.arity === 2) {

package/src/iso.js

@@ -7,7 +7,7 @@ import {
 } from './term.js';
 import { createParserOperatorState, parseClauses } from './parser.js';
 import { formatTermForWrite } from './write.js';
-import { emptyTerminalSequence, expandDcgBody, isListOrPartialList } from './dcg.js';
+import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 
 let isoFresh = 0;
 
@@ -490,7 +490,7 @@ function* clauseBuiltin({ solver, goal, env }) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
   callableOrVariable(goal.args[1], env);
   const indicator = compound('/', [atom(head.name), numberTerm(head.arity)]);
-  if (solver.registry.get(head.name, head.arity)) {
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(head)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
   }
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
@@ -529,9 +529,13 @@ function procedureIndicator(head) {
   return compound('/', [atom(head.name), numberTerm(head.arity)]);
 }
 
+function isGrammarRuleProcedure(head) {
+  return head.name === '-->' && head.arity === 2;
+}
+
 function assertModifiable(solver, head, module = 'user') {
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? module);
-  if (solver.registry.get(head.name, head.arity) || (group && !group.dynamic)) {
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(head));
   }
 }
@@ -558,7 +562,7 @@ function* retractBuiltin({ solver, goal, env }) {
   const parts = clauseParts(goal.args[0], env);
   requireClauseHead(parts.head);
   const group = solver.program.findGroup(parts.head.name, parts.head.arity, parts.head.module ?? goal.module ?? 'user');
-  if (solver.registry.get(parts.head.name, parts.head.arity) || (group && !group.dynamic)) {
+  if (solver.registry.get(parts.head.name, parts.head.arity) || isGrammarRuleProcedure(parts.head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(parts.head));
   }
   if (!group) return;
@@ -581,7 +585,7 @@ function* retractAllBuiltin({ solver, goal, env }) {
   const head = deref(goal.args[0], env);
   requireClauseHead(head);
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
-  if (solver.registry.get(head.name, head.arity) || (group && !group.dynamic)) {
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(head));
   }
   if (group) {
@@ -615,7 +619,7 @@ function* abolishBuiltin({ solver, goal, env }) {
   const target = predicateIndicatorParts(goal.args[0], env);
   const module = goal.module ?? 'user';
   const group = solver.program.findGroup(target.name, target.arity, module);
-  if (solver.registry.get(target.name, target.arity) || (group && !group.dynamic)) {
+  if (solver.registry.get(target.name, target.arity) || isGrammarRuleProcedure(target) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', target.indicator);
   }
   solver.program.abolishDynamicGroup(target.name, target.arity, module);
@@ -1519,8 +1523,19 @@ function callable(term, env) {
   term = resolveCallable(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
   if (term.type !== ATOM && term.type !== COMPOUND) throw new PrologError('type_error(callable)', term);
+  validateControlCallable(term, term);
   return term;
 }
+function validateControlCallable(term, culprit) {
+  if (term.type !== COMPOUND || ![',', ';', '->'].includes(term.name) || term.arity !== 2) return;
+  for (const argument of term.args) {
+    if (argument.type === VAR) throw new PrologError('instantiation_error');
+    if (argument.type !== ATOM && argument.type !== COMPOUND) {
+      throw new PrologError('type_error(callable)', culprit);
+    }
+    validateControlCallable(argument, culprit);
+  }
+}
 function resolveCallable(term, env) {
   const resolved = deref(term, env);
   if (resolved.type !== COMPOUND) return resolved;
@@ -1555,14 +1570,14 @@ function* phraseBuiltin({ solver, goal, env }) {
   if (grammarBody.type !== ATOM && grammarBody.type !== COMPOUND) {
     throw new PrologError('type_error(callable)', grammarBody);
   }
-
   const input = goal.args[1];
   const requestedOutput = goal.arity === 2 ? emptyTerminalSequence() : goal.args[2];
+  validateDcgEmbeddedGoals(grammarBody, input, requestedOutput);
   if (!isListOrPartialList(input, env)) {
-    throw new PrologError('type_error(terminal_sequence)', deref(input, env));
+    throw new PrologError('type_error(list)', deref(input, env));
   }
   if (!isListOrPartialList(requestedOutput, env)) {
-    throw new PrologError('type_error(terminal_sequence)', deref(requestedOutput, env));
+    throw new PrologError('type_error(list)', deref(requestedOutput, env));
   }
 
   // Delay the final output unification to keep phrase/3 steadfast in its

package/src/parser.js

@@ -33,7 +33,7 @@ function isPlainAtomStartCode(code) {
   return code >= 97 && code <= 122;
 }
 
-const graphicAtomChars = '#$&*+-./<=>@^~\\;:';
+const graphicAtomChars = '#$&*+-./<=>@^~\\:';
 
 // ISO operator syntax is lowered to the same ordinary compound terms used by
 // canonical notation. Commas remain separators except inside parentheses.
@@ -285,10 +285,22 @@ 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) === '*')) {
+      const start = this.pos;
+      this.take();
+      while (isGraphicAtomCode(this.peek().charCodeAt(0))) this.take();
+      return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
+    }
     if (ch === '!') {
       this.take();
       return { type: TOK.ATOM, text: '!', line };
     }
+    if (ch === ';') {
+      this.take();
+      return { type: TOK.ATOM, text: ';', line };
+    }
 
     const punct = {
       '(': TOK.LPAREN, ')': TOK.RPAREN, '[': TOK.LBRACKET, ']': TOK.RBRACKET,

package/src/quads.js

@@ -192,12 +192,21 @@ function executeQuery(program, query, input, maxSolutions, options) {
   const solver = new Solver(program, {
     ...options,
     registry: options.registry ?? getEyePrologRegistry(),
-    solutionLimit: Math.max(1, maxSolutions),
+    // The solver's counter also observes completed nested searches (for
+    // example each arm of a DCG disjunction).  Bound the public iterator here
+    // instead of letting those internal completions consume the quad's answer
+    // allowance.
+    solutionLimit: Math.max(maxSolutions, options.solutionLimit ?? 10000000),
     ioOptions: {
       input,
       write: (text) => { pendingOutput += String(text); },
     },
   });
+  // Undefined predicates are test failures rather than silent negative
+  // answers unless the source explicitly selected another unknown policy.
+  if (!(program.prologFlagDirectives ?? []).some(([flag]) => flag.type === ATOM && flag.name === 'unknown')) {
+    solver.prologFlags.get('unknown').value = atom('error');
+  }
   const solutions = [];
   let error = null;
   let tailOutput = '';

package/src/solver.js

@@ -281,6 +281,12 @@ export class Solver {
         this.stats.solve_one_goal_calls++;
         const group = this.program.findGroup(goal.name, goal.arity, goal.module ?? 'user');
         if (!group) {
+          if (goal.name === '-->' && goal.arity === 2) {
+            throw new PrologError(
+              'existence_error(procedure)',
+              compound('/', [compound('-->', []), numberTerm(2)]),
+            );
+          }
           if (this.prologFlags.get('unknown')?.value?.name === 'error') {
             throw new PrologError(
               'existence_error(procedure)',

package/test/conformance/THIRD_PARTY.md

@@ -13,8 +13,8 @@ Part 3 grammar cases are additionally adapted from Logtalk's
 `tests/logtalk/methods/phrase_2_3/tests.lgt` and
 `tests/logtalk/dcgs/tests.lgt` suites. Object and unit-test scaffolding was
 removed, translator-only assertions were converted to executable grammar
-behavior where possible, and expected list errors follow the Part 3
-`terminal_sequence` terminology used by EyeProlog.
+behavior where possible, and expected list errors use the portable ISO
+`type_error(list)` term.
 
 Copyright 1998-2026 Paulo Moura <pmoura@logtalk.org>
 

package/test/conformance/expected-errors/iso/dcg_phrase_bad_input.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), not_a_terminal_sequence)
+error(type_error(list), not_a_terminal_sequence)

package/test/conformance/expected-errors/iso/dcg_phrase_bad_output.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), not_a_terminal_sequence)
+error(type_error(list), not_a_terminal_sequence)

package/test/conformance/expected-errors/iso/logtalk_dcg_bad_input_precedence.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), not_a_terminal_sequence)
+error(type_error(list), not_a_terminal_sequence)

package/test/conformance/expected-errors/iso/logtalk_dcg_bad_output_precedence.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), not_a_terminal_sequence)
+error(type_error(list), not_a_terminal_sequence)

package/test/conformance/expected-errors/iso/logtalk_dcg_embedded_noncallable.txt

@@ -1 +1 @@
-error(type_error(callable), 1)
+error(type_error(callable), (1, =([], [])))

package/test/conformance/expected-errors/iso/logtalk_dcg_improper_semicontext.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), [a | b])
+error(type_error(list), [a | b])

package/test/conformance/expected-errors/iso/logtalk_dcg_improper_terminal_rule.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), [a | b])
+error(type_error(list), [a | b])

package/test/conformance/expected-errors/iso/logtalk_dcg_invalid_semicontext.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), b)
+error(type_error(list), b)

package/test/conformance/expected-errors/iso/logtalk_dcg_nested_noncallable.txt

@@ -1 +1 @@
-error(type_error(callable), 1)
+error(type_error(callable), (1, =([__anon1], [])))

package/test/conformance/expected-errors/iso/logtalk_dcg_noncallable_after_failure.txt

@@ -1 +1 @@
-error(type_error(callable), 1)
+error(type_error(callable), (1, =("y", [])))

package/test/conformance/expected-errors/iso/logtalk_dcg_noncallable_after_success.txt

@@ -1 +1 @@
-error(type_error(callable), 1)
+error(type_error(callable), (1, =([__anon1], [])))

package/test/conformance/expected-errors/iso/logtalk_dcg_phrase_improper_input.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), [a | b])
+error(type_error(list), [a | b])

package/test/conformance/expected-errors/iso/logtalk_dcg_phrase_improper_output.txt

@@ -1 +1 @@
-error(type_error(terminal_sequence), [a | b])
+error(type_error(list), [a | b])

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

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

package/test/run-regression.mjs

@@ -198,6 +198,19 @@ why(
         assertEqual(Boolean(program.findGroup('?-', 2)), false, 'quad is inert');
       },
     },
+    {
+      name: 'parser separates compact ISO solo tokens and atom dots',
+      run: () => {
+        const program = Program.parse(
+          `compact ?- call((!;\\+1)).\n   true.\n\n` +
+          `dot ?- functor([_],.,2).\n   true.\n`,
+        );
+        assertEqual(program.quads.length, 2, 'quad count');
+        assertEqual(program.quads[0].query.args[0].name, ';', 'disjunction');
+        assertEqual(program.quads[0].query.args[0].args[1].name, '\\+', 'negation');
+        assertEqual(program.quads[1].query.args[1].name, '.', 'dot atom');
+      },
+    },
     {
       name: 'runQuads checks portable answer descriptions',
       run: () => {
@@ -221,6 +234,81 @@ why(
         assertEqual(result.stdout, 'quads: 12 run, 12 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads matches the corrected ISO phrase quad boundaries',
+      run: () => {
+        const source = String.raw`c2 ?- call((1,fail)).
+   type_error(callable,(1,fail)).
+
+c3 ?- call((fail,1)).
+   type_error(callable,(fail,1)).
+
+c4 ?- call((!;1)).
+   type_error(callable,(!;1)).
+
+24 ?- asserta((a-->b)).
+   permission_error(modify,static_procedure,(-->)/2).
+
+25 ?- clause((a-->b),B).
+   permission_error(access,private_procedure,(-->)/2).
+
+26 ?- (X-->Y).
+   existence_error(procedure,(-->)/2).
+
+5 ?- phrase([a|b],L).
+   type_error(list,[a|b]).
+
+10 ?- phrase(([a],{1}),[]).
+   type_error(callable,(...,...)).
+
+37 ?- phrase((!,[a],{1}),[]).
+   type_error(callable,(...,...)).
+
+12 ?- phrase('|'([],[a]),[a]).
+   true.
+
+14 ?- phrase(([a];[]),L).
+   L=[a] ; L=[].
+
+15 ?- phrase({fail,1},L).
+   type_error(callable,((fail,1),...)).
+
+29 ?- phrase(([a],\+1),[]).
+   false.
+
+30 ?- phrase(([a],\+1;[]),[]).
+   true.
+
+31 ?- phrase(phrase(phrase,[]),L).
+   existence_error(procedure,phrase/4).
+
+32 ?- phrase(call([]),[]).
+   existence_error(procedure,[]/2).
+
+41 ?- phrase([],non_list).
+   type_error(list,non_list).
+
+42 ?- phrase([],[a|non_list]).
+   type_error(list,[a|non_list]).
+
+43 ?- phrase([],L,non_list).
+   type_error(list,non_list).
+
+44 ?- phrase([],L,[a|non_list]).
+   type_error(list,[a|non_list]).
+
+46 ?- phrase((1,{2}),[]).
+   type_error(callable,1).
+
+47 ?- phrase(({2},1),[]).
+   type_error(callable,1).
+`;
+        const result = publicApi.runQuads(source);
+        assertEqual(result.total, 22, 'quad total');
+        assertEqual(result.passed, 22, 'quad passed');
+        assertEqual(result.stdout, 'quads: 22 run, 22 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'runQuads rejects malformed answer substitutions',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5341,8 +5341,8 @@ look_ahead(X), [X] --> [X].
 `phrase(+Body,?Sequence)` accepts or generates a complete sequence.
 `phrase(+Body,?Sequence,?Rest)` leaves `Rest` unconsumed and is steadfast in
 that argument. A variable body raises `instantiation_error`; a non-callable
-body raises `type_error(callable)`. EyeProlog performs the optional Part 3
-terminal-sequence checks and reports `type_error(terminal_sequence)`.
+body raises `type_error(callable)`. EyeProlog performs terminal-sequence checks
+and reports the portable ISO `type_error(list)` error term.
 
 Part 3 leaves `\+//1` and standalone `->//2` implementation dependent.
 EyeProlog uses non-consuming negation (`\+ Body` tests from the current state)
@@ -6138,6 +6138,10 @@ records its quads; it does not execute them or add their queries and answers as
 program clauses. A quad run prints a summary and exits with status `1` when any
 description fails.
 
+Unless the source explicitly selects another `unknown` flag, quad execution
+uses `unknown=error`, so an undefined predicate is reported rather than being
+accepted as a negative answer.
+
 Answer descriptions support ordered answers separated by `;`, acceptable
 alternatives separated by `|`, `true`, `false`, standard error descriptions,
 and the `unexpected` annotation for an answer that must not occur (`inattendue`