Greatly improved and cleaned up codebase. Fixed several bugs.

Author: Jacob-Noah

jink.py

@@ -1,44 +1,70 @@
-import sys
-import json
+import sys, argparse
+from jink import optimizer
 from jink.lexer import Lexer
 from jink.parser import Parser
 from jink.optimizer import optimize
-from jink.interpreter import Interpreter
-from jink.utils.classes import Environment
+from jink.interpreter import Interpreter, Environment
 from jink.repl import REPL
-lexer = Lexer()
-parser = Parser()
-interpreter = Interpreter()
-env = Environment()
+# from jink.compiler import Compiler
 
-env.def_func('print', lambda scope, args: print('\n'.join([str(x) for x in args]) or 'null'))
-env.def_func('string', lambda scope, args: [str(x or 'null') for x in args][0] if len(args) == 1 else [str(x or 'null') for x in args])
-env.def_func('input', lambda scope, args: input(' '.join(args)))
+def get_code_from_path(path):
+  if not path.endswith('.jk'):
+    path += '.jk'
+  code = open(path).read()
+  if not code:
+    raise Exception(f"Error reading file {sys.argv[0]}")
+  return code
 
-code = ''
-if len(sys.argv) > 1 and '-v' not in sys.argv:
+if len(sys.argv) >= 1 and sys.argv[0] == 'jink.py':
   sys.argv.pop(0)
-  _path = ' '.join(sys.argv)
-  if not _path.endswith('.jk'):
-    _path += '.jk'
-  code = open(_path).read()
 
-  if not code:
-    raise Exception(f"Error reading file {sys.argv[0]}")
+verbose = False
+to_compile = False
 
-  AST = optimize(parser.parse(lexer.parse(code)))
+if '-v' in sys.argv:
+  sys.argv.remove('-v')
+  verbose = True
+if '-c' in sys.argv:
+  sys.argv.remove('-c')
 
-  # For testing (printing the AST)
-  # _AST = ""
-  # for expr in AST:
-  #   _AST += (f"{expr}, ").replace("'", '"')
-  # print(_AST[:-2])
+# Launch REPL
+if len(sys.argv) == 0 or (len(sys.argv) == 1 and sys.argv[0] == '-v'):
+  print("jink REPL - use '[jink] help' for help - type 'exit' to exit.")
+  repl = REPL(sys.stdin, sys.stdout, verbose=verbose)
+  repl.main_loop()
+
+elif len(sys.argv) >= 1:
+  if sys.argv[0] == 'help':
+    print('\n'.join([
+      "jink - strongly typed, JavaScript-like programming language.",
+      "https://www.github.com/jink-lang/jink",
+      "",
+      "args:",
+      "  > -v -- verbose; will output AST." # and if compiling, both optimized and unoptimized LLVM IR.",
+      # "  > -c -- compile; will use compiler instead of interpreter."
+      "",
+      "usage:",
+      "  > [jink] help                 -- shows this prompt.",
+      "  > [jink] path/to/file[.jk]    -- executes interpreter on file.",
+      "  > [jink] -v path/to/file[.jk] -- executes interpreter on file verbose mode.",
+      # "  > [jink] -c path/to/file[.jk] -- executes compiler on file.",
+      # "  > [jink] -c -v path/to/file[.jk] -- executes compiler on file in verbose mode.",
+      "  > [jink]                      -- launches interpreted interactive REPL.",
+      "  > [jink] -v                   -- launches interpreted interactive REPL in verbose mode."
+    ]))
 
-  interpreter.evaluate(AST, env)
-else:
-  if '-v' in sys.argv:
-    repl = REPL(sys.stdin, sys.stdout, env, verbose=True)
   else:
-    repl = REPL(sys.stdin, sys.stdout, env)
-  while True:
-    repl.main_loop()
+    path = ' '.join(sys.argv)
+    code = get_code_from_path(path)
+
+    if to_compile:
+      raise NotImplementedError("Compiler not yet implemented.")
+      # Compiler()._eval(code, optimize=True, verbose=verbose)
+    else:
+      AST = optimize(Parser().parse(Lexer().parse(code), verbose=verbose))
+      env = Environment()
+      env.add_builtins()
+      Interpreter().evaluate(AST, env)
+
+if __name__ == "__main__":
+  pass

jink/interpreter.py

