Rework functions and add everything you need for a rudimentary FizzBuzz

compiler.js

       pos++
       continue
     }
+    if (char === '|') {
+      tokens.push({
+        type: 'bar',
+        value: char
+      })
+      pos++
+      continue
+    }
     let whitespace = /[;\s]/
     if (whitespace.test(char)) {
       if (char === ';') {
       }
     }
 
+    if (token.type === 'bar') {
+      pos++
+      return {
+        type: 'BarLiteral',
+        value: token.value
+      }
+    }
+
     if (token.type === 'string') {
       pos++
       return {
         break
       case 'DollarVar':
         break
+      case 'BarLiteral':
+        break
       default:
         throw {
           name: 'Compiler Error',
         value: node.value
       })
     },
+    BarLiteral: function (node, parent) {
+      parent._context.push({
+        type: 'BarLiteral',
+        value: node.value
+      })
+    },
     VariableReference: function (node, parent) {
       parent._context.push({
         type: 'VariableReference',
   return newAst
 }
 
-
+var escapeDepth = 0
 var generator = function (node) {
 
   switch (node.type) {
       return (generator(node.expr) + ';')
       break
     case 'FunctionCall':
-      if (node.callee.name !== 'def') {
+      if (!node.callee.name.match('(def|if|repeat)')) {
         return (generator(node.callee) + '(' + node.args.map(generator).join(', ') + ')')
       } else {
         return (generator(node.callee) + '(' + node.args.map((v, i) => {
             return generator(v) + ', '
           } else {
             if (i === 1) {
-              return "'" + generator(v) + '; '
+              return 'function() {' + generator(v) + ';'
             } else {
               return generator(v) + '; '
             }
           }
-        }).join('') + "')")
+        }).join('') + '})')
       }
       break;
     case 'DollarVar':
-      return '$' + node.value
+      return 'arguments[' + (+node.value-1) + ']'
+      break
+    case 'BarLiteral':
+      return '}, function() {'
       break
     case 'FunctionName':
       return '_.' + node.name
       break
     case 'VariableReference':
-      return '_.ref("' + node.value + '")'
+      return '_.ref(\'' + node.value + '\')'
       break
     case 'NumberLiteral':
       return '{value: ' + node.value + '}'
 
 
 // const myInput = '(assign twelve 12) (assign myvar (add twelve (subtract 6 2))) (log myvar)'
+const fileNameIn = process.argv[2]
+const fileNameOut = fileNameIn + '.js'
 const myInput = fs.readFileSync(process.argv[2], { encoding: 'utf-8' })
 const preProcessedInput = preprocess(myInput)
 const myTokens = tokenizer(preProcessedInput)
 const transformedTree = transformer(parsedTree)
 //console.log(JSON.stringify(transformedTree,null,2))
 const output = generator(transformedTree)
-fs.writeFileSync('output.js', output)
+fs.writeFileSync(fileNameOut, output)

example.mc

 ngs without stupid escape 
 
 characters")
+(repeat 5 (log 10))
+(log scopelol)
+(repeat scopelol (log 10))
+(if (eq 2 scopelol) (log "2 == scopelol") | (log "2 != scopelol"))

fizzbuzz.mc

+(def fizzbuzz
+  (assign i 1)
+  (repeat $1
+    (if (eq (modulo i 3) 0) (if (eq (modulo i 5) 0) (log "FizzBuzz") | (log "Fizz")))
+    (if (eq (modulo i 5) 0) (log "Buzz") | (log i))
+    (assign i (add i 1))
+  )
+)
+
+(fizzbuzz 100)

stdlib.js

       console.warn("Warning! Redefining function, did you mean to do this?")
     }
     function_defs[prop.name] = body;
+  },
+  repeat: function (amount, body) {
+    for (i = 0 ; i < amount.value; i++) {
+        body() 
+    }
+  },
+  eQ: function (arg1, arg2) {
+    return {
+      value: arg1.value === arg2.value
+    }
+  },
+  eq: function (arg1, arg2) {
+    return {
+      value: arg1.value == arg2.value
+    }
+  },
+  if: function (pred, body_true, body_false) {
+    if (pred.value) {
+      body_true()
+    } else {
+      if (body_false) {
+        body_false()
+      }
+    }
+  },
+  modulo: function (arg1, arg2) {
+    return {
+      value: (arg1.value % arg2.value)
+    }
   }
 }
 
     } else {
       methods = Object.keys(function_defs)
       if (methods.includes(prop)) {
-        return (function () { eval(function_defs[prop].replace(/\$(\d+)/g, (m, n) => JSON.stringify(arguments[(+n-1)]))) })
+        //return (function () { eval(function_defs[prop].replace(/\$(\d+)/g, (m, n) => JSON.stringify(arguments[(+n-1)]))) })
+        return function_defs[prop]
       } else {
         console.error("Undefined function call! No such function: ", prop)
       }