24230140724

Committed 10 Apr 2026 06:40AM UTC coverage: 64.286% (-2.6%) from 66.866%

Build # 24230140724

Build Type

Pull #139

github

Committed by

web-flow

Commit Message

Merge a9d74eda8 into c5fc711d7

Pull Request Pull Request #139: Add SVML engine

Coverage Stats

1240 of 2334 branches covered (53.13%)

Branch coverage included in aggregate %.

1054 of 1647 new or added lines in 16 files covered. (64.0%)

1 existing line in 1 file now uncovered.

4169 of 6080 relevant lines covered (68.57%)

4473.77 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) {	1✔
8	ArrayBuffer.transfer = (source, length) => {	1✔
9	if (!(source instanceof ArrayBuffer))	1!
NEW 10	throw new TypeError("Source must be an instance of ArrayBuffer");	×
11	if (length <= source.byteLength) return source.slice(0, length);	1!
12	const sourceView = new Uint8Array(source);	1✔
13	const destView = new Uint8Array(new ArrayBuffer(length));	1✔
14	destView.set(sourceView);	1✔
15	return destView.buffer;	1✔
16	};
17	}
18
19	/**
20	* A little-endian byte buffer class.
21	*/
22	export default class Buffer {	1✔
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;	2✔
31	this.cursor = 0;	2✔
32	this._written = 0;	2✔
33	this._buffer = new ArrayBuffer(this._capacity);	2✔
34	this._view = new DataView(this._buffer);	2✔
35	}
36
37	private maybeExpand(n: number) {
38	if (this.cursor + n < this._capacity) {	16✔
39	return;	15✔
40	}
41
42	while (this.cursor + n >= this._capacity) {	1✔
43	this._capacity *= 2;	1✔
44	}
45	this._buffer = ArrayBuffer.transfer(this._buffer, this._capacity);	1✔
46	this._view = new DataView(this._buffer);	1✔
47	}
48
49	private updateWritten() {
50	this._written = Math.max(this._written, this.cursor);	16✔
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);	15✔
75	this._view[`set${signed ? "I" : "Ui"}nt${s}`](this.cursor, n, true);	15✔
76	this.cursor += s / 8;	15✔
77	this.updateWritten();	15✔
78	}
79
80	putI(s: 8 \| 16 \| 32, n: number) {
81	this.put(n, true, s);	2✔
82	}
83
84	putU(s: 8 \| 16 \| 32, n: number) {
85	this.put(n, false, s);	13✔
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);	1✔
97	new Uint8Array(this._buffer, this.cursor, a.byteLength).set(a);	1✔
98	this.cursor += a.byteLength;	1✔
99	this.updateWritten();	1✔
100	}
101
102	align(n: number) {
103	const rem = this.cursor % n;	2✔
104	if (rem === 0) {	2✔
105	return;	2✔
106	}
NEW 107	this.cursor += n - rem;	×
108	}
109
110	asArray(): Uint8Array {
111	return new Uint8Array(this._buffer.slice(0, this._written));	3✔
112	}
113
114	get written(): number {
NEW 115	return this._written;	×
116	}
117	}

source-academy / py-slang / 24230140724

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