openalgo-script 0.1.0-alpha.1 → 0.2.0

package/src/core/engine/values/heap.ts

@@ -0,0 +1,295 @@
+/**
+ * The object heap: arrays, grids and drawing objects, `compiled-program.md`
+ * 3.2.
+ *
+ * Everything here exists to serve one requirement, section 6.2's: after a
+ * restore, two cells that held the same array still hold the same array, and a
+ * `push` through one is visible through the other. A heap addressed by integer
+ * gives that for nothing, because a restore puts integers back and the graph
+ * was never taken apart.
+ *
+ * **Rollback is an undo journal rather than a copy.** Section 6.2 permits a
+ * full copy, copy on write, an undo journal or nothing at all, and requires the
+ * semantics rather than the representation. A full copy of the heap at every
+ * bar is quadratic in a study that keeps a drawing object per bar, which is a
+ * study people write, so the journal takes a copy of an object the first time a
+ * bar touches it and of nothing else. A bar that changes nothing costs nothing.
+ *
+ * **What nothing can reach is dropped at a checkpoint.** A study that builds an
+ * array every bar and keeps none of them would otherwise grow for as long as
+ * the chart is open, and refusing it at a ceiling would be the wrong answer:
+ * the objects are rubbish, not a program asking for too much. The sweep runs
+ * only once the heap has grown past what the last one found live, so its cost
+ * is spread over the allocations that made it necessary.
+ */
+import type { Value } from './value.js';
+import { isRef, reference } from './value.js';
+
+/** The kinds of object a reference can point at. */
+export type ObjectKind = 'array' | 'table' | 'line' | 'label' | 'box' | 'polyline';
+
+/** One cell a script wrote into a grid during this bar. */
+export interface GridCell {
+  readonly row: number;
+  readonly col: number;
+  readonly text: Value;
+  readonly textColor: Value;
+  readonly bgColor: Value;
+  readonly align: Value;
+}
+
+export interface ArrayObject {
+  readonly kind: 'array';
+  items: Value[];
+}
+
+export interface TableObject {
+  readonly kind: 'table';
+  readonly rows: number;
+  readonly cols: number;
+  /**
+   * The cells written this bar, in write order.
+   *
+   * Not in a checkpoint and not rolled back: step 3 of every execution empties
+   * the buffers, so a re-executed bar rebuilds them from nothing.
+   */
+  cells: GridCell[];
+}
+
+export interface DrawingObject {
+  readonly kind: 'line' | 'label' | 'box' | 'polyline';
+  props: Record<string, Value>;
+  deleted: boolean;
+  /** The bar it was deleted on, for OS4005's message. */
+  deletedAt: number;
+}
+
+export type HeapObject = ArrayObject | TableObject | DrawingObject;
+
+export function isDrawing(object: HeapObject): object is DrawingObject {
+  return object.kind !== 'array' && object.kind !== 'table';
+}
+
+function copyObject(object: HeapObject): HeapObject {
+  if (object.kind === 'array') return { kind: 'array', items: [...object.items] };
+  if (object.kind === 'table') {
+    return { kind: 'table', rows: object.rows, cols: object.cols, cells: [...object.cells] };
+  }
+  return {
+    kind: object.kind,
+    props: { ...object.props },
+    deleted: object.deleted,
+    deletedAt: object.deletedAt,
+  };
+}
+
+/** What a caller must offer the sweep: every value a live root holds. */
+export type RootWalk = (visit: (value: Value) => void) => void;
+
+export class Heap {
+  private readonly objects: (HeapObject | undefined)[] = [];
+  private readonly free: number[] = [];
+  /** Drawing object ids in creation order, which is the order a host draws them. */
+  private drawingIds: number[] = [];
+  /** A copy of each object taken before the first change this bar made to it. */
+  private readonly taken = new Map<number, HeapObject>();
+  /** Ids allocated during this bar, oldest first. */
+  private created: number[] = [];
+  /** The drawing roster's length when this bar began. */
+  private drawingsAtBarStart = 0;
+  private liveAtSweep = 0;
+  private sinceSweep = 0;
+  private elements = 0;
+  /**
+   * Drawing objects created and not yet deleted, kept as a running count.
+   *
+   * Counted rather than measured because two things ask for it on the hot
+   * path: `draw.count()` on every bar and the object ceiling on every
+   * creation. Walking the roster for each would make a study that holds ten
+   * thousand objects quadratic in the number it holds, which is the study the
+   * ceiling exists for. The count is adjusted by the same journal that undoes
+   * everything else, so a rolled back creation is a rolled back count.
+   */
+  private drawingsLive = 0;
+
+  /** Objects alive right now, which is what a heap ceiling counts. */
+  liveCount(): number {
+    return this.objects.length - this.free.length;
+  }
+
+  /** Drawing objects the script has created and not deleted. */
+  drawingCount(): number {
+    return this.drawingsLive;
+  }
+
+  /** Total array elements held. */
+  elementCount(): number {
+    return this.elements;
+  }
+
+  get(id: number): HeapObject | undefined {
+    return this.objects[id];
+  }
+
+  /** The object a reference names, or nothing when the value is not one. */
+  deref(value: Value): HeapObject | undefined {
+    return isRef(value) ? this.objects[value.id] : undefined;
+  }
+
+  allocate(object: HeapObject): number {
+    const reused = this.free.pop();
+    const id = reused ?? this.objects.length;
+    this.objects[id] = object;
+    this.created.push(id);
+    this.sinceSweep += 1;
+    if (object.kind === 'array') this.elements += object.items.length;
+    if (isDrawing(object)) {
+      this.drawingIds.push(id);
+      this.drawingsLive += 1;
+    }
+    return id;
+  }
+
+  /**
+   * Delete one drawing object, which is the only thing that ends its life.
+   *
+   * Here rather than in the library call so that the roster, the count and the
+   * journal cannot disagree: a caller that set the flag itself would leave the
+   * count saying one thing and the objects another, and the first symptom
+   * would be a ceiling refusing a script that had deleted everything.
+   *
+   * Deleting twice does nothing and is not an error. The script asked for the
+   * object to be gone and it is gone; only a change to a deleted object is
+   * OS4005.
+   */
+  deleteDrawing(id: number, bar: number): void {
+    const object = this.objects[id];
+    if (object === undefined || !isDrawing(object) || object.deleted) return;
+    this.touch(id);
+    object.deleted = true;
+    object.deletedAt = bar;
+    this.drawingsLive -= 1;
+  }
+
+  /**
+   * Announce a change to an object before making it.
+   *
+   * The copy is taken once per bar per object: the journal only has to restore
+   * the state the bar started in, so the second change to the same object has
+   * nothing to record.
+   */
+  touch(id: number): void {
+    if (this.taken.has(id)) return;
+    const object = this.objects[id];
+    if (object === undefined) return;
+    this.taken.set(id, copyObject(object));
+  }
+
+  /** Called after an array's length changes, so the ceiling sees it. */
+  countElements(delta: number): void {
+    this.elements += delta;
+  }
+
+  /** The drawing objects a host should see, in creation order. */
+  drawings(): readonly { readonly id: number; readonly object: DrawingObject }[] {
+    const out: { id: number; object: DrawingObject }[] = [];
+    for (const id of this.drawingIds) {
+      const object = this.objects[id];
+      if (object === undefined || !isDrawing(object) || object.deleted) continue;
+      out.push({ id, object });
+    }
+    return out;
+  }
+
+  /** Undo every change this bar made, which is section 6.3 for the heap. */
+  rollback(): void {
+    for (const [id, object] of this.taken) {
+      const current = this.objects[id];
+      if (current !== undefined && current.kind === 'array' && object.kind === 'array') {
+        this.elements += object.items.length - current.items.length;
+      }
+      // A deletion this bar made is undone with everything else, so the object
+      // comes back and the count comes back with it.
+      if (current !== undefined && isDrawing(current) && isDrawing(object)) {
+        this.drawingsLive += (object.deleted ? 0 : 1) - (current.deleted ? 0 : 1);
+      }
+      this.objects[id] = object;
+    }
+    this.taken.clear();
+    for (let i = this.created.length - 1; i >= 0; i -= 1) {
+      const id = this.created[i];
+      if (id === undefined) continue;
+      const object = this.objects[id];
+      if (object !== undefined && object.kind === 'array') this.elements -= object.items.length;
+      // An object created and then deleted on the same bar was counted out of
+      // the roster by the deletion, so only a live one is counted out here.
+      if (object !== undefined && isDrawing(object) && !object.deleted) this.drawingsLive -= 1;
+      this.objects[id] = undefined;
+      this.free.push(id);
+      this.sinceSweep -= 1;
+    }
+    this.created = [];
+    this.drawingIds.length = this.drawingsAtBarStart;
+  }
+
+  /** Accept every change this bar made. The journal starts again empty. */
+  commit(): void {
+    this.taken.clear();
+    this.created = [];
+    this.drawingsAtBarStart = this.drawingIds.length;
+  }
+
+  /** Drop what nothing can reach. Only at a checkpoint, and only when it pays. */
+  sweep(roots: RootWalk): void {
+    if (this.sinceSweep < this.liveAtSweep + 256) return;
+    const live = new Set<number>();
+    const pending: number[] = [];
+
+    const visit = (value: Value): void => {
+      if (!isRef(value) || live.has(value.id)) return;
+      if (this.objects[value.id] === undefined) return;
+      live.add(value.id);
+      pending.push(value.id);
+    };
+
+    roots(visit);
+    // Every drawing object that has not been deleted is a root of its own: the
+    // surface holds it, so a script that draws a box and keeps no name for it
+    // still gets a box.
+    for (const id of this.drawingIds) {
+      const object = this.objects[id];
+      if (object !== undefined && isDrawing(object) && !object.deleted) visit(reference(id));
+    }
+
+    while (pending.length > 0) {
+      const id = pending.pop();
+      if (id === undefined) continue;
+      const object = this.objects[id];
+      if (object === undefined) continue;
+      if (object.kind === 'array') for (const item of object.items) visit(item);
+      else if (object.kind === 'table') {
+        for (const cell of object.cells) {
+          visit(cell.text);
+          visit(cell.textColor);
+          visit(cell.bgColor);
+        }
+      } else for (const key of Object.keys(object.props)) visit(object.props[key] ?? null);
+    }
+
+    for (let id = 0; id < this.objects.length; id += 1) {
+      const object = this.objects[id];
+      if (object === undefined || live.has(id)) continue;
+      if (object.kind === 'array') this.elements -= object.items.length;
+      // A drawing that has not been deleted is a root of its own, so this
+      // subtracts nothing in practice. It is written because the day the roots
+      // change is the day a silently wrong count would start.
+      if (isDrawing(object) && !object.deleted) this.drawingsLive -= 1;
+      this.objects[id] = undefined;
+      this.free.push(id);
+    }
+    this.drawingIds = this.drawingIds.filter((id) => live.has(id));
+    this.drawingsAtBarStart = this.drawingIds.length;
+    this.liveAtSweep = live.size;
+    this.sinceSweep = 0;
+  }
+}

