Debian Codegraph @

rts/javascript/values.js

raw
1 // Start of values.js
2 var futharkPrimtypes =
3 new Set([
4 'i8',
5 'i16',
6 'i32',
7 'i64',
8 'u8',
9 'u16',
10 'u32',
11 'u64',
12 'f16',
13 'f32',
14 'f64',
15 'bool']);
16
17
18 var typToType = { ' i8' : Int8Array ,
19 ' i16' : Int16Array ,
20 ' i32' : Int32Array ,
21 ' i64' : BigInt64Array ,
22 ' u8' : Uint8Array ,
23 ' u16' : Uint16Array ,
24 ' u32' : Uint32Array ,
25 ' u64' : BigUint64Array ,
26 ' f16' : Uint16Array ,
27 ' f32' : Float32Array ,
28 ' f64' : Float64Array ,
29 'bool' : Uint8Array
30 };
31
32 function binToStringArray(buff, array) {
33 for (var i = 0; i < array.length; i++) {
34 array[i] = buff[i];
35 }
36 }
37
38 function fileToBuff(fname) {
39 var readline = require('readline');
40 var fs = require('fs');
41 var buff = fs.readFileSync(fname);
42 return buff;
43 }
44
45 var typToSize = {
46 "bool" : 1,
47 " u8" : 1,
48 " i8" : 1,
49 " u16" : 2,
50 " i16" : 2,
51 " u32" : 4,
52 " i32" : 4,
53 " f16" : 2,
54 " f32" : 4,
55 " u64" : 8,
56 " i64" : 8,
57 " f64" : 8,
58 }
59
60 function toU8(ta) {
61 return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength);
62 }
63
64 function construct_binary_value(v, typ) {
65 var dims;
66 var payload_bytes;
67 var filler;
68 if (v instanceof FutharkOpaque) {
69 throw "Opaques are not supported";
70 } else if (v instanceof FutharkArray) {
71 var t = v.futharkType();
72 var ftype = " ".slice(t.length) + t;
73 var shape = v.shape();
74 var ta = v.toTypedArray(shape);
75 var da = new BigInt64Array(shape);
76 dims = shape.length;
77 payload_bytes = da.byteLength + ta.byteLength;
78 filler = (bytes) => {
79 bytes.set(toU8(da), 7);
80 bytes.set(toU8(ta), 7 + da.byteLength);
81 }
82 } else {
83 var ftype = " ".slice(typ.length) + typ;
84 dims = 0;
85 payload_bytes = typToSize[ftype];
86 filler = (bytes) => {
87 var scalar = new (typToType[ftype])([v]);
88 bytes.set(toU8(scalar), 7);
89 }
90 }
91 var total_bytes = 7 + payload_bytes;
92 var bytes = new Uint8Array(total_bytes);
93 bytes[0] = Buffer.from('b').readUInt8();
94 bytes[1] = 2;
95 bytes[2] = dims;
96 for (var i = 0; i < 4; i++) {
97 bytes[3+i] = ftype.charCodeAt(i);
98 }
99 filler(bytes);
100 return Buffer.from(bytes);
101 }
102
103 class Reader {
104 constructor(f) {
105 this.f = f;
106 this.buff = fileToBuff(f);
107 }
108
109 read_bin_array(num_dim, typ) {
110 var u8_array = new Uint8Array(num_dim * 8);
111 binToStringArray(this.buff.slice(0, num_dim * 8), u8_array);
112 var shape = new BigInt64Array(u8_array.buffer);
113 var length = shape[0];
114 for (var i = 1; i < shape.length; i++) {
115 length = length * shape[i];
116 }
117 length = Number(length);
118 var dbytes = typToSize[typ];
119 var u8_data = new Uint8Array(length * dbytes);
120 binToStringArray(this.buff.slice(num_dim * 8, num_dim * 8 + dbytes * length), u8_data);
121 var data = new (typToType[typ])(u8_data.buffer);
122 var tmp_buff = this.buff.slice(num_dim * 8, num_dim * 8 + dbytes * length);
123 this.buff = this.buff.slice(num_dim * 8 + dbytes * length);
124 return [shape, data];
125 }
126
127 read_bin_scalar(typ) {
128 var size = typToSize[typ];
129 var u8_array = new Uint8Array(size);
130 binToStringArray(this.buff, u8_array);
131 var array = new (typToType[typ])(u8_array.buffer);
132 this.buff = this.buff.slice(u8_array.length); // Update buff to be unread part of the string
133 return array[0];
134 }
135
136 skip_spaces() {
137 while (this.buff.length > 0 && this.buff.slice(0, 1).toString().trim() == "") {
138 this.buff = this.buff.slice(1);
139 }
140 }
141
142 read_binary(typename, dim) {
143 // Skip leading white space
144 while (this.buff.slice(0, 1).toString().trim() == "") {
145 this.buff = this.buff.slice(1);
146 }
147 if (this.buff[0] != 'b'.charCodeAt(0)) {
148 throw "Not in binary format"
149 }
150 var version = this.buff[1];
151 if (version != 2) {
152 throw "Not version 2";
153 }
154 var num_dim = this.buff[2];
155 var typ = this.buff.slice(3, 7);
156 this.buff = this.buff.slice(7);
157 var exp_typ = "[]".repeat(dim) + typename;
158 var given_typ = "[]".repeat(num_dim) + typ.toString().trim();
159 console.log(exp_typ);
160 console.log(given_typ);
161 if (exp_typ !== given_typ) {
162 throw ("Expected type : " + exp_typ + ", Actual type : " + given_typ);
163 }
164 if (num_dim === 0) {
165 return this.read_bin_scalar(typ);
166 } else {
167 return this.read_bin_array(num_dim, typ);
168 }
169 }
170
171 get_buff() {
172 return this.buff;
173 }
174 }
175
176 // Function is redudant but is helpful for keeping consistent with python implementation
177 function skip_spaces(reader) {
178 reader.skip_spaces();
179 }
180
181 function read_value(typename, reader) {
182 var typ = typename;
183 var dim = 0;
184 while (typ.slice(0, 2) === "[]") {
185 dim = dim + 1;
186 typ = typ.slice(2);
187 }
188 if (!futharkPrimtypes.has(typ)) {
189 throw ("Unkown type: " + typ);
190 }
191
192 var val = reader.read_binary(typ, dim);
193 return val;
194 }
195
196 // End of values.js