@swf2es/runtime 0.0.0-stage → 0.1.1

package/src/avm2/natives/xml/parser.ts

@@ -0,0 +1,414 @@
+// XML text into tags, as avmplus' XMLParser: a tokenizer, not a validating
+// parser, whose leniency and errors are avmplus', which E4X's are. The tree
+// is made from its tags in build.ts.
+//
+// Translated from avmplus' core/XMLParser16.cpp, this file is subject to the
+// Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+import { isSpace } from "./chars.js";
+
+// The tags, as XMLTag's node types.
+export const TAG_ELEMENT = 1;
+export const TAG_TEXT = 3;
+export const TAG_CDATA = 4;
+export const TAG_PROCESSING_INSTRUCTION = 7;
+export const TAG_COMMENT = 8;
+export const TAG_DOCTYPE = 10;
+export const TAG_XML_DECLARATION = 13;
+
+// What getNext gives, as XMLParser's status codes: a tag, the end, or the
+// error E4X throws for each (see PARSE_ERRORS in values.ts).
+export const OK = 0;
+export const END = -1;
+export const UNTERMINATED_CDATA = -2;
+export const UNTERMINATED_XML_DECLARATION = -3;
+export const UNTERMINATED_DOCTYPE = -4;
+export const UNTERMINATED_COMMENT = -5;
+export const MALFORMED_ELEMENT = -6;
+export const UNTERMINATED_ATTRIBUTE_VALUE = -8;
+export const UNTERMINATED_PROCESSING_INSTRUCTION = -10;
+
+export class XMLTag {
+  type = 0;
+  /** An element's name (with "/" first for an end tag), or the text of any other tag. */
+  text = "";
+  /** Whether an element closed itself, as <a/>. */
+  empty = false;
+  /** An element's attributes, name then value. */
+  attributes: string[] = [];
+
+  reset(): void {
+    this.type = 0;
+    this.text = "";
+    this.empty = false;
+    this.attributes = [];
+  }
+}
+
+/** The entities XMLParser knows: the XML ones, and nbsp. */
+const ENTITIES: Record<string, string> = {
+  amp: "&",
+  quot: '"',
+  apos: "'",
+  lt: "<",
+  gt: ">",
+  nbsp: "\u00a0",
+};
+
+export class XMLParser {
+  private pos = 0;
+  private ignoreWhite = false;
+  private condenseWhite = false;
+  private readonly text: string;
+
+  constructor(text: string) {
+    this.text = text;
+  }
+
+  /** As XMLParser::parse: from the start, whitespace-only text left out if `ignoreWhite`. */
+  parse(ignoreWhite: boolean): void {
+    this.pos = 0;
+    this.ignoreWhite = ignoreWhite;
+  }
+
+  setCondenseWhite(condense: boolean): void {
+    this.condenseWhite = condense;
+  }
+
+  private atEnd(): boolean {
+    return this.pos >= this.text.length;
+  }
+
+  /** Past whitespace: false at the end. */
+  private skipWhiteSpace(): boolean {
+    while (!this.atEnd() && isSpace(this.text.charCodeAt(this.pos))) {
+      this.pos++;
+    }
+
+    return !this.atEnd();
+  }
+
+  /** Whether the text at `at` starts with `s`, ignoring ASCII case, as matchesLatin1_caseless. */
+  private matchesCaseless(s: string, at: number): boolean {
+    return this.text.slice(at, at + s.length).toLowerCase() === s.toLowerCase();
+  }
+
+  /** The next tag into `tag`: OK, END, or an error. */
+  getNext(tag: XMLTag): number {
+    const str = this.text;
+    tag.reset();
+    if (this.atEnd()) {
+      return END;
+    }
+
+    // With ignoreWhite, no text nodes of whitespace alone.
+    if (this.ignoreWhite && !this.skipWhiteSpace()) {
+      return END;
+    }
+
+    let start = this.pos;
+    if (str[this.pos] !== "<") {
+      // Text, up to the next < or the end.
+      let next = str.indexOf("<", this.pos + 1);
+      if (next < 0) {
+        next = str.length;
+      }
+
+      this.pos = next;
+      tag.text = this.unescape(start, next);
+      if (this.ignoreWhite && this.condenseWhite) {
+        tag.text = trimWhitespace(tag.text);
+      }
+
+      tag.type = TAG_TEXT;
+      return OK;
+    }
+
+    if (this.matchesCaseless("<?xml ", start)) {
+      const end = str.indexOf("?>", start + 6);
+      if (end >= 0) {
+        tag.text = str.slice(start + 2, end);
+        this.pos = end + 2;
+        tag.type = TAG_XML_DECLARATION;
+        return OK;
+      }
+
+      return UNTERMINATED_XML_DECLARATION;
+    }
+
+    if (this.matchesCaseless("<!DOCTYPE", start)) {
+      // Up to its >, past any <...> within it.
+      let depth = 0;
+      let end = start + 1;
+      while (!this.atEnd()) {
+        const ch = str[end++];
+        if (ch === "<") {
+          depth++;
+        } else if (ch === ">") {
+          if (!depth) {
+            tag.text = str.slice(start, end);
+            tag.type = TAG_DOCTYPE;
+            this.pos = end;
+            return OK;
+          }
+
+          depth--;
+        }
+
+        this.pos = end;
+      }
+
+      return UNTERMINATED_DOCTYPE;
+    }
+
+    if (this.matchesCaseless("<![CDATA[", start)) {
+      start += 9;
+      const end = str.indexOf("]]>", start);
+      if (end >= 0) {
+        tag.text = str.slice(start, end);
+        tag.type = TAG_CDATA;
+        this.pos = end + 3;
+        return OK;
+      }
+
+      return UNTERMINATED_CDATA;
+    }
+
+    if (str.startsWith("<?", start)) {
+      start += 2;
+      const end = str.indexOf("?>", start);
+      if (end >= 0) {
+        tag.text = str.slice(start, end);
+        tag.type = TAG_PROCESSING_INSTRUCTION;
+        this.pos = end + 2;
+        return OK;
+      }
+
+      return UNTERMINATED_PROCESSING_INSTRUCTION;
+    }
+
+    start = ++this.pos;
+    if (str.startsWith("!--", start)) {
+      start += 3;
+      const end = str.indexOf("-->", start);
+      if (end >= 0) {
+        tag.text = str.slice(start, end);
+        tag.type = TAG_COMMENT;
+        this.pos = end + 3;
+        return OK;
+      }
+
+      return UNTERMINATED_COMMENT;
+    }
+
+    // An element: its name, up to >, whitespace or />.
+    start = this.pos;
+    while (!this.atEnd()) {
+      const ch = str[this.pos];
+      if (ch === ">" || isSpace(ch.charCodeAt(0))) {
+        break;
+      }
+
+      if (ch === "/" && this.pos < str.length - 1 && str[this.pos + 1] === ">") {
+        break;
+      }
+
+      this.pos++;
+    }
+
+    if (this.atEnd() || this.pos === start) {
+      return MALFORMED_ELEMENT;
+    }
+
+    tag.text = this.unescape(start, this.pos);
+    tag.type = TAG_ELEMENT;
+
+    // Its attributes.
+    let ch = "";
+    for (;;) {
+      if (!this.skipWhiteSpace()) {
+        return MALFORMED_ELEMENT;
+      }
+
+      ch = str[this.pos];
+      if (ch === ">") {
+        break;
+      }
+
+      if (ch === "/" && this.pos < str.length - 1 && str[this.pos + 1] === ">") {
+        tag.empty = true;
+        ch = str[++this.pos];
+        break;
+      }
+
+      start = this.pos;
+      while (!isSpace(ch.charCodeAt(0)) && ch !== "=" && ch !== ">") {
+        this.pos++;
+        if (this.atEnd()) {
+          return MALFORMED_ELEMENT;
+        }
+
+        ch = str[this.pos];
+      }
+
+      if (start === this.pos) {
+        return MALFORMED_ELEMENT;
+      }
+
+      const name = this.unescape(start, this.pos);
+      if (!this.skipWhiteSpace()) {
+        return MALFORMED_ELEMENT;
+      }
+
+      if (str[this.pos++] !== "=") {
+        return MALFORMED_ELEMENT;
+      }
+
+      if (!this.skipWhiteSpace()) {
+        return MALFORMED_ELEMENT;
+      }
+
+      const delimiter = str[this.pos++];
+      if (delimiter !== '"' && delimiter !== "'") {
+        return MALFORMED_ELEMENT;
+      }
+
+      // Up to the closing quote; < is not allowed within.
+      start = this.pos;
+      ch = "";
+      while (ch !== delimiter) {
+        if (this.atEnd() || ch === "<") {
+          return UNTERMINATED_ATTRIBUTE_VALUE;
+        }
+
+        ch = str[this.pos++];
+      }
+
+      tag.attributes.push(name, this.unescape(start, this.pos - 1));
+    }
+
+    if (ch === ">") {
+      this.pos++;
+    }
+
+    return OK;
+  }
+
+  /**
+   * As XMLParser::unescape: [start, last) with its entity and character
+   * references decoded: &#dd; and &#xhh; up to 0xFFFF, and ENTITIES. An &
+   * without a ; ends the decoding; one that is not a known reference is
+   * kept as it is.
+   */
+  private unescape(start: number, last: number): string {
+    const str = this.text;
+    if (start === last) {
+      return "";
+    }
+
+    let bgn = str.indexOf("&", start);
+    if (bgn < 0 || bgn >= last) {
+      return str.slice(start, last);
+    }
+
+    let dest = "";
+    let end = start;
+    while (bgn >= start && bgn < last) {
+      const ampBgn = bgn;
+      const ampEnd = str.indexOf(";", ++bgn);
+      if (ampEnd < 0 || ampEnd >= last) {
+        break;
+      }
+
+      dest += str.slice(end, bgn - 1);
+      end = ampEnd;
+      let len = end - bgn;
+      let ok = true;
+      if (len >= 2) {
+        if (str[bgn] === "#") {
+          let ch = str.charCodeAt(++bgn);
+          len--;
+          let base = 10;
+          if (len >= 2 && ch === 0x78) {
+            base = 16;
+            bgn++;
+            len--;
+          }
+
+          if (len > 0) {
+            let value = 0;
+            while (len-- && ok) {
+              ch = str.charCodeAt(bgn++);
+              if (ch >= 0x41 && ch <= 0x46) {
+                ch -= 7;
+              } else if (ch >= 0x61 && ch <= 0x66) {
+                ch -= 0x61 - 0x41 + 7;
+              }
+
+              ch -= 0x30;
+              if (ch >= 0 && ch < base) {
+                value = value * base + ch;
+              } else {
+                ok = false;
+              }
+
+              if (value > 0xffff) {
+                ok = false;
+              }
+            }
+
+            if (ok) {
+              dest += String.fromCharCode(value);
+              bgn = ++end;
+            }
+          }
+        } else if (len <= 4) {
+          const entity = ENTITIES[str.slice(bgn, end)];
+          if (entity !== undefined && Object.hasOwn(ENTITIES, str.slice(bgn, end))) {
+            dest += entity;
+            bgn = ++end;
+          } else {
+            ok = false;
+          }
+        } else {
+          ok = false;
+        }
+      } else {
+        ok = false;
+      }
+
+      if (!ok) {
+        // Kept as it is, rather than dropped, which would break content.
+        bgn = end + 1;
+        if (ampBgn < end) {
+          dest += str.slice(ampBgn, end);
+        }
+      }
+
+      bgn = str.indexOf("&", bgn);
+      if (bgn >= last) {
+        bgn = -1;
+      }
+    }
+
+    if (end < last) {
+      dest += str.slice(end, last);
+    }
+
+    return dest;
+  }
+}
+
+/** As _condenseWhitespace: `s` without leading and trailing whitespace. */
+function trimWhitespace(s: string): string {
+  let start = 0;
+  while (start < s.length && isSpace(s.charCodeAt(start))) {
+    start++;
+  }
+
+  let end = s.length - 1;
+  while (end > start && isSpace(s.charCodeAt(end))) {
+    end--;
+  }
+
+  return s.slice(start, end + 1);
+}