package/src/core/engine/values/index.ts

@@ -0,0 +1,34 @@
+/**
+ * What a running program holds: the six values of `compiled-program.md` 3.1
+ * and the heap the sixth one points into.
+ *
+ * Separate from the engine's own module because the library needs both and the
+ * engine needs both, and a value model that lived inside either one would make
+ * the other import it through a door it has no business going through.
+ */
+export type { ColourValue, Reference, Value } from './value.js';
+export {
+  ABSENT,
+  colour,
+  isAbsent,
+  isBool,
+  isColour,
+  isNumber,
+  isRef,
+  isString,
+  numberValue,
+  reference,
+  tagOf,
+  valuesEqual,
+} from './value.js';
+
+export type {
+  ArrayObject,
+  DrawingObject,
+  GridCell,
+  HeapObject,
+  ObjectKind,
+  RootWalk,
+  TableObject,
+} from './heap.js';
+export { Heap, isDrawing } from './heap.js';

package/src/core/engine/values/value.ts

@@ -0,0 +1,158 @@
+/**
+ * The six values a running program can hold, `compiled-program.md` 3.1.
+ *
+ * Absence is `null`, a number is a number, a boolean is a boolean and a string
+ * is a string, so four of the six tags are the ones the host language already
+ * carries and cost nothing to test. The two that have no native tag, a colour
+ * and a reference, are objects carrying a `tag` field, so `typeof` answers the
+ * question for every value in one step and no value can be mistaken for
+ * another.
+ *
+ * **Absence is never a number.** Section 3.4 is explicit that a not-a-number
+ * sentinel would make absence propagate through arithmetic by accident, which
+ * is the right answer for four operators and the wrong one for six, and would
+ * turn `isNone` into a floating point comparison. `null` has none of those
+ * properties, and the two rules the arithmetic actually needs, absence in
+ * gives absence out and a non-finite result becomes absent, are then written
+ * once each rather than hidden inside a representation.
+ *
+ * **A reference is an integer into the heap, not a pointer to an object.**
+ * That choice is what makes section 6.2's hardest requirement free: a
+ * checkpoint copies the heap table, every reference in a restored cell is the
+ * same integer it was, and two cells that shared an array still share it. A
+ * representation that put the object itself in the cell would have to work out
+ * which cells pointed at the same object and rebuild the graph, and a restore
+ * that deep copied each cell separately would silently turn one array into two.
+ */
+
+/** Red, green and blue as whole numbers 0 to 255, alpha as a number 0 to 1. */
+export interface ColourValue {
+  readonly tag: 'color';
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+  readonly a: number;
+}
+
+/** A handle into the object heap. Opaque to a script, and equal only to itself. */
+export interface Reference {
+  readonly tag: 'ref';
+  readonly id: number;
+}
+
+/** A value on the machine. */
+export type Value = null | number | boolean | string | ColourValue | Reference;
+
+/** Absence, the value a script writes `none`. */
+export const ABSENT = null;
+
+export function isAbsent(value: Value): value is null {
+  return value === null;
+}
+
+export function isNumber(value: Value): value is number {
+  return typeof value === 'number';
+}
+
+export function isBool(value: Value): value is boolean {
+  return typeof value === 'boolean';
+}
+
+export function isString(value: Value): value is string {
+  return typeof value === 'string';
+}
+
+export function isColour(value: Value): value is ColourValue {
+  return typeof value === 'object' && value !== null && value.tag === 'color';
+}
+
+export function isRef(value: Value): value is Reference {
+  return typeof value === 'object' && value !== null && value.tag === 'ref';
+}
+
+export function reference(id: number): Reference {
+  return { tag: 'ref', id };
+}
+
+/**
+ * A number made safe to store, by the two rules of section 3.1 that hold at
+ * every arithmetic result and every store.
+ *
+ * A result with no finite value is absent, checked here rather than at the end
+ * of an expression so that `(1e308 * 10) / 10` is absent rather than depending
+ * on where an engine happens to round. Negative zero becomes positive zero, so
+ * nothing downstream can observe the sign of a zero and two engines cannot
+ * differ over a minus in front of one.
+ */
+export function numberValue(x: number): Value {
+  if (!Number.isFinite(x)) return ABSENT;
+  return x === 0 ? 0 : x;
+}
+
+/** The name of a value's tag, for a diagnostic that has to say what it found. */
+export function tagOf(value: Value): string {
+  if (value === null) return 'none';
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'boolean':
+      return 'bool';
+    case 'string':
+      return 'string';
+    default:
+      return value.tag === 'color' ? 'color' : 'reference';
+  }
+}
+
+/**
+ * Whole channels, and an alpha held to its range.
+ *
+ * `stdlib.md` 11.2 requires every call that computes a colour to round red,
+ * green and blue with the language's own rounding, halves away from zero,
+ * before it returns, so that the value model's invariant holds of every colour
+ * and not only of a literal.
+ */
+export function colour(r: number, g: number, b: number, a: number): ColourValue {
+  return {
+    tag: 'color',
+    r: channel(r),
+    g: channel(g),
+    b: channel(b),
+    a: a < 0 ? 0 : a > 1 ? 1 : a === 0 ? 0 : a,
+  };
+}
+
+function channel(x: number): number {
+  if (!Number.isFinite(x)) return 0;
+  const rounded = halfAway(x);
+  return rounded < 0 ? 0 : rounded > 255 ? 255 : rounded;
+}
+
+/** The language's rounding, halves away from zero, `stdlib.md` 8.1. */
+function halfAway(x: number): number {
+  const below = Math.floor(x);
+  const fraction = x - below;
+  if (fraction > 0.5) return below + 1;
+  if (fraction < 0.5) return below;
+  return x > 0 ? below + 1 : below;
+}
+
+/**
+ * Whether two values are equal under `EQ`, which is total: it always answers.
+ *
+ * Absent equals absent and nothing else. Two colours are equal when all four
+ * channels match. Two references are equal when they are the same object,
+ * which is `language.md` 9.3 and the reason `arrayEqual` exists in the library
+ * for comparing contents.
+ */
+export function valuesEqual(a: Value, b: Value): boolean {
+  if (a === null || b === null) return a === b;
+  if (typeof a === 'number' || typeof a === 'boolean' || typeof a === 'string') {
+    return a === b;
+  }
+  if (typeof b !== 'object' || b === null) return false;
+  if (a.tag === 'color') {
+    return b.tag === 'color' && a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
+  }
+  return b.tag === 'ref' && a.id === b.id;
+}

