Add strings and preprocessor directives

README.md

 they should be from `example.mc`. A `;` denotes that the rest of the line (until the compiler sees `\n`) as a comment and 
 means that it will not be compiled.
 
+In addition to the regular include(coming soon), there is also a preprocessing directive called `` `source <filename> `` which can be used 
+to just directly insert the contents of `<filename>` into the file. Instead of wasting the compilers energy checking for circular
+sources, you have two options, to not be so stupid or wait for the call stack to overflow.
+
 The compiler runs like `node compiler.js file.mc` where `file.mc` is the file you wish to compile, and this will produce an
 `output.js` which requires `stdlib.js` to be in the same directory when running for now at least.
 

compiler.js

 const fs = require('fs')
 
+var preprocess = function (input) {
+  let inputArr = input.split('\n')
+  for (i = 0; i < inputArr.length; i++) {
+    line = inputArr[i]
+    if (line.startsWith('`source')) {
+      line = fs.readFileSync(line.split(' ')[1], { encoding: 'utf-8' })
+      inputArr[i] = preprocess(line)
+    }
+  }
+  return inputArr.join('\n')
+}
+
 var tokenizer = function (input) {
   let pos = 0
   let tokens = []
       }
       continue
     }
+    let stringChars = /['"]/
+    if (stringChars.test(char)) {
+      let myDelim = char
+      let stringString = ''
+      char = input[++pos]
+      while (char !== myDelim) {
+        if (char !== '\n') {
+          stringString += char
+        }
+        char = input[++pos]
+      }
+      pos++
+      tokens.push({
+        type: 'string',
+        value: stringString
+      })
+      continue
+    }
     let numbers = /[0-9]/
     if (numbers.test(char)) {
       let numberString = ''
       }
     }
 
+    if (token.type === 'string') {
+      pos++
+      return {
+        type: 'StringLiteral',
+        value: token.value
+      }
+    }
+
     if (token.type === 'paren' && token.value == '(') {
       token = input[++pos]
       if (token.type !== 'name') {
         break
       case 'NumberLiteral':
         break
+      case 'StringLiteral':
+        break
       case 'DollarVar':
         break
       default:
         value: node.value
       })
     },
+    StringLiteral: function (node, parent) {
+      parent._context.push({
+        type: 'StringLiteral',
+        value: node.value
+      })
+    },
     VariableReference: function (node, parent) {
       parent._context.push({
         type: 'VariableReference',
     case 'NumberLiteral':
       return '{value: ' + node.value + '}'
       break
+    case 'StringLiteral':
+      return '{ value: \'' + node.value + '\' }'
+      break
     default:
       throw {
         name: 'Compiler Error',
 
 // const myInput = '(assign twelve 12) (assign myvar (add twelve (subtract 6 2))) (log myvar)'
 const myInput = fs.readFileSync(process.argv[2], { encoding: 'utf-8' })
-const myTokens = tokenizer(myInput)
+const preProcessedInput = preprocess(myInput)
+const myTokens = tokenizer(preProcessedInput)
 const parsedTree = parser(myTokens)
 const transformedTree = transformer(parsedTree)
 //console.log(JSON.stringify(transformedTree,null,2))

example.mc

 (myF) ; Calling an argument-less function
 (log 0)
 (log 0)
-(log 1)
 (log 0)
 (log 0)
 (log 0)
 (argTest 43 scopelol) ; Custom functions with arguments are called like any other
+(log "We got a string!")
+(argTest "You can call functions with strings!" "Yay!")
+(log "It supports multiline stri
+ngs without stupid escape 
+
+characters")