eyeprolog 0.5.13 → 0.5.15

package/examples/riemann-hypothesis.pl

@@ -11,6 +11,11 @@
 %% goal: zero_check(X0, X1, X2)
 
 
+:- discontiguous(zeta_zero/1).
+:- discontiguous(real_part/2).
+:- discontiguous(imaginary_part/2).
+:- discontiguous(source/2).
+
 % --- Sample zero catalogue -------------------------------------------------
 %
 % The three z* entries stand for catalogued non-trivial zeros of the

package/examples/spacecraft-battery-diagnosis.pl

@@ -23,14 +23,14 @@ telemetry(bp1, cell_delta_v, 0.19).
 redundant_telemetry(bp1, temperature_c, 76.0).
 
 % Illustrative engineering limits and available cooling power.
-limit(max_safe_temperature_c, 60.0).
-limit(max_temperature_rise_c_per_min, 1.5).
-limit(max_cell_delta_v, 0.08).
+safety_limit(max_safe_temperature_c, 60.0).
+safety_limit(max_temperature_rise_c_per_min, 1.5).
+safety_limit(max_cell_delta_v, 0.08).
 cooling_capacity_w(bp1, 12.0).
 
 % Thermal margin is positive below the limit and negative above it.
 metric(Pack, thermal_margin_c, Margin) :-
-  limit(max_safe_temperature_c, Maximum),
+  safety_limit(max_safe_temperature_c, Maximum),
   telemetry(Pack, temperature_c, Temperature),
   (Margin is Maximum - Temperature).
 
@@ -43,17 +43,17 @@ metric(Pack, resistive_heating_w, Heating) :-
 
 over_temperature(Pack) :-
   telemetry(Pack, temperature_c, Temperature),
-  limit(max_safe_temperature_c, Maximum),
+  safety_limit(max_safe_temperature_c, Maximum),
   (Temperature > Maximum).
 
 rapid_heating(Pack) :-
   telemetry(Pack, temperature_rise_c_per_min, Rate),
-  limit(max_temperature_rise_c_per_min, Maximum),
+  safety_limit(max_temperature_rise_c_per_min, Maximum),
   (Rate > Maximum).
 
 cell_imbalance(Pack) :-
   telemetry(Pack, cell_delta_v, Delta),
-  limit(max_cell_delta_v, Maximum),
+  safety_limit(max_cell_delta_v, Maximum),
   (Delta > Maximum).
 
 heating_exceeds_cooling(Pack) :-
@@ -65,7 +65,7 @@ heating_exceeds_cooling(Pack) :-
 corroborated_over_temperature(Pack) :-
   telemetry(Pack, temperature_c, Primary),
   redundant_telemetry(Pack, temperature_c, Redundant),
-  limit(max_safe_temperature_c, Maximum),
+  safety_limit(max_safe_temperature_c, Maximum),
   (Primary > Maximum),
   (Redundant > Maximum).
 

package/examples/vulnerability-impact.pl

@@ -14,6 +14,10 @@
 %% goal: urgent_patch(X0, X1)
 
 
+:- discontiguous(vulnerability/2).
+:- discontiguous(cvss/2).
+:- discontiguous(fixed_by/2).
+
 service(webapp).
 service(worker).
 service(frontend).

package/index.d.ts

