fez-lisp 1.3.27 → 1.4.0

package/package.json

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

package/src/compiler.js

@@ -112,11 +112,7 @@ const Helpers = {
   not: 'not=(a)=>+!a',
   and: `and=(a, b)=>+(a&&b)`,
   or: `or=(a, b)=>+(a||b)`,
-  log_effect: `log_effect=(msg)=>{console.log(msg);return msg}`,
-  log_char_effect: `log_char_effect=(msg)=>{console.log(String.fromCharCode(msg));return msg}`,
-  log_string_effect: `log_string_effect=(msg)=>{console.log(msg.map(x=>String.fromCharCode(x)).join(''));return msg}`,
-  clear_effect: `clear_effect=()=>{console.clear();return 0}`,
-  get: 'get=(arr,i)=>arr.at(i)',
+  get: 'get=(arr,i)=>arr[i]',
   length: 'length=(arr)=>arr.length',
   __tco: `__tco=fn=>(...args)=>{let result=fn(...args);while(typeof result==='function')result=result();return result}`,
   atom_predicate: `atom_predicate=(number)=>+(typeof number==='number')`,
@@ -144,10 +140,10 @@ const semiColumnEdgeCases = new Set([
   ';]',
   ';^'
 ])
-const parse = (Arguments, Drill) => Arguments.map((x) => compile(x, Drill))
+const parse = (Arguments, Drill) => Arguments.map((x) => comp(x, Drill))
 const parseArgs = (Arguments, Drill, separator = ',') =>
   parse(Arguments, Drill).join(separator)
-const compile = (tree, Drill) => {
+const comp = (tree, Drill) => {
   if (!tree) return ''
   const [first, ...Arguments] = !isLeaf(tree) ? tree : [tree]
   if (first == undefined) return '[];'
@@ -157,19 +153,19 @@ const compile = (tree, Drill) => {
       case KEYWORDS.BLOCK: {
         if (Arguments.length > 1) {
           return `(${Arguments.map((x) =>
-            (compile(x, Drill) ?? '').toString().trim()
+            (comp(x, Drill) ?? '').toString().trim()
           )
             .filter((x) => x !== undefined)
             .join(',')});`
         } else {
-          const res = compile(Arguments[0], Drill)
+          const res = comp(Arguments[0], Drill)
           return res !== undefined ? res.toString().trim() : ''
         }
       }
       case KEYWORDS.CALL_FUNCTION: {
         const first = Arguments.pop()
         const rest = Arguments
-        const apply = compile(first, Drill)
+        const apply = comp(first, Drill)
         return `${
           apply[apply.length - 1] === ';'
             ? apply.substring(0, apply.length - 1)
@@ -192,7 +188,7 @@ const compile = (tree, Drill) => {
           const body = functionArgs.pop()
           const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
           deepRename(n, `()=>${newName}`, body)
-          const evaluatedBody = compile(body, FunctionDrill)
+          const evaluatedBody = comp(body, FunctionDrill)
           const vars = FunctionDrill.Variables.size
             ? `var ${[...FunctionDrill.Variables].join(',')};`
             : ''
@@ -211,7 +207,7 @@ const compile = (tree, Drill) => {
           const body = functionArgs.pop()
           deepRename(n, newName, body)
           const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
-          const evaluatedBody = compile(body, FunctionDrill)
+          const evaluatedBody = comp(body, FunctionDrill)
           const vars = FunctionDrill.Variables.size
             ? `var ${[...FunctionDrill.Variables].join(',')};`
             : ''
@@ -224,23 +220,23 @@ const compile = (tree, Drill) => {
         } else {
           const name = lispToJavaScriptVariableName(n)
           Drill.Variables.add(name)
-          return `${name}=${compile(Arguments[1], Drill)};`
+          return `${name}=${comp(Arguments[1], Drill)};`
         }
       }
       case KEYWORDS.IS_ATOM:
         Drill.Helpers.add('atom_predicate')
-        return `atom_predicate(${compile(Arguments[0], Drill)});`
+        return `atom_predicate(${comp(Arguments[0], Drill)});`
       case KEYWORDS.IS_LAMBDA:
         Drill.Helpers.add('lambda_predicate')
-        return `lambda_predicate(${compile(Arguments[0], Drill)});`
+        return `lambda_predicate(${comp(Arguments[0], Drill)});`
       case KEYWORDS.CREATE_ARRAY:
         return `[${parseArgs(Arguments, Drill)}];`
       case KEYWORDS.ARRAY_LENGTH:
         Drill.Helpers.add('length')
-        return `length(${compile(Arguments[0], Drill)})`
+        return `length(${comp(Arguments[0], Drill)})`
       case KEYWORDS.GET_ARRAY:
         Drill.Helpers.add('get')
-        return `get(${compile(Arguments[0], Drill)}, ${compile(
+        return `get(${comp(Arguments[0], Drill)}, ${comp(
           Arguments[1],
           Drill
         )});`
@@ -248,7 +244,7 @@ const compile = (tree, Drill) => {
         const functionArgs = Arguments
         const body = Arguments.pop()
         const InnerDrills = { Variables: new Set(), Helpers: Drill.Helpers }
-        const evaluatedBody = compile(body, InnerDrills)
+        const evaluatedBody = comp(body, InnerDrills)
         const vars = InnerDrills.Variables.size
           ? `var ${[...InnerDrills.Variables].join(',')};`
           : ''
@@ -278,7 +274,7 @@ const compile = (tree, Drill) => {
         return `+(${parseArgs(Arguments, Drill, token)});`
       case KEYWORDS.SUBTRACTION:
         return Arguments.length === 1
-          ? `(-${compile(Arguments[0], Drill)});`
+          ? `(-${comp(Arguments[0], Drill)});`
           : `(${parse(Arguments, Drill)
               // Add space so it doesn't consider it 2--1 but 2- -1
               .map((x) => (typeof x === 'number' && x < 0 ? ` ${x}` : x))
@@ -297,21 +293,17 @@ const compile = (tree, Drill) => {
       case KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT:
         return `(${parseArgs(Arguments, Drill, token)});`
       case KEYWORDS.REMAINDER_OF_DIVISION:
-        return `(${compile(Arguments[0], Drill)}%${compile(
-          Arguments[1],
-          Drill
-        )});`
+        return `(${comp(Arguments[0], Drill)}%${comp(Arguments[1], Drill)});`
       case KEYWORDS.BIT_TYPE:
-        return `(${compile(Arguments[0], Drill)}>>>0).toString(2)`
+        return `(${comp(Arguments[0], Drill)}>>>0).toString(2)`
       case KEYWORDS.BITWISE_NOT:
-        return `~(${compile(Arguments[0], Drill)})`
+        return `~(${comp(Arguments[0], Drill)})`
       case KEYWORDS.NOT:
-        return `(+!${compile(Arguments[0], Drill)})`
+        return `(+!${comp(Arguments[0], Drill)})`
       case KEYWORDS.IF: {
-        return `(${compile(Arguments[0], Drill)}?${compile(
-          Arguments[1],
-          Drill
-        )}:${Arguments.length === 3 ? compile(Arguments[2], Drill) : 0});`
+        return `(${comp(Arguments[0], Drill)}?${comp(Arguments[1], Drill)}:${
+          Arguments.length === 3 ? comp(Arguments[2], Drill) : 0
+        });`
       }
       default: {
         const camelCased = lispToJavaScriptVariableName(token)
@@ -327,10 +319,10 @@ const compile = (tree, Drill) => {
   }
 }
 const HelpersEntries = new Map(Object.entries(Helpers))
-export const comp = (ast) => {
+export const compile = (ast) => {
   const Drill = { Variables: new Set(), Helpers: new Set() }
   const raw = AST.parse(AST.stringify(ast)) // cloning for fn renames mutations
-    .map((tree) => compile(tree, Drill))
+    .map((tree) => comp(tree, Drill))
     .filter((x) => x !== undefined)
     .join('\n')
   let program = ''
@@ -348,5 +340,5 @@ export const comp = (ast) => {
     ? `var ${[...Drill.Variables].join(',')};`
     : ''
   const top = `${help}${vars}`
-  return `${top}${program}`
+  return `(()=>{${top};return${program}})()`
 }

package/src/evaluator.js

@@ -1,34 +1,58 @@
-import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
+import { keywords } from './interpreter.js'
+import {
+  APPLY,
+  ATOM,
+  KEYWORDS,
+  SPECIAL_FORMS_SET,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
 import { isLeaf } from './parser.js'
 import { stringifyArgs } from './utils.js'
-
-export const evaluate = (exp, env) => {
+export const DEFAULT_MAXIMUM_FUNCTION_CALLS = 262144
+export const MAXIMUM_FUNCTION_CALLS = process.env.FEZ_MAXIMUM_FUNCTION_CALLS
+  ? +process.env.FEZ_MAXIMUM_FUNCTION_CALLS
+  : DEFAULT_MAXIMUM_FUNCTION_CALLS
+export const evaluate = (exp, env = keywords) => {
   const [first, ...rest] = isLeaf(exp) ? [exp] : exp
   if (first == undefined) return []
+  const value = first[VALUE]
   switch (first[TYPE]) {
     case WORD: {
-      const word = env[first[VALUE]]
+      const word = env[value]
       if (word == undefined)
-        throw new ReferenceError(`Undefined variable ${first[VALUE]}`)
+        throw new ReferenceError(`Undefined variable ${value}`)
       return word
     }
     case APPLY: {
-      const apply = env[first[VALUE]]
+      const apply = env[value]
       if (apply == undefined)
         throw new ReferenceError(
-          `Undefined (${KEYWORDS.ANONYMOUS_FUNCTION}) ${first[VALUE]}`
+          `Undefined (${KEYWORDS.ANONYMOUS_FUNCTION}) (${value})`
         )
       if (typeof apply !== 'function')
         throw new TypeError(
-          `${first[VALUE]} is not a (${KEYWORDS.ANONYMOUS_FUNCTION})`
+          `${value} is not a (${KEYWORDS.ANONYMOUS_FUNCTION})`
         )
-      return apply(rest, env)
+      const isSpecial = SPECIAL_FORMS_SET.has(value)
+      if (!isSpecial) {
+        evaluate.count = (evaluate.count || 0) + 1
+        if (evaluate.count > MAXIMUM_FUNCTION_CALLS) {
+          evaluate.count = 0
+          throw new RangeError('Maximum function invocation limit exceeded')
+        }
+      }
+      const result = apply(rest, env, value)
+      if (!isSpecial) evaluate.stack.pop()
+      return result
     }
     case ATOM:
-      return first[VALUE]
+      return value
     default:
       throw new ReferenceError(
         `Attempting to access Undefined near ${stringifyArgs(exp)}`
       )
   }
 }
+evaluate.stack = [KEYWORDS.CALL_FUNCTION]