Numbers in a DWG file, read and written bit for bit

A 64-bit value read from eight bytes of the bit stream.

The eight bytes are placed into a Float64Array's byte view and the number read back, with no arithmetic: every finite value, negative zero included, is exactly the stored one. The byte order is the machine's, so the code assumes a little-endian machine.

RD() {
  for (let i = 0; i < 8; i++) f64b[i] = this.RC();
  return f64[0];
}

A value stored as a two-bit code: a full 64-bit value, exactly 1.0 or exactly 0.0.

Codes 1 and 2 return the constants 1.0 and 0.0; code 0 reads a raw double. Code 3 is an error, not a value.

/** 2.5 BITDOUBLE. */
BD() {
  switch (this.BB()) {
    case 0: return this.RD();
    case 1: return 1.0;
    case 2: return 0.0;
    default: throw new DwgReadError(msg('ccdwg.err.bitdouble'));
  }
}

A value stored as the bytes in which it differs from a default value.

The default's bytes are loaded and the low four, or the low four and the next two, are replaced by bytes from the file; no arithmetic touches the value. The result is exact when the default passed in is the one the writer used.

/** 2.9 BitDouble with default. */
DD(def) {
  switch (this.BB()) {
    case 0: return def;
    case 1: {
      f64[0] = def;
      for (let i = 0; i < 4; i++) f64b[i] = this.RC();
      return f64[0];
    }
    case 2: {
      f64[0] = def;
      f64b[4] = this.RC(); f64b[5] = this.RC();
      for (let i = 0; i < 4; i++) f64b[i] = this.RC();
      return f64[0];
    }
    default: return this.RD();
  }
}

An unsigned 64-bit whole number from two 32-bit halves.

value = high × 2³² + low

The halves are combined as an ordinary 64-bit number, which holds whole numbers exactly only up to 2^53. A larger value is rounded to the nearest representable number.

RLL() { const lo = this.RL(), hi = this.RL(); return hi * 4294967296 + lo; }

A whole number of up to seven bytes, the count given by three bits.

value = Σ byteᵢ × 256ⁱ

Summed as an ordinary number, low byte first. Seven bytes can hold up to 2^56, so a value above 2^53 is rounded.

/** 2.4 BITLONGLONG. */
BLL() {
  const n = this.bits(3);
  let v = 0, m = 1;
  for (let i = 0; i < n; i++) { v += this.RC() * m; m *= 256; }
  return v;
}

An object handle, absolute or as an offset from another handle.

value = Σ byte × 256ᵏ; codes 6, 8, A, C: ref + 1, ref − 1, ref + value, ref − value

Handles are ordinary numbers, exact up to 2^53; the code comment says larger ones do not occur in practice. A relative code below a small reference can give a negative handle; the function does not check.

/**
 * 2.13 handle reference → absolute handle (Number; handles above 2^53 do not occur in practice).
 * `ref` is the handle offsets are taken from (codes 6, 8, A, C). `this.hcode` keeps the code.
 */
H(ref = 0) {
  const b = this.RC();
  const code = b >> 4, n = b & 15;
  let v = 0;
  for (let i = 0; i < n; i++) v = v * 256 + this.RC();
  this.hcode = code;
  switch (code) {
    case 6: return ref + 1;
    case 8: return ref - 1;
    case 0xA: return ref + v;
    case 0xC: return ref - v;
    default: return v;
  }
}

A signed whole number stored seven bits per byte.

value = Σ (byte & 0x7F) × 2^(7i); the last byte carries 6 bits and the sign

The groups are added with multiplications by powers of two, not with 32-bit shifts, so values above 2^31 are not truncated; exact up to 2^53.

/** Modular char, signed (2.6). */
export function readMC(b, pos) {
  let v = 0, shift = 0, byte;
  for (;;) {
    byte = b[pos++];
    if (byte & 0x80) { v += (byte & 0x7F) * 2 ** shift; shift += 7; continue; }
    const neg = byte & 0x40;
    v += (byte & 0x3F) * 2 ** shift;
    mod.pos = pos;
    return neg ? -v : v;
  }
}

A 64-bit value written as its eight bytes.

The value is stored into a Float64Array and its eight bytes are written in order: no rounding and no conversion to text.

RD(v) { f64[0] = v; for (let i = 0; i < 8; i++) this.RC(f64b[i]); }

A value written as a two-bit code for exactly 0.0 or 1.0, or as a full 64-bit value.

The short codes are used only for values exactly equal to 0 or 1. Negative zero is written in full, so its sign survives.

BD(v) {
  if (v === 0 && !Object.is(v, -0)) this.BB(2); else if (v === 1) this.BB(1); else { this.BB(0); this.RD(v); }
}

A value written as a two-bit code when it equals its default, or in full.

Only two forms are written: equal to the default, or all eight bytes. The partial forms that share bytes with the default are never written. Negative zero compares equal to a default of zero and is then written as the default.

/** BitDouble with default (2.9): same as the default → 00, else a full RD (11). */
DD(v, def) { if (v === def || (Number.isNaN(v) && Number.isNaN(def))) this.BB(0); else { this.BB(3); this.RD(v); } }

A thickness written as one bit when it is zero, or as a bit double.

The zero test is a truth test, so a thickness that is not a number is written as zero as well.

/** BitThickness (2.10): R2000+ one bit for 0.0. */
BT(v) { if (!v) this.B(1); else { this.B(0); this.BD(v); } }

A 32-bit whole number in its short or full form.

The value is truncated toward zero to a whole number first, and a value that is not a number becomes 0. A value outside 32 bits is wrapped by the unsigned shift, not refused.

BL(v) {
  v = Math.trunc(v) || 0;
  if (v === 0) this.BB(2);
  else if (v > 0 && v < 256) { this.BB(1); this.RC(v); }
  else { this.BB(0); this.RL(v >>> 0); }
}

A 16-bit whole number in its short or full form.

Truncated toward zero to a whole number; the full form keeps the low 16 bits, so a value outside 16 bits is wrapped.

BS(v) {
  v = Math.trunc(v) || 0;
  if (v === 0) this.BB(2); else if (v === 256) this.BB(3);
  else if (v > 0 && v < 256) { this.BB(1); this.RC(v); }
  else { this.BB(0); this.RS(v & 0xFFFF); }
}

A 64-bit whole number as a three-bit byte count and its bytes.

The value goes through BigInt, limited to 64 unsigned bits, and is split into bytes with BigInt shifts, so every bit of a BigInt input is kept. An ordinary number passed in is exact only up to 2^53, and one with a fraction is refused by BigInt with an error.

BLL(v) {
  let x = BigInt.asUintN(64, BigInt(v || 0));
  const bytes = [];
  while (x > 0n) { bytes.push(Number(x & 0xFFn)); x >>= 8n; }
  this.bits(bytes.length, 3);
  for (const b of bytes) this.RC(b);
}

The three coordinates of a point as bit doubles.

A missing coordinate, and one that is not a number, is written as 0; every other value is written unchanged.

P3(p) { this.BD3(p?.x || 0, p?.y || 0, p?.z || 0); }

A handle as its bytes, most significant first.

byte = v mod 256; v = ⌊v ÷ 256⌋

Division and remainder on an ordinary number: exact for handles up to 2^53. A handle given as text is read as hexadecimal; a negative one is written as 0.

export function handleBytes(value) {
  const bytes = [];
  let v = typeof value === 'string' ? parseInt(value, 16) || 0 : Math.max(0, Math.trunc(value || 0));
  while (v > 0) { bytes.unshift(v % 256); v = Math.floor(v / 256); }
  return bytes;
}