fez-lisp 1.4.4 → 1.4.6

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/evaluator.js

@@ -2,6 +2,7 @@ import { keywords } from './interpreter.js'
 import {
   APPLY,
   ATOM,
+  DEBUG,
   KEYWORDS,
   SPECIAL_FORMS_SET,
   TYPE,
@@ -9,7 +10,7 @@ import {
   WORD
 } from './keywords.js'
 import { isLeaf } from './parser.js'
-import { callStack, stringifyArgs } from './utils.js'
+import { stringifyArgs } from './utils.js'
 export const evaluate = (exp, env = keywords) => {
   const [first, ...rest] = isLeaf(exp) ? [exp] : exp
   if (first == undefined) return []
@@ -33,7 +34,8 @@ export const evaluate = (exp, env = keywords) => {
         )
       const isSpecial = SPECIAL_FORMS_SET.has(value)
       const result = apply(rest, env, value)
-      if (!isSpecial) callStack.pop()
+      if (!isSpecial && Array.isArray(env[DEBUG.CALLSTACK]))
+        env[DEBUG.CALLSTACK].pop()
       return result
     }
     case ATOM:

package/src/interpreter.js

@@ -6,10 +6,11 @@ import {
   FALSE,
   TRUE,
   TYPES,
-  RUNTIME_TYPES
+  RUNTIME_TYPES,
+  DEBUG
 } from './keywords.js'
 import { evaluate } from './evaluator.js'
-import { callStack, isForbiddenVariableName, stringifyArgs } from './utils.js'
+import { isForbiddenVariableName, stringifyArgs } from './utils.js'
 import { LISP } from './parser.js'
 export const keywords = {
   [KEYWORDS.ADDITION]: (args, env) => {
@@ -773,7 +774,12 @@ export const keywords = {
           writable: true
         })
       }
-      if (name) callStack.push(name)
+      if (
+        name &&
+        Array.isArray(env[DEBUG.CALLSTACK]) &&
+        name !== env[DEBUG.CALLSTACK].at(-1)
+      )
+        env[DEBUG.CALLSTACK].push(name)
       return evaluate(body, localEnv)
     }
   },

package/src/keywords.js

@@ -40,7 +40,7 @@ export const KEYWORDS = {
   DEFINE_VARIABLE: 'let',
 
   SET_ARRAY: 'set!',
-  ERROR: 'throw'
+  ERROR: 'throw',
 }
 
 export const TYPES = {
@@ -54,7 +54,9 @@ export const RUNTIME_TYPES = {
 }
 export const DEBUG = {
   LOG: 'log',
-  ASSERT: 'assert'
+  ASSERT: 'assert',
+  CALLSTACK: '(CALLSTACK)' // so that you can't use it in the code
+
 }
 
 export const SPECIAL_FORMS_SET = new Set(Object.values(KEYWORDS))

package/src/utils.js

@@ -232,39 +232,6 @@ export const wrapInBlock = (ast) => [
 ]
 export const interpret = (ast, keywords) =>
   ast.reduce((_, x) => evaluate(x, keywords), 0)
-export const fez = (source, options = {}) => {
-  const env = { ...keywords }
-  try {
-    if (typeof source === 'string') {
-      source = deSuggarSource(source)
-      const valid = handleUnbalancedQuotes(
-        handleUnbalancedParens(removeNoCode(source))
-      )
-      const code = !options.mutation ? removeMutation(valid) : valid
-      if (!code.length && options.throw) throw new Error('Nothing to parse!')
-      const parsed = LISP.parse(code)
-      const scope = deSuggarAst(parsed)
-      const ast = wrapInBlock(shake(scope, std))
-      // if (options.check) typeCheck(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 compile(ast)
-      return evaluate(ast, env)
-    } else {
-      throw new Error('Source has to be either a lisp source code or an AST')
-    }
-  } catch (error) {
-    const err = error.message.replace("'[object Array]'", '(array)')
-    // .replace('object', '(array)')
-    logError(err)
-    if (options.throw) throw err
-    return err
-  }
-}
 export const shake = (parsed, std) => treeShake(parsed, std).concat(parsed)
 export const tree = (source, std) =>
   std
@@ -317,133 +284,162 @@ const identity = (name) => [
     [1, 'x']
   ]
 ]
