fez-lisp 1.4.1 → 1.4.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/lib/baked/std.js +1 -1
- package/package.json +1 -1
- package/src/compiler.js +5 -0
- package/src/interpreter.js +240 -154
- package/src/keywords.js +3 -3
- package/src/utils.js +9 -27
package/src/interpreter.js
CHANGED
@@ -17,23 +17,27 @@ export const keywords = {
|
|
17
17
|
throw new RangeError(
|
18
18
|
`Invalid number of arguments for (${
|
19
19
|
KEYWORDS.ADDITION
|
20
|
-
}), expected (= 2) but got ${args.length}\n\
|
20
|
+
}), expected (= 2) but got ${args.length}\n\n(${
|
21
21
|
KEYWORDS.ADDITION
|
22
22
|
} ${stringifyArgs(args)})`
|
23
23
|
)
|
24
24
|
const a = evaluate(args[0], env)
|
25
25
|
if (typeof a !== 'number')
|
26
26
|
throw new TypeError(
|
27
|
-
`First arguments of (${KEYWORDS.ADDITION})
|
27
|
+
`First arguments of (${KEYWORDS.ADDITION}) must be a (${
|
28
28
|
RUNTIME_TYPES.NUMBER
|
29
|
-
})\n\
|
29
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
30
|
+
KEYWORDS.ADDITION
|
31
|
+
} ${stringifyArgs(args)})`
|
30
32
|
)
|
31
33
|
const b = evaluate(args[1], env)
|
32
34
|
if (typeof b !== 'number')
|
33
35
|
throw new TypeError(
|
34
|
-
`Second arguments of (${KEYWORDS.ADDITION})
|
36
|
+
`Second arguments of (${KEYWORDS.ADDITION}) must be a (${
|
35
37
|
RUNTIME_TYPES.NUMBER
|
36
|
-
})\n\
|
38
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
39
|
+
KEYWORDS.ADDITION
|
40
|
+
} ${stringifyArgs(args)})`
|
37
41
|
)
|
38
42
|
return a + b
|
39
43
|
},
|
@@ -42,23 +46,27 @@ export const keywords = {
|
|
42
46
|
throw new RangeError(
|
43
47
|
`Invalid number of arguments for (${
|
44
48
|
KEYWORDS.MULTIPLICATION
|
45
|
-
}), expected (= 2) but got ${args.length}\n\
|
49
|
+
}), expected (= 2) but got ${args.length}\n\n(${
|
46
50
|
KEYWORDS.MULTIPLICATION
|
47
51
|
} ${stringifyArgs(args)})`
|
48
52
|
)
|
49
53
|
const a = evaluate(args[0], env)
|
50
54
|
if (typeof a !== 'number')
|
51
55
|
throw new TypeError(
|
52
|
-
`First arguments of (${KEYWORDS.MULTIPLICATION})
|
56
|
+
`First arguments of (${KEYWORDS.MULTIPLICATION}) must be a (${
|
53
57
|
RUNTIME_TYPES.NUMBER
|
54
|
-
})\n\
|
58
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
59
|
+
KEYWORDS.MULTIPLICATION
|
60
|
+
} ${stringifyArgs(args)})`
|
55
61
|
)
|
56
62
|
const b = evaluate(args[1], env)
|
57
63
|
if (typeof b !== 'number')
|
58
64
|
throw new TypeError(
|
59
|
-
`Second arguments of (${KEYWORDS.MULTIPLICATION})
|
65
|
+
`Second arguments of (${KEYWORDS.MULTIPLICATION}) must be a (${
|
60
66
|
RUNTIME_TYPES.NUMBER
|
61
|
-
})\n\
|
67
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
68
|
+
KEYWORDS.MULTIPLICATION
|
69
|
+
} ${stringifyArgs(args)})`
|
62
70
|
)
|
63
71
|
return a * b
|
64
72
|
},
|
@@ -67,24 +75,28 @@ export const keywords = {
|
|
67
75
|
throw new RangeError(
|
68
76
|
`Invalid number of arguments for (${
|
69
77
|
KEYWORDS.SUBTRACTION
|
70
|
-
}), expected (or (= 1) (= 2)) but got ${args.length}\n\
|
78
|
+
}), expected (or (= 1) (= 2)) but got ${args.length}\n\n(${
|
71
79
|
KEYWORDS.SUBTRACTION
|
72
80
|
} ${stringifyArgs(args)})`
|
73
81
|
)
|
74
82
|
const a = evaluate(args[0], env)
|
75
83
|
if (typeof a !== 'number')
|
76
84
|
throw new TypeError(
|
77
|
-
`First argument of (${KEYWORDS.SUBTRACTION})
|
85
|
+
`First argument of (${KEYWORDS.SUBTRACTION}) must be a (${
|
78
86
|
RUNTIME_TYPES.NUMBER
|
79
|
-
})\n\
|
87
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
88
|
+
KEYWORDS.SUBTRACTION
|
89
|
+
} ${stringifyArgs(args)})`
|
80
90
|
)
|
81
91
|
if (args.length === 1) return -a
|
82
92
|
const b = evaluate(args[1], env)
|
83
93
|
if (typeof b !== 'number')
|
84
94
|
throw new TypeError(
|
85
|
-
`Second argument of (${KEYWORDS.SUBTRACTION})
|
95
|
+
`Second argument of (${KEYWORDS.SUBTRACTION}) must be a (${
|
86
96
|
RUNTIME_TYPES.NUMBER
|
87
|
-
})\n\
|
97
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
98
|
+
KEYWORDS.SUBTRACTION
|
99
|
+
} ${stringifyArgs(args)})`
|
88
100
|
)
|
89
101
|
return a - b
|
90
102
|
},
|
@@ -93,7 +105,7 @@ export const keywords = {
|
|
93
105
|
throw new RangeError(
|
94
106
|
`Invalid number of arguments for (${
|
95
107
|
KEYWORDS.DIVISION
|
96
|
-
}), expected (= 2) but got ${args.length}\n\
|
108
|
+
}), expected (= 2) but got ${args.length}\n\n(${
|
97
109
|
KEYWORDS.DIVISION
|
98
110
|
} ${stringifyArgs(args)})`
|
99
111
|
)
|
@@ -102,22 +114,26 @@ export const keywords = {
|
|
102
114
|
throw new TypeError(
|
103
115
|
`First argument of (${KEYWORDS.DIVISION}) is not (${
|
104
116
|
RUNTIME_TYPES.NUMBER
|
105
|
-
})\n\
|
117
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
118
|
+
KEYWORDS.DIVISION
|
119
|
+
} ${stringifyArgs(args)})`
|
106
120
|
)
|
107
121
|
const b = evaluate(args[1], env)
|
108
122
|
if (typeof b !== 'number')
|
109
123
|
throw new TypeError(
|
110
124
|
`Second argument of (${KEYWORDS.DIVISION}) is not (${
|
111
125
|
RUNTIME_TYPES.NUMBER
|
112
|
-
})\n\
|
126
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
127
|
+
KEYWORDS.DIVISION
|
128
|
+
} ${stringifyArgs(args)})`
|
113
129
|
)
|
114
130
|
if (b === 0)
|
115
131
|
throw new TypeError(
|
116
132
|
`Second Argument of (${
|
117
133
|
KEYWORDS.DIVISION
|
118
|
-
}) can't be a
|
119
|
-
|
120
|
-
} ${stringifyArgs(args)})`
|
134
|
+
}) can't be a 0 (division by 0 is not allowed) but ${LISP.source(
|
135
|
+
args[1]
|
136
|
+
)} is 0\n\n(${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
|
121
137
|
)
|
122
138
|
return a / b
|
123
139
|
},
|
@@ -126,7 +142,7 @@ export const keywords = {
|
|
126
142
|
throw new RangeError(
|
127
143
|
`Invalid number of arguments for (${
|
128
144
|
KEYWORDS.REMAINDER_OF_DIVISION
|
129
|
-
}), expected (= 2) but got ${args.length}\n\
|
145
|
+
}), expected (= 2) but got ${args.length}\n\n(${
|
130
146
|
KEYWORDS.REMAINDER_OF_DIVISION
|
131
147
|
} ${stringifyArgs(args)})`
|
132
148
|
)
|
@@ -135,22 +151,26 @@ export const keywords = {
|
|
135
151
|
throw new TypeError(
|
136
152
|
`First argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
|
137
153
|
RUNTIME_TYPES.NUMBER
|
138
|
-
})\n\
|
154
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
155
|
+
KEYWORDS.REMAINDER_OF_DIVISION
|
156
|
+
} ${stringifyArgs(args)})`
|
139
157
|
)
|
140
158
|
const b = evaluate(args[1], env)
|
141
159
|
if (typeof b !== 'number')
|
142
160
|
throw new TypeError(
|
143
161
|
`Second argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
|
144
162
|
RUNTIME_TYPES.NUMBER
|
145
|
-
})\n\
|
163
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
164
|
+
KEYWORDS.REMAINDER_OF_DIVISION
|
165
|
+
} ${stringifyArgs(args)})`
|
146
166
|
)
|
147
167
|
if (b === 0)
|
148
168
|
throw new TypeError(
|
149
169
|
`Second argument of (${
|
150
170
|
KEYWORDS.REMAINDER_OF_DIVISION
|
151
|
-
}) can't be a
|
152
|
-
|
153
|
-
} ${stringifyArgs(args)})`
|
171
|
+
}) can't be a 0 (division by 0 is not allowed) but ${LISP.source(
|
172
|
+
args[1]
|
173
|
+
)} is 0\n\n(${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
|
154
174
|
)
|
155
175
|
|
156
176
|
return a % b
|
@@ -160,23 +180,25 @@ export const keywords = {
|
|
160
180
|
throw new RangeError(
|
161
181
|
`Invalid number of arguments to (${
|
162
182
|
KEYWORDS.BITWISE_AND
|
163
|
-
}) (= 2 required)\n\
|
164
|
-
args
|
165
|
-
)})`
|
183
|
+
}) (= 2 required)\n\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
|
166
184
|
)
|
167
185
|
const a = evaluate(args[0], env)
|
168
186
|
if (typeof a !== 'number')
|
169
187
|
throw new TypeError(
|
170
|
-
`First arguments of (${KEYWORDS.BITWISE_AND})
|
188
|
+
`First arguments of (${KEYWORDS.BITWISE_AND}) must be a (${
|
171
189
|
RUNTIME_TYPES.NUMBER
|
172
|
-
})\n\
|
190
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
191
|
+
KEYWORDS.BITWISE_AND
|
192
|
+
} ${stringifyArgs(args)})`
|
173
193
|
)
|
174
194
|
const b = evaluate(args[1], env)
|
175
195
|
if (typeof b !== 'number')
|
176
196
|
throw new TypeError(
|
177
|
-
`Second arguments of (${KEYWORDS.BITWISE_AND})
|
197
|
+
`Second arguments of (${KEYWORDS.BITWISE_AND}) must be a (${
|
178
198
|
RUNTIME_TYPES.NUMBER
|
179
|
-
})\n\
|
199
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
200
|
+
KEYWORDS.BITWISE_AND
|
201
|
+
} ${stringifyArgs(args)})`
|
180
202
|
)
|
181
203
|
return a & b
|
182
204
|
},
|
@@ -185,16 +207,16 @@ export const keywords = {
|
|
185
207
|
throw new RangeError(
|
186
208
|
`Invalid number of arguments to (${
|
187
209
|
KEYWORDS.BITWISE_NOT
|
188
|
-
}) (= 1 required)\n\
|
189
|
-
args
|
190
|
-
)})`
|
210
|
+
}) (= 1 required)\n\n(${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
|
191
211
|
)
|
192
212
|
const operand = evaluate(args[0], env)
|
193
213
|
if (typeof operand !== 'number')
|
194
214
|
throw new TypeError(
|
195
|
-
`Argument of (${KEYWORDS.BITWISE_NOT})
|
215
|
+
`Argument of (${KEYWORDS.BITWISE_NOT}) must be a (${
|
196
216
|
RUNTIME_TYPES.NUMBER
|
197
|
-
})\n\
|
217
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
218
|
+
KEYWORDS.BITWISE_NOT
|
219
|
+
} ${stringifyArgs(args)})`
|
198
220
|
)
|
199
221
|
return ~operand
|
200
222
|
},
|
@@ -203,17 +225,25 @@ export const keywords = {
|
|
203
225
|
throw new RangeError(
|
204
226
|
`Invalid number of arguments to (${
|
205
227
|
KEYWORDS.BITWISE_OR
|
206
|
-
}) (= 2 required)\n\
|
207
|
-
args
|
208
|
-
)})`
|
228
|
+
}) (= 2 required)\n\n(${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
|
209
229
|
)
|
210
230
|
const a = evaluate(args[0], env)
|
231
|
+
if (typeof a !== 'number')
|
232
|
+
throw new TypeError(
|
233
|
+
`First arguments of (${KEYWORDS.BITWISE_OR}) must be a (${
|
234
|
+
RUNTIME_TYPES.NUMBER
|
235
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
236
|
+
KEYWORDS.BITWISE_OR
|
237
|
+
} ${stringifyArgs(args)})`
|
238
|
+
)
|
211
239
|
const b = evaluate(args[1], env)
|
212
|
-
if (typeof
|
240
|
+
if (typeof b !== 'number')
|
213
241
|
throw new TypeError(
|
214
|
-
`
|
242
|
+
`Second arguments of (${KEYWORDS.BITWISE_OR}) must be a (${
|
215
243
|
RUNTIME_TYPES.NUMBER
|
216
|
-
})\n\
|
244
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
245
|
+
KEYWORDS.BITWISE_OR
|
246
|
+
} ${stringifyArgs(args)})`
|
217
247
|
)
|
218
248
|
return a | b
|
219
249
|
},
|
@@ -222,17 +252,25 @@ export const keywords = {
|
|
222
252
|
throw new RangeError(
|
223
253
|
`Invalid number of arguments to (${
|
224
254
|
KEYWORDS.BITWISE_XOR
|
225
|
-
}) (= 2 required)\n\
|
226
|
-
args
|
227
|
-
)})`
|
255
|
+
}) (= 2 required)\n\n(${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
|
228
256
|
)
|
229
257
|
const a = evaluate(args[0], env)
|
258
|
+
if (typeof a !== 'number')
|
259
|
+
throw new TypeError(
|
260
|
+
`First arguments of (${KEYWORDS.BITWISE_XOR}) must be a (${
|
261
|
+
RUNTIME_TYPES.NUMBER
|
262
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
263
|
+
KEYWORDS.BITWISE_XOR
|
264
|
+
} ${stringifyArgs(args)})`
|
265
|
+
)
|
230
266
|
const b = evaluate(args[1], env)
|
231
|
-
if (typeof
|
267
|
+
if (typeof b !== 'number')
|
232
268
|
throw new TypeError(
|
233
|
-
`
|
269
|
+
`Second arguments of (${KEYWORDS.BITWISE_XOR}) must be a (${
|
234
270
|
RUNTIME_TYPES.NUMBER
|
235
|
-
})\n\
|
271
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
272
|
+
KEYWORDS.BITWISE_XOR
|
273
|
+
} ${stringifyArgs(args)})`
|
236
274
|
)
|
237
275
|
return a ^ b
|
238
276
|
},
|
@@ -241,17 +279,27 @@ export const keywords = {
|
|
241
279
|
throw new RangeError(
|
242
280
|
`Invalid number of arguments to (${
|
243
281
|
KEYWORDS.BITWISE_LEFT_SHIFT
|
244
|
-
}) (= 2 required)\n\
|
282
|
+
}) (= 2 required)\n\n(${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(
|
283
|
+
args
|
284
|
+
)})`
|
285
|
+
)
|
286
|
+
const a = evaluate(args[0], env)
|
287
|
+
if (typeof a !== 'number')
|
288
|
+
throw new TypeError(
|
289
|
+
`First arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) must be a (${
|
290
|
+
RUNTIME_TYPES.NUMBER
|
291
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
245
292
|
KEYWORDS.BITWISE_LEFT_SHIFT
|
246
293
|
} ${stringifyArgs(args)})`
|
247
294
|
)
|
248
|
-
const a = evaluate(args[0], env)
|
249
295
|
const b = evaluate(args[1], env)
|
250
|
-
if (typeof
|
296
|
+
if (typeof b !== 'number')
|
251
297
|
throw new TypeError(
|
252
|
-
`
|
298
|
+
`Second arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) must be a (${
|
253
299
|
RUNTIME_TYPES.NUMBER
|
254
|
-
})\n\
|
300
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
301
|
+
KEYWORDS.BITWISE_LEFT_SHIFT
|
302
|
+
} ${stringifyArgs(args)})`
|
255
303
|
)
|
256
304
|
return a << b
|
257
305
|
},
|
@@ -260,17 +308,27 @@ export const keywords = {
|
|
260
308
|
throw new RangeError(
|
261
309
|
`Invalid number of arguments to (${
|
262
310
|
KEYWORDS.BITWISE_RIGHT_SHIFT
|
263
|
-
}) (= 2 required)\n\
|
311
|
+
}) (= 2 required)\n\n(${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(
|
312
|
+
args
|
313
|
+
)})`
|
314
|
+
)
|
315
|
+
const a = evaluate(args[0], env)
|
316
|
+
if (typeof a !== 'number')
|
317
|
+
throw new TypeError(
|
318
|
+
`First arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) must be a (${
|
319
|
+
RUNTIME_TYPES.NUMBER
|
320
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
264
321
|
KEYWORDS.BITWISE_RIGHT_SHIFT
|
265
322
|
} ${stringifyArgs(args)})`
|
266
323
|
)
|
267
|
-
const a = evaluate(args[0], env)
|
268
324
|
const b = evaluate(args[1], env)
|
269
|
-
if (typeof
|
325
|
+
if (typeof b !== 'number')
|
270
326
|
throw new TypeError(
|
271
|
-
`
|
327
|
+
`Second arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) must be a (${
|
272
328
|
RUNTIME_TYPES.NUMBER
|
273
|
-
})\n\
|
329
|
+
}) but ${LISP.source(args[1])} is not\n\n(${
|
330
|
+
KEYWORDS.BITWISE_RIGHT_SHIFT
|
331
|
+
} ${stringifyArgs(args)})`
|
274
332
|
)
|
275
333
|
return a >> b
|
276
334
|
},
|
@@ -279,17 +337,29 @@ export const keywords = {
|
|
279
337
|
throw new RangeError(
|
280
338
|
`Invalid number of arguments to (${
|
281
339
|
KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
|
282
|
-
}) (= 2 required)\n\
|
340
|
+
}) (= 2 required)\n\n(${
|
283
341
|
KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
|
284
342
|
} ${stringifyArgs(args)})`
|
285
343
|
)
|
286
344
|
const a = evaluate(args[0], env)
|
345
|
+
if (typeof a !== 'number')
|
346
|
+
throw new TypeError(
|
347
|
+
`First arguments of (${
|
348
|
+
KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
|
349
|
+
}) must be a (${RUNTIME_TYPES.NUMBER}) but ${LISP.source(
|
350
|
+
args[0]
|
351
|
+
)} is not\n\n(${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(
|
352
|
+
args
|
353
|
+
)})`
|
354
|
+
)
|
287
355
|
const b = evaluate(args[1], env)
|
288
|
-
if (typeof
|
356
|
+
if (typeof b !== 'number')
|
289
357
|
throw new TypeError(
|
290
|
-
`
|
291
|
-
|
292
|
-
})
|
358
|
+
`Second arguments of (${
|
359
|
+
KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
|
360
|
+
}) must be a (${RUNTIME_TYPES.NUMBER}) but ${LISP.source(
|
361
|
+
args[1]
|
362
|
+
)} is not\n\n(${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(
|
293
363
|
args
|
294
364
|
)})`
|
295
365
|
)
|
@@ -303,22 +373,20 @@ export const keywords = {
|
|
303
373
|
throw new RangeError(
|
304
374
|
`Invalid number of arguments for (${
|
305
375
|
KEYWORDS.GET_ARRAY
|
306
|
-
}) (= 2 required)\n\
|
307
|
-
args
|
308
|
-
)})`
|
376
|
+
}) (= 2 required)\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
|
309
377
|
)
|
310
378
|
const array = evaluate(args[0], env)
|
311
379
|
if (!Array.isArray(array))
|
312
380
|
throw new TypeError(
|
313
381
|
`First argument of (${KEYWORDS.GET_ARRAY}) must be an (${
|
314
382
|
RUNTIME_TYPES.ARRAY
|
315
|
-
})\n\
|
383
|
+
})\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
|
316
384
|
)
|
317
385
|
if (array.length === 0)
|
318
386
|
throw new RangeError(
|
319
387
|
`First argument of (${KEYWORDS.GET_ARRAY}) is an empty (${
|
320
388
|
RUNTIME_TYPES.ARRAY
|
321
|
-
})\n\
|
389
|
+
})\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
|
322
390
|
)
|
323
391
|
const index = evaluate(args[1], env)
|
324
392
|
if (!Number.isInteger(index) || index < 0)
|
@@ -327,9 +395,7 @@ export const keywords = {
|
|
327
395
|
KEYWORDS.GET_ARRAY
|
328
396
|
}) must be a positive (32 bit ${
|
329
397
|
RUNTIME_TYPES.NUMBER
|
330
|
-
}) (= i ${index})\n\
|
331
|
-
args
|
332
|
-
)})`
|
398
|
+
}) (= i ${index})\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
|
333
399
|
)
|
334
400
|
if (index > array.length - 1)
|
335
401
|
throw new RangeError(
|
@@ -337,14 +403,14 @@ export const keywords = {
|
|
337
403
|
RUNTIME_TYPES.ARRAY
|
338
404
|
}) bounds (= i ${index}) expected (and (>= i 0) (< i ${
|
339
405
|
array.length
|
340
|
-
}))\n\
|
406
|
+
}))\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
|
341
407
|
)
|
342
408
|
const value = array.at(index)
|
343
409
|
if (value == undefined)
|
344
410
|
throw new RangeError(
|
345
411
|
`Trying to get a null value in (${RUNTIME_TYPES.ARRAY}) at (${
|
346
412
|
KEYWORDS.GET_ARRAY
|
347
|
-
})\n\
|
413
|
+
})\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
|
348
414
|
)
|
349
415
|
return value
|
350
416
|
},
|
@@ -353,18 +419,16 @@ export const keywords = {
|
|
353
419
|
throw new RangeError(
|
354
420
|
`Invalid number of arguments for (${
|
355
421
|
KEYWORDS.SET_ARRAY
|
356
|
-
}) (or 1 3) required\n\
|
357
|
-
args
|
358
|
-
)})`
|
422
|
+
}) (or 1 3) required\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
|
359
423
|
)
|
360
424
|
const array = evaluate(args[0], env)
|
361
425
|
if (!Array.isArray(array))
|
362
426
|
throw new TypeError(
|
363
427
|
`First argument of (${KEYWORDS.SET_ARRAY}) must be an (${
|
364
428
|
RUNTIME_TYPES.ARRAY
|
365
|
-
}) but
|
366
|
-
|
367
|
-
)})`
|
429
|
+
}) but ${LISP.source(args[0])} is not\n\n(${
|
430
|
+
KEYWORDS.SET_ARRAY
|
431
|
+
} ${stringifyArgs(args)})`
|
368
432
|
)
|
369
433
|
if (args.length === 1) {
|
370
434
|
array.pop()
|
@@ -374,7 +438,7 @@ export const keywords = {
|
|
374
438
|
throw new TypeError(
|
375
439
|
`Second argument of (${KEYWORDS.SET_ARRAY}) must be a positive (${
|
376
440
|
RUNTIME_TYPES.NUMBER
|
377
|
-
} integer) (= i ${index})\n\
|
441
|
+
} integer) (= i ${index}) but ${LISP.source(args[1])} is not\n\n(${
|
378
442
|
KEYWORDS.SET_ARRAY
|
379
443
|
} ${stringifyArgs(args)})`
|
380
444
|
)
|
@@ -384,14 +448,16 @@ export const keywords = {
|
|
384
448
|
RUNTIME_TYPES.ARRAY
|
385
449
|
}) bounds (${index}) expected (and (>= i 0) (< i ${
|
386
450
|
array.length
|
387
|
-
}))\n\
|
451
|
+
})) but ${LISP.source(args[1])} is not\n\n(${
|
452
|
+
KEYWORDS.SET_ARRAY
|
453
|
+
} ${stringifyArgs(args)})`
|
388
454
|
)
|
389
455
|
const value = evaluate(args[2], env)
|
390
456
|
if (value == undefined)
|
391
457
|
throw new RangeError(
|
392
458
|
`Trying to set a null value in (${RUNTIME_TYPES.ARRAY}) at (${
|
393
459
|
KEYWORDS.SET_ARRAY
|
394
|
-
})\n\
|
460
|
+
})\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
|
395
461
|
)
|
396
462
|
array[index] = value
|
397
463
|
}
|
@@ -402,16 +468,16 @@ export const keywords = {
|
|
402
468
|
throw new RangeError(
|
403
469
|
`Invalid number of arguments for (${
|
404
470
|
KEYWORDS.ARRAY_LENGTH
|
405
|
-
}) (= 1 required)\n\
|
406
|
-
args
|
407
|
-
)})`
|
471
|
+
}) (= 1 required)\n\n(${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
|
408
472
|
)
|
409
473
|
const array = evaluate(args[0], env)
|
410
474
|
if (!Array.isArray(array))
|
411
475
|
throw new TypeError(
|
412
476
|
`First argument of (${KEYWORDS.ARRAY_LENGTH}) must be an ${
|
413
477
|
RUNTIME_TYPES.ARRAY
|
414
|
-
}\n\
|
478
|
+
} but ${LISP.source(args[0])} is not\n\n(${
|
479
|
+
KEYWORDS.ARRAY_LENGTH
|
480
|
+
} ${stringifyArgs(args)})`
|
415
481
|
)
|
416
482
|
return array.length
|
417
483
|
},
|
@@ -420,7 +486,7 @@ export const keywords = {
|
|
420
486
|
throw new RangeError(
|
421
487
|
`Invalid number of arguments for (${
|
422
488
|
KEYWORDS.IF
|
423
|
-
}), expected (or (= 3) (= 2)) but got ${args.length}\n\
|
489
|
+
}), expected (or (= 3) (= 2)) but got ${args.length}\n\n(${
|
424
490
|
KEYWORDS.IF
|
425
491
|
} ${stringifyArgs(args)})`
|
426
492
|
)
|
@@ -429,9 +495,9 @@ export const keywords = {
|
|
429
495
|
throw new TypeError(
|
430
496
|
`Condition of (${
|
431
497
|
KEYWORDS.IF
|
432
|
-
}) must be ${TRUE} or ${FALSE} but
|
433
|
-
|
434
|
-
|
498
|
+
}) must be ${TRUE} or ${FALSE} but ${LISP.source(args[0])} is not\n\n(${
|
499
|
+
KEYWORDS.IF
|
500
|
+
} ${stringifyArgs(args)})`
|
435
501
|
)
|
436
502
|
return condition
|
437
503
|
? evaluate(args[1], env)
|
@@ -442,18 +508,18 @@ export const keywords = {
|
|
442
508
|
[KEYWORDS.NOT]: (args, env) => {
|
443
509
|
if (args.length !== 1)
|
444
510
|
throw new RangeError(
|
445
|
-
`Invalid number of arguments for (${
|
511
|
+
`Invalid number of arguments for (${KEYWORDS.NOT}) (= 1 required)\n\n(${
|
446
512
|
KEYWORDS.NOT
|
447
|
-
}
|
513
|
+
} ${stringifyArgs(args)})`
|
448
514
|
)
|
449
515
|
const operand = evaluate(args[0], env)
|
450
516
|
if (operand !== FALSE && operand !== TRUE)
|
451
517
|
throw new TypeError(
|
452
518
|
`Condition of (${
|
453
519
|
KEYWORDS.NOT
|
454
|
-
}) must be ${TRUE} or ${FALSE} but
|
455
|
-
|
456
|
-
|
520
|
+
}) must be ${TRUE} or ${FALSE} but ${LISP.source(args[0])} is not\n\n(${
|
521
|
+
KEYWORDS.NOT
|
522
|
+
} ${stringifyArgs(args)})`
|
457
523
|
)
|
458
524
|
return +!evaluate(args[0], env)
|
459
525
|
},
|
@@ -462,21 +528,25 @@ export const keywords = {
|
|
462
528
|
throw new RangeError(
|
463
529
|
`Invalid number of arguments for (${
|
464
530
|
KEYWORDS.EQUAL
|
465
|
-
}) (= 2 required)\n\
|
531
|
+
}) (= 2 required)\n\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
|
466
532
|
)
|
467
533
|
const a = evaluate(args[0], env)
|
468
534
|
const b = evaluate(args[1], env)
|
469
535
|
if (typeof a !== 'number')
|
470
536
|
throw new TypeError(
|
471
|
-
`
|
537
|
+
`First argument of (${KEYWORDS.EQUAL}) must be a ${
|
472
538
|
RUNTIME_TYPES.NUMBER
|
473
|
-
}\n\
|
539
|
+
} but ${LISP.source(args[0])} is not\n\n(${
|
540
|
+
KEYWORDS.EQUAL
|
541
|
+
} ${stringifyArgs(args)})`
|
474
542
|
)
|
475
543
|
if (typeof b !== 'number')
|
476
544
|
throw new TypeError(
|
477
|
-
`
|
545
|
+
`Second argument of (${KEYWORDS.EQUAL}) must be a ${
|
478
546
|
RUNTIME_TYPES.NUMBER
|
479
|
-
}\n\
|
547
|
+
} but ${LISP.source(args[1])} is not\n\n(${
|
548
|
+
KEYWORDS.EQUAL
|
549
|
+
} ${stringifyArgs(args)})`
|
480
550
|
)
|
481
551
|
return +(a === b)
|
482
552
|
},
|
@@ -485,23 +555,25 @@ export const keywords = {
|
|
485
555
|
throw new RangeError(
|
486
556
|
`Invalid number of arguments for (${
|
487
557
|
KEYWORDS.LESS_THAN
|
488
|
-
}) (= 2 required)\n\
|
489
|
-
args
|
490
|
-
)})`
|
558
|
+
}) (= 2 required)\n\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
|
491
559
|
)
|
492
560
|
const a = evaluate(args[0], env)
|
493
561
|
const b = evaluate(args[1], env)
|
494
562
|
if (typeof a !== 'number')
|
495
563
|
throw new TypeError(
|
496
|
-
`
|
564
|
+
`First argument of (${KEYWORDS.LESS_THAN}) must be a ${
|
497
565
|
RUNTIME_TYPES.NUMBER
|
498
|
-
}\n\
|
566
|
+
} but ${LISP.source(args[0])} is not\n\n(${
|
567
|
+
KEYWORDS.LESS_THAN
|
568
|
+
} ${stringifyArgs(args)})`
|
499
569
|
)
|
500
570
|
if (typeof b !== 'number')
|
501
571
|
throw new TypeError(
|
502
|
-
`
|
572
|
+
`Second argument of (${KEYWORDS.LESS_THAN}) must be a ${
|
503
573
|
RUNTIME_TYPES.NUMBER
|
504
|
-
}\n\
|
574
|
+
} but ${LISP.source(args[1])} is not\n\n(${
|
575
|
+
KEYWORDS.LESS_THAN
|
576
|
+
} ${stringifyArgs(args)})`
|
505
577
|
)
|
506
578
|
return +(a < b)
|
507
579
|
},
|
@@ -510,23 +582,23 @@ export const keywords = {
|
|
510
582
|
throw new RangeError(
|
511
583
|
`Invalid number of arguments for (${
|
512
584
|
KEYWORDS.GREATHER_THAN
|
513
|
-
}) (= 2 required)\n\
|
514
|
-
args
|
515
|
-
)})`
|
585
|
+
}) (= 2 required)\n\n(${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
|
516
586
|
)
|
517
587
|
const a = evaluate(args[0], env)
|
518
588
|
const b = evaluate(args[1], env)
|
519
589
|
if (typeof a !== 'number')
|
520
590
|
throw new TypeError(
|
521
|
-
`
|
591
|
+
`First argument of (${KEYWORDS.GREATHER_THAN}) must be a ${
|
522
592
|
RUNTIME_TYPES.NUMBER
|
523
|
-
}\n\
|
593
|
+
} but ${LISP.source(args[0])} is not\n\n(${
|
594
|
+
KEYWORDS.GREATHER_THAN
|
595
|
+
} ${stringifyArgs(args)})`
|
524
596
|
)
|
525
597
|
if (typeof b !== 'number')
|
526
598
|
throw new TypeError(
|
527
|
-
`
|
528
|
-
|
529
|
-
}
|
599
|
+
`Second argument of (${KEYWORDS.GREATHER_THAN}) must be a ${
|
600
|
+
RUNTIME_TYPES.NUMBER
|
601
|
+
} but ${LISP.source(args[1])} is not\n\n(${
|
530
602
|
KEYWORDS.GREATHER_THAN
|
531
603
|
} ${stringifyArgs(args)})`
|
532
604
|
)
|
@@ -537,7 +609,7 @@ export const keywords = {
|
|
537
609
|
throw new RangeError(
|
538
610
|
`Invalid number of arguments for (${
|
539
611
|
KEYWORDS.GREATHER_THAN_OR_EQUAL
|
540
|
-
}) (= 2 required)\n\
|
612
|
+
}) (= 2 required)\n\n(${
|
541
613
|
KEYWORDS.GREATHER_THAN_OR_EQUAL
|
542
614
|
} ${stringifyArgs(args)})`
|
543
615
|
)
|
@@ -545,17 +617,17 @@ export const keywords = {
|
|
545
617
|
const b = evaluate(args[1], env)
|
546
618
|
if (typeof a !== 'number')
|
547
619
|
throw new TypeError(
|
548
|
-
`
|
549
|
-
|
550
|
-
}
|
620
|
+
`First argument of (${KEYWORDS.GREATHER_THAN_OR_EQUAL}) must be a ${
|
621
|
+
RUNTIME_TYPES.NUMBER
|
622
|
+
} but ${LISP.source(args[0])} is not\n\n(${
|
551
623
|
KEYWORDS.GREATHER_THAN_OR_EQUAL
|
552
624
|
} ${stringifyArgs(args)})`
|
553
625
|
)
|
554
626
|
if (typeof b !== 'number')
|
555
627
|
throw new TypeError(
|
556
|
-
`
|
557
|
-
|
558
|
-
}
|
628
|
+
`Second argument of (${KEYWORDS.GREATHER_THAN_OR_EQUAL}) must be a ${
|
629
|
+
RUNTIME_TYPES.NUMBER
|
630
|
+
} but ${LISP.source(args[1])} is not\n\n(${
|
559
631
|
KEYWORDS.GREATHER_THAN_OR_EQUAL
|
560
632
|
} ${stringifyArgs(args)})`
|
561
633
|
)
|
@@ -566,25 +638,25 @@ export const keywords = {
|
|
566
638
|
throw new RangeError(
|
567
639
|
`Invalid number of arguments for (${
|
568
640
|
KEYWORDS.LESS_THAN_OR_EQUAL
|
569
|
-
}) (= 2 required)\n\
|
570
|
-
|
571
|
-
|
641
|
+
}) (= 2 required)\n\n(${KEYWORDS.LESS_THAN_OR_EQUAL} ${stringifyArgs(
|
642
|
+
args
|
643
|
+
)})`
|
572
644
|
)
|
573
645
|
const a = evaluate(args[0], env)
|
574
646
|
const b = evaluate(args[1], env)
|
575
647
|
if (typeof a !== 'number')
|
576
648
|
throw new TypeError(
|
577
|
-
`
|
578
|
-
|
579
|
-
}
|
649
|
+
`First argument of (${KEYWORDS.LESS_THAN_OR_EQUAL}) must be a ${
|
650
|
+
RUNTIME_TYPES.NUMBER
|
651
|
+
} but ${LISP.source(args[0])} is not\n\n(${
|
580
652
|
KEYWORDS.LESS_THAN_OR_EQUAL
|
581
653
|
} ${stringifyArgs(args)})`
|
582
654
|
)
|
583
655
|
if (typeof b !== 'number')
|
584
656
|
throw new TypeError(
|
585
|
-
`
|
586
|
-
|
587
|
-
}
|
657
|
+
`Second argument of (${KEYWORDS.LESS_THAN_OR_EQUAL}) must be a ${
|
658
|
+
RUNTIME_TYPES.NUMBER
|
659
|
+
} but ${LISP.source(args[1])} is not\n\n(${
|
588
660
|
KEYWORDS.LESS_THAN_OR_EQUAL
|
589
661
|
} ${stringifyArgs(args)})`
|
590
662
|
)
|
@@ -593,16 +665,16 @@ export const keywords = {
|
|
593
665
|
[KEYWORDS.AND]: (args, env) => {
|
594
666
|
if (args.length !== 2)
|
595
667
|
throw new RangeError(
|
596
|
-
`Invalid number of arguments for (${
|
668
|
+
`Invalid number of arguments for (${KEYWORDS.AND}) (= 2 required)\n\n(${
|
597
669
|
KEYWORDS.AND
|
598
|
-
}
|
670
|
+
} ${stringifyArgs(args)})`
|
599
671
|
)
|
600
672
|
const a = evaluate(args[0], env)
|
601
673
|
if (a !== FALSE && a !== TRUE)
|
602
674
|
throw new TypeError(
|
603
675
|
`Condition of (${
|
604
676
|
KEYWORDS.AND
|
605
|
-
}) must be ${TRUE} or ${FALSE} but got\n\
|
677
|
+
}) must be ${TRUE} or ${FALSE} but got\n\n(${
|
606
678
|
KEYWORDS.AND
|
607
679
|
} ${stringifyArgs(args)})`
|
608
680
|
)
|
@@ -612,7 +684,7 @@ export const keywords = {
|
|
612
684
|
throw new TypeError(
|
613
685
|
`Condition of (${
|
614
686
|
KEYWORDS.AND
|
615
|
-
}) must be ${TRUE} or ${FALSE} but got\n\
|
687
|
+
}) must be ${TRUE} or ${FALSE} but got\n\n(${
|
616
688
|
KEYWORDS.AND
|
617
689
|
} ${stringifyArgs(args)})`
|
618
690
|
)
|
@@ -621,16 +693,16 @@ export const keywords = {
|
|
621
693
|
[KEYWORDS.OR]: (args, env) => {
|
622
694
|
if (args.length !== 2)
|
623
695
|
throw new RangeError(
|
624
|
-
`Invalid number of arguments for (${
|
696
|
+
`Invalid number of arguments for (${KEYWORDS.OR}) (= 2 required)\n\n(${
|
625
697
|
KEYWORDS.OR
|
626
|
-
}
|
698
|
+
} ${stringifyArgs(args)})`
|
627
699
|
)
|
628
700
|
const a = evaluate(args[0], env)
|
629
701
|
if (a !== FALSE && a !== TRUE)
|
630
702
|
throw new TypeError(
|
631
703
|
`Condition of (${
|
632
704
|
KEYWORDS.OR
|
633
|
-
}) must be ${TRUE} or ${FALSE} but got\n\
|
705
|
+
}) must be ${TRUE} or ${FALSE} but got\n\n(${
|
634
706
|
KEYWORDS.OR
|
635
707
|
} ${stringifyArgs(args)})`
|
636
708
|
)
|
@@ -640,7 +712,7 @@ export const keywords = {
|
|
640
712
|
throw new TypeError(
|
641
713
|
`Condition of (${
|
642
714
|
KEYWORDS.OR
|
643
|
-
}) must be ${TRUE} or ${FALSE} but got\n\
|
715
|
+
}) must be ${TRUE} or ${FALSE} but got\n\n(${
|
644
716
|
KEYWORDS.OR
|
645
717
|
} ${stringifyArgs(args)})`
|
646
718
|
)
|
@@ -651,7 +723,7 @@ export const keywords = {
|
|
651
723
|
throw new RangeError(
|
652
724
|
`Invalid number of arguments to (${
|
653
725
|
KEYWORDS.DEFINE_VARIABLE
|
654
|
-
}) (= 2 required)\n\
|
726
|
+
}) (= 2 required)\n\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(
|
655
727
|
args
|
656
728
|
)})`
|
657
729
|
)
|
@@ -662,11 +734,11 @@ export const keywords = {
|
|
662
734
|
throw new SyntaxError(
|
663
735
|
`First argument of (${KEYWORDS.DEFINE_VARIABLE}) must be word but got ${
|
664
736
|
TYPES[type]
|
665
|
-
}\n\
|
737
|
+
}\n\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
|
666
738
|
)
|
667
739
|
else if (isForbiddenVariableName(name))
|
668
740
|
throw new ReferenceError(
|
669
|
-
`Variable name ${name} is forbidden
|
741
|
+
`Variable name ${name} is forbidden \n\n(${
|
670
742
|
KEYWORDS.DEFINE_VARIABLE
|
671
743
|
} ${stringifyArgs(args)})`
|
672
744
|
)
|
@@ -686,7 +758,7 @@ export const keywords = {
|
|
686
758
|
name ? ` ${name}` : ''
|
687
759
|
}) are provided (expects ${params.length} but got ${
|
688
760
|
props.length
|
689
|
-
})\n\
|
761
|
+
})\n\n(${KEYWORDS.ANONYMOUS_FUNCTION} ${stringifyArgs(params)})`
|
690
762
|
)
|
691
763
|
const localEnv = Object.create(env)
|
692
764
|
// localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
|
@@ -706,7 +778,7 @@ export const keywords = {
|
|
706
778
|
throw new RangeError(
|
707
779
|
`Invalid number of arguments to (${
|
708
780
|
KEYWORDS.CALL_FUNCTION
|
709
|
-
}) (>= 1 required)\n\
|
781
|
+
}) (>= 1 required)\n\n(${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(
|
710
782
|
args
|
711
783
|
)})`
|
712
784
|
)
|
@@ -715,7 +787,7 @@ export const keywords = {
|
|
715
787
|
throw new TypeError(
|
716
788
|
`Preceeding arguments of (${
|
717
789
|
KEYWORDS.CALL_FUNCTION
|
718
|
-
}) must not be an reserved word\n\
|
790
|
+
}) must not be an reserved word\n\n(${
|
719
791
|
KEYWORDS.CALL_FUNCTION
|
720
792
|
} ${stringifyArgs(args)})`
|
721
793
|
)
|
@@ -724,7 +796,7 @@ export const keywords = {
|
|
724
796
|
throw new TypeError(
|
725
797
|
`Last argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
|
726
798
|
KEYWORDS.ANONYMOUS_FUNCTION
|
727
|
-
}) but got ${LISP.stringify(apply)}\n\
|
799
|
+
}) but got ${LISP.stringify(apply)}\n\n(${
|
728
800
|
KEYWORDS.CALL_FUNCTION
|
729
801
|
} ${stringifyArgs(args)})`
|
730
802
|
)
|
@@ -736,7 +808,7 @@ export const keywords = {
|
|
736
808
|
throw new RangeError(
|
737
809
|
`Invalid number of arguments to (${
|
738
810
|
KEYWORDS.BLOCK
|
739
|
-
}) (>= 1 required)\n\
|
811
|
+
}) (>= 1 required)\n\n(${KEYWORDS.BLOCK} ${stringifyArgs(args)})`
|
740
812
|
)
|
741
813
|
return args.reduce((_, x) => evaluate(x, env), FALSE)
|
742
814
|
},
|
@@ -745,7 +817,7 @@ export const keywords = {
|
|
745
817
|
throw new RangeError(
|
746
818
|
`Invalid number of arguments for (${
|
747
819
|
KEYWORDS.IS_ATOM
|
748
|
-
}) (= 1 required)\n\
|
820
|
+
}) (= 1 required)\n\n(${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
|
749
821
|
)
|
750
822
|
return +(typeof evaluate(args[0], env) === 'number')
|
751
823
|
},
|
@@ -754,10 +826,24 @@ export const keywords = {
|
|
754
826
|
throw new RangeError(
|
755
827
|
`Invalid number of arguments for (${
|
756
828
|
KEYWORDS.IS_LAMBDA
|
757
|
-
}) (= 1 required)\n\
|
758
|
-
args
|
759
|
-
)})`
|
829
|
+
}) (= 1 required)\n\n(${KEYWORDS.IS_LAMBDA} ${stringifyArgs(args)})`
|
760
830
|
)
|
761
831
|
return +(typeof evaluate(args[0], env) === 'function')
|
832
|
+
},
|
833
|
+
[KEYWORDS.ERROR]: (args, env) => {
|
834
|
+
if (args.length !== 1)
|
835
|
+
throw new RangeError(
|
836
|
+
`Invalid number of arguments to (${KEYWORDS.ERROR}) (= 1 required) (${
|
837
|
+
KEYWORDS.ERROR
|
838
|
+
} ${stringifyArgs(args)})`
|
839
|
+
)
|
840
|
+
const expression = evaluate(args[0], env)
|
841
|
+
if (!Array.isArray(expression))
|
842
|
+
throw new TypeError(
|
843
|
+
`Argument of (${KEYWORDS.ERROR}) must be an (${
|
844
|
+
KEYWORDS.ARRAY_TYPE
|
845
|
+
}) but got (${expression}) (${KEYWORDS.ERROR} ${stringifyArgs(args)})`
|
846
|
+
)
|
847
|
+
throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
|
762
848
|
}
|
763
849
|
}
|