24231627677

Committed 10 Apr 2026 07:23AM UTC coverage: 66.856% (-0.01%) from 66.866%

Build # 24231627677

Build Type

Pull #139

github

Committed by

web-flow

Commit Message

Merge 15e3ae631 into c5fc711d7

Pull Request Pull Request #139: Add SVML engine

Coverage Stats

1325 of 2342 branches covered (56.58%)

Branch coverage included in aggregate %.

1196 of 1652 new or added lines in 16 files covered. (72.4%)

4 existing lines in 4 files now uncovered.

4311 of 6088 relevant lines covered (70.81%)

4476.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.8

/src/utils/buffer.ts

declare global {
  interface ArrayBufferConstructor {
    transfer(source: ArrayBuffer, length: number): ArrayBuffer;
  }
}

if (!ArrayBuffer.transfer) {
  ArrayBuffer.transfer = (source, length) => {
    if (!(source instanceof ArrayBuffer))
      throw new TypeError("Source must be an instance of ArrayBuffer");
    if (length <= source.byteLength) return source.slice(0, length);
    const sourceView = new Uint8Array(source);
    const destView = new Uint8Array(new ArrayBuffer(length));
    destView.set(sourceView);
    return destView.buffer;
  };
}

/**
 * A little-endian byte buffer class.
 */
export default class Buffer {
  private _capacity: number;
  public cursor: number;
  private _written: number;
  private _buffer: ArrayBuffer;
  private _view: DataView;

  constructor() {
    this._capacity = 32;
    this.cursor = 0;
    this._written = 0;
    this._buffer = new ArrayBuffer(this._capacity);
    this._view = new DataView(this._buffer);
  }

  private maybeExpand(n: number) {
    if (this.cursor + n <= this._capacity) {
      return;
    }

    while (this.cursor + n > this._capacity) {
      this._capacity *= 2;
    }
    this._buffer = ArrayBuffer.transfer(this._buffer, this._capacity);
    this._view = new DataView(this._buffer);
  }

  private updateWritten() {
    this._written = Math.max(this._written, this.cursor);
  }

  get(signed: boolean, s: 8 | 16 | 32): number {
    const r = this._view[`get${signed ? "I" : "Ui"}nt${s}`](this.cursor, true);
    this.cursor += s / 8;
    return r;
  }

  getI(s: 8 | 16 | 32): number {
    return this.get(true, s);
  }

  getU(s: 8 | 16 | 32): number {
    return this.get(false, s);
  }

  getF(s: 32 | 64): number {
    const r = this._view[`getFloat${s}`](this.cursor, true);
    this.cursor += s / 8;
    return r;
  }

  put(n: number, signed: boolean, s: 8 | 16 | 32) {
    this.maybeExpand(s / 8);
    this._view[`set${signed ? "I" : "Ui"}nt${s}`](this.cursor, n, true);
    this.cursor += s / 8;
    this.updateWritten();
  }

  putI(s: 8 | 16 | 32, n: number) {
    this.put(n, true, s);
  }

  putU(s: 8 | 16 | 32, n: number) {
    this.put(n, false, s);
  }

  putF(s: 32 | 64, n: number) {
    this.maybeExpand(s / 8);
    this._view[`setFloat${s}`](this.cursor, n, true);
    this.cursor += s / 8;
    this.updateWritten();
  }

  putA(a: Uint8Array) {
    this.maybeExpand(a.byteLength);
    new Uint8Array(this._buffer, this.cursor, a.byteLength).set(a);
    this.cursor += a.byteLength;
    this.updateWritten();
  }

  align(n: number) {
    const rem = this.cursor % n;
    if (rem === 0) {
      return;
    }
    this.cursor += n - rem;
  }

  asArray(): Uint8Array {
    return new Uint8Array(this._buffer.slice(0, this._written));
  }

  get written(): number {
    return this._written;
  }
}

