fez-lisp 1.3.15 → 1.3.17

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.
Files changed (2) hide show
  1. package/package.json +1 -1
  2. package/src/macros.js +209 -104
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "fez-lisp",
3
3
  "description": "Lisp interpreted & compiled to JavaScript",
4
4
  "author": "AT290690",
5
- "version": "1.3.15",
5
+ "version": "1.3.17",
6
6
  "type": "module",
7
7
  "main": "index.js",
8
8
  "keywords": [
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,130 +378,206 @@ export const deSuggarAst = (ast, scope) => {
371
378
  break
372
379
  case KEYWORDS.DEFINE_VARIABLE:
373
380
  {
374
- if (!isLeaf(exp[VALUE])) {
375
- const left = exp[VALUE]
381
+ if (!isLeaf(exp[1]) && exp[1][0][TYPE] === APPLY) {
382
+ const left = exp[1]
376
383
  const right = exp.at(-1)
377
- // const key = AST.stringify(exp)
378
- // const index = scope.findIndex(
379
- // (x) => AST.stringify(x) === key
380
- // )
381
- const lastLeft = left.pop()
382
- const isSlicing = lastLeft[VALUE] !== PLACEHOLDER
383
- const vars = left.slice(1)
384
- const indexes = vars
385
- .map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
386
- .filter((x) => x !== -1)
384
+ const isList =
385
+ left[left.length - 2][VALUE] === KEYWORDS.BITWISE_NOT
387
386
  let newScope
388
- exp.length = 0
389
- switch (left[0][VALUE]) {
390
- case KEYWORDS.CREATE_ARRAY:
391
- {
392
- if (
393
- !isLeaf(right) &&
394
- right[0][TYPE] === APPLY &&
395
- right[0][VALUE] === KEYWORDS.CREATE_ARRAY
396
- ) {
397
- const values = right.slice(1)
398
- newScope = indexes.map((i) => [
399
- [APPLY, KEYWORDS.DEFINE_VARIABLE],
400
- vars[i],
401
- values[i]
402
- ])
403
- if (isSlicing)
404
- newScope.push([
405
- [APPLY, KEYWORDS.DEFINE_VARIABLE],
406
- lastLeft,
407
- [
408
- [APPLY, KEYWORDS.CREATE_ARRAY],
409
- ...values.slice(indexes.at(-1) + 1)
410
- ]
411
- ])
412
- } else {
413
- newScope = indexes.map((i) => [
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 [
414
415
  [APPLY, KEYWORDS.DEFINE_VARIABLE],
415
- vars[i],
416
- [[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
417
- ])
418
- if (isSlicing)
419
- newScope.push([
420
- [APPLY, KEYWORDS.DEFINE_VARIABLE],
421
- lastLeft,
422
- [
423
- [APPLY, KEYWORDS.CALL_FUNCTION],
424
- SLICE,
425
- right,
426
- [ATOM, indexes.at(-1) + 1]
427
- ]
428
- ])
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
+ ]
429
428
  }
430
- exp.iron = true
431
- exp.push(newScope)
432
- deSuggarAst(exp)
429
+ newScope.push([
430
+ [APPLY, KEYWORDS.DEFINE_VARIABLE],
431
+ lastLeft,
432
+ wrap
433
+ ])
433
434
  }
434
- break
435
- default:
436
- break
435
+ }
436
+ vars[0][TYPE] = WORD
437
+ exp.length = 0
438
+ } else {
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) => [
460
+ [APPLY, KEYWORDS.DEFINE_VARIABLE],
461
+ vars[i],
462
+ [[APPLY, KEYWORDS.GET_ARRAY], right, [ATOM, i]]
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
+ }
437
476
  }
477
+ exp.iron = true
478
+ exp.push(newScope)
479
+ deSuggarAst(exp)
438
480
  }
439
481
  }
440
482
  break
441
483
  case KEYWORDS.ANONYMOUS_FUNCTION:
442
484
  {
443
485
  const body = exp.at(-1)
444
- const block =
445
- body[0][TYPE] === APPLY && body[0][VALUE] === KEYWORDS.BLOCK
446
- ? body[1]
447
- : body
486
+ const block = hasBlock(body) ? body[1] : body
448
487
  const newBlock = [[APPLY, KEYWORDS.BLOCK]]
449
488
  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
- ) {
455
- const left = exp[i]
456
- const right = [WORD, `_arg${i}`]
457
- const lastLeft = left.pop()
458
- const isSlicing = lastLeft[VALUE] !== PLACEHOLDER
459
- const vars = left.slice(1)
460
- const indexes = vars
461
- .map((x, i) => (x[VALUE] === PLACEHOLDER ? -1 : i))
462
- .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
489
+ if (!isLeaf(exp[i]) && exp[i][0][TYPE] === APPLY) {
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)
504
+
505
+ newBlock.push(
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
+ })
521
+ )
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
+ ]
487
530
  }
488
- exp[exp.length - 1] = newBlock.concat([block])
489
- deSuggarAst(block)
531
+ newBlock.push([
532
+ [APPLY, KEYWORDS.DEFINE_VARIABLE],
533
+ lastLeft,
534
+ wrap
535
+ ])
536
+ }
490
537
 
491
- break
492
- default:
493
- break
538
+ left[0][TYPE] = WORD
539
+ exp[i] = right
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
+ }
494
574
  }
575
+ exp[exp.length - 1] = newBlock.concat([block])
576
+ deSuggarAst(block)
495
577
  }
496
578
  }
497
579
  }
580
+
498
581
  break
499
582
  }
500
583
  prev = first
@@ -529,6 +612,8 @@ export const replaceStrings = (source) => {
529
612
  )
530
613
  return source
531
614
  }
615
+ const hasBlock = (body) =>
616
+ body[0][TYPE] === APPLY && body[0][VALUE] === KEYWORDS.BLOCK
532
617
  const iron = (scope) => {
533
618
  const indecies = scope
534
619
  .map((x, i) => {
@@ -549,6 +634,26 @@ const iron = (scope) => {
549
634
  for (let i = 0; i < copy.length; ++i) scope[i] = copy[i]
550
635
  }
551
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
+ }
552
657
  export const replaceQuotes = (source) =>
553
658
  source
554
659
  .replaceAll(/\'\(/g, `(${KEYWORDS.CREATE_ARRAY} `)