fez-lisp 1.3.16 → 1.3.18
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/lib/baked/std.js +1 -1
- package/package.json +1 -1
- package/src/macros.js +195 -71
package/package.json
CHANGED
package/src/macros.js
CHANGED
|
@@ -69,6 +69,12 @@ export const deSuggarAst = (ast, scope) => {
|
|
|
69
69
|
case APPLY:
|
|
70
70
|
{
|
|
71
71
|
switch (first[VALUE]) {
|
|
72
|
+
// case KEYWORDS.CALL_FUNCTION: {
|
|
73
|
+
// if (prev === undefined && scope[0][VALUE] === KEYWORDS.CALL_FUNCTION) {
|
|
74
|
+
// exp[0][VALUE] = KEYWORDS.BLOCK
|
|
75
|
+
// }
|
|
76
|
+
// }
|
|
77
|
+
// break
|
|
72
78
|
case KEYWORDS.BLOCK:
|
|
73
79
|
{
|
|
74
80
|
if (
|
|
@@ -82,6 +88,7 @@ export const deSuggarAst = (ast, scope) => {
|
|
|
82
88
|
exp.length = 1
|
|
83
89
|
scope = [[APPLY, KEYWORDS.BLOCK], ...rest]
|
|
84
90
|
exp[1] = [[APPLY, KEYWORDS.ANONYMOUS_FUNCTION], scope]
|
|
91
|
+
|
|
85
92
|
deSuggarAst(exp, scope)
|
|
86
93
|
} else {
|
|
87
94
|
scope = exp
|
|
@@ -371,55 +378,101 @@ export const deSuggarAst = (ast, scope) => {
|
|
|
371
378
|
break
|
|
372
379
|
case KEYWORDS.DEFINE_VARIABLE:
|
|
373
380
|
{
|
|
374
|
-
if (!isLeaf(exp[
|
|
375
|
-
const left = exp[
|
|
381
|
+
if (!isLeaf(exp[1]) && exp[1][0][TYPE] === APPLY) {
|
|
382
|
+
const left = exp[1]
|
|
376
383
|
const right = exp.at(-1)
|
|
377
|
-
const
|
|
378
|
-
|
|
379
|
-
const vars = left
|
|
380
|
-
const indexes = vars
|
|
381
|
-
.map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
|
|
382
|
-
.filter((x) => x !== -1)
|
|
384
|
+
const isList =
|
|
385
|
+
left[left.length - 2][VALUE] === KEYWORDS.BITWISE_NOT
|
|
383
386
|
let newScope
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
[
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
387
|
+
if (isList) {
|
|
388
|
+
const lastLeft = left.pop()
|
|
389
|
+
left.pop() // tail separator
|
|
390
|
+
const vars = left
|
|
391
|
+
if (
|
|
392
|
+
!isLeaf(right) &&
|
|
393
|
+
right[0][TYPE] === APPLY &&
|
|
394
|
+
right[0][VALUE] === SUGGAR.CREATE_LIST
|
|
395
|
+
) {
|
|
396
|
+
throw new SyntaxError(
|
|
397
|
+
`Destrcuturing requires right hadnd side to be a word but got an apply ${stringifyArgs(
|
|
398
|
+
exp
|
|
399
|
+
)}`
|
|
400
|
+
)
|
|
401
|
+
} else {
|
|
402
|
+
newScope = vars
|
|
403
|
+
.map((x, i) => [x, i])
|
|
404
|
+
.filter((x) => x[0][VALUE] !== PLACEHOLDER)
|
|
405
|
+
.map(([name, n]) => {
|
|
406
|
+
let wrap = right
|
|
407
|
+
for (let i = 0; i < n; ++i) {
|
|
408
|
+
wrap = [
|
|
409
|
+
[APPLY, KEYWORDS.GET_ARRAY],
|
|
410
|
+
wrap,
|
|
411
|
+
[ATOM, 1]
|
|
412
|
+
]
|
|
413
|
+
}
|
|
414
|
+
return [
|
|
415
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
416
|
+
name,
|
|
417
|
+
[[APPLY, KEYWORDS.GET_ARRAY], wrap, [ATOM, 0]]
|
|
418
|
+
]
|
|
419
|
+
})
|
|
420
|
+
if (lastLeft[VALUE] !== PLACEHOLDER) {
|
|
421
|
+
let wrap = right
|
|
422
|
+
for (let i = 0; i < vars.length; ++i) {
|
|
423
|
+
wrap = [
|
|
424
|
+
[APPLY, KEYWORDS.GET_ARRAY],
|
|
425
|
+
wrap,
|
|
426
|
+
[ATOM, 1]
|
|
427
|
+
]
|
|
428
|
+
}
|
|
429
|
+
newScope.push([
|
|
430
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
431
|
+
lastLeft,
|
|
432
|
+
wrap
|
|
433
|
+
])
|
|
434
|
+
}
|
|
435
|
+
}
|
|
436
|
+
vars[0][TYPE] = WORD
|
|
437
|
+
exp.length = 0
|
|
406
438
|
} else {
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
439
|
+
const lastLeft = left.pop()
|
|
440
|
+
// const isList = exp[i][exp[i].length - 2][VALUE] === KEYWORDS.BITWISE_NOT
|
|
441
|
+
const isSlicing = lastLeft[VALUE] !== PLACEHOLDER
|
|
442
|
+
const vars = left
|
|
443
|
+
const indexes = vars
|
|
444
|
+
.map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
|
|
445
|
+
.filter((x) => x !== -1)
|
|
446
|
+
vars[0][TYPE] = WORD
|
|
447
|
+
exp.length = 0
|
|
448
|
+
if (
|
|
449
|
+
!isLeaf(right) &&
|
|
450
|
+
right[0][TYPE] === APPLY &&
|
|
451
|
+
right[0][VALUE] === KEYWORDS.CREATE_ARRAY
|
|
452
|
+
) {
|
|
453
|
+
throw new SyntaxError(
|
|
454
|
+
`Destrcuturing requires right hadnd side to be a word but got an apply ${stringifyArgs(
|
|
455
|
+
exp
|
|
456
|
+
)}`
|
|
457
|
+
)
|
|
458
|
+
} else {
|
|
459
|
+
newScope = indexes.map((i) => [
|
|
414
460
|
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
415
|
-
|
|
416
|
-
[
|
|
417
|
-
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
418
|
-
SLICE,
|
|
419
|
-
right,
|
|
420
|
-
[ATOM, indexes.at(-1) + 1]
|
|
421
|
-
]
|
|
461
|
+
vars[i],
|
|
462
|
+
[[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
|
|
422
463
|
])
|
|
464
|
+
if (isSlicing)
|
|
465
|
+
newScope.push([
|
|
466
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
467
|
+
lastLeft,
|
|
468
|
+
[
|
|
469
|
+
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
470
|
+
SLICE,
|
|
471
|
+
right,
|
|
472
|
+
[ATOM, indexes.at(-1) + 1]
|
|
473
|
+
]
|
|
474
|
+
])
|
|
475
|
+
}
|
|
423
476
|
}
|
|
424
477
|
exp.iron = true
|
|
425
478
|
exp.push(newScope)
|
|
@@ -430,45 +483,94 @@ export const deSuggarAst = (ast, scope) => {
|
|
|
430
483
|
case KEYWORDS.ANONYMOUS_FUNCTION:
|
|
431
484
|
{
|
|
432
485
|
const body = exp.at(-1)
|
|
433
|
-
const block =
|
|
434
|
-
body[0][TYPE] === APPLY && body[0][VALUE] === KEYWORDS.BLOCK
|
|
435
|
-
? body[1]
|
|
436
|
-
: body
|
|
486
|
+
const block = hasBlock(body) ? body[1] : body
|
|
437
487
|
const newBlock = [[APPLY, KEYWORDS.BLOCK]]
|
|
438
488
|
for (let i = 1; i < exp.length - 1; ++i) {
|
|
439
489
|
if (!isLeaf(exp[i]) && exp[i][0][TYPE] === APPLY) {
|
|
440
|
-
const
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
.
|
|
490
|
+
const isList =
|
|
491
|
+
exp[i][exp[i].length - 2][VALUE] ===
|
|
492
|
+
KEYWORDS.BITWISE_NOT
|
|
493
|
+
if (isList) {
|
|
494
|
+
const left = exp[i]
|
|
495
|
+
const right = [WORD, `_arg${i}`]
|
|
496
|
+
const lastLeft = left.pop()
|
|
497
|
+
|
|
498
|
+
left.pop() // tail separator
|
|
499
|
+
|
|
500
|
+
const vars = left
|
|
501
|
+
const indexes = vars
|
|
502
|
+
.map((x, i) => [x, i])
|
|
503
|
+
.filter((x) => x[0][VALUE] !== PLACEHOLDER)
|
|
449
504
|
|
|
450
|
-
{
|
|
451
|
-
// const tempBlcok = [...block[VALUE]]
|
|
452
505
|
newBlock.push(
|
|
453
|
-
...indexes.map((
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
506
|
+
...indexes.map(([name, n]) => {
|
|
507
|
+
let wrap = right
|
|
508
|
+
for (let i = 0; i < n; ++i) {
|
|
509
|
+
wrap = [
|
|
510
|
+
[APPLY, KEYWORDS.GET_ARRAY],
|
|
511
|
+
wrap,
|
|
512
|
+
[ATOM, 1]
|
|
513
|
+
]
|
|
514
|
+
}
|
|
515
|
+
return [
|
|
516
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
517
|
+
name,
|
|
518
|
+
[[APPLY, KEYWORDS.GET_ARRAY], wrap, [ATOM, 0]]
|
|
519
|
+
]
|
|
520
|
+
})
|
|
458
521
|
)
|
|
459
|
-
if (
|
|
522
|
+
if (lastLeft[VALUE] !== PLACEHOLDER) {
|
|
523
|
+
let wrap = right
|
|
524
|
+
for (let i = 0; i < vars.length; ++i) {
|
|
525
|
+
wrap = [
|
|
526
|
+
[APPLY, KEYWORDS.GET_ARRAY],
|
|
527
|
+
wrap,
|
|
528
|
+
[ATOM, 1]
|
|
529
|
+
]
|
|
530
|
+
}
|
|
460
531
|
newBlock.push([
|
|
461
532
|
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
462
533
|
lastLeft,
|
|
463
|
-
|
|
464
|
-
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
465
|
-
SLICE,
|
|
466
|
-
right,
|
|
467
|
-
[ATOM, indexes.at(-1) + 1]
|
|
468
|
-
]
|
|
534
|
+
wrap
|
|
469
535
|
])
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
left[0][TYPE] = WORD
|
|
470
539
|
exp[i] = right
|
|
471
540
|
exp[i].length = 2
|
|
541
|
+
} else {
|
|
542
|
+
const left = exp[i]
|
|
543
|
+
const right = [WORD, `_arg${i}`]
|
|
544
|
+
left[0][TYPE] = WORD
|
|
545
|
+
const lastLeft = left.pop()
|
|
546
|
+
const isSlicing = lastLeft[VALUE] !== PLACEHOLDER
|
|
547
|
+
const vars = left
|
|
548
|
+
const indexes = vars
|
|
549
|
+
.map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
|
|
550
|
+
.filter((x) => x !== -1)
|
|
551
|
+
{
|
|
552
|
+
// const tempBlcok = [...block[VALUE]]
|
|
553
|
+
newBlock.push(
|
|
554
|
+
...indexes.map((i) => [
|
|
555
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
556
|
+
vars[i],
|
|
557
|
+
[[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
|
|
558
|
+
])
|
|
559
|
+
)
|
|
560
|
+
if (isSlicing)
|
|
561
|
+
newBlock.push([
|
|
562
|
+
[APPLY, KEYWORDS.DEFINE_VARIABLE],
|
|
563
|
+
lastLeft,
|
|
564
|
+
[
|
|
565
|
+
[APPLY, KEYWORDS.CALL_FUNCTION],
|
|
566
|
+
SLICE,
|
|
567
|
+
right,
|
|
568
|
+
[ATOM, indexes.at(-1) + 1]
|
|
569
|
+
]
|
|
570
|
+
])
|
|
571
|
+
exp[i] = right
|
|
572
|
+
exp[i].length = 2
|
|
573
|
+
}
|
|
472
574
|
}
|
|
473
575
|
exp[exp.length - 1] = newBlock.concat([block])
|
|
474
576
|
deSuggarAst(block)
|
|
@@ -510,6 +612,8 @@ export const replaceStrings = (source) => {
|
|
|
510
612
|
)
|
|
511
613
|
return source
|
|
512
614
|
}
|
|
615
|
+
const hasBlock = (body) =>
|
|
616
|
+
body[0] && body[0][TYPE] === APPLY && body[0][VALUE] === KEYWORDS.BLOCK
|
|
513
617
|
const iron = (scope) => {
|
|
514
618
|
const indecies = scope
|
|
515
619
|
.map((x, i) => {
|
|
@@ -530,6 +634,26 @@ const iron = (scope) => {
|
|
|
530
634
|
for (let i = 0; i < copy.length; ++i) scope[i] = copy[i]
|
|
531
635
|
}
|
|
532
636
|
}
|
|
637
|
+
const iron2 = (scope, exp) => {
|
|
638
|
+
const key = AST.stringify(exp)
|
|
639
|
+
const indexes = new Set(
|
|
640
|
+
scope
|
|
641
|
+
.map((x, i) => (AST.stringify(x) === key ? i : -1))
|
|
642
|
+
.filter((x) => x !== -1)
|
|
643
|
+
)
|
|
644
|
+
console.log(indexes)
|
|
645
|
+
if (indexes.size) {
|
|
646
|
+
const copy = []
|
|
647
|
+
for (let i = 0; i < scope.length; ++i) {
|
|
648
|
+
if (indexes.has(i)) {
|
|
649
|
+
copy.push(...scope[i][0])
|
|
650
|
+
} else {
|
|
651
|
+
copy.push(scope[i])
|
|
652
|
+
}
|
|
653
|
+
}
|
|
654
|
+
for (let i = 0; i < copy.length; ++i) scope[i] = copy[i]
|
|
655
|
+
}
|
|
656
|
+
}
|
|
533
657
|
export const replaceQuotes = (source) =>
|
|
534
658
|
source
|
|
535
659
|
.replaceAll(/\'\(/g, `(${KEYWORDS.CREATE_ARRAY} `)
|