1	declare global {
2	interface ArrayBufferConstructor {
3	transfer(source: ArrayBuffer, length: number): ArrayBuffer;
4	}
5	}
6
7	if (!ArrayBuffer.transfer) {	2✔
8	ArrayBuffer.transfer = (source, length) => {	2✔
9	if (!(source instanceof ArrayBuffer))	16!
NEW 10	throw new TypeError("Source must be an instance of ArrayBuffer");	×
11	if (length <= source.byteLength) return source.slice(0, length);	16!
12	const sourceView = new Uint8Array(source);	16✔
13	const destView = new Uint8Array(new ArrayBuffer(length));	16✔
14	destView.set(sourceView);	16✔
15	return destView.buffer;	16✔
16	};
17	}
18
19	/**
20	* A little-endian byte buffer class.
21	*/
22	export default class Buffer {	2✔
23	private _capacity: number;
24	public cursor: number;
25	private _written: number;
26	private _buffer: ArrayBuffer;
27	private _view: DataView;
28
29	constructor() {
30	this._capacity = 32;	32✔
31	this.cursor = 0;	32✔
32	this._written = 0;	32✔
33	this._buffer = new ArrayBuffer(this._capacity);	32✔
34	this._view = new DataView(this._buffer);	32✔
35	}
36
37	private maybeExpand(n: number) {
38	if (this.cursor + n <= this._capacity) {	458✔
39	return;	442✔
40	}
41
42	while (this.cursor + n > this._capacity) {	16✔
43	this._capacity *= 2;	20✔
44	}
45	this._buffer = ArrayBuffer.transfer(this._buffer, this._capacity);	16✔
46	this._view = new DataView(this._buffer);	16✔
47	}
48
49	private updateWritten() {
50	this._written = Math.max(this._written, this.cursor);	458✔
51	}
52
53	get(signed: boolean, s: 8 \| 16 \| 32): number {
NEW 54	const r = this._view[`get${signed ? "I" : "Ui"}nt${s}`](this.cursor, true);	×
NEW 55	this.cursor += s / 8;	×
NEW 56	return r;	×
57	}
58
59	getI(s: 8 \| 16 \| 32): number {
NEW 60	return this.get(true, s);	×
61	}
62
63	getU(s: 8 \| 16 \| 32): number {
NEW 64	return this.get(false, s);	×
65	}
66
67	getF(s: 32 \| 64): number {
NEW 68	const r = this._view[`getFloat${s}`](this.cursor, true);	×
NEW 69	this.cursor += s / 8;	×
NEW 70	return r;	×
71	}
72
73	put(n: number, signed: boolean, s: 8 \| 16 \| 32) {
74	this.maybeExpand(s / 8);	441✔
75	this._view[`set${signed ? "I" : "Ui"}nt${s}`](this.cursor, n, true);	441✔
76	this.cursor += s / 8;	441✔
77	this.updateWritten();	441✔
78	}
79
80	putI(s: 8 \| 16 \| 32, n: number) {
81	this.put(n, true, s);	53✔
82	}
83
84	putU(s: 8 \| 16 \| 32, n: number) {
85	this.put(n, false, s);	388✔
86	}
87
88	putF(s: 32 \| 64, n: number) {
NEW 89	this.maybeExpand(s / 8);	×
NEW 90	this._view[`setFloat${s}`](this.cursor, n, true);	×
NEW 91	this.cursor += s / 8;	×
NEW 92	this.updateWritten();	×
93	}
94
95	putA(a: Uint8Array) {
96	this.maybeExpand(a.byteLength);	17✔
97	new Uint8Array(this._buffer, this.cursor, a.byteLength).set(a);	17✔
98	this.cursor += a.byteLength;	17✔
99	this.updateWritten();	17✔
100	}
101
102	align(n: number) {
103	const rem = this.cursor % n;	34✔
104	if (rem === 0) {	34✔
105	return;	34✔
106	}
NEW 107	this.cursor += n - rem;	×
108	}
109
110	asArray(): Uint8Array {
111	return new Uint8Array(this._buffer.slice(0, this._written));	49✔
112	}
113
114	get written(): number {
NEW 115	return this._written;	×
116	}
117	}

source-academy / py-slang / 24231627677

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous