functions partially implemented

Author: lewis-weinberger

Diff for: package.xml

@@ -17,5 +17,6 @@
   <filein>src/Parser.st</filein>
   <filein>src/RuntimeError.st</filein>
   <filein>src/Environment.st</filein>
+  <filein>src/Callable.st</filein>
   <filein>src/Interpreter.st</filein>
 </package>

Diff for: src/Callable.st

@@ -0,0 +1,34 @@
+Object subclass: Callable [
+    <comment: 'My instances can be called.'>
+    call: anInterpreter arguments: someArguments [
+        "Evaluate the function/class call"
+
+        <category: 'evaluation'>
+        self subclassResponsibility
+    ]
+
+    arity [
+        <category: 'evaluation'>
+        self subclassResponsibility
+    ]
+]
+
+Callable subclass: Clock [
+    <comment: 'A native function to measure time'>
+    call: anInterpreter arguments: someArguments [
+        "Evaluate the clock() function call, returning seconds since
+         midnight 01/01/1901"
+
+        <category: 'evaluation'>
+        ^Time secondClock
+    ]
+
+    arity [
+        <category: 'evaluation'>
+        ^0
+    ]
+]
+
+Eval [
+    Time initialize
+]

Diff for: src/Expr.st

@@ -87,6 +87,53 @@ Expr subclass: ExprBinary [
     ]
 ]
 
+Expr subclass: ExprCall [
+    | callee paren arguments |
+
+    ExprCall class >> callee: aCallee paren: aParen arguments: anArguments [
+        <category: 'instance creation'>
+        ^self new
+            callee: aCallee;
+            paren: aParen;
+            arguments: anArguments;
+            yourself.
+    ]
+
+    callee: aCallee [
+        <category: 'setter'>
+        callee := aCallee.
+    ]
+
+    callee [
+        <category: 'getter'>
+        ^callee.
+    ]
+
+    paren: aParen [
+        <category: 'setter'>
+        paren := aParen.
+    ]
+
+    paren [
+        <category: 'getter'>
+        ^paren.
+    ]
+
+    arguments: anArguments [
+        <category: 'setter'>
+        arguments := anArguments.
+    ]
+
+    arguments [
+        <category: 'getter'>
+        ^arguments.
+    ]
+
+    accept: aVisitor [
+        ^aVisitor visitCallExpr: self.
+    ]
+]
+
 Expr subclass: ExprGrouping [
     | expression |
 

Diff for: src/Interpreter.st

@@ -1,5 +1,5 @@
 Object subclass: Interpreter [
-    | environment |
+    | environment globals |
     <comment: 'My instances are evaluators for the Lox programming language.'>
 
     Interpreter class >> new [
@@ -16,7 +16,9 @@ Object subclass: Interpreter [
         "Initialize the interpreter environment"
 
         <category: 'initialization'>
-        environment := Environment new.
+        globals := Environment new.
+        globals define: 'clock' value: Clock new.
+        environment := globals
     ]
 
     interpret: statements [
@@ -300,4 +302,28 @@ Object subclass: Interpreter [
         "Unreachable"
         ^nil
     ]
+
+    visitCallExpr: expr [
+        "Evaluate a functional call expression"
+
+        <category: 'evaluation'>
+        | callee arguments function |
+        callee := self evaluate: (expr callee).
+        (callee isKindOf: Callable) ifFalse: [
+            ^RuntimeError
+                error: (expr paren)
+                message: 'Can only call functions and classes.'
+        ].
+
+        arguments := OrderedCollection new.
+        (expr arguments) do: [ :each | arguments add: (self evaluate: each) ].
+        (arguments size ~= callee arity) ifTrue: [
+            ^RuntimeError
+                error: (expr paren)
+                message: 'Expected ' , callee arity displayString ,
+                         ' arguments but got ' , arguments size displayString , '.'
+        ].
+
+        ^callee call: self arguments: arguments
+    ]
 ]

Diff for: src/Lox.st

@@ -21,7 +21,8 @@ either running programs from source or providing an interactive interpreter.'>
 
         <category: 'debugging'>
         stderr
-            nextPutAll: '[line ', aLine displayString, '] Error' , aLocation , ': ' , aMessage;
+            nextPutAll: '[line ', aLine displayString ,
+                        '] Error' , aLocation , ': ' , aMessage;
             nl;
             flush.
         hadError := true
@@ -41,7 +42,10 @@ either running programs from source or providing an interactive interpreter.'>
         aToken type = #EOF ifTrue: [
             Lox report: aToken line where: ' at end' message: aMessage.
         ] ifFalse: [
-            Lox report: aToken line where: (' at ''' , aToken lexeme , '''') message: aMessage.
+            Lox
+                report: aToken line
+                where: (' at ''' , aToken lexeme , '''')
+                message: aMessage.
         ]
     ]
 

Diff for: src/Parser.st

@@ -168,7 +168,7 @@ the Lox programming language.'>
         self consume: #LeftParen expect: 'Expect ''('' after ''for''.'.
 
         (self match: #(#Semicolon)) ifTrue: [ ini := nil ].
-        (self match: #(#Var)) ifTrue: [ 
+        (self match: #(#Var)) ifTrue: [
             ini := self varDeclaration
         ] ifFalse: [
             ini := self expressionStatement
@@ -389,7 +389,49 @@ the Lox programming language.'>
             right := self unary.
             ^ExprUnary operator: operator right: right
         ].
-        ^self primary.
+        ^self call.
+    ]
+
+    finishCall: callee [
+        "Helper to parse function arguments"
+
+        <category: 'helper'>
+        | arguments paren |
+        arguments := OrderedCollection new.
+        (self check: #RightParen) ifFalse: [
+            arguments add: (self expression).
+            [ self match: #(#Comma) ] whileTrue: [
+                ((arguments size) >= 255) ifTrue: [
+                    ^ParseError
+                        error: (self peek)
+                        message: 'Can''t have more than 255 arguments'
+                ].
+                arguments add: (self expression)
+            ]
+        ].
+
+        paren := self
+            consume: #RightParen
+            expect: 'Expect '')'' after arguments.'.
+        ^ExprCall callee: callee paren: paren arguments: arguments.
+    ]
+
+    call [
+        "Grammar rule for a function call"
+
+        <category: 'rule'>
+        | expr done |
+        expr := self primary.
+        done := false.
+        [ done ] whileFalse: [
+            (self match: #(#LeftParen)) ifTrue: [
+                expr := self finishCall: expr
+            ] ifFalse: [
+                done := true
+            ]
+        ].
+
+        ^expr.
     ]
 
     primary [

Diff for: tool/generate_ast

@@ -22,6 +22,7 @@ class code for different types of node in the Lox abstract syntax tree'>
             base: 'Expr'
             types: #('Assign: name value'
                      'Binary: left operator right'
+                     'Call: callee paren arguments'
                      'Grouping: expression'
                      'Literal: value'
                      'Logical: left operator right'