@@ -16,6 +16,8 @@ export interface EyePrologRunOptions {
   sourceMetadata?: boolean;
   strictNegation?: boolean;
   analyzeNegation?: boolean;
+  /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
+  doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {
     input?: string;
     write?: (text: string) => void;
@@ -88,6 +90,7 @@ export class Program {
   constructor(clauses?: EyePrologClause[], options?: EyePrologRunOptions);
   clauses: EyePrologClause[];
   groups: Map<string, EyePrologPredicateGroup>;
+  doubleQuotes: 'chars' | 'codes' | 'atom';
   negationDependencies: Array<{ from: string; to: string; negative: boolean }>;
   negationStratificationErrors: Array<{ from: string; to: string }>;
   stratifiedNegation: boolean;
@@ -101,7 +104,7 @@ export class Program {
   assertStratifiedNegation(): true;
   isStratifiedNegation(): boolean;
   groupHasRule(group: EyePrologPredicateGroup): boolean;
-  sourceFactLines(predicateKeys?: Set<string> | null): Set<string>;
+  sourceFactLines(predicateKeys?: Set<string> | null, options?: { doubleQuotes?: 'chars' | 'codes' | 'atom' }): Set<string>;
 }
 
 export interface BuiltinDefinition {
@@ -181,7 +184,7 @@ export function compareNumberText(left: string, right: string): number;
 export function makeProgram(source: string, options?: EyePrologRunOptions): Program;
 export function parseClauses(source: string, options?: EyePrologRunOptions): EyePrologClause[];
 export function parseProgramText(source: string, options?: EyePrologRunOptions): EyePrologClause[];
-export function parseGoalText(source: string): EyePrologTerm;
+export function parseGoalText(source: string, options?: EyePrologRunOptions): EyePrologTerm;
 export function createDefaultRegistry(): BuiltinRegistry;
 export function createEyePrologRegistry(): BuiltinRegistry;
 export function getDefaultRegistry(): BuiltinRegistry;

package/package.json

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

package/src/cli.js

@@ -128,22 +128,27 @@ async function loadExplanation() {
 }
 
 async function runDefault(engine, program, options) {
+  const registry = engine.getEyePrologRegistry();
+  const solver = new engine.Solver(program, {
+    registry,
+    ioOptions: { write: (text) => process.stdout.write(String(text)) },
+  });
+  program = solver.program;
   const goals = options.goals.map((text) => {
-    const goal = engine.parseGoalText(text);
+    const goal = engine.parseGoalText(text, {
+      doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    });
     if (goal.type === 'var') throw new engine.PrologError('instantiation_error');
     if (goal.type !== 'atom' && goal.type !== 'compound') throw new engine.PrologError('type_error(callable)', goal);
     return goal;
   });
   const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
-  const facts = program.sourceFactLines(queriedKeys);
+  const writeOptions = {
+    doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+  };
+  const facts = program.sourceFactLines(queriedKeys, writeOptions);
   const lines = new Set();
-  const registry = engine.getEyePrologRegistry();
   const explanation = options.proof ? await loadExplanation() : null;
-  const solver = new engine.Solver(program, {
-    registry,
-    ioOptions: { write: (text) => process.stdout.write(String(text)) },
-  });
-  program = solver.program;
   try {
     solver.runInitializations();
     for (const goal of goals) {
@@ -151,7 +156,10 @@ async function runDefault(engine, program, options) {
       for (const env of solver.solve([goal], new engine.Env(), 0)) {
         if (!engine.termIsGround(goal, env)) continue;
 
-        const line = `${engine.termToString(goal, env, true)}.\n`;
+        const currentWriteOptions = {
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        };
+        const line = `${engine.termToString(goal, env, true, currentWriteOptions)}.\n`;
         if (facts.has(line) || lines.has(line)) continue;
 
         lines.add(line);

package/src/index.js

@@ -47,9 +47,12 @@ export function run(source, options = {}) {
     },
   });
   program = solver.program;
-  const goals = normalizeGoals(options);
+  const goals = normalizeGoals(options, solver);
+  const writeOptions = {
+    doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+  };
   const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
-  const facts = program.sourceFactLines(queriedKeys);
+  const facts = program.sourceFactLines(queriedKeys, writeOptions);
   const seen = new Set();
   let haltCode = null;
   try {
@@ -59,7 +62,10 @@ export function run(source, options = {}) {
       for (const env of solver.solve([goal], new Env(), 0)) {
         const resolved = copyResolved(goal, env);
         if (!termIsGround(resolved)) continue;
-        const line = `${termToString(resolved, new Env(), true)}.\n`;
+        const currentWriteOptions = {
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        };
+        const line = `${termToString(resolved, new Env(), true, currentWriteOptions)}.\n`;
         if (facts.has(line) || seen.has(line)) continue;
         seen.add(line);
         output.push(line);
@@ -73,10 +79,14 @@ export function run(source, options = {}) {
   return { stdout: output.join(''), stats: solver.stats, haltCode };
 }
 
-function normalizeGoals(options) {
+function normalizeGoals(options, solver) {
   const requested = options.goals ?? (options.goal == null ? [] : [options.goal]);
   return requested.map((requestedGoal) => {
-    const goal = typeof requestedGoal === 'string' ? parseGoalText(requestedGoal) : requestedGoal;
+    const goal = typeof requestedGoal === 'string'
+      ? parseGoalText(requestedGoal, {
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        })
+      : requestedGoal;
     if (goal.type === VAR) throw new PrologError('instantiation_error');
     if (goal.type !== ATOM && goal.type !== COMPOUND) throw new PrologError('type_error(callable)', goal);
     return goal;

package/src/iso.js

@@ -920,6 +920,7 @@ function readTermFromStream(stream, solver) {
       const clauses = parseClauses(convertedTermText(candidate.text, solver), {
         sourceMetadata: false,
         operatorState,
+        doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
       });
       if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
       stream.position = candidate.end;

package/src/parser.js

@@ -1,6 +1,6 @@
 // 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, cons, emptyList, numberTerm, stringTerm, variable } from './term.js';
+import { atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
@@ -143,6 +143,12 @@ class Parser {
     this.line = 1;
     this.anonymous = 0;
     this.sourceMetadata = options.sourceMetadata !== false;
+    this.parserFlagState = options.parserFlagState ?? {
+      doubleQuotes: options.doubleQuotes ?? 'chars',
+    };
+    if (!['chars', 'codes', 'atom'].includes(this.parserFlagState.doubleQuotes)) {
+      throw new Error(`invalid double_quotes parser flag: ${this.parserFlagState.doubleQuotes}`);
+    }
     const operatorState = options.operatorState ?? createParserOperatorState(
       options.operatorDefinitions ?? [],
       options.includeDefaultOperators !== false,
@@ -174,6 +180,14 @@ class Parser {
     for (const name of names) this.defineOperator(priority, specifierTerm.name, name);
     return true;
   }
+  applyParserFlagDirective(directive) {
+    if (directive.type !== 'compound' || directive.name !== 'set_prolog_flag' || directive.arity !== 2) return;
+    const [flag, value] = directive.args;
+    if (flag.type === 'atom' && flag.name === 'double_quotes' &&
+        value.type === 'atom' && ['chars', 'codes', 'atom'].includes(value.name)) {
+      this.parserFlagState.doubleQuotes = value.name;
+    }
+  }
   peek(offset = 0) {
     return this.source[this.pos + offset] ?? '';
   }
@@ -494,7 +508,31 @@ class Parser {
     if (this.token.type === TOK.STRING) {
       const value = this.token.text;
       this.advance();
-      return stringTerm(value);
+      if (this.parserFlagState.doubleQuotes === 'atom') {
+        if (this.token.type === TOK.LPAREN) {
+          this.advance();
+          const args = [];
+          if (this.token.type === TOK.RPAREN) {
+            throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(value)} for arity zero data`);
+          }
+          while (true) {
+            args.push(this.parseTerm(0, false));
+            if (this.token.type !== TOK.COMMA) break;
+            this.advance();
+          }
+          this.expect(TOK.RPAREN, ')');
+          this.advance();
+          return compound(value, args);
+        }
+        return atom(value);
+      }
+      const items = Array.from(value, (character) =>
+        this.parserFlagState.doubleQuotes === 'chars'
+          ? atom(character)
+          : numberTerm(character.codePointAt(0)));
+      let list = emptyList();
+      for (let i = items.length - 1; i >= 0; i--) list = cons(items[i], list);
+      return list;
     }
     if (this.token.type === TOK.NUMBER) {
       const value = this.token.text;
@@ -544,6 +582,7 @@ class Parser {
           throw new Error(`parse line ${line}: bad term`);
         }
         this.expect(TOK.DOT, '.');
+        this.applyParserFlagDirective(directive);
         this.advance();
         const clause = { head: compound(':-', [directive]), body: [] };
         clauseNumber++;
@@ -588,11 +627,17 @@ function listAtomNames(term) {
 
 
 export function parseClauses(source, options = {}) {
+  const ownsParserFlagState = options.parserFlagState == null;
+  const initialDoubleQuotes = options.doubleQuotes ?? 'chars';
+  const parserOptions = ownsParserFlagState
+    ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes } }
+    : options;
   if (options.sourceMetadata === false) {
-    const clauses = parseClausesFastNoSource(source);
+    const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
+    if (ownsParserFlagState) parserOptions.parserFlagState.doubleQuotes = initialDoubleQuotes;
   }
-  return new Parser(source, options).parseProgram();
+  return new Parser(source, parserOptions).parseProgram();
 }
 
 // Streaming parser entry points used by ProgramBuilder.  The ordinary public
@@ -602,8 +647,8 @@ export function parseClausesInto(source, options = {}, emit) {
   new Parser(source, options).parseProgram(emit);
 }
 
-export function tryParseClausesFastInto(source, emit, emitBinary = null) {
-  return parseClausesFastNoSource(source, emit, emitBinary) !== null;
+export function tryParseClausesFastInto(source, emit, emitBinary = null, options = {}) {
+  return parseClausesFastNoSource(source, emit, emitBinary, options) !== null;
 }
 
 function isSimpleName(text) {
@@ -624,7 +669,7 @@ const SIMPLE_VARIABLE = /^(?:_|[A-Z_][A-Za-z0-9_]*)$/;
 const SIMPLE_ATOM = /^[a-z][A-Za-z0-9_]*$/;
 const GRAPHIC_ATOM = /^[#$&*+\-\/<=>@^~\\]+$/;
 
-function parseClausesFastNoSource(source, emit = null, emitBinary = null) {
+function parseClausesFastNoSource(source, emit = null, emitBinary = null, options = {}) {
   source = String(source ?? '');
   const numberCache = new Map();
   const stringCache = new Map();
@@ -896,7 +941,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null) {
       return true;
     }
     try {
-      const parsed = new Parser(text, { sourceMetadata: false }).parseProgram();
+      const parsed = new Parser(text, { ...options, sourceMetadata: false }).parseProgram();
       for (const clause of parsed) accept(clause);
       return true;
     } catch (_) {
@@ -938,12 +983,12 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null) {
   return clauses ?? true;
 }
 
-export function parseProgramText(source) {
-  return parseClauses(source);
+export function parseProgramText(source, options = {}) {
+  return parseClauses(source, options);
 }
 
-export function parseGoalText(text) {
-  const clauses = parseClauses(`zz_goal((${text})).`);
+export function parseGoalText(text, options = {}) {
+  const clauses = parseClauses(`zz_goal((${text})).`, options);
   const head = clauses[0]?.head;
   if (clauses.length !== 1 || head?.type !== 'compound' ||
       head.name !== 'zz_goal' || head.arity !== 1 || clauses[0].body.length !== 0) {

package/src/program.js

@@ -97,6 +97,7 @@ export class Program {
     this.initializations = [];
     this.prologFlagDirectives = [];
     this.charConversionDirectives = [];
+    this.doubleQuotes = options.doubleQuotes ?? 'chars';
     this._revisionState = { value: 0 };
     this.mutable = false;
     this._negationAnalysis = null;
@@ -372,19 +373,19 @@ export class Program {
   groupHasRule(group) {
     return group.clauses.some((clause) => clauseBodyLength(clause) > 0);
   }
-  sourceFactLines(predicateKeys = null) {
+  sourceFactLines(predicateKeys = null, options = {}) {
     const lines = new Set();
     const env = new Env();
     for (const clause of this.clauses) {
       if (isCompactBinaryClause(clause)) {
         if (clause.bodyName != null) continue;
         if (predicateKeys && !predicateKeys.has(`${clause.headName}/2`)) continue;
-        lines.add(`${termToString(clause.head, env, true)}.\n`);
+        lines.add(`${termToString(clause.head, env, true, options)}.\n`);
         continue;
       }
       if (clause.body.length !== 0 || (clause.head.type !== ATOM && clause.head.type !== COMPOUND)) continue;
       if (predicateKeys && !predicateKeys.has(`${clause.head.name}/${clause.head.arity}`)) continue;
-      lines.add(`${termToString(clause.head, env, true)}.\n`);
+      lines.add(`${termToString(clause.head, env, true, options)}.\n`);
     }
     return lines;
   }
@@ -530,9 +531,10 @@ function buildProgramFromSources(sources, options) {
 function loadSourcesIntoBuilder(builder, sources, options, fast) {
   const ensured = new Set();
   const operatorState = createParserOperatorState();
+  const parserFlagState = { doubleQuotes: options.doubleQuotes ?? 'chars' };
   const prepared = sources.map((source) => ({
     source,
-    options: { ...sourceOptionsFor(source, options), operatorState },
+    options: { ...sourceOptionsFor(source, options), operatorState, parserFlagState },
   }));
   for (const item of prepared) {
     const filename = sourcePath(item.options);
@@ -545,6 +547,7 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
         : item.source?.text ?? item.source?.source ?? '';
       if (!loadSourceIntoBuilder(builder, text, item.options, ensured, fast)) return false;
     }
+    builder.program.doubleQuotes = parserFlagState.doubleQuotes;
     return true;
   } catch (error) {
     if (error === FAST_PARSE_ABORT) return false;
@@ -600,7 +603,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, fast) {
       ));
       if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
     };
-    const parsed = tryParseClausesFastInto(source, accept, acceptBinary);
+    const parsed = tryParseClausesFastInto(source, accept, acceptBinary, options);
     if (parsed) flush();
     return parsed;
   }

package/src/solver.js

@@ -27,11 +27,19 @@ export class Solver {
     this.prologFlags = options.prologFlags ?? defaultPrologFlags(this.registry?.eyePrologLibrary ? 'fail' : 'error');
     this.charConversions = options.charConversions ?? new Map();
     if (!options.prologFlags) {
+      if (['chars', 'codes', 'atom'].includes(program.doubleQuotes)) {
+        this.prologFlags.get('double_quotes').value = compound(program.doubleQuotes, []);
+      }
       for (const [flag, value] of program.prologFlagDirectives ?? []) {
+        if (flag.type === 'var' || value.type === 'var') throw new PrologError('instantiation_error');
+        if (flag.type !== 'atom') throw new PrologError('type_error(atom)', flag);
         const definition = this.prologFlags.get(flag.name);
-        if (flag.type === 'atom' && value.type === 'atom' && definition?.changeable && definition.allowed.includes(value.name)) {
-          definition.value = value;
+        if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
+        if (value.type !== 'atom' || !definition.allowed.includes(value.name)) {
+          throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
         }
+        if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
+        definition.value = value;
       }
     }
     if (!options.charConversions) {
@@ -383,7 +391,7 @@ function defaultPrologFlags(unknown = 'error') {
     ['debug', { value: compound('off', []), allowed: ['on', 'off'], changeable: true }],
     ['max_arity', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
-    ['double_quotes', { value: compound('atom', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],
+    ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],
   ]);
 }
 

package/src/term.js

@@ -314,37 +314,68 @@ function writeString(value, quoteStrings) {
   let out = '"';
   for (const ch of value) {
     if (ch === '"' || ch === '\\') out += `\\${ch}`;
+    else if (ch === '\x07') out += '\\a';
+    else if (ch === '\b') out += '\\b';
+    else if (ch === '\r') out += '\\r';
+    else if (ch === '\f') out += '\\f';
+    else if (ch === '\t') out += '\\t';
     else if (ch === '\n') out += '\\n';
+    else if (ch === '\v') out += '\\v';
     else out += ch;
   }
   return out + '"';
 }
 
-function writeList(term, env) {
+function quotedListText(term, env, doubleQuotes) {
+  if (doubleQuotes !== 'chars' && doubleQuotes !== 'codes') return null;
+  const characters = [];
+  let cursor = term;
+  while (true) {
+    cursor = deref(cursor, env);
+    if (isEmptyList(cursor)) return characters.length === 0 ? null : characters.join('');
+    if (!isCons(cursor)) return null;
+    const item = deref(cursor.args[0], env);
+    if (doubleQuotes === 'chars') {
+      if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
+      characters.push(item.name);
+    } else {
+      if (item.type !== NUMBER || !/^\d+$/.test(item.name)) return null;
+      const code = BigInt(item.name);
+      if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return null;
+      characters.push(String.fromCodePoint(Number(code)));
+    }
+    cursor = cursor.args[1];
+  }
+}
+
+function writeList(term, env, options) {
+  const quotedText = quotedListText(term, env, options.doubleQuotes);
+  if (quotedText != null) return writeString(quotedText, true);
   const parts = [];
   let cursor = term;
   while (true) {
     cursor = deref(cursor, env);
     if (isEmptyList(cursor)) return `[${parts.join(', ')}]`;
     if (!isCons(cursor)) {
-      if (parts.length) return `[${parts.join(', ')} | ${termToString(cursor, env, true)}]`;
-      return `[${termToString(cursor, env, true)}]`;
+      if (parts.length) return `[${parts.join(', ')} | ${termToString(cursor, env, true, options)}]`;
+      return `[${termToString(cursor, env, true, options)}]`;
     }
-    parts.push(termToString(cursor.args[0], env, true));
+    parts.push(termToString(cursor.args[0], env, true, options));
     cursor = cursor.args[1];
   }
 }
 
-export function termToString(term, env = new Env(), quoteStrings = true) {
+export function termToString(term, env = new Env(), quoteStrings = true, options = {}) {
+  options = { doubleQuotes: options.doubleQuotes ?? 'chars' };
   const resolved = deref(term, env);
   if (resolved.type === VAR) return writeVariable(resolved.name);
-  if (isCons(resolved)) return writeList(resolved, env);
+  if (isCons(resolved)) return writeList(resolved, env, options);
   if (resolved.type === STRING) return writeString(resolved.name, quoteStrings);
   if (resolved.type === ATOM) return writeAtom(resolved.name);
   if (resolved.type === NUMBER) return resolved.name;
   if (resolved.type === COMPOUND && resolved.arity === 0) return writeAtom(resolved.name);
   if (resolved.type === COMPOUND && resolved.name === '{}' && resolved.arity === 1) {
-    return `{${termToString(resolved.args[0], env, true)}}`;
+    return `{${termToString(resolved.args[0], env, true, options)}}`;
   }
   if (isConjunction(resolved)) {
     const parts = [];
@@ -352,16 +383,16 @@ export function termToString(term, env = new Env(), quoteStrings = true) {
     while (true) {
       cursor = deref(cursor, env);
       if (isConjunction(cursor)) {
-        parts.push(termToString(cursor.args[0], env, true));
+        parts.push(termToString(cursor.args[0], env, true, options));
         cursor = cursor.args[1];
       } else {
-        parts.push(termToString(cursor, env, true));
+        parts.push(termToString(cursor, env, true, options));
         break;
       }
     }
     return `(${parts.join(', ')})`;
   }
-  return `${writeAtom(resolved.name)}(${resolved.args.map((arg) => termToString(arg, env, true)).join(', ')})`;
+  return `${writeAtom(resolved.name)}(${resolved.args.map((arg) => termToString(arg, env, true, options)).join(', ')})`;
 }
 
 export function lexicalValue(term, env) {

package/src/write.js

@@ -52,7 +52,13 @@ function writeString(value) {
   let out = '"';
   for (const ch of value) {
     if (ch === '"' || ch === '\\') out += `\\${ch}`;
+    else if (ch === '\x07') out += '\\a';
+    else if (ch === '\b') out += '\\b';
+    else if (ch === '\r') out += '\\r';
+    else if (ch === '\f') out += '\\f';
+    else if (ch === '\t') out += '\\t';
     else if (ch === '\n') out += '\\n';
+    else if (ch === '\v') out += '\\v';
     else out += ch;
   }
   return out + '"';

package/test/conformance/README.md

@@ -90,7 +90,7 @@ Selected cases are adapted from the ISO and standard-core suites of Scryer
 Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 279 cases in `iso/` and 685 file-based conformance cases in
+The corpus has 280 cases in `iso/` and 686 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 RDF-tool, example, and book-example checks, `npm test` is the release gate.

package/test/conformance/cases/arithmetic/082_comparison_semantics.pl

@@ -1,4 +1,4 @@
-% Reference 9.3: comparison handles numbers, durations, strings, and lexical scalars.
+% Reference 9.3: comparison handles numbers, durations, character lists, and lexical scalars.
 %% goal: answer(X0, X1)
 
 answer(integer_order, ok) :- (9 < 10).
@@ -7,5 +7,5 @@ answer(numeric_not_lexical, ok) :- (10 < 100).
 answer(duration_years, ok) :- ('P1Y' @< 'P2Y').
 answer(duration_months, ok) :- ('P1Y1M' @> 'P1Y').
 answer(atom_lexical, ok) :- (alpha @< beta).
-answer(string_lexical, ok) :- ("z" @> "a").
+answer(char_list_order, ok) :- ("z" @> "a").
 answer(compound_lexical_text, ok) :- (pair(a, 1) @< pair(b, 1)).

package/test/conformance/cases/arithmetic/extra_le_equal_string.pl

@@ -1,3 +1,3 @@
 %% goal: answer(X0)
 
-answer(le_equal_string) :- ("abc" @=< "abc").
+answer(le_equal_char_list) :- ("abc" @=< "abc").

package/test/conformance/cases/context/extra_context_ignores_string_parts.pl

@@ -4,4 +4,4 @@ context_member((Left, _right), Member) :- context_member(Left, Member).
 context_member((_left, Right), Member) :- context_member(Right, Member).
 context_member(Member, Member) :- Member \= (_left, _right).
 context_parts(Context, Name, Args) :- context_member(Context, Statement), (Statement =.. [Name | Args]), atom(Name).
-answer(context_ignores_string_parts) :- context_parts("not a term", _, _).
+answer(context_inspects_char_list) :- context_parts("not a term", _, _).

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

@@ -0,0 +1,27 @@
+% ISO double-quoted list notation follows the active double_quotes flag.
+%% goal: default_chars(X0)
+%% goal: default_empty(X0)
+%% goal: default_shape(X0)
+%% goal: atom_mode(X0)
+%% goal: atom_functor(X0)
+%% goal: atom_shape(X0)
+%% goal: codes_mode(X0)
+%% goal: codes_shape(X0)
+
+stored_chars("ab").
+stored_empty("").
+default_chars(Value) :- stored_chars(Value).
+default_empty(Value) :- stored_empty(Value).
+default_shape(compound) :- compound("a"), \+ atomic("a").
+
+:- set_prolog_flag(double_quotes, atom).
+stored_atom("ab").
+stored_compound("pair"(a, b)).
+atom_mode(Value) :- stored_atom(Value).
+atom_functor(Value) :- stored_compound(Value).
+atom_shape(atomic) :- atom("a"), atomic("a").
+
+:- set_prolog_flag(double_quotes, codes).
+stored_codes("ab").
+codes_mode(Value) :- stored_codes(Value).
+codes_shape(compound) :- compound("a"), \+ atomic("a").

package/test/conformance/cases/strings/023_quoted_escapes_readback.pl

@@ -1,6 +1,5 @@
-% Reference 3.5, 11: quoted strings and atoms preserve escape sequences at read-back.
-raw(string, "line\nnext\t\\slash").
+% Reference 3.5, 11: double-quoted lists and quoted atoms preserve escapes at read-back.
+raw(char_list, "line\nnext\t\\slash").
 raw(atom, 'line\nnext\t\\slash').
 answer(K, V) :- raw(K, V).
 %% goal: answer(X0, X1)
-

package/test/conformance/cases/terms/003_terms_and_readback.pl

@@ -5,7 +5,7 @@ raw_value(atom, pat).
 raw_value(quoted_atom, 'atom with spaces').
 raw_value(quoted_quote, 'needs''quote').
 raw_value(empty_atom, '').
-raw_value(string, "line\nquote: \"ok\"").
+raw_value(char_list, "line\nquote: \"ok\"").
 raw_value(integer, -42).
 raw_value(decimal, 0.25).
 raw_value(scientific, 1.25e-3).

package/test/conformance/cases/terms/073_term_introspection_edges.pl

@@ -3,7 +3,7 @@
 
 answer(functor_atom, pair(Name, Arity)) :- functor(alpha, Name, Arity).
 answer(functor_number, pair(Name, Arity)) :- functor(42, Name, Arity).
-answer(functor_string, pair(Name, Arity)) :- functor("hi", Name, Arity).
+answer(functor_char_list, pair(Name, Arity)) :- functor("hi", Name, Arity).
 answer(arg_nested, X) :- arg(1, path(edge(a, b), c), X).
 answer(compose_nested, X) :- (X =.. [outer | [inner(a), [b, c]]]).
 answer(compose_atom_empty_args, X) :- (X =.. [z | []]).