@@ -1,5 +1,93 @@
-from .utils.classes import *
-from .utils.evals import *
+from jink.utils.classes import *
+from jink.utils.evals import *
+
+TYPES = {
+  int: 'int',
+  float: 'float',
+  str: 'string',
+  dict: 'obj'
+}
+
+# The interpreter environment
+class Environment:
+  def __init__(self, parent=None, s_type=None, debug=False):
+    self._id = parent._id + 1 if parent else 0
+    self.index = {}
+    self.parent = parent
+    self.type = s_type
+    self.debug = debug
+
+  # To define builtin methods - only for use on the top level interpreter environment
+  def add_builtins(self):
+    self.def_func('print', lambda scope, args: print('\n'.join([str(x) for x in args]) or 'null'))
+    self.def_func('string', lambda scope, args: [str(x or 'null') for x in args][0] if len(args) == 1 else [str(x or 'null') for x in args])
+    self.def_func('input', lambda scope, args: input(' '.join(args)))
+
+  def extend(self, s_type):
+    return Environment(self, s_type)
+
+  def find_scope(self, name):
+    if self.debug:
+      print(f"Searching for {name} in scopes..")
+    scope = self
+    while scope:
+      if self.debug:
+        print(f"Searching {scope._id}.. found {list(self.index.keys())}")
+      if name in scope.index:
+        return scope
+      scope = scope.parent
+
+  def get_var(self, name):
+    scope = self.find_scope(name)
+    if not scope:
+      raise Exception(f"{name} is not defined.")
+
+    elif name in scope.index:
+      return scope.index[name]
+
+    raise Exception(f"{name} is not defined.")
+
+  # Functions override to update values
+  # from parent scopes in local scope during their lifecycle
+  def set_var(self, name, value, var_type=None, fn_scoped=False):
+    scope = self.find_scope(name)
+
+    for py_type, _type in TYPES.items():
+      if isinstance(value, py_type):
+        val_type = _type
+    
+    if fn_scoped:
+      self.index[name] = { 'value': value, 'type': val_type, 'var_type': var_type }
+      return value
+
+    # Assignments
+    if scope:
+      v = scope.get_var(name)
+
+      if var_type != None:
+        raise Exception(f"{name} is already defined.")
+      elif v['var_type'] == 'const':
+        raise Exception(f"Constant {name} is not reassignable.")
+
+      scope.index[name]['value'] = value
+      scope.index[name]['type'] = val_type
+
+    # Definitions
+    else:
+      if not var_type:
+        raise Exception(f"Expected let or const, got 'null' for {name}.")
+      self.index[name] = { 'value': value, 'type': val_type, 'var_type': var_type }
+
+    return value
+
+  def def_func(self, name, func):
+    if self.debug:
+      print(f"Defining {name} in {self._id}")
+    self.index[name] = func
+    return func
+
+  def __str__(self):
+    return f"{self.parent or 'null'}->{self._id}:{list(self.index.keys())}"
 
 class Interpreter:
   def __init__(self):
@@ -28,8 +116,10 @@ def evaluate_top(self, expr):
             raise Exception(f"Object '{expr.name}' does not contain the property '{expr.index['index'].name}'")
           else:
             return obj[expr.index['index'].name]
+
+        # TODO: Object methods, classes.
         elif isinstance(expr.index['index'], CallExpression):
-          pass
+          return self.call_function(expr.index['index'])
 
     elif isinstance(expr, (StringLiteral, IntegerLiteral, FloatingPointLiteral)):
       return self.unwrap_value(expr)
@@ -40,6 +130,8 @@ def evaluate_top(self, expr):
     elif isinstance(expr, Null):
       return { 'type': 'null', 'value': 'null' }
 
+    # TODO Properly evaluate unary operators modifying variables
+    # (e.g. pre and post increment ++i and i++)
     elif isinstance(expr, UnaryOperator):
       value = self.evaluate_top(expr.value)
       return UNOP_EVALS[expr.operator](self.unwrap_value(value)) or 0
@@ -70,17 +162,15 @@ def evaluate_top(self, expr):
       self.evaluate(expr.body, self.env)
 
     elif isinstance(expr, CallExpression):
-      scope = self.env.extend('call')
-      func = self.evaluate_top(expr.name)
-      return func(scope, [self.unwrap_value(self.evaluate_top(arg)) for arg in expr.args])
+      return self.call_function(expr)
 
     elif isinstance(expr, Function):
       return self.make_function(expr)
 
     elif isinstance(expr, Return):
-      result = self.evaluate_top(expr.expression)
+      result = self.evaluate_top(expr.value)
       return { 'type': 'return', 'value': self.unwrap_value(result) }
-    
+
     elif isinstance(expr, dict):
       return expr
 
@@ -95,6 +185,12 @@ def evaluate_condition(self, cond):
       elif cond['type'] != 'bool':
         return 'true'
 
+  # Call a function in a new scope
+  def call_function(self, expr):
+    scope = self.env.extend(f"call_{expr.name.name}")
+    func = self.evaluate_top(expr.name)
+    return func(scope, [self.unwrap_value(self.evaluate_top(arg)) for arg in expr.args])
+
   # Make a function
   def make_function(self, func):
     def function(scope, args):
@@ -104,21 +200,14 @@ def function(scope, args):
       if len(args) > len(params):
         raise Exception(f"Function '{func.name}' takes {len(params)} arguments but {len(args)} were given.")
 