package/src/core/engine/verify-budgets.ts

@@ -0,0 +1,202 @@
+/**
+ * The budgets a host is willing to spend, `compiled-program.md` 2.4 and 9.4 step
+ * 7.
+ *
+ * Separate from `verify.ts` because it answers a different question. Verification
+ * asks whether this is a valid program, which every engine answers the same way
+ * because the specification says how. These ask whether this host will run it,
+ * and two hosts may honestly differ: a ceiling here is a configuration, not a
+ * property of the language.
+ *
+ * **None of them silently caps anything.** 2.4 is explicit: a host refuses at
+ * load, naming the limit and the value it allows. A program that quietly gets a
+ * smaller budget than it asked for produces a wrong number instead of a message,
+ * and nothing on the chart would say which number.
+ *
+ * The walks below read tables that verification has not reached yet, because the
+ * budget refusals are step 7 of 9.4 and verification is step 8. Reading them
+ * defensively is what keeps the specification's order from turning a malformed
+ * program into a thrown error rather than the OS6018 step 8 is about to report,
+ * naming the instruction.
+ */
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { EngineLimits } from './budget.js';
+import { NO_POSITION, failure } from './errors.js';
+import type { CompiledProgram, Instruction, Request } from './types.js';
+
+/** Each ceiling in turn, stopping at the first the program is over. */
+export function checkBudgets(
+  program: CompiledProgram,
+  limits: EngineLimits,
+): Diagnostic | undefined {
+  if (limits.loops !== null && program.limits.loops > limits.loops) {
+    return failure('OS5003', NO_POSITION, {
+      option: 'loops',
+      max: limits.loops,
+      found: program.limits.loops,
+    });
+  }
+  const history = program.limits.history;
+  if (limits.history !== null && history !== null && history > limits.history) {
+    return failure('OS5003', NO_POSITION, {
+      option: 'history',
+      max: limits.history,
+      found: history,
+    });
+  }
+  if (limits.instructions !== null) {
+    let found = 0;
+    for (const code of allCode(program)) found += code.length;
+    if (found > limits.instructions) {
+      return failure('OS5009', NO_POSITION, { found, max: limits.instructions });
+    }
+  }
+  if (limits.states !== null && program.states.length > limits.states) {
+    const [first, second] = busiestPair(program);
+    return failure('OS5004', NO_POSITION, {
+      found: program.states.length,
+      max: limits.states,
+      first,
+      second,
+    });
+  }
+  if (limits.requests !== null) {
+    // `host-interface.md` 5.2: the ceiling is the host's and it is stated at
+    // load, because the whole set of reads is known then. A nested read is one
+    // of them: it is a second series the host keeps in step with the chart.
+    const found = countRequests(program.requests);
+    if (found > limits.requests) {
+      return failure('OS5006', NO_POSITION, { found, max: limits.requests });
+    }
+  }
+  const depth = callDepth(program);
+  if (depth > limits.frames) {
+    return failure('OS5005', NO_POSITION, {
+      construct: 'a call',
+      found: depth,
+      max: limits.frames,
+    });
+  }
+  return undefined;
+}
+
+/** Every read the file makes, the ones written inside another included. */
+function countRequests(requests: readonly Request[]): number {
+  let found = 0;
+  for (const one of requests) found += 1 + countRequests(one.body.requests);
+  return found;
+}
+
+/**
+ * The opcode of one element of an instruction list, or nothing when it is not
+ * an instruction at all.
+ *
+ * The budget refusals are step 7 of 9.4 and verification is step 8, so the two
+ * walks below read lists that nothing has yet proved are instruction lists.
+ * Reading them defensively is what keeps the specification's order from turning
+ * a malformed program into a thrown error rather than the OS6018 step 8 is
+ * about to report, naming the instruction.
+ */
+function opcodeOf(instruction: Instruction): string | undefined {
+  return Array.isArray(instruction) ? instruction[0] : undefined;
+}
+
+/**
+ * The two functions whose nesting produced the most call paths.
+ *
+ * OS5004's message names them because the number of paths grows
+ * multiplicatively where several functions each call the next more than once,
+ * and a reader who is told only the total has nowhere to start. The pair with
+ * the most call sites between them is where the multiplication happened.
+ */
+function busiestPair(program: CompiledProgram): readonly [string, string] {
+  const counts = new Map<string, number>();
+  const lists: readonly (readonly [string, readonly Instruction[]])[] = [
+    ['the top level', program.code],
+    ...program.functions.map(
+      (one) => [one.name, one.code] as readonly [string, readonly Instruction[]],
+    ),
+  ];
+  for (const [caller, code] of lists) {
+    for (const instruction of code) {
+      if (opcodeOf(instruction) !== 'CALL_FN') continue;
+      const site = program.callSites[instruction[1] as number];
+      const callee = site === undefined ? undefined : program.functions[site.fn]?.name;
+      if (callee === undefined) continue;
+      const key = `${caller}\u0000${callee}`;
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+  }
+  let best: readonly [string, string] = ['the top level', 'the functions it calls'];
+  let most = 0;
+  // Sorted before the walk, so the answer does not depend on a map's order.
+  for (const key of [...counts.keys()].sort()) {
+    const count = counts.get(key) ?? 0;
+    if (count <= most) continue;
+    const [caller, callee] = key.split('\u0000');
+    best = [caller ?? '', callee ?? ''];
+    most = count;
+  }
+  return best;
+}
+
+/**
+ * The deepest chain of call sites, which is the deepest the frame stack goes.
+ *
+ * Recursion is an error in the language, so the call graph is acyclic and the
+ * walk terminates; the visited set is a guard against a program that was
+ * written by something other than this compiler, and it stops rather than
+ * looping forever.
+ */
+function callDepth(program: CompiledProgram): number {
+  const bodies = program.functions.map((one) => one.code);
+  const sitesIn = (code: readonly Instruction[]): number[] =>
+    code.flatMap((one) =>
+      opcodeOf(one) === 'CALL_FN' && typeof one[1] === 'number' ? [one[1]] : [],
+    );
+
+  const known = new Map<number, number>();
+  const walking = new Set<number>();
+  const depthOf = (site: number): number => {
+    const cached = known.get(site);
+    if (cached !== undefined) return cached;
+    if (walking.has(site)) return 1;
+    walking.add(site);
+    const fn = program.callSites[site]?.fn;
+    const body = fn === undefined ? undefined : bodies[fn];
+    let deepest = 0;
+    for (const inner of body === undefined ? [] : sitesIn(body)) {
+      deepest = Math.max(deepest, depthOf(inner));
+    }
+    walking.delete(site);
+    known.set(site, deepest + 1);
+    return deepest + 1;
+  };
+
+  let deepest = 0;
+  for (const site of sitesIn(program.code)) deepest = Math.max(deepest, depthOf(site));
+  return deepest + 1;
+}
+
+/**
+ * Every instruction list in the program, the bodies of its reads included.
+ *
+ * A read's expression is part of the program: an engine that cannot run an
+ * `ELEM` cannot run one inside a read either, and a budget or a tag worked out
+ * from the bar's list alone would say otherwise.
+ */
+export function allCode(program: CompiledProgram): (readonly Instruction[])[] {
+  const lists: (readonly Instruction[])[] = [
+    program.code,
+    ...program.functions.map((one) => one.code),
+  ];
+  const walk = (requests: readonly Request[]): void => {
+    for (const request of requests) {
+      lists.push(request.body.code);
+      for (const one of request.body.functions) lists.push(one.code);
+      walk(request.body.requests);
+    }
+  };
+  walk(program.requests);
+  return lists;
+}