package/src/avm2/natives/xml/strings.ts

@@ -0,0 +1,241 @@
+// E4X's strings: XML and XMLList as toString and toXMLString write them,
+// pretty printed or not.
+//
+// Translated from avmplus' core/XMLObject.cpp and XMLListObject.cpp, this
+// file is subject to the Mozilla Public License, v. 2.0:
+// http://mozilla.org/MPL/2.0/.
+
+import type { AsObject } from "../../descriptors.js";
+import { type Namespace, prefixedNamespace, prefixOf } from "../../names.js";
+import type { Runtime } from "../../runtime.js";
+import { escapeAttributeValue, escapeElementValue } from "./escape.js";
+import { getNamespace, hasPrefix } from "./names.js";
+import {
+  ATTRIBUTE,
+  CDATA,
+  COMMENT,
+  ELEMENT,
+  PROCESSING_INSTRUCTION,
+  TEXT,
+  type XMLNode,
+} from "./node.js";
+import { e4x, okToPrettyPrint } from "./values.js";
+
+// Strings.
+
+/** As GenerateUniquePrefix: "" if no namespace has it, else the first of aaa to zzz none has. */
+function uniquePrefix(ns: Namespace, namespaces: Namespace[]): Namespace {
+  if (!namespaces.some((n) => prefixOf(n) === "")) {
+    return prefixedNamespace("", ns.uri ?? "");
+  }
+
+  const a = 0x61;
+  for (let x1 = 0; x1 < 26; x1++) {
+    for (let x2 = 0; x2 < 26; x2++) {
+      for (let x3 = 0; x3 < 26; x3++) {
+        const p = String.fromCharCode(a + x1, a + x2, a + x3);
+        if (!namespaces.some((n) => prefixOf(n) === p)) {
+          return prefixedNamespace(p, ns.uri ?? "");
+        }
+      }
+    }
+  }
+
+  return ns;
+}
+
+/** As XMLObject::__toXMLString, E4X 10.2.1: `node` as XML text, into `out`. */
+function toXMLStringOf(
+  rt: Runtime,
+  node: XMLNode,
+  ancestors: Namespace[],
+  indentLevel: number,
+  out: string[],
+): void {
+  const e = e4x(rt);
+  const pretty = okToPrettyPrint(e);
+  if (pretty && indentLevel > 0) {
+    out.push(" ".repeat(indentLevel));
+  }
+
+  switch (node.kind) {
+    case TEXT:
+      out.push(escapeElementValue(node.value, pretty));
+      return;
+    case CDATA:
+      out.push(`<![CDATA[${node.value}]]>`);
+      return;
+    case ATTRIBUTE:
+      out.push(escapeAttributeValue(node.value));
+      return;
+    case COMMENT:
+      out.push(`<!--${node.value}-->`);
+      return;
+    case PROCESSING_INSTRUCTION:
+      out.push(`<?${node.name} ${node.value}?>`);
+      return;
+  }
+
+  // The namespaces in scope not already among the ancestors'.
+  const origLength = ancestors.length;
+  for (const ns of node.inScopeNamespaces()) {
+    if (!ancestors.some((ns2) => ns.uri === ns2.uri && prefixOf(ns) === prefixOf(ns2))) {
+      ancestors.push(ns);
+    }
+  }
+
+  // This node's namespace, and its attributes', each with a prefix.
+  let own = getNamespace(node.ns, ancestors);
+  if (prefixOf(own) === undefined) {
+    own = uniquePrefix(own, ancestors);
+    ancestors.push(own);
+  }
+
+  for (const a of node.attributes) {
+    if (a.name !== null) {
+      const ns = getNamespace(a.ns, ancestors);
+      if (prefixOf(ns) === undefined) {
+        ancestors.push(uniquePrefix(ns, ancestors));
+      }
+    }
+  }
+
+  const prefix = prefixOf(own) as string;
+  const qualified = prefix !== "" ? `${prefix}:${node.name}` : (node.name as string);
+  out.push("<", qualified);
+  for (const a of node.attributes) {
+    if (a.name !== null) {
+      out.push(" ");
+      const ns = getNamespace(a.ns, ancestors);
+      if (hasPrefix(ns)) {
+        out.push(prefixOf(ns) as string, ":");
+      }
+
+      out.push(a.name, '="', escapeAttributeValue(a.value), '"');
+    }
+  }
+
+  for (let i = origLength; i < ancestors.length; i++) {
+    const ns = ancestors[i];
+    if (ns.uri !== "") {
+      const p = prefixOf(ns);
+      out.push(p !== "" ? ` xmlns:${p}="` : ' xmlns="', ns.uri ?? "", '"');
+    }
+  }
+
+  const children = node.children;
+  if (!children.length) {
+    out.push("/>");
+    return;
+  }
+
+  out.push(">");
+  const indentChildren = children.length > 1 || (children[0].kind & ~(TEXT | CDATA)) !== 0;
+  const nextIndentLevel = e.prettyPrinting && indentChildren ? indentLevel + e.prettyIndent : 0;
+
+  // The ancestors' namespaces less those whose prefix one here declares
+  // again, so that each is declared where it is shadowed.
+  const scope: Namespace[] = [];
+  for (let i = 0; i < ancestors.length; i++) {
+    const first = ancestors[i];
+    if (i < origLength) {
+      let j = origLength;
+      while (j < ancestors.length && prefixOf(ancestors[j]) !== prefixOf(first)) {
+        j++;
+      }
+
+      if (j === ancestors.length) {
+        scope.push(first);
+      }
+    } else {
+      scope.push(first);
+    }
+  }
+
+  const scopeLength = scope.length;
+  for (const child of children) {
+    if (pretty && indentChildren) {
+      out.push("\n");
+    }
+
+    toXMLStringOf(rt, child, scope, nextIndentLevel, out);
+    scope.length = scopeLength;
+  }
+
+  if (pretty && indentChildren) {
+    out.push("\n");
+    if (indentLevel > 0) {
+      out.push(" ".repeat(indentLevel));
+    }
+  }
+
+  out.push("</", qualified, ">");
+}
+
+export function xmlToXMLString(rt: Runtime, node: XMLNode): string {
+  const out: string[] = [];
+  toXMLStringOf(rt, node, [], 0, out);
+  return out.join("");
+}
+
+export function listToXMLString(rt: Runtime, list: AsObject): string {
+  const out: string[] = [];
+  const nodes: XMLNode[] = list.$nodes;
+  for (let i = 0; i < nodes.length; i++) {
+    if (i) {
+      out.push("\n");
+    }
+
+    toXMLStringOf(rt, nodes[i], [], 0, out);
+  }
+
+  return out.join("");
+}
+
+/** As XMLObject::toString, E4X 10.1.1: a simple node's text, else its XML. */
+export function xmlToString(rt: Runtime, node: XMLNode): string {
+  if (node.kind & (TEXT | CDATA | ATTRIBUTE)) {
+    return node.value;
+  }
+
+  if (node.hasSimpleContent()) {
+    let s = "";
+    for (const child of node.children) {
+      if (child.kind !== COMMENT && child.kind !== PROCESSING_INSTRUCTION) {
+        s += xmlToString(rt, child);
+      }
+    }
+
+    return s;
+  }
+
+  return xmlToXMLString(rt, node);
+}
+
+export function listHasSimpleContent(nodes: XMLNode[]): boolean {
+  if (nodes.length === 0) {
+    return true;
+  }
+
+  if (nodes.length === 1) {
+    return nodes[0].hasSimpleContent();
+  }
+
+  return !nodes.some((n) => n.kind === ELEMENT);
+}
+
+export function listToString(rt: Runtime, list: AsObject): string {
+  const nodes: XMLNode[] = list.$nodes;
+  if (listHasSimpleContent(nodes)) {
+    let s = "";
+    for (const node of nodes) {
+      if (node.kind !== COMMENT && node.kind !== PROCESSING_INSTRUCTION) {
+        s += xmlToString(rt, node);
+      }
+    }
+
+    return s;
+  }
+
+  return listToXMLString(rt, list);
+}