-export const callStack = [KEYWORDS.BLOCK]
+// export const result = (ast) => {
+//   try {
+//     return { output: evaluate(ast, keywords), error: null }
+//   } catch (error) {
+//     const isMaxCallStack =
+//       error.message.includes('Maximum call stack size exceeded') ||
+//       error.message.includes('too much recursion')
+//     return {
+//       output: null,
+//       error: {
+//         stack: [...callStack],
+//         message: isMaxCallStack
+//           ? error
+//           : `${error}\n${callStack
+//               .reverse()
+//               .map((x, i) => `${Array(i + 2).join(' ')}(${x} ...)`)
+//               .join('\n')}`
+//       }
+//     }
+//   }
+// }
 export const debug = (ast) => {
-  callStack.length = 0
-  callStack.push(KEYWORDS.BLOCK)
-  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 debugEnv = {
+    ...keywords,
+    [DEBUG.CALLSTACK]: [KEYWORDS.BLOCK],
+    [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 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('')
+        }
+        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)})`
                 )
-              }
-              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)})`
+              console.log(
+                expression.map((x) => String.fromCharCode(x)).join('')
               )
-          }
-        } else console.log(expression)
-        return expression
-      },
-      [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 (${
+            }
+            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.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
-            }), expected even number of arguments but got ${args.length} (${
+            }) must be ${TRUE} or ${FALSE} but got (${
               DEBUG.ASSERT
             } ${stringifyArgs(args)})`
           )
-        for (let i = 0; i < args.length; i += 2) {
-          const condition = evaluate(args[i], env)
-          if (condition !== FALSE && condition !== TRUE)
+        if (condition) {
+          const error = args[i + 1]
+          if (error[0][TYPE] === APPLY && error[0][VALUE] === KEYWORDS.ERROR)
+            return evaluate(error, env)
+          else
             throw new TypeError(
-              `Condition of (${
-                DEBUG.ASSERT
-              }) must be ${TRUE} or ${FALSE} but got (${
-                DEBUG.ASSERT
-              } ${stringifyArgs(args)})`
+              `Concequence of (${DEBUG.ASSERT}) must be (${
+                KEYWORDS.ERROR
+              }) but got (${DEBUG.ASSERT} ${stringifyArgs(args)})`
             )
-          if (condition) {
-            const error = args[i + 1]
-            if (error[0][TYPE] === APPLY && error[0][VALUE] === KEYWORDS.ERROR)
-              return evaluate(error, env)
-            else
-              throw new TypeError(
-                `Concequence of (${DEBUG.ASSERT}) must be (${
-                  KEYWORDS.ERROR
-                }) but got (${DEBUG.ASSERT} ${stringifyArgs(args)})`
-              )
-          }
         }
-        return 0
       }
+      return 0
+    }
+  }
+  try {
+    const evaluated = evaluate(ast, debugEnv)
+    const block = ast[1][1]
+    const temp = block.shift()
+    block.unshift(temp, identity(DEBUG.LOG), identity(DEBUG.ASSERT))
+    return {
+      evaluated,
+      compiled: compile(ast),
+      error: null
     }
-    evaluate(ast, debugEnv)
   } catch (error) {
     const isMaxCallStack =
       error.message.includes('Maximum call stack size exceeded') ||
       error.message.includes('too much recursion')
-    if (!isMaxCallStack) {
-      error.message += `\n${callStack
-        .reverse()
-        .map((x, i) => `\x1b[33m${Array(i + 2).join('.')}\x1b[31m(${x} \x1b[39m...\x1b[31m)`)
-        .join('\n')}`
-      throw error
-    } else logError(error.message)
+    return {
+      compiled: null,
+      evaluated: null,
+      error: {
+        message: isMaxCallStack
+          ? error.message
+          : `${error.message}\n${debugEnv[DEBUG.CALLSTACK]
+              .reverse()
+              .map((x, i) => `${Array(i + 2).join(' ')}(${x} ...)`)
+              .join('\n')}`,
+        stack: debugEnv[DEBUG.CALLSTACK]
+      }
+    }
   }
-  const block = ast[1][1]
-  const temp = block.shift()
-  block.unshift(temp, identity(DEBUG.LOG), identity(DEBUG.ASSERT))
-  return compile(ast)
 }