@portll/cobolwork 0.6.0 → 0.7.0

package/lib/pli/stmt/procedure.mjs

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for PL/I PROCEDURE, ENTRY, PACKAGE, BEGIN, and END statements.
+
+const PROC_OPTIONS = new Set([
+  'RECURSIVE', 'NONRECURSIVE', 'REORDER', 'ORDER', 'EXTERNAL', 'EXT',
+  'CHARGRAPHIC', 'NOCHARGRAPHIC', 'REDUCIBLE', 'IRREDUCIBLE'
+]);
+
+const BEGIN_OPTIONS = new Set([
+  'ORDER', 'REORDER', 'CHARGRAPHIC', 'NOCHARGRAPHIC'
+]);
+
+function parseNameList(c, failMsg) {
+  const items = c.items();
+  const names = [];
+  for (const item of items) {
+    if (item.length === 1 && item[0].t === 'op' && item[0].v === '*') {
+      names.push('*');
+    } else if (item.length === 1 && item[0].t === 'word') {
+      names.push(item[0].u);
+    } else {
+      c.fail(failMsg);
+    }
+  }
+  return names;
+}
+
+function parseOptionsList(c) {
+  const items = c.items();
+  const options = [];
+  for (const item of items) {
+    if (item.length === 0) continue;
+    const first = item[0];
+    if (first.t !== 'word') {
+      c.fail('an option name');
+    }
+    const opt = { name: first.u, args: null };
+    let i = 1;
+    if (i < item.length && item[i].t === 'op' && item[i].v === '(') {
+      const start = i;
+      let depth = 0;
+      for (; i < item.length; i++) {
+        if (item[i].t === 'op' && item[i].v === '(') depth++;
+        else if (item[i].t === 'op' && item[i].v === ')') {
+          depth--;
+          if (depth === 0) { i++; break; }
+        }
+      }
+      if (depth !== 0) {
+        c.fail("matching ')'");
+      }
+      opt.args = item.slice(start + 1, i - 1);
+    }
+    if (i < item.length) {
+      c.fail('end of option');
+    }
+    options.push(opt);
+  }
+  return options;
+}
+
+function parseProcedure(c, stmt) {
+  c.expectWord(['PROCEDURE', 'PROC']);
+  const name = stmt.labels.length ? stmt.labels[stmt.labels.length - 1].name : null;
+  const node = {
+    kind: 'PROCEDURE',
+    name,
+    params: [],
+    options: [],
+    returns: null,
+    recursive: false,
+    external: null,
+    order: null
+  };
+
+  if (c.isOp('(')) {
+    const items = c.items();
+    for (const item of items) {
+      if (item.length === 1 && item[0].t === 'word') {
+        node.params.push(item[0].u);
+      } else {
+        c.fail('a parameter name');
+      }
+    }
+  }
+
+  while (!c.done()) {
+    if (c.isWord('OPTIONS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.options.push(...parseOptionsList(c));
+    } else if (c.isWord('RETURNS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.returns = c.group();
+    } else if (c.isWord(['RECURSIVE', 'NONRECURSIVE'])) {
+      const t = c.next();
+      node.recursive = t.u === 'RECURSIVE';
+    } else if (c.isWord(['ORDER', 'REORDER'])) {
+      const t = c.next();
+      node.order = t.u;
+    } else if (c.isWord(['EXTERNAL', 'EXT'])) {
+      c.next();
+      if (c.isOp('(')) {
+        const inner = c.group();
+        if (inner.length === 1 && inner[0].t === 'lit') {
+          node.external = inner[0].v;
+        } else if (inner.length === 1 && inner[0].t === 'word') {
+          node.external = inner[0].u;
+        } else {
+          c.fail("a name or literal");
+        }
+      } else {
+        node.external = true;
+      }
+    } else if (c.isWord(['CHARGRAPHIC', 'NOCHARGRAPHIC', 'REDUCIBLE', 'IRREDUCIBLE'])) {
+      const t = c.next();
+      node.options.push({ name: t.u, args: null });
+    } else {
+      c.fail('a PROCEDURE option');
+    }
+  }
+
+  return node;
+}
+
+function parseEntry(c, stmt) {
+  c.expectWord('ENTRY');
+  const name = stmt.labels.length ? stmt.labels[stmt.labels.length - 1].name : null;
+  const node = {
+    kind: 'ENTRY',
+    name,
+    params: [],
+    options: [],
+    returns: null,
+    recursive: false,
+    external: null,
+    order: null
+  };
+
+  if (c.isOp('(')) {
+    const items = c.items();
+    for (const item of items) {
+      if (item.length === 1 && item[0].t === 'word') {
+        node.params.push(item[0].u);
+      } else {
+        c.fail('a parameter name');
+      }
+    }
+  }
+
+  while (!c.done()) {
+    if (c.isWord('RETURNS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.returns = c.group();
+    } else if (c.isWord('OPTIONS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.options.push(...parseOptionsList(c));
+    } else if (c.isWord(['EXTERNAL', 'EXT'])) {
+      c.next();
+      if (c.isOp('(')) {
+        const inner = c.group();
+        if (inner.length === 1 && inner[0].t === 'lit') {
+          node.external = inner[0].v;
+        } else if (inner.length === 1 && inner[0].t === 'word') {
+          node.external = inner[0].u;
+        } else {
+          c.fail("a name or literal");
+        }
+      } else {
+        node.external = true;
+      }
+    } else {
+      c.fail('an ENTRY option');
+    }
+  }
+
+  return node;
+}
+
+function parsePackage(c, stmt) {
+  c.expectWord('PACKAGE');
+  const name = stmt.labels.length ? stmt.labels[stmt.labels.length - 1].name : null;
+  const node = {
+    kind: 'PACKAGE',
+    name,
+    exports: null,
+    reserves: null,
+    options: []
+  };
+
+  while (!c.done()) {
+    if (c.isWord('EXPORTS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.exports = parseNameList(c, 'an export name');
+    } else if (c.isWord('RESERVES')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.reserves = parseNameList(c, 'a reserve name');
+    } else if (c.isWord('OPTIONS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.options.push(...parseOptionsList(c));
+    } else {
+      c.fail('a PACKAGE option');
+    }
+  }
+
+  return node;
+}
+
+function parseBegin(c, stmt) {
+  c.expectWord('BEGIN');
+  const node = {
+    kind: 'BEGIN',
+    options: []
+  };
+
+  while (!c.done()) {
+    if (c.isWord(['OPTIONS', 'ORDER', 'REORDER', 'CHARGRAPHIC', 'NOCHARGRAPHIC'])) {
+      const t = c.next();
+      if (t.u === 'OPTIONS') {
+        if (!c.isOp('(')) c.fail("'('");
+        node.options.push(...parseOptionsList(c));
+      } else {
+        node.options.push({ name: t.u, args: null });
+      }
+    } else {
+      c.fail('a BEGIN option');
+    }
+  }
+
+  return node;
+}
+
+function parseEnd(c, stmt) {
+  c.expectWord('END');
+  let label = null;
+  if (!c.done()) {
+    if (c.isWord()) {
+      label = c.next().u;
+    } else {
+      c.fail('a label or end of statement');
+    }
+  }
+  return { kind: 'END', label };
+}
+
+export const parsers = {
+  PROCEDURE: parseProcedure,
+  ENTRY: parseEntry,
+  PACKAGE: parsePackage,
+  BEGIN: parseBegin,
+  END: parseEnd
+};

package/lib/pli/stmt/stream.mjs

@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for PL/I stream I/O statements: GET, PUT, DISPLAY, FORMAT, and FLUSH.
+import { cursor, split } from '../cursor.mjs';
+import { parseExpression, parseReference } from '../expr.mjs';
+
+function parseFormatItem(c) {
+  const start = c.pos;
+  let factor = null;
+  // A parenthesised group followed by another item is an iteration factor, (N) F(5,2); one followed
+  // by ',' or the end is a nested format list, (A, X(2)).
+  if (c.isOp('(')) {
+    const inner = c.group();
+    const next = c.peek();
+    if (next && (next.t === 'word' || (next.t === 'op' && next.v === '('))) {
+      const s = cursor(inner);
+      factor = parseExpression(s);
+      if (!s.done()) s.fail('end of iteration factor');
+    } else {
+      c.pos = start;
+    }
+  } else if (c.peek() && c.peek().t === 'num') {
+    factor = c.next();
+  }
+
+  if (c.isOp('(')) {
+    const inner = c.group();
+    const s = cursor(inner);
+    const items = [];
+    while (!s.done()) {
+      const item = parseFormatItem(s);
+      items.push(item);
+      if (!s.done()) {
+        if (s.isOp(',')) s.next();
+        else s.fail("',' or ')'");
+      }
+    }
+    const toks = c.slice(start);
+    return { factor, items, toks };
+  }
+
+  const t = c.peek();
+  if (!t) c.fail('a format item');
+  if (t.t === 'word') {
+    c.next();
+    if (c.isOp('(')) c.group();
+    else if (t.u === 'P' && c.peek() && c.peek().t === 'lit') c.next();
+  } else if (t.t === 'lit') {
+    c.next();
+  } else {
+    c.fail('a format item');
+  }
+  return { factor, items: null, toks: c.slice(start) };
+}
+
+function parseFormatList(c) {
+  const inner = c.group();
+  const s = cursor(inner);
+  const items = [];
+  while (!s.done()) {
+    const item = parseFormatItem(s);
+    items.push(item);
+    if (!s.done()) {
+      if (s.isOp(',')) s.next();
+      else s.fail("',' or ')'");
+    }
+  }
+  return items;
+}
+
+// A repetitive specification, (X(I) DO I = 1 TO N), is an item whose parentheses hold a DO at depth one.
+function isRepetitive(toks) {
+  if (!toks.length || toks[0].t !== 'op' || toks[0].v !== '(') return false;
+  let depth = 0;
+  for (const t of toks) {
+    if (t.t === 'op' && t.v === '(') depth++;
+    else if (t.t === 'op' && t.v === ')') depth--;
+    else if (depth === 1 && t.t === 'word' && t.u === 'DO') return true;
+  }
+  return false;
+}
+
+function parseDataList(c) {
+  const items = [];
+  for (const toks of split(c.group(), ',')) {
+    if (!toks.length) c.fail('a data item');
+    if (isRepetitive(toks)) { items.push({ t: 'repetitive', toks }); continue; }
+    const s = cursor(toks);
+    items.push(parseExpression(s));
+    if (!s.done()) s.fail("',' or ')'");
+  }
+  return items;
+}
+
+function parsePut(c, stmt, ctx) {
+  c.expectWord('PUT');
+  const node = { kind: 'PUT', file: null, string: null, page: false, line: null, skip: null, mode: null, data: [], formats: [] };
+
+  while (!c.done()) {
+    if (c.isWord('FILE')) {
+      c.next();
+      c.expectOp('(');
+      node.file = parseReference(c);
+      c.expectOp(')');
+    } else if (c.isWord('STRING')) {
+      c.next();
+      c.expectOp('(');
+      node.string = parseExpression(c);
+      c.expectOp(')');
+    } else if (c.isWord('PAGE')) {
+      c.next();
+      node.page = true;
+    } else if (c.isWord('LINE')) {
+      c.next();
+      c.expectOp('(');
+      node.line = parseExpression(c);
+      c.expectOp(')');
+    } else if (c.isWord('SKIP')) {
+      c.next();
+      if (c.isOp('(')) {
+        c.next();
+        node.skip = parseExpression(c);
+        c.expectOp(')');
+      } else {
+        node.skip = true;
+      }
+    } else if (c.isWord('LIST')) {
+      c.next();
+      node.mode = 'LIST';
+      if (c.isOp('(')) {
+        node.data = parseDataList(c);
+      }
+    } else if (c.isWord('EDIT')) {
+      c.next();
+      node.mode = 'EDIT';
+      // EDIT takes one or more (data list) (format list) pairs.
+      do {
+        node.data.push(...parseDataList(c));
+        node.formats.push(parseFormatList(c));
+      } while (c.isOp('('));
+    } else if (c.isWord('DATA')) {
+      c.next();
+      node.mode = 'DATA';
+      if (c.isOp('(')) {
+        node.data = parseDataList(c);
+      }
+    } else {
+      c.fail('PUT option');
+    }
+  }
+  return node;
+}
+
+function parseGet(c, stmt, ctx) {
+  c.expectWord('GET');
+  const node = { kind: 'GET', file: null, string: null, page: false, line: null, skip: null, copy: null, mode: null, data: [], formats: [] };
+
+  while (!c.done()) {
+    if (c.isWord('FILE')) {
+      c.next();
+      c.expectOp('(');
+      node.file = parseReference(c);
+      c.expectOp(')');
+    } else if (c.isWord('STRING')) {
+      c.next();
+      c.expectOp('(');
+      node.string = parseExpression(c);
+      c.expectOp(')');
+    } else if (c.isWord('PAGE')) {
+      c.next();
+      node.page = true;
+    } else if (c.isWord('LINE')) {
+      c.next();
+      c.expectOp('(');
+      node.line = parseExpression(c);
+      c.expectOp(')');
+    } else if (c.isWord('SKIP')) {
+      c.next();
+      if (c.isOp('(')) {
+        c.next();
+        node.skip = parseExpression(c);
+        c.expectOp(')');
+      } else {
+        node.skip = true;
+      }
+    } else if (c.isWord('COPY')) {
+      c.next();
+      if (c.isOp('(')) {
+        c.next();
+        node.copy = parseReference(c);
+        c.expectOp(')');
+      } else {
+        node.copy = true;
+      }
+    } else if (c.isWord('LIST')) {
+      c.next();
+      node.mode = 'LIST';
+      if (c.isOp('(')) {
+        node.data = parseDataList(c);
+      }
+    } else if (c.isWord('EDIT')) {
+      c.next();
+      node.mode = 'EDIT';
+      // EDIT takes one or more (data list) (format list) pairs.
+      do {
+        node.data.push(...parseDataList(c));
+        node.formats.push(parseFormatList(c));
+      } while (c.isOp('('));
+    } else if (c.isWord('DATA')) {
+      c.next();
+      node.mode = 'DATA';
+      if (c.isOp('(')) {
+        node.data = parseDataList(c);
+      }
+    } else {
+      c.fail('GET option');
+    }
+  }
+  return node;
+}
+
+function parseDisplay(c, stmt, ctx) {
+  c.expectWord('DISPLAY');
+  c.expectOp('(');
+  const value = parseExpression(c);
+  c.expectOp(')');
+  const node = { kind: 'DISPLAY', value, reply: null, event: null, routcde: null, desc: null };
+
+  while (!c.done()) {
+    if (c.isWord('REPLY')) {
+      c.next();
+      c.expectOp('(');
+      node.reply = parseReference(c);
+      c.expectOp(')');
+    } else if (c.isWord('EVENT')) {
+      c.next();
+      c.expectOp('(');
+      node.event = parseReference(c);
+      c.expectOp(')');
+    } else if (c.isWord('ROUTCDE')) {
+      c.next();
+      c.expectOp('(');
+      node.routcde = parseDataList(c);
+      c.expectOp(')');
+    } else if (c.isWord('DESC')) {
+      c.next();
+      c.expectOp('(');
+      node.desc = parseDataList(c);
+      c.expectOp(')');
+    } else {
+      c.fail('DISPLAY option');
+    }
+  }
+  return node;
+}
+
+function parseFormat(c, stmt, ctx) {
+  c.expectWord('FORMAT');
+  const items = parseFormatList(c);
+  return { kind: 'FORMAT', items };
+}
+
+function parseFlush(c, stmt, ctx) {
+  c.expectWord('FLUSH');
+  c.expectWord('FILE');
+  c.expectOp('(');
+  let file;
+  if (c.isOp('*')) {
+    c.next();
+    file = '*';
+  } else {
+    file = parseReference(c);
+  }
+  c.expectOp(')');
+  return { kind: 'FLUSH', file };
+}
+
+export const parsers = {
+  PUT: parsePut,
+  GET: parseGet,
+  DISPLAY: parseDisplay,
+  FORMAT: parseFormat,
+  FLUSH: parseFlush,
+};

package/lib/pli/storage.mjs

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// The storage a PL/I element takes and the boundary it needs, from its DECLARE attributes, as the
+// Enterprise PL/I Language Reference's alignment table gives them (LP(32), OFFSETSIZE(4)). Sizes
+// and alignments are in bits so unaligned bit strings pack.
+
+const STRING_TYPES = new Set(['CHARACTER', 'BIT', 'GRAPHIC', 'WIDECHAR', 'UCHAR']);
+const UNALIGNED_BY_DEFAULT = new Set([...STRING_TYPES, 'PICTURE']);
+const ARITHMETIC = new Set(['FIXED', 'FLOAT', 'BINARY', 'DECIMAL', 'PRECISION', 'SIGNED', 'UNSIGNED', 'REAL', 'COMPLEX']);
+const UNIT = { CHARACTER: 8, BIT: 1, GRAPHIC: 16, WIDECHAR: 16, UCHAR: 32 };
+// Program-control data: bytes and alignment in bytes.
+const CONTROL = { POINTER: [4, 4], HANDLE: [4, 4], OFFSET: [4, 4], FILE: [4, 4], ENTRY: [8, 4], LABEL: [8, 4], FORMAT: [8, 4], TASK: [16, 4] };
+
+// Names that occupy no storage of their own.
+const NO_STORAGE = new Set(['BUILTIN', 'GENERIC', 'CONDITION']);
+// File description attributes declare a file even when FILE itself is not written.
+const FILE_DESCRIPTION = new Set(['STREAM', 'RECORD', 'INPUT', 'OUTPUT', 'UPDATE', 'SEQUENTIAL', 'DIRECT', 'TRANSIENT', 'KEYED', 'PRINT', 'ENVIRONMENT', 'BUFFERED', 'UNBUFFERED', 'BACKWARDS', 'EXCLUSIVE']);
+// Attributes that say nothing about the data type, so a name carrying only these takes the default.
+const NOT_TYPE = new Set(['STATIC', 'AUTOMATIC', 'BASED', 'CONTROLLED', 'DEFINED', 'POSITION', 'PARAMETER', 'EXTERNAL', 'INTERNAL', 'INITIAL', 'ALIGNED', 'UNALIGNED', 'NORMAL', 'ABNORMAL', 'ASSIGNABLE', 'NONASSIGNABLE', 'CONNECTED', 'NONCONNECTED', 'BYADDR', 'BYVALUE', 'OPTIONAL', 'INONLY', 'OUTONLY', 'INOUT', 'RESERVED', 'VALUE']);
+
+const plainNumber = (toks) => (toks && toks.length === 1 && toks[0].t === 'num' && /^\d+$/.test(toks[0].v) ? Number(toks[0].v) : null);
+
+function precisionOf(args) {
+  if (!args || !args.length) return null;
+  const parts = [[]];
+  for (const t of args) { if (t.t === 'op' && t.v === ',') parts.push([]); else parts[parts.length - 1].push(t); }
+  const signed = (p) => (p.length === 2 && p[0].t === 'op' && p[0].v === '-' ? -plainNumber([p[1]]) : plainNumber(p));
+  return { p: plainNumber(parts[0]), q: parts[1] ? signed(parts[1]) : 0 };
+}
+
+// Bytes a PICTURE occupies: every picture character except V, K and the F scaling factor, a
+// repetition factor (n) multiplying the character after it, CR and DB two characters each.
+export function pictureBytes(pic) {
+  const s = pic.toUpperCase().replace(/F\(\s*[+-]?\d+\s*\)/g, '');
+  let n = 0;
+  for (const m of s.matchAll(/\((\d+)\)(CR|DB|.)|(CR|DB)|([^VK])|[VK]/g)) {
+    if (m[2]) n += Number(m[1]) * (m[2].length === 2 ? 2 : m[2] === 'V' || m[2] === 'K' ? 0 : 1);
+    else if (m[3]) n += 2;
+    else if (m[4]) n += 1;
+  }
+  return n;
+}
+
+// { type, bits, align (bits), aligned, varying, base, scale, precision, known } for one element.
+// bits is null when an extent is not a constant (CHAR(*), CHAR(N), REFER). align is what the
+// element needs once ALIGNED or UNALIGNED is settled; `inherited` is the containing structure's
+// explicit choice, used when the element makes none of its own.
+export function storageOf(attributes, { inherited = null, name = null } = {}) {
+  const has = (n) => attributes.find((a) => a.name === n);
+  if (attributes.some((a) => NO_STORAGE.has(a.name))) return { type: attributes.find((a) => NO_STORAGE.has(a.name)).name, bits: 0, align: 8, aligned: null, known: true, storage: false };
+  if (has('TYPE')) return { type: 'TYPE', typeName: has('TYPE').args?.[0]?.u ?? null, bits: null, align: 8, aligned: null, known: false };
+  if (!has('FILE') && attributes.some((a) => FILE_DESCRIPTION.has(a.name))) attributes = [...attributes, { name: 'FILE', args: null }];
+  // RULES(IBM): a name with no data attribute is FIXED BINARY(15) when it starts with I to N, else
+  // FLOAT DECIMAL(6).
+  if (name && attributes.every((a) => NOT_TYPE.has(a.name))) {
+    const implicit = /^[I-N]/.test(name) ? [{ name: 'FIXED', args: null }, { name: 'BINARY', args: null }] : [{ name: 'FLOAT', args: null }, { name: 'DECIMAL', args: null }];
+    return { ...storageOf([...attributes, ...implicit], { inherited }), implicit: true };
+  }
+  const explicit = has('ALIGNED') ? true : has('UNALIGNED') ? false : null;
+  const alignedN = has('ALIGNED') && plainNumber(has('ALIGNED').args);
+  let type = null;
+  let bits = null;
+  let aligned;
+  let alignAligned = 8;
+  let alignUnaligned = 8;
+  const out = {};
+
+  const stringType = attributes.find((a) => STRING_TYPES.has(a.name));
+  const varying = has('VARYING') ? 'VARYING' : has('VARYINGZ') ? 'VARYINGZ' : has('VARYING4') ? 'VARYING4' : null;
+  if (stringType) {
+    type = stringType.name;
+    const n = stringType.args ? plainNumber(stringType.args) : 1;
+    const unit = UNIT[type];
+    aligned = explicit ?? inherited ?? !UNALIGNED_BY_DEFAULT.has(type);
+    if (n != null) {
+      if (type === 'BIT' && !varying) bits = aligned ? Math.ceil(n / 8) * 8 : n;
+      else if (type === 'BIT') bits = (varying === 'VARYING4' ? 32 : 16) + (aligned ? Math.ceil(n / 8) * 8 : n);
+      else bits = n * unit + (varying === 'VARYING' ? 16 : varying === 'VARYING4' ? 32 : varying === 'VARYINGZ' ? (type === 'CHARACTER' || type === 'UCHAR' ? 8 : 16) : 0);
+    }
+    alignAligned = varying === 'VARYING' ? 16 : varying === 'VARYING4' ? 32 : 8;
+    alignUnaligned = type === 'BIT' && !varying ? 1 : 8;
+    Object.assign(out, { length: n, varying });
+  } else if (has('PICTURE')) {
+    type = 'PICTURE';
+    aligned = explicit ?? inherited ?? false;
+    bits = has('PICTURE').picture != null ? pictureBytes(has('PICTURE').picture) * 8 : null;
+    out.picture = has('PICTURE').picture ?? null;
+  } else if (has('AREA')) {
+    type = 'AREA';
+    aligned = true;
+    const n = has('AREA').args ? plainNumber(has('AREA').args) : 1000;
+    bits = n == null ? null : (16 + n) * 8;
+    alignAligned = alignUnaligned = 64;
+  } else if (Object.keys(CONTROL).some((k) => has(k))) {
+    type = Object.keys(CONTROL).find((k) => has(k));
+    aligned = explicit ?? inherited ?? true;
+    const limited = type === 'ENTRY' && has('LIMITED');
+    const [bytes, align] = limited ? [4, 4] : CONTROL[type];
+    bits = bytes * 8;
+    alignAligned = align * 8;
+  } else if (attributes.some((a) => ARITHMETIC.has(a.name))) {
+    const last = (names) => [...attributes].reverse().find((a) => names.includes(a.name) && a.args);
+    const scale = has('FIXED') ? 'FIXED' : 'FLOAT';
+    const base = has('BINARY') ? 'BINARY' : 'DECIMAL';
+    const prec = precisionOf(last(['FIXED', 'FLOAT', 'BINARY', 'DECIMAL', 'PRECISION'])?.args);
+    const unsigned = !!has('UNSIGNED');
+    const p = prec?.p ?? (scale === 'FIXED' ? (base === 'BINARY' ? 15 : 5) : base === 'BINARY' ? 21 : 6);
+    type = `${scale} ${base}`;
+    aligned = explicit ?? inherited ?? true;
+    Object.assign(out, { scale, base, precision: p, fraction: prec?.q ?? 0, signed: !unsigned });
+    if (prec && prec.p == null) bits = null;
+    else if (scale === 'FIXED' && base === 'DECIMAL') { bits = Math.ceil((p + 1) / 2) * 8; alignAligned = 8; }
+    else if (scale === 'FIXED') {
+      const q = unsigned ? p - 1 : p;
+      const bytes = q <= 7 ? 1 : q <= 15 ? 2 : q <= 31 ? 4 : 8;
+      bits = bytes * 8;
+      alignAligned = bytes * 8;
+    } else {
+      const short = base === 'BINARY' ? p <= 21 : p <= 6;
+      const long = base === 'BINARY' ? p <= 53 : p <= 16;
+      bits = short ? 32 : long ? 64 : 128;
+      alignAligned = short ? 32 : 64;
+    }
+    if (has('COMPLEX') && bits != null) bits *= 2;
+  } else {
+    return { type: null, bits: null, align: 8, aligned: explicit ?? inherited ?? null, known: false };
+  }
+  const align = alignedN ? alignedN * 8 : aligned ? alignAligned : alignUnaligned;
+  return { type, bits, align, aligned, known: bits != null, ...out };
+}