securemark 0.299.3 → 0.300.0

package/src/combinator/effect/backtrack.ts

@@ -0,0 +1,64 @@
+import { always } from '../control/state';
+import { Parser, Input } from '../parser';
+import { Scope } from './scope';
+
+interface Data {
+  readonly segment: number;
+  readonly position: number;
+  readonly range: number;
+  readonly linebreak: number;
+}
+
+export class Backtrack {
+  constructor(
+    private readonly scope: Scope<Input>,
+  ) {
+  }
+  private readonly stack: Data[] = [];
+  public memory(data: Data): void {
+    this.stack.push(data);
+  }
+  private unmemory(): void {
+    this.stack.pop();
+  }
+  private backtrack(): void {
+    assert(this.stack.length > 0);
+    const { segment, position, range, linebreak } = this.stack.pop()!;
+    const input = this.scope.peek();
+    input.segment = segment;
+    input.position = position;
+    input.range = range;
+    input.linebreak = linebreak;
+  }
+  public handle(state: boolean): void {
+    state
+      ? this.unmemory()
+      : this.backtrack();
+  }
+}
+
+export function backtrack<P extends Parser>(parser: P): P;
+export function backtrack<T>(parser: Parser<T>): Parser<T> {
+  assert(parser);
+  return always([
+    (input, output) => {
+      const { backtrack, segment, position, range, linebreak } = input;
+      backtrack.memory({
+        segment,
+        position,
+        range,
+        linebreak,
+      });
+      output.push();
+      return output.context;
+    },
+    parser,
+    ({ backtrack }, output) => {
+      output.state
+        ? output.flat()
+        : output.pop();
+      backtrack.handle(output.state);
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/effect/clock.ts

@@ -0,0 +1,10 @@
+import { Input, Output } from '../parser';
+
+export function spend(input: Input, output: Output<unknown>, cost: number): void {
+  assert(cost >= 0);
+  const resources = input.resources ?? { clock: cost, recursions: [1] };
+  if (resources.clock >= 0 && resources.clock - cost < 0) {
+    output.error ??= new Error('Too many creations');
+  }
+  resources.clock -= cost;
+}

package/src/combinator/effect/precedence.ts

@@ -0,0 +1,50 @@
+import { Parser, Input } from '../parser';
+import { Delimiters } from '../delimiter';
+import { always } from '../control/state';
+
+export class Precedence {
+  constructor(input: Input) {
+    this.delimiters = input.delimiters;
+  }
+  private readonly stack: number[] = [];
+  private readonly delimiters: Delimiters;
+  public get(): number {
+    return this.stack.at(-1) ?? 0;
+  }
+  public modify(precedence: number): void {
+    const p = this.get();
+    this.stack.push(precedence);
+    precedence > p && this.delimiters.shift(precedence);
+  }
+  public revert(precedence: number): void {
+    assert(this.stack.length > 0);
+    const p = this.stack.pop()!;
+    precedence > p && this.delimiters.unshift();
+  }
+}
+
+export function precedence<P extends Parser>(precedence: number, parser: P): P;
+export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
+  assert(precedence >= 0);
+  interface Memory {
+    readonly precedence: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const p = input.precedence;
+      precedence > p && input.delimiters.shift(precedence);
+      input.memory = {
+        precedence: p,
+      };
+      input.precedence = precedence;
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      const p = input.memory.precedence;
+      input.precedence = p;
+      precedence > p && input.delimiters.unshift();
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/effect/recursion.ts

@@ -0,0 +1,30 @@
+import { Parser, Output } from '../parser';
+import { always } from '../control/state';
+import { min } from 'spica/alias';
+
+export function recursion<P extends Parser>(index: number, parser: P): P;
+export function recursion<T>(index: number, parser: Parser<T>): Parser<T> {
+  assert(index >= 0);
+  return always([
+    (input, output) => {
+      const resources = input.resources ?? { clock: 1, recursions: [1] };
+      const { recursions } = resources;
+      recur(output, recursions, index, 1);
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      const resources = input.resources ?? { clock: 1, recursions: [1] };
+      const { recursions } = resources;
+      recur(output, recursions, index, -1);
+      return output.context;
+    },
+  ]);
+}
+export function recur(output: Output<unknown>, recursions: number[], index: number, size: number, force: boolean = false): void {
+  index = min(index, recursions.length && recursions.length - 1);
+  if (recursions[index] < size - +force) {
+    output.error ??= new Error('Too much recursion');
+  }
+  recursions[index] -= size;
+}

package/src/combinator/effect/scope.ts

@@ -0,0 +1,100 @@
+import { Parser, Input, Output, subinput } from '../parser';
+import { always } from '../control/state';
+
+interface Memory {
+  readonly SID: number;
+  readonly source: string;
+  readonly position: number;
+  readonly offset: number;
+  readonly linebreak: number;
+  readonly range: number;
+}
+
+export class Scope<I extends Input> {
+  constructor(input: I) {
+    this.inputs.push(input);
+  }
+  private readonly inputs: I[] = [];
+  private readonly memories: Memory[] = [];
+  public peek(): I {
+    //assert(this.inputs.length > 0);
+    return this.inputs.at(-1)!;
+  }
+  public focus(subsource: string): void {
+    const input = this.peek();
+    assert(subsource.length <= input.source.length);
+    assert(input.position - subsource.length >= 0);
+    input.position -= subsource.length;
+    const { SID, source, position, offset, linebreak, range } = input;
+    this.memories.push({
+      SID,
+      source,
+      position,
+      offset,
+      linebreak,
+      range,
+    });
+    subinput(subsource, input);
+  }
+  public unfocus(state = true, continuous = false): void {
+    assert(this.memories.length > 0);
+    const input = this.peek();
+    const { source, position } = input;
+    const memory = this.memories.pop()!;
+    input.SID = memory.SID;
+    input.position = state
+      ? continuous && position > 0
+        ? memory.position + position
+        : memory.position + source.length
+      : memory.position;
+    input.source = memory.source;
+    assert(position <= source.length);
+    input.offset = memory.offset;
+    input.linebreak = memory.linebreak;
+    input.range = memory.range;
+  }
+  public push(source: string): I {
+    const input = this.peek().clone(source);
+    this.inputs.push(input);
+    return input;
+  }
+  public pop(): I {
+    this.inputs.pop();
+    return this.peek();
+  }
+}
+
+export function scope<P extends Parser>(
+  conv: (input: Parser.Input<P>, output: Output<Parser.Node<P>>) => string,
+  parser: P,
+  isolation: boolean,
+): P;
+export function scope<T>(
+  conv: (input: Input, output: Output<T>) => string,
+  parser: Parser<T>,
+  isolation: boolean,
+): Parser<T> {
+  assert(parser);
+  return always([
+    (input, output) => {
+      const { source, position } = input;
+      const src = conv(input, output);
+      !isolation && input.position === position
+        ? input.position = source.length
+        : 0;
+      isolation
+        ? input.scope.push(src)
+        : input.scope.focus(src);
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      isolation
+        ? input.scope.pop()
+        : input.scope.unfocus();
+      if (!output.state) return;
+      assert(input.position <= input.source.length);
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/effect/state.ts

@@ -0,0 +1,72 @@
+import { Parser, Result, Input } from '../parser';
+import { always } from '../control/state';
+
+export class State<T> {
+  constructor(private readonly initial: T) {
+  }
+  private readonly stack: T[] = [];
+  public get(): T {
+    return this.stack.at(-1) ?? this.initial;
+  }
+  public put(state: T): void {
+    this.stack.push(state);
+  }
+  public delete(): T {
+    assert(this.stack.length > 0);
+    const state = this.stack.pop()!;
+    return state;
+  }
+}
+
+export function state<P extends Parser>(state: number, parser: P): P;
+export function state<P extends Parser>(state: number, positive: boolean, parser: P): P;
+export function state<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof positive === 'function') {
+    parser = positive;
+    positive = true;
+  }
+  assert(state);
+  assert(parser = parser!);
+  interface Memory {
+    readonly state: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const s = input.state;
+      input.state = positive
+        ? s | state
+        : s & ~state;
+      input.memory = {
+        state: s,
+      };
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      input.state = input.memory.state;
+      return output.context;
+    },
+  ]);
+}
+
+export function constraint<P extends Parser>(state: number, parser: P): P;
+//export function constraint<P extends Parser>(state: number, positive: boolean, parser: P): P;
+export function constraint<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof positive === 'function') {
+    parser = positive;
+    positive = false;
+  }
+  assert(state);
+  assert(parser = parser!);
+  return always([
+    (input, output) => {
+      const s = positive
+        ? state & input.state
+        : state & ~input.state;
+      return s === state
+        ? output.context
+        : Result.skip;
+    },
+    parser,
+  ]);
+}

package/src/combinator/{data/node.ts → parser/list.ts}

@@ -1,6 +1,6 @@
-import { Parser, Context } from './parser';
+import { Parser, Input } from '../parser';
 
-export class List<N extends List.Node = List.Node, C extends Context = Context, D extends Parser<unknown, C>[] = any> {
+export class List<N extends List.Node = List.Node, I extends Input = Input, S extends readonly Parser<unknown, I>[] = Parser<unknown, I, any[]>[]> {
   constructor(nodes?: ArrayLike<N>) {
     if (nodes === undefined) return;
     for (let i = 0; i < nodes.length; ++i) {
@@ -15,8 +15,8 @@ export class List<N extends List.Node = List.Node, C extends Context = Context,
   }
   public insert(node: N, before?: N): N {
     assert(!node.next && !node.prev);
-    if (before === undefined) return this.push(node);
-    if (before === this.head) return this.unshift(node);
+    if (before === undefined) return this.push(node), node;
+    if (before === this.head) return this.unshift(node), node;
     if (++this.length === 1) {
       return this.head = this.last = node;
     }
@@ -43,21 +43,25 @@ export class List<N extends List.Node = List.Node, C extends Context = Context,
     node.next = node.prev = undefined;
     return node;
   }
-  public unshift(node: N): N {
+  public unshift(node: N): this {
     assert(!node.next && !node.prev);
     if (++this.length === 1) {
-      return this.head = this.last = node;
+      this.head = this.last = node;
+      return this;
     }
     node.next = this.head;
-    return this.head = this.head!.prev = node;
+    this.head = this.head!.prev = node;
+    return this;
   }
-  public push(node: N): N {
+  public push(node: N): this {
     assert(!node.next && !node.prev);
     if (++this.length === 1) {
-      return this.head = this.last = node;
+      this.head = this.last = node;
+      return this;
     }
     node.prev = this.last;
-    return this.last = this.last!.next = node;
+    this.last = this.last!.next = node;
+    return this;
   }
   public shift(): N | undefined {
     if (this.length === 0) return;
@@ -89,6 +93,18 @@ export class List<N extends List.Node = List.Node, C extends Context = Context,
     list.clear();
     return this;
   }
+  public truncateBefore(node: N): void {
+    assert(node.next || node.prev || this.head === this.last);
+    if (node.prev === undefined) return;
+    this.delete(node.prev);
+    this.head = node;
+  }
+  public truncateAfter(node: N): void {
+    assert(node.next || node.prev || this.head === this.last);
+    if (node.next === undefined) return;
+    this.delete(node.next);
+    this.last = node;
+  }
   public clear(): void {
     this.length = 0;
     this.head = this.last = undefined;
@@ -134,8 +150,17 @@ export class List<N extends List.Node = List.Node, C extends Context = Context,
   }
 }
 export namespace List {
-  export class Node {
-    public next?: this = undefined;
-    public prev?: this = undefined;
+  export interface Node {
+    next?: this;
+    prev?: this;
   }
 }
+export class Node<N> implements List.Node {
+  constructor(
+    public value: N,
+    public flags: number = 0,
+  ) {
+  }
+  public next?: this = undefined;
+  public prev?: this = undefined;
+}