fez-lisp 1.3.15 → 1.3.16
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/package.json +1 -1
- package/src/macros.js +71 -90
package/package.json
CHANGED
package/src/macros.js
CHANGED
|
@@ -371,70 +371,59 @@ export const deSuggarAst = (ast, scope) => {
|
|
|
371
371
|
break
|
|
372
372
|
case KEYWORDS.DEFINE_VARIABLE:
|
|
373
373
|
{
|
|
374
|
-
if (!isLeaf(exp[VALUE])) {
|
|
374
|
+
if (!isLeaf(exp[VALUE]) && exp[VALUE][0][TYPE] === APPLY) {
|
|
375
375
|
const left = exp[VALUE]
|
|
376
376
|
const right = exp.at(-1)
|
|
377
|
-
// const key = AST.stringify(exp)
|
|
378
|
-
// const index = scope.findIndex(
|
|
379
|
-
// (x) => AST.stringify(x) === key
|
|
380
|
-
// )
|
|
381
377
|
const lastLeft = left.pop()
|
|
382
378
|
const isSlicing = lastLeft[VALUE] !== PLACEHOLDER
|
|
383
|
-
const vars = left
|
|
379
|
+
const vars = left
|
|
384
380
|
const indexes = vars
|
|
385
381
|
.map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
|
|
386
382
|
.filter((x) => x !== -1)
|
|
387
383
|
let newScope
|
|
384
|
+
vars[0][TYPE] = WORD
|
|
388
385
|
exp.length = 0
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
[ATOM, indexes.at(-1) + 1]
|
|
427
|
-
]
|
|
428
|
-
])
|
|
429
|
-
}
|
|
430
|
-
exp.iron = true
|
|
431
|
-
exp.push(newScope)
|
|
432
|
-
deSuggarAst(exp)
|
|
433
|
-
}
|
|
434
|
-
break
|
|
435
|
-
default:
|
|
436
|
-
break
|
|
386
|
+
if (
|
|
387
|
+
!isLeaf(right) &&
|
|
388
|
+
right[0][TYPE] === APPLY &&
|
|
389
|
+
right[0][VALUE] === KEYWORDS.CREATE_ARRAY
|
|
390
|
+
) {
|
|
391
|
+
const values = right.slice(1)
|
|
392
|
+
newScope = indexes.map((i) => [
|
|
393
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
394
|
+
vars[i],
|
|
395
|
+
values[i]
|
|
396
|
+
])
|
|
397
|
+
if (isSlicing)
|
|
398
|
+
newScope.push([
|
|
399
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
400
|
+
lastLeft,
|
|
401
|
+
[
|
|
402
|
+
[APPLY, KEYWORDS.CREATE_ARRAY],
|
|
403
|
+
...values.slice(indexes.at(-1) + 1)
|
|
404
|
+
]
|
|
405
|
+
])
|
|
406
|
+
} else {
|
|
407
|
+
newScope = indexes.map((i) => [
|
|
408
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
409
|
+
vars[i],
|
|
410
|
+
[[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
|
|
411
|
+
])
|
|
412
|
+
if (isSlicing)
|
|
413
|
+
newScope.push([
|
|
414
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
415
|
+
lastLeft,
|
|
416
|
+
[
|
|
417
|
+
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
418
|
+
SLICE,
|
|
419
|
+
right,
|
|
420
|
+
[ATOM, indexes.at(-1) + 1]
|
|
421
|
+
]
|
|
422
|
+
])
|
|
437
423
|
}
|
|
424
|
+
exp.iron = true
|
|
425
|
+
exp.push(newScope)
|
|
426
|
+
deSuggarAst(exp)
|
|
438
427
|
}
|
|
439
428
|
}
|
|
440
429
|
break
|
|
@@ -447,54 +436,46 @@ export const deSuggarAst = (ast, scope) => {
|
|
|
447
436
|
: body
|
|
448
437
|
const newBlock = [[APPLY, KEYWORDS.BLOCK]]
|
|
449
438
|
for (let i = 1; i < exp.length - 1; ++i) {
|
|
450
|
-
if (
|
|
451
|
-
!isLeaf(exp[i]) &&
|
|
452
|
-
exp[i][0][TYPE] === APPLY &&
|
|
453
|
-
exp[i][0][VALUE] === KEYWORDS.CREATE_ARRAY
|
|
454
|
-
) {
|
|
439
|
+
if (!isLeaf(exp[i]) && exp[i][0][TYPE] === APPLY) {
|
|
455
440
|
const left = exp[i]
|
|
456
441
|
const right = [WORD, `_arg${i}`]
|
|
442
|
+
left[0][TYPE] = WORD
|
|
457
443
|
const lastLeft = left.pop()
|
|
458
444
|
const isSlicing = lastLeft[VALUE] !== PLACEHOLDER
|
|
459
|
-
const vars = left
|
|
445
|
+
const vars = left
|
|
460
446
|
const indexes = vars
|
|
461
447
|
.map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
|
|
462
448
|
.filter((x) => x !== -1)
|
|
463
|
-
switch (left[0][VALUE]) {
|
|
464
|
-
case KEYWORDS.CREATE_ARRAY:
|
|
465
|
-
{
|
|
466
|
-
// const tempBlcok = [...block[VALUE]]
|
|
467
|
-
newBlock.push(
|
|
468
|
-
...indexes.map((i) => [
|
|
469
|
-
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
470
|
-
vars[i],
|
|
471
|
-
[[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
|
|
472
|
-
])
|
|
473
|
-
)
|
|
474
|
-
if (isSlicing)
|
|
475
|
-
newBlock.push([
|
|
476
|
-
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
477
|
-
lastLeft,
|
|
478
|
-
[
|
|
479
|
-
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
480
|
-
SLICE,
|
|
481
|
-
right,
|
|
482
|
-
[ATOM, indexes.at(-1) + 1]
|
|
483
|
-
]
|
|
484
|
-
])
|
|
485
|
-
exp[i] = right
|
|
486
|
-
exp[i].length = 2
|
|
487
|
-
}
|
|
488
|
-
exp[exp.length - 1] = newBlock.concat([block])
|
|
489
|
-
deSuggarAst(block)
|
|
490
449
|
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
450
|
+
{
|
|
451
|
+
// const tempBlcok = [...block[VALUE]]
|
|
452
|
+
newBlock.push(
|
|
453
|
+
...indexes.map((i) => [
|
|
454
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
455
|
+
vars[i],
|
|
456
|
+
[[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
|
|
457
|
+
])
|
|
458
|
+
)
|
|
459
|
+
if (isSlicing)
|
|
460
|
+
newBlock.push([
|
|
461
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
462
|
+
lastLeft,
|
|
463
|
+
[
|
|
464
|
+
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
465
|
+
SLICE,
|
|
466
|
+
right,
|
|
467
|
+
[ATOM, indexes.at(-1) + 1]
|
|
468
|
+
]
|
|
469
|
+
])
|
|
470
|
+
exp[i] = right
|
|
471
|
+
exp[i].length = 2
|
|
494
472
|
}
|
|
473
|
+
exp[exp.length - 1] = newBlock.concat([block])
|
|
474
|
+
deSuggarAst(block)
|
|
495
475
|
}
|
|
496
476
|
}
|
|
497
477
|
}
|
|
478
|
+
|
|
498
479
|
break
|
|
499
480
|
}
|
|
500
481
|
prev = first
|