Develop

examples/main.ll

@@ -1,76 +1,9 @@
->> "start: main.ll";
-
-func counter() -> func -> void {
-  var i -> number := 0;
-  func count() -> void {
-    i := i + 1;
-    >> i;
+<> Fibonacci
+func fib(n -> number) -> number {
+  if (n < 2) {
+    return n;
   }
-
-  return count;
+  return fib(n - 1) + fib(n - 2);
 }
+>> fib(28);
 
-var cc -> func -> void;
-var dd -> func -> void;
-counter();
-cc := counter();
-dd := cc;
-cc();
-cc();
-cc();
-dd();
-dd();
-dd();
-
-var x -> number := 5;
-
-class address {
-  var street -> string := "123 Main St";
-  var city -> string := "Springfield";
-  var state -> string := "IL";
-  var zip -> string := "62704";
-
-  func print() -> void {
-    >> street;
-    >> city;
-    >> state;
-    >> zip;
-  }
-}
-
-class person {
-  var age -> number := 12 + x;
-  var name -> string := "John";
-  var addr -> address := address();
-
-  func print() -> void {
-    >> "Hello, I am" >> name;
-  }
-}
-
-class student : person {
-  var code -> number := 35;
-
-  func print() -> void {
-    >> "Hi, I am a student, my name is" >> name;
-  }
-}
-
-func newperson() -> person {
-  var p -> person := person();
-  >> p.age;
-  >> p.name;
-  p.addr.print();
-  return p;
-}
-var person1 -> person := newperson();
-
-var p -> person := person();
-p.addr.print();
-
-var lout -> func -> void := p.print;
-lout();
-
-
-var s -> student := student();
-s.print();

examples/refactor.ll

@@ -24,6 +24,11 @@ class person {
 
 var p -> person := person();
 p.print();
-
+if (x > -12) {
+  var y -> number := 10;
+  dd := counter();
+  cc();
+  dd();
+}
 var lout -> func -> void := p.print;
 lout();

grammar_rules

@@ -29,7 +29,10 @@ class_declaration     : class identifier : identifier '{' ( variable_declaration
 variable_declaration  : 'var' identifier '->' type := expression
                       | 'var' identifier '->' type;
 
-func_declaration      : 'func' identifier '(' ')' -> type? '{' statement_list '}'
+func_declaration      : 'func' identifier '(' parameters? ')' -> type? '{' statement_list '}'
+
+parameters            : identifier -> type ( COMMA identifier -> type )*
+arguments             : expression ( COMMA expression )* 
 
 type                  : 'string' | 'number' | void | identifier | '(' ')' -> type?
 output_stream         : >> output output_stream*
@@ -57,5 +60,5 @@ factor                : (PLUS|MINUS)factor
 
 property_chain        : (identifier_or_call) ( . property_chain )*
 identifier_or_call    : identifier | call
-call                  : identifier '(' ')'
+call                  : identifier '(' arguments? ')'
 identifier            : IDENTIFIER

src/ast/ast.h

@@ -95,17 +95,6 @@ class ClassDeclarationAST : public AST {
   std::vector<FunctionDeclarationAST *> methods;
 };
 
-class FunctionDeclarationAST : public AST {
-public:
-  FunctionDeclarationAST(Token identifier, std::stack<TypeAST*> types,
-                         StatementListAST *statements)
-      : identifier(identifier), types(types), statements(statements) {}
-  ASTValue *accept(ASTVisitor &visitor) override;
-
-  std::stack<TypeAST*> types;
-  Token identifier;
-  StatementListAST *statements;
-};
 
 class OutputStreamAST : public AST {
 public:
@@ -126,14 +115,33 @@ class InputStreamAST : public AST {
 
 class VariableDeclarationAST : public AST {
 public:
-  VariableDeclarationAST(std::stack<TypeAST*> types, Token identifier, AST *value)
-      : types(types), identifier(identifier), value(value) {}
+  VariableDeclarationAST(TypeAST* type, Token identifier, AST *value)
+      : type(type), identifier(identifier), value(value) {}
   ASTValue *accept(ASTVisitor &visitor) override;
 
-  std::stack<TypeAST*> types;
+  TypeAST* type;
   Token identifier;
   AST *value;
 };
+class FunctionDeclarationAST : public AST {
+public:
+  FunctionDeclarationAST(Token identifier, TypeAST *type,
+                         std::vector<VariableDeclarationAST *> parameters,
+                         StatementListAST *statements)
+      : identifier(identifier), type(type), parameters(parameters), statements(statements) {}
+  ASTValue *accept(ASTVisitor &visitor) override;
+  std::vector<std::string> getParameterNames() {
+    std::vector<std::string> names;
+    for (auto &parameter : parameters)
+      names.push_back(parameter->identifier.getValue());
+    return names;
+  }
+
+  TypeAST *type;
+  std::vector<VariableDeclarationAST *> parameters;
+  Token identifier;
+  StatementListAST *statements;
+};
 
 class AssignmentVariableAST : public AST {
 public:
@@ -185,10 +193,10 @@ class PropertyChainAST : public AST {
 
 class TypeAST : public AST {
 public:
-  TypeAST(Token token) : token(token) {}
+  TypeAST(std::stack<IdentifierAST*> types) : types(types) {}
   ASTValue *accept(ASTVisitor &visitor) override;
 
-  Token token;
+  std::stack<IdentifierAST*> types;
 };
 
 class IdentifierAST : public AST {

src/ast/interpreter_visitor.cpp

@@ -95,22 +95,18 @@ ASTValue *InterpreterVisitor::visitClassDeclaration(ClassDeclarationAST *expr) {
 
 ASTValue *
 InterpreterVisitor::visitFunctionDeclaration(FunctionDeclarationAST *expr) {
+  ASTValue *type = expr->type->accept(*this);
+  std::vector<LangObject *> parameters;
+  for (auto &parameter : expr->parameters)
+    parameters.push_back(parameter->type->accept(*this)->value);
 
-  ASTValue *type = nullptr;
-  std::stack<TypeAST *> types = expr->types;
-  while (!types.empty()) {
-    ASTValue *t = types.top()->accept(*this);
-    if (type == nullptr)
-      type = t;
-    else
-      type = new ASTValue(new LangFunction(nullptr, type->value, this->scope));
-    types.pop();
-  }
+  /*for (auto &parameter : expr->parameters)*/
+  /*  parameter->accept(*this);*/
 
-  FuncSymbol *func =
-      new FuncSymbol(expr->identifier.getValue(),
-                     new ASTValue(new LangFunction(expr->statements,
-                                                   type->value, this->scope)));
+  FuncSymbol *func = new FuncSymbol(
+      expr->identifier.getValue(),
+      new ASTValue(new LangFunction(expr->statements, parameters, expr->parameters,
+                                    type->value, this->scope)));
   this->scope->set(func);
   return new ASTValue(new LangNil());
 }
@@ -136,17 +132,8 @@ ASTValue *InterpreterVisitor::visitInputStream(InputStreamAST *expr) {
 ASTValue *
 InterpreterVisitor::visitVariableDeclaration(VariableDeclarationAST *expr) {
   ASTValue *value = expr->value->accept(*this);
+  ASTValue *type = expr->type->accept(*this);
 
-  ASTValue *type = nullptr;
-  std::stack<TypeAST *> types = expr->types;
-  while (!types.empty()) {
-    ASTValue *t = types.top()->accept(*this);
-    if (type == nullptr)
-      type = t;
-    else
-      type = new ASTValue(new LangFunction(nullptr, type->value, this->scope));
-    types.pop();
-  }
   if (dynamic_cast<LangNil *>(value->value) != nullptr)
     value->value = new LangNil(type->value);
   this->scope->set(new VarSymbol(expr->identifier.getValue(), value));
@@ -218,11 +205,18 @@ ASTValue *InterpreterVisitor::visitUnaryOperatorExpr(UnaryOperatorAST *expr) {
   throw RuntimeError("invalid operator: " + expr->op.getValue(), expr->op);
 }
 
-ASTValue *InterpreterVisitor::visitCall(LangObject *callee, std::string name, Token &token) {
+ASTValue *InterpreterVisitor::visitCall(LangObject *callee, std::string name, std::vector<LangObject *> arguments,
+                                        Token &token) {
   if (typeid(*callee) == typeid(LangFunction)) {
     LangFunction *func = dynamic_cast<LangFunction *>(callee);
     ScopedSymbolTable *currentScope = this->scope;
     this->scope = func->getScope()->newScope("functioncall");
+    for (int i = 0; i < func->getParameters().size(); i++) {
+      std::string name = func->getParameters()[i]->identifier.getValue();
+      ASTValue *value = new ASTValue(arguments[i]);
+      this->scope->set(new VarSymbol(name, value));
+    } 
+
     LangObject *returnValue = new LangVoid();
     try {
       func->getValue()->accept(*this);
@@ -242,7 +236,12 @@ ASTValue *InterpreterVisitor::visitCall(LangObject *callee, std::string name, To
 ASTValue *InterpreterVisitor::visitCall(CallAST *expr) {
   ASTValue *value =
       this->scope->getValue(expr->identifier.getValue(), this->jumpTable[expr]);
-  return this->visitCall(value->value, expr->identifier.getValue(), expr->identifier);
+  std::vector<LangObject *> arguments;
+  for (auto &argument : expr->arguments)
+    arguments.push_back(argument->accept(*this)->value);
+
+  return this->visitCall(value->value, expr->identifier.getValue(), arguments,
+                         expr->identifier);
 }
 
 ASTValue *InterpreterVisitor::visitPropertyChain(PropertyChainAST *expr) {
@@ -258,14 +257,30 @@ ASTValue *InterpreterVisitor::visitPropertyChain(PropertyChainAST *expr) {
     } else if (typeid(*node) == typeid(CallAST)) {
       CallAST *call = dynamic_cast<CallAST *>(node);
       value = instance->getScope()->getValue(call->identifier.getValue(), 0);
-      value = this->visitCall(value->value, call->identifier.getValue(), call->identifier);
+      std::vector<LangObject *> arguments; 
+      for (auto &argument : call->arguments)
+        arguments.push_back(argument->accept(*this)->value);
+
+      value = this->visitCall(value->value, call->identifier.getValue(), arguments,
+                              call->identifier);
     }
   }
   return value;
 }
 
 ASTValue *InterpreterVisitor::visitType(TypeAST *expr) {
-  return this->scope->getValue(expr->token.getValue(), this->jumpTable[expr]);
+  ASTValue *type = nullptr;
+  std::stack<IdentifierAST *> types = expr->types;
+  while (!types.empty()) {
+    ASTValue *t = types.top()->accept(*this);
+    if (type == nullptr)
+      type = t;
+    else
+      type =
+          new ASTValue(new LangFunction(nullptr, {}, {}, type->value, this->scope));
+    types.pop();
+  }
+  return type;
 }
 
 ASTValue *InterpreterVisitor::visitIdentifier(IdentifierAST *expr) {

src/ast/interpreter_visitor.h

@@ -5,61 +5,63 @@
 #include "visitor.h"
 #include <iostream>
 
-class InterpreterVisitor: public ASTVisitor {
+class InterpreterVisitor : public ASTVisitor {
 public:
-  static void setJumpTable(std::unordered_map<AST*, int> jumpTable) {
+  static void setJumpTable(std::unordered_map<AST *, int> jumpTable) {
     InterpreterVisitor::jumpTable = jumpTable;
   }
+
 protected:
 private:
   static ScopedSymbolTable *scope;
-  static std::unordered_map<AST*, int> jumpTable;
+  static std::unordered_map<AST *, int> jumpTable;
+
+  ASTValue *visitCall(LangObject *callee, std::string name,
+                      std::vector<LangObject *> arguments, Token &token);
 
-  ASTValue *visitCall(LangObject *callee, std::string name, Token &token);
+  ASTValue *visitStatementList(StatementListAST *expr) override;
 
-  ASTValue* visitStatementList(StatementListAST *expr) override; 
+  ASTValue *visitBLock(BlockAST *expr) override;
 
-  ASTValue* visitBLock(BlockAST *expr) override;
+  ASTValue *visitReturn(ReturnAST *expr) override;
 
-  ASTValue* visitReturn(ReturnAST *expr) override;
+  ASTValue *visitWhileStatement(WhileStatementAST *expr) override;
 
-  ASTValue* visitWhileStatement(WhileStatementAST *expr) override; 
+  ASTValue *visitForStatement(ForStatementAST *expr) override;
 
-  ASTValue* visitForStatement(ForStatementAST *expr) override; 
+  ASTValue *visitIfStatement(IfStatementAST *expr) override;
 
-  ASTValue* visitIfStatement(IfStatementAST *expr) override; 
+  ASTValue *visitClassDeclaration(ClassDeclarationAST *expr) override;
 
-  ASTValue* visitClassDeclaration(ClassDeclarationAST *expr) override;
+  ASTValue *visitFunctionDeclaration(FunctionDeclarationAST *expr) override;
 
-  ASTValue* visitFunctionDeclaration(FunctionDeclarationAST *expr) override; 
+  ASTValue *visitOutputStream(OutputStreamAST *expr) override;
 
-  ASTValue* visitOutputStream(OutputStreamAST *expr) override; 
+  ASTValue *visitInputStream(InputStreamAST *expr) override;
 
-  ASTValue* visitInputStream(InputStreamAST *expr) override; 
-
-  ASTValue* visitVariableDeclaration(VariableDeclarationAST *expr) override; 
+  ASTValue *visitVariableDeclaration(VariableDeclarationAST *expr) override;
 
-  ASTValue* visitAssignmentVariable(AssignmentVariableAST *expr) override; 
+  ASTValue *visitAssignmentVariable(AssignmentVariableAST *expr) override;
 
-  ASTValue* visitBinaryOperatorExpr(BinaryOperatorAST *expr) override; 
+  ASTValue *visitBinaryOperatorExpr(BinaryOperatorAST *expr) override;
 
-  ASTValue* visitUnaryOperatorExpr(UnaryOperatorAST *expr) override; 
+  ASTValue *visitUnaryOperatorExpr(UnaryOperatorAST *expr) override;
 
-  ASTValue* visitCall(CallAST *expr) override;
+  ASTValue *visitCall(CallAST *expr) override;
 
-  ASTValue* visitPropertyChain(PropertyChainAST *expr) override;
+  ASTValue *visitPropertyChain(PropertyChainAST *expr) override;
 
-  ASTValue* visitType(TypeAST* expr) override;
+  ASTValue *visitType(TypeAST *expr) override;
 
-  ASTValue* visitIdentifier(IdentifierAST *expr) override; 
+  ASTValue *visitIdentifier(IdentifierAST *expr) override;
 
-  ASTValue* visitNumberExpr(NumberAST *expr) override; 
+  ASTValue *visitNumberExpr(NumberAST *expr) override;
 
-  ASTValue* visitStringExpr(StringAST *expr) override; 
+  ASTValue *visitStringExpr(StringAST *expr) override;
 
-  ASTValue* visitVoid(VoidAST *expr) override;
+  ASTValue *visitVoid(VoidAST *expr) override;
 
-  ASTValue* visitNil(NilAST *expr) override;
+  ASTValue *visitNil(NilAST *expr) override;
 };
 
 #endif // INTERPRETER_VISITOR_H