fez-lisp 1.3.27 → 1.4.0

package/src/keywords.js

@@ -39,12 +39,7 @@ export const KEYWORDS = {
   CALL_FUNCTION: 'apply',
   DEFINE_VARIABLE: 'let',
 
-  SET_ARRAY: 'set!',
-
-  LOG: 'log!',
-  LOG_STRING: 'log-string!',
-  LOG_CHAR: 'log-char!',
-  CLEAR_CONSOLE: 'clear!'
+  SET_ARRAY: 'set!'
 }
 
 export const TYPES = {
@@ -56,3 +51,10 @@ export const RUNTIME_TYPES = {
   NUMBER: 'number',
   ARRAY: 'array'
 }
+export const DEBUG = {
+  LOG: 'log',
+  ASSERT: 'assert',
+  ERROR: 'error'
+}
+
+export const SPECIAL_FORMS_SET = new Set(Object.values(KEYWORDS))

package/src/macros.js

@@ -31,7 +31,7 @@ export const SUGGAR = {
 }
 export const deSuggarAst = (ast, scope) => {
   if (scope === undefined) scope = ast
-  if (ast.length === 0) throw new SyntaxError(`No expressions to evaluate`)
+  if (ast.length === 0) throw new SyntaxError(`No expressions...`)
   // for (const node of ast)
   //   if (node[0] && node[0][TYPE] === APPLY && node[0][VALUE] === KEYWORDS.BLOCK)
   //     throw new SyntaxError(`Top level (${KEYWORDS.BLOCK}) is not allowed`)
@@ -667,11 +667,6 @@ const iron2 = (scope, exp) => {
 }
 export const replaceQuotes = (source) =>
   source
-    .replaceAll(/\'\(/g, `(${KEYWORDS.CREATE_ARRAY} `)
-    .replaceAll(/\`\(/g, `(${SUGGAR.CREATE_LIST} `)
-    .replaceAll(/\(\)/g, `(${KEYWORDS.CREATE_ARRAY})`)
-    .replaceAll(/\[\]/g, `(${KEYWORDS.CREATE_ARRAY})`)
-    .replaceAll(/\{\}/g, `(${SUGGAR.CREATE_LIST})`)
     .replaceAll(/\[/g, `(${KEYWORDS.CREATE_ARRAY} `)
     .replaceAll(/\]/g, ')')
     .replaceAll(/\{/g, `(${SUGGAR.CREATE_LIST} `)

package/src/parser.js

@@ -61,7 +61,7 @@ export const LISP = {
       }
       return out
     }
-    return ast.map(dfs).join(' ')
+    return dfs(ast)
   }
 }
 export const AST = {

package/src/utils.js

@@ -1,6 +1,17 @@
 import std from '../lib/baked/std.js'
-import { comp, OPTIMIZATIONS } from './compiler.js'
-import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
+import { compile, OPTIMIZATIONS } from './compiler.js'
+import {
+  APPLY,
+  ATOM,
+  DEBUG,
+  FALSE,
+  KEYWORDS,
+  RUNTIME_TYPES,
+  TRUE,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
 import { evaluate } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
 import {
@@ -11,7 +22,7 @@ import {
 import { keywords } from './interpreter.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
-export const logSuccess = (output) => console.log(output, '\x1b[0m')
+export const logSuccess = (output) => console.log('\x1b[32m', output, '\x1b[0m')
 // export const replaceEmptyArrays = (source) =>
 //   source
 export const removeNoCode = (source) =>
@@ -236,19 +247,18 @@ export const fez = (source, options = {}) => {
       const scope = deSuggarAst(parsed)
       const ast = wrapInBlock(shake(scope, std))
       // if (options.check) typeCheck(ast)
-      if (options.compile) return comp(ast)
+      if (options.compile) return compile(ast)
       return evaluate(ast, env)
     } else if (Array.isArray(source)) {
       const ast = !options.mutation
         ? AST.parse(AST.stringify(source).replace(new RegExp(/!/g), 'ǃ'))
         : source
-      if (options.compile) return comp(ast)
+      if (options.compile) return compile(ast)
       return evaluate(ast, env)
     } else {
       throw new Error('Source has to be either a lisp source code or an AST')
     }
   } catch (error) {
-    // console.log(error)
     const err = error.message.replace("'[object Array]'", '(array)')
     // .replace('object', '(array)')
     logError(err)
@@ -313,4 +323,175 @@ export const ast = (source, deps) =>
       deps.reduce((a, b) => a.concat(b), [])
     )
   )
+
 export const astWithStd = (source) => wrapInBlock(shake(prep(source), std))
+export const parse = (source) =>
+  wrapInBlock(
+    shake(
+      deSuggarAst(
+        LISP.parse(
+          removeNoCode(
+            handleUnbalancedQuotes(
+              handleUnbalancedParens(deSuggarSource(source))
+            )
+          )
+        )
+      ),
+      std
+    )
+  )
+export const debug = (ast) => {
+  try {
+    const debugEnv = {
+      ...keywords,
+      [DEBUG.LOG]: (args, env) => {
+        if (args.length !== 1 && args.length !== 2)
+          throw new RangeError(
+            `Invalid number of arguments to (${DEBUG.LOG}) (or (= 1) (= 2)) (${
+              DEBUG.LOG
+            } ${stringifyArgs(args)})`
+          )
+        const expression = evaluate(args[0], env)
+        if (args.length === 2) {
+          const option = evaluate(args[1], env)
+          if (!Array.isArray(option)) {
+            throw new TypeError(
+              `Second argument of (${DEBUG.LOG}) must be an (${
+                RUNTIME_TYPES.ARRAY
+              }) but got (${expression}) (${DEBUG.LOG} ${stringifyArgs(args)})`
+            )
+          }
+          const type = option.map((x) => String.fromCharCode(x)).join('')
+          switch (type) {
+            case 'string':
+            case 'str':
+              {
+                if (!Array.isArray(expression))
+                  throw new TypeError(
+                    `Argument of (${DEBUG.LOG}) must be an (${
+                      RUNTIME_TYPES.ARRAY
+                    }) in the case ${type} but got (${expression}) (${
+                      DEBUG.LOG
+                    } ${stringifyArgs(args)})`
+                  )
+                console.log(
+                  expression.map((x) => String.fromCharCode(x)).join('')
+                )
+              }
+              break
+            case 'char':
+            case 'ch':
+              {
+                if (typeof expression !== 'number')
+                  throw new TypeError(
+                    `Argument argument of (${DEBUG.LOG}) must be a (${
+                      RUNTIME_TYPES.NUMBER
+                    }) in the case ${type} but got (${expression}) (${
+                      DEBUG.LOG
+                    } ${stringifyArgs(args)})`
+                  )
+                console.log(String.fromCharCode(expression))
+              }
+
+              break
+            case '*':
+              console.log(expression)
+              break
+            default:
+              throw new TypeError(
+                `Invalid number of option to (${
+                  DEBUG.LOG
+                }) got ${option} ${stringifyArgs(args)})`
+              )
+          }
+        } else console.log(expression)
+        return expression
+      },
+      [DEBUG.ERROR]: (args, env) => {
+        if (args.length !== 1)
+          throw new RangeError(
+            `Invalid number of arguments to (${DEBUG.ERROR}) (= 1 required) (${
+              DEBUG.ERROR
+            } ${stringifyArgs(args)})`
+          )
+        const expression = evaluate(args[0], env)
+        if (!Array.isArray(expression))
+          throw new TypeError(
+            `Argument of (${DEBUG.ERROR}) must be an (${
+              DEBUG.ARRAY_TYPE
+            }) but got (${expression}) (${DEBUG.ERROR} ${stringifyArgs(args)})`
+          )
+        throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
+      },
+      [DEBUG.ASSERT]: (args, env) => {
+        if (args.length < 2)
+          throw new RangeError(
+            `Invalid number of arguments for (${
+              DEBUG.ASSERT
+            }), expected (> 2 required) but got ${args.length} (${
+              DEBUG.ASSERT
+            } ${stringifyArgs(args)})`
+          )
+        if (args.length % 2 !== 0)
+          throw new RangeError(
+            `Invalid number of arguments for (${
+              DEBUG.ASSERT
+            }), expected even number of arguments but got ${args.length} (${
+              DEBUG.ASSERT
+            } ${stringifyArgs(args)})`
+          )
+        for (let i = 0; i < args.length; i += 2) {
+          const condition = evaluate(args[i], env)
+          if (condition !== FALSE && condition !== TRUE)
+            throw new TypeError(
+              `Condition of (${
+                DEBUG.ASSERT
+              }) must be ${TRUE} or ${FALSE} but got (${
+                DEBUG.ASSERT
+              } ${stringifyArgs(args)})`
+            )
+          if (condition) {
+            const error = args[i + 1]
+            if (error[0][TYPE] === APPLY && error[0][VALUE] === DEBUG.ERROR)
+              return evaluate(error, env)
+            else
+              throw new TypeError(
+                `Concequence of (${DEBUG.ASSERT}) must be (${
+                  DEBUG.ERROR
+                }) but got (${DEBUG.ASSERT} ${stringifyArgs(args)})`
+              )
+          }
+        }
+        return 0
+      }
+    }
+    evaluate(ast, debugEnv)
+  } catch (error) {
+    if (
+      !error.message.includes('Maximum call stack size exceeded') &&
+      !error.message.includes('too much recursion') &&
+      error.message !== 'Maximum function invocation limit exceeded'
+    ) {
+      error.message += `\n\nscope:\n(${evaluate.stack.at(-1)})`
+      throw error
+    } else logError(error.message)
+  }
+  const identity = (name) => [
+    [0, 'let'],
+    [1, name],
+    [
+      [0, 'lambda'],
+      [1, 'x'],
+      [1, 'x']
+    ]
+  ]
+  const block = ast[1][1]
+  const temp = block.shift()
+  block.unshift(
+    temp,
+    identity(DEBUG.LOG),
+    identity(DEBUG.ERROR),
+    identity(DEBUG.ASSERT)
+  )
+  return compile(ast)
+}