-      # Apply arguments to this call's scope, otherwise use function defaults if any
+      # Apply arguments to this call's scope
+      # If argument doesn't exist use function default if it exists
       i = 0
 
       for p in params:
         default = None
 
-        if isinstance(p, Assignment):
-          default = p.value or 'null'
-          name = p.ident.name
-          _type = p.type
-          class Object(): pass
-          p = Object()
-          setattr(p, 'name', name)
-          setattr(p, 'type', _type)
-        elif p.default:
+        if p.default:
           default = self.unwrap_value(p.default)
 
         if len(args) > i:
@@ -128,9 +217,9 @@ class Object(): pass
 
         if value != None:
           try:
-            scope.set_var(p.name, value, p.type)
-          except:
-            raise Exception(f"Improper function parameter or call argument at function '{func.name}'.")
+            scope.set_var(p.name, value, p.type, fn_scoped=True)
+          except Exception as e:
+            raise Exception(f"{e}\nException: Improper function parameter or call argument at function '{func.name}'.")
         i += 1
 
       # Ensure returning of the correct value

jink/lexer.py

@@ -1,6 +1,6 @@
-from .utils.names import *
-from .utils.classes import Token
-from .utils.future_iter import FutureIter
+from jink.utils.names import *
+from jink.utils.classes import Token, TokenType
+from jink.utils.future_iter import FutureIter
 
 KEYWORDS = KEYWORDS + TYPES
 
@@ -50,7 +50,7 @@ def parse_tokens(self):
         if char == '\n':
           self.line_pos = 0
           self.line += 1
-          yield Token('newline', 'newline', self.line, self.pos)
+          yield Token(TokenType.NEWLINE, 'newline', self.line, self.pos)
 
       # Comments
       elif char == '/':
@@ -61,23 +61,23 @@ def parse_tokens(self):
 
       # Brackets
       elif char == '(':
-        yield Token('lparen', '(', self.line, self.pos)
+        yield Token(TokenType.LPAREN, '(', self.line, self.pos)
       elif char == ')':
-        yield Token('rparen', ')', self.line, self.pos)
+        yield Token(TokenType.RPAREN, ')', self.line, self.pos)
       elif char == '[':
-        yield Token('lbracket', '[', self.line, self.pos)
+        yield Token(TokenType.LBRACKET, '[', self.line, self.pos)
       elif char == ']':
-        yield Token('rbracket', ']', self.line, self.pos)
+        yield Token(TokenType.RBRACKET, ']', self.line, self.pos)
       elif char == '{':
-        yield Token('lbrace', '{', self.line, self.pos)
+        yield Token(TokenType.LBRACE, '{', self.line, self.pos)
       elif char == '}':
-        yield Token('rbrace', '}', self.line, self.pos)
+        yield Token(TokenType.RBRACE, '}', self.line, self.pos)
 
       elif char == ';':
-        yield Token('semicolon', ';', self.line, self.pos)
+        yield Token(TokenType.SEMICOLON, ';', self.line, self.pos)
 
       elif char == ',':
-        yield Token('comma', ',', self.line, self.pos)
+        yield Token(TokenType.COMMA, ',', self.line, self.pos)
 
       elif char in ("'", '"'):
         yield self.parse_string(char)
@@ -104,8 +104,8 @@ def parse_ident(self, char):
       self.code._next()
       self.line_pos += 1
     if ident in KEYWORDS:
-      return Token('keyword', ident, self.line, self.pos)
-    return Token('identifier', ident, self.line, self.pos)
+      return Token(TokenType.KEYWORD, ident, self.line, self.pos)
+    return Token(TokenType.IDENTIFIER, ident, self.line, self.pos)
 
   # 2 + 2 = 4 - 1 = 3
   def parse_operator(self, operator):
@@ -119,7 +119,7 @@ def parse_operator(self, operator):
       raise Exception('Invalid operator on {0}:{1}\n  {2}\n  {3}'.format(
         self.line, line_start, str(self.code).split('\n')[self.line - 1], f"{' ' * (line_start - 1)}^"
       ))
-    return Token('operator', operator, self.line, start)
+    return Token(TokenType.OPERATOR, operator, self.line, start)
 
   # Yay, I can "Hello world" now!
   def parse_string(self, char):
@@ -163,7 +163,7 @@ def parse_string(self, char):
         self.line, start, str(self.code).split('\n')[self.line - 1], f"{' ' * (start - 1)}^"
       ))
 
-    return Token('string', string, self.line, start)
+    return Token(TokenType.STRING, string, self.line, start)
 
   # Crunch those numbers.
   def parse_number(self, char):
@@ -180,7 +180,7 @@ def parse_number(self, char):
         self.line, line_start, str(self.code).split('\n')[self.line - 1], f"{' ' * (line_start - 1)}^"
       ))
     else:
-      return Token('number', num, self.line, self.pos)
+      return Token(TokenType.NUMBER, num, self.line, self.pos)
 
   # Do I really need to comment on comments?
   def process_comment(self):