├── tests
    ├── include.ter.result
    ├── hello.ter.result
    ├── library.ter
    ├── errorString.ter
    ├── args.ter.args
    ├── hello.ter
    ├── functions.ter.result
    ├── errorString.ter.error
    ├── args.ter.result
    ├── include.ter
    ├── loops.ter.result
    ├── classes.ter.result
    ├── args.ter
    ├── incdec.ter.result
    ├── operators.ter.result
    ├── bitwiseShift.ter.result
    ├── limits.ter.result
    ├── bitwiseOperators.ter.result
    ├── operators.modulo.ter.result
    ├── limits.ter
    ├── incdec.ter
    ├── operators.ter
    ├── loops.ter
    ├── bitwiseShift.ter
    ├── functions.ter
    ├── classes.ter
    ├── bitwiseOperators.ter
    ├── operators.modulo.ter
    ├── run.sh
    └── run.bat
├── logo-ter-terlang.png
├── src
    ├── utils
    │   ├── RuntimeError.cpp
    │   ├── RuntimeError.hpp
    │   ├── Debug.hpp
    │   ├── Helpers.hpp
    │   └── Debug.cpp
    ├── Ter.hpp
    ├── parser
    │   ├── IncludeRun.hpp
    │   ├── IncludeRun.cpp
    │   ├── Visitor.hpp
    │   ├── Parser.hpp
    │   ├── Stmt.cpp
    │   ├── Expr.cpp
    │   ├── Stmt.hpp
    │   ├── Expr.hpp
    │   └── Parser.cpp
    ├── interpreter
    │   ├── BuiltinFactory.hpp
    │   ├── ArrayType.hpp
    │   ├── Callable.hpp
    │   ├── Function.hpp
    │   ├── ArrayType.cpp
    │   ├── Instance.hpp
    │   ├── Class.hpp
    │   ├── Environment.hpp
    │   ├── Class.cpp
    │   ├── Function.cpp
    │   ├── Instance.cpp
    │   ├── BuiltinFactory.cpp
    │   ├── Builtin.hpp
    │   ├── Environment.cpp
    │   ├── Resolver.hpp
    │   ├── Interpreter.hpp
    │   ├── Builtin.cpp
    │   ├── Resolver.cpp
    │   └── Interpreter.cpp
    ├── tokenizer
    │   ├── Token.hpp
    │   ├── TokenType.hpp
    │   ├── Token.cpp
    │   ├── Scanner.hpp
    │   └── Scanner.cpp
    ├── main.cpp
    └── Ter.cpp
├── .gitignore
├── debug.ter
├── CMakeLists.txt
├── README.md
└── LICENSE


/tests/include.ter.result:
--------------------------------------------------------------------------------
1 | 18
2 | 


--------------------------------------------------------------------------------
/tests/hello.ter.result:
--------------------------------------------------------------------------------
1 | Hello Ter!
2 | 


--------------------------------------------------------------------------------
/tests/library.ter:
--------------------------------------------------------------------------------
1 | auto value=18
2 | 


--------------------------------------------------------------------------------
/tests/errorString.ter:
--------------------------------------------------------------------------------
1 | auto a="this is a text
2 | 


--------------------------------------------------------------------------------
/tests/args.ter.args:
--------------------------------------------------------------------------------
1 | first second --third "My Four"


--------------------------------------------------------------------------------
/tests/hello.ter:
--------------------------------------------------------------------------------
1 | auto a="Hello Ter!"
2 | output(a)
3 | 


--------------------------------------------------------------------------------
/tests/functions.ter.result:
--------------------------------------------------------------------------------
1 | My content
2 | 12
3 | 7
4 | 13


--------------------------------------------------------------------------------
/tests/errorString.ter.error:
--------------------------------------------------------------------------------
1 | error: line: 2: Unterminated string.
2 | 


--------------------------------------------------------------------------------
/tests/args.ter.result:
--------------------------------------------------------------------------------
1 | [first, second, --third, "My, Four"]
2 | second
3 | 


--------------------------------------------------------------------------------
/tests/include.ter:
--------------------------------------------------------------------------------
1 | include("./library.ter")
2 | output(value); // 18
3 | 


--------------------------------------------------------------------------------
/tests/loops.ter.result:
--------------------------------------------------------------------------------
1 | 0 | 1 | 2 | 3 | 4 | 
2 | 0 | 1 | 2 | 3 | 4 | 
3 | 


--------------------------------------------------------------------------------
/tests/classes.ter.result:
--------------------------------------------------------------------------------
1 | Cat name is: Bob
2 | I am dog!
3 | Human: Peter
4 | 


--------------------------------------------------------------------------------
/tests/args.ter:
--------------------------------------------------------------------------------
1 | auto params = args()
2 | output(params)
3 | output(params[1])
4 | 


--------------------------------------------------------------------------------
/tests/incdec.ter.result:
--------------------------------------------------------------------------------
1 |     Increment
2 | 1|2|3
3 |     Decrement
4 | 3|2|1
5 | 


--------------------------------------------------------------------------------
/tests/operators.ter.result:
--------------------------------------------------------------------------------
1 | 5
2 | -1
3 | 6
4 | 0.666667
5 | 2
6 | 2
7 | 3
8 | 1
9 | 


--------------------------------------------------------------------------------
/logo-ter-terlang.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/terroo/terlang/HEAD/logo-ter-terlang.png


--------------------------------------------------------------------------------
/tests/bitwiseShift.ter.result:
--------------------------------------------------------------------------------
1 |     Shift left
2 | 4503599627370496|36028797018963968|4|65500
3 |     Shift right
4 | 1|8|0|65500
5 | 


--------------------------------------------------------------------------------
/tests/limits.ter.result:
--------------------------------------------------------------------------------
1 | 9007199254740991
2 | 9007199254740992
3 | 9007199254740992
4 | -9007199254740991
5 | -9007199254740992
6 | -9007199254740992
7 | 


--------------------------------------------------------------------------------
/tests/bitwiseOperators.ter.result:
--------------------------------------------------------------------------------
1 | 0|0|0|-1
2 | 0|-1|-1|0
3 | 1|-1|-2|-9007199254740992
4 | 6004799503160660|-3002399751580329|-9007199254740989|-6004799503160662
5 | 


--------------------------------------------------------------------------------
/src/utils/RuntimeError.cpp:
--------------------------------------------------------------------------------
1 | #include "RuntimeError.hpp"
2 | 
3 | RuntimeError::RuntimeError(const Token& token, const std::string& message) :
4 |    std::runtime_error{message}, token{token} {}
5 | 


--------------------------------------------------------------------------------
/tests/operators.modulo.ter.result:
--------------------------------------------------------------------------------
1 |    Regular
2 | 1|1|-1|-1|0
3 |    Limit 53 bits
4 | 1|-0|9007199254740990|1
5 |    Floating point
6 | 1.500000|-1.200000|0.100000
7 |    Zero
8 | -nan|-nan|-nan
9 | 


--------------------------------------------------------------------------------
/tests/limits.ter:
--------------------------------------------------------------------------------
 1 | auto a=9007199254740990
 2 | for(auto i = 0; i < 3; ++i){
 3 |   a=a+1
 4 |   output(a)
 5 | }
 6 | a=-9007199254740990
 7 | for(auto i = 0; i < 3; ++i){
 8 |   a=a-1
 9 |   output(a)
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/incdec.ter:
--------------------------------------------------------------------------------
 1 | auto a=1
 2 | output("    Increment")
 3 |   out(a++) out("|")
 4 |   out(a) out("|")
 5 |   output(++a)
 6 | output("    Decrement")
 7 |   out(a--) out("|")
 8 |   out(a) out("|")
 9 |   output(--a)
10 | 


--------------------------------------------------------------------------------
/tests/operators.ter:
--------------------------------------------------------------------------------
 1 | auto a=2;
 2 | auto b=3;
 3 | 
 4 | output(a+b);
 5 | output(a-b);
 6 | output(a*b);
 7 | output(a/b);
 8 | output(a%b);
 9 | output(a&b);
10 | output(a|b);
11 | output(a^b);
12 | /* TODO
13 | output(a<<b);
14 | output(a>>b);
15 | */


--------------------------------------------------------------------------------
/tests/loops.ter:
--------------------------------------------------------------------------------
 1 | for(auto i = 0; i < 5; ++i){ // Or i++
 2 |   out(to_string(i) + " | ")
 3 | }
 4 | out("\n") // 0 | 1 | 2 | 3 | 4 |
 5 | 
 6 | 
 7 | auto i = 0;
 8 | while(i < 5){
 9 |   out(to_string(i) + " | ")
10 |   ++i;
11 | }
12 | out("\n") // 0 | 1 | 2 | 3 | 4 |
13 | 


--------------------------------------------------------------------------------
/src/utils/RuntimeError.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stdexcept>
 4 | #include "../tokenizer/Token.hpp"
 5 | 
 6 | class RuntimeError : public std::runtime_error {
 7 |   public:
 8 |     const Token& token;
 9 |     RuntimeError(const Token& token, const std::string& message);
10 | };
11 | 


--------------------------------------------------------------------------------
/src/Ter.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | 
 5 | class Ter {
 6 |   private: 
 7 |     static void run(const std::string&);
 8 | 
 9 |   public:
10 |     static void run_file(const std::string&);
11 |     static void run_script(const std::string&);
12 |     static void repl();
13 | };
14 | 


--------------------------------------------------------------------------------
/tests/bitwiseShift.ter:
--------------------------------------------------------------------------------
 1 | output("    Shift left")
 2 |   out(1<<52) out("|")
 3 |   out(1<<55) out("|")
 4 |   out(1<<2) out("|")
 5 |   output(65500<<0)
 6 | output("    Shift right")
 7 |   out(4503599627370496>>52) out("|")
 8 |   out(36028797018963968>>52) out("|")
 9 |   out(4>>3) out("|")
10 |   output(65500>>0)


--------------------------------------------------------------------------------
/src/parser/IncludeRun.hpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | 
 3 | #include "../tokenizer/Token.hpp"
 4 | 
 5 | class IncludeRun {
 6 |   public:
 7 |     static void scanFile(std::string path);
 8 |     static void run(const std::string&);
 9 |     static std::vector<Token> tokens;
10 |     static std::vector<Token> getTokens();
11 | };
12 | 


--------------------------------------------------------------------------------
/src/interpreter/BuiltinFactory.hpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include <functional>
3 | #include <memory>
4 | #include <typeindex>
5 | #include "Callable.hpp"
6 | 
7 | extern std::unordered_map<std::type_index, std::function<std::shared_ptr<Callable>()>> builtinFactory;
8 | extern std::unordered_map<std::string, std::type_index> builtinNames;
9 | 


--------------------------------------------------------------------------------
/tests/functions.ter:
--------------------------------------------------------------------------------
 1 | set print(str){
 2 |   output(str);
 3 | }
 4 | 
 5 | set add(x, y){
 6 |   return x + y;
 7 | }
 8 | 
 9 | set increment(a){
10 |   return ++a;
11 | }
12 | 
13 | print("My content"); // My content
14 | output(add(3, 9)); // 12
15 | 
16 | auto result = increment(6);
17 | output(result); // 7
18 | 
19 | output(increment(add(3,9))) //13
20 | 


--------------------------------------------------------------------------------
/tests/classes.ter:
--------------------------------------------------------------------------------
 1 | class Animal {
 2 |   cat(name){
 3 |     output("Cat name is: " + name);
 4 |   }
 5 | 
 6 |   dog(){
 7 |     output("I am dog!");
 8 |   }
 9 | 
10 |   descAnimal(human){
11 |     return "Human: " + human;
12 |   }
13 | }
14 | 
15 | Animal().cat("Bob");
16 | 
17 | auto obj = Animal();
18 | obj.dog();
19 | 
20 | output(obj.descAnimal("Peter"));
21 | 


--------------------------------------------------------------------------------
/src/tokenizer/Token.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <any>
 4 | #include <string>
 5 | #include "TokenType.hpp"
 6 | 
 7 | class Token {
 8 |   public:
 9 |     TokenType type;
10 |     std::string lexeme;
11 |     std::any literal;
12 |     int line;
13 | 
14 |     Token(TokenType type, std::string, std::any, int);
15 |     bool operator <(const Token& obj) const;
16 |     std::string toString();
17 | };
18 | 


--------------------------------------------------------------------------------
/src/interpreter/ArrayType.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <any>
 4 | #include <vector>
 5 | 
 6 | class ArrayType {
 7 |   private:
 8 |     void insertAtIndex(int index, std::any value);
 9 | 
10 |   public:
11 |     std::vector<std::any> values;
12 |     void append(std::any value);
13 |     bool setAtIndex(int index, std::any value);
14 |     std::any getEleAt(int index);
15 |     int length();
16 | };
17 | 


--------------------------------------------------------------------------------
/src/interpreter/Callable.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <any>
 5 | #include <string>
 6 | 
 7 | class Interpreter;
 8 | 
 9 | class Callable {
10 |   public:
11 |     virtual int arity() = 0;
12 |     virtual std::any call(Interpreter &interpreter,
13 |             std::vector<std::any> arguments) = 0;
14 |     virtual std::string toString() = 0;
15 |     virtual ~Callable() = default;
16 | };
17 | 
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | build
34 | desk
35 | web
36 | doc.md
37 | 


--------------------------------------------------------------------------------
/tests/bitwiseOperators.ter:
--------------------------------------------------------------------------------
 1 | auto a=0; auto b=0
 2 | out(a&b) out("|") out(a|b) out("|") out(a^b) out("|") output(~a)
 3 | a=-1
 4 | out(a&b) out("|") out(a|b) out("|") out(a^b) out("|") output(~a)
 5 | a=9007199254740991
 6 | b=-9007199254740991
 7 | out(a&b) out("|") out(a|b) out("|") out(a^b) out("|") output(~a)
 8 | a= 6004799503160661  //  0x15555555555555
 9 | b= -3002399751580330 // -0xaaaaaaaaaaaaa
10 | out(a&b) out("|") out(a|b) out("|") out(a^b) out("|") output(~a)
11 | 


--------------------------------------------------------------------------------
/src/utils/Debug.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include "../tokenizer/Token.hpp"
 4 | #include "RuntimeError.hpp"
 5 | 
 6 | class Debug {
 7 |   private:
 8 |     static void report(int, const std::string&, const std::string&);
 9 | 
10 |   public:
11 |     inline static std::string filename;
12 |     inline static bool hadError = false;
13 |     inline static bool hadRuntimeError = false;
14 |     static void error(int line, const std::string&);
15 |     static void error(Token token, const std::string&);
16 |     static void runtimeError(const RuntimeError& error);
17 | };
18 | 


--------------------------------------------------------------------------------
/src/tokenizer/TokenType.hpp:
--------------------------------------------------------------------------------
 1 | enum class TokenType {
 2 |   LEFT_PAREN, RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE, RIGHT_BRACKET, LEFT_BRACKET,
 3 |   COMMA, DOT, MINUS, PLUS, SEMICOLON, SLASH, STAR, PLUS_PLUS, MINUS_MINUS,
 4 |   PERCENT, AMPERSAND, CARET, VBAR, TILDE,
 5 | 
 6 |   BANG, BANG_EQUAL,
 7 |   EQUAL, EQUAL_EQUAL,
 8 |   GREATER, GREATER_EQUAL, GREATER_GREATER,
 9 |   LESS, LESS_EQUAL, LESS_LESS,
10 | 
11 |   IDENTIFIER, STRING, NUMBER, INCLUDE,
12 | 
13 |   AND, CLASS, ELSE, FALSE, SET, FOR, IF, NIL, OR, OUT,
14 |   OUTPUT, RETURN, SUPER, THIS, TRUE, AUTO, WHILE,
15 | 
16 |   TER_EOF 
17 | };
18 | 
19 | 


--------------------------------------------------------------------------------
/tests/operators.modulo.ter:
--------------------------------------------------------------------------------
 1 | output("   Regular")
 2 |  out(7 % 3) out("|")
 3 |  out(7 % -3) out("|")
 4 |  out(-7 % 3) out("|")
 5 |  out(-7 % -3) out("|")
 6 |  output(10 % 5)
 7 | output("   Limit 53 bits")
 8 |  out(9007199254740991 % 2) out("|")
 9 |  out(-9007199254740991 % 9007199254740991) out("|")
10 |  out(9007199254740990 % 9007199254740991) out("|")
11 |  output(9007199254740991 % 9007199254740990)
12 | output("   Floating point")
13 |  out(7.5 % 3) out("|")
14 |  out(-10.2 % 3) out("|")
15 |  output(10 % 3.3)
16 | output("   Zero")
17 |  out(7 % 0) out("|")
18 |  out(-10.2 % 0) out("|")
19 |  output(0 % 0)
20 | 


--------------------------------------------------------------------------------
/src/interpreter/Function.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <memory>
 5 | 
 6 | class Interpreter;
 7 | 
 8 | #include "../parser/Stmt.hpp"
 9 | #include "Callable.hpp"
10 | #include "Environment.hpp"
11 | 
12 | class Function: public Callable {
13 |   private:
14 |     std::shared_ptr<Statement::Function> declaration;
15 |     std::weak_ptr<Env> closure;
16 | 
17 |   public:
18 |     Function(std::shared_ptr<Statement::Function> declaration,
19 |         std::shared_ptr<Env> closure);
20 |     int arity();
21 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments);
22 |     std::string toString();
23 | };
24 | 


--------------------------------------------------------------------------------
/src/interpreter/ArrayType.cpp:
--------------------------------------------------------------------------------
 1 | #include "ArrayType.hpp"
 2 | 
 3 | void ArrayType::append(std::any value) {
 4 |   values.push_back(value);
 5 | }
 6 | 
 7 | std::any ArrayType::getEleAt(int index) {
 8 |   return values.at(static_cast<size_t>(index));
 9 | }
10 | 
11 | int ArrayType::length() {
12 |   return static_cast<int>(values.size());
13 | }
14 | 
15 | bool ArrayType::setAtIndex(int index, std::any value) {
16 |   if(index == length()){
17 |     values.insert(values.begin() + index, value);
18 |   }else if(index < length() && index >= 0) {
19 |     values[static_cast<size_t>(index)] = value;
20 |   }else{
21 |     return false;
22 |   }
23 |   return true;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/interpreter/Instance.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Callable.hpp"
 4 | #include "Interpreter.hpp"
 5 | #include <memory>
 6 | #include <unordered_map>
 7 | 
 8 | class Class;
 9 | 
10 | class Instance : public Callable {
11 |   public:
12 |     Instance(std::shared_ptr<Class> klass);
13 | 
14 |     std::shared_ptr<Class> klass;
15 |     std::unordered_map<std::string, std::any> fields;
16 | 
17 |     std::any get(const Token& name);
18 |     void set(const Token& name, std::any value);
19 | 
20 |     int arity() override;
21 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
22 |     std::string toString() override;
23 | };
24 | 


--------------------------------------------------------------------------------
/src/interpreter/Class.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <optional>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include "Function.hpp"
 7 | 
 8 | class Instance;
 9 | 
10 | class Class : public Callable{
11 |   public:
12 |     Class(const std::string& name, std::unordered_map<std::string, std::shared_ptr<Function>> methods);
13 |     std::string name;
14 |     std::unordered_map<std::string, std::shared_ptr<Function>> methods;
15 |     std::optional<std::shared_ptr<Function>> findMethod(const std::string& l_name);
16 | 
17 |     int arity() override;
18 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
19 |     std::string toString() override;
20 | };
21 | 


--------------------------------------------------------------------------------
/src/utils/Helpers.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | 
 6 | class Helpers {
 7 |   private:
 8 |     int size;
 9 |     std::vector<std::string> args;
10 |     Helpers() = default;
11 | 
12 |   public:
13 |     static Helpers& get_instance() {
14 |       static Helpers instance;
15 |       return instance;
16 |     }
17 | 
18 |     void set_args(const int& new_size, const std::vector<std::string>& new_args) {
19 |       this->size = new_size;
20 |       this->args = new_args;
21 |     }
22 | 
23 |     std::vector<std::string> get_args(){
24 |       return this->args;
25 |     }
26 | 
27 |     Helpers(const Helpers&) = delete;
28 |     void operator=(const Helpers&) = delete;
29 | };
30 | 
31 | 


--------------------------------------------------------------------------------
/src/interpreter/Environment.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | #include <any>
 5 | #include <memory>
 6 | 
 7 | #include "../tokenizer/Token.hpp"
 8 | 
 9 | class Env : public std::enable_shared_from_this<Env> {
10 |   private:
11 |     std::shared_ptr<Env> enclosing;
12 |     std::unordered_map<std::string, std::any> values;
13 | 
14 |   public:
15 |     Env();
16 |     Env(std::shared_ptr<Env> enclosing);
17 |     void define(const std::string& name, std::any value);
18 |     std::any get(const Token& name);
19 |     void assign(const Token& name, std::any value);
20 |     std::any getAt(int distance, const std::string& name);
21 |     void assignAt(int distance, Token& name, std::any value);
22 |     std::shared_ptr<Env> anchestor(int distance);
23 | };
24 | 


--------------------------------------------------------------------------------
/debug.ter:
--------------------------------------------------------------------------------
 1 | auto compiler = "clang++ -stdlib=libc++"
 2 | auto add_flags = "-O0 -fno-omit-frame-pointer -Wsign-conversion -Wnull-dereference -Wdouble-promotion -Wformat=2 -Wcast-align -Wconversion"
 3 | auto sanitize = "-fsanitize=undefined -fsanitize=leak"
 4 | auto flags = "-g -Wall -Werror -Wextra -Wshadow -Wpedantic -fsanitize=address"
 5 | auto build = compiler + " " + add_flags + " " + sanitize + " " + " " + flags + " ./src/*.cpp"
 6 | 
 7 | output(build)
 8 | exec(build)
 9 | /*
10 | 
11 | Compile all:
12 | 
13 | clang++ -stdlib=libc++ -O0 -fno-omit-frame-pointer -Wsign-conversion -Wnull-dereference -Wdouble-promotion -Wformat=2 -Wcast-align -Wconversion -fsanitize=undefined -fsanitize=leak -g -Wall -Werror -Wextra -Wshadow -Wpedantic -fsanitize=address $(find src -name '*.cpp')
14 | 
15 | */
16 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.25.0)
 2 | 
 3 | set (CMAKE_CXX_STANDARD 23)
 4 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -ffast-math")
 5 | 
 6 | project(Terlang
 7 |   LANGUAGES CXX
 8 |   VERSION 0.0.1
 9 | )
10 | 
11 | add_executable(ter src/main.cpp src/Ter.cpp)
12 | 
13 | # Add sources by module
14 | function(add_sources module)
15 |     file(GLOB sources "src/${module}/*.cpp")
16 |     target_sources(ter PRIVATE ${sources})
17 | endfunction()
18 | 
19 | add_sources(tokenizer)
20 | add_sources(utils)
21 | add_sources(interpreter)
22 | add_sources(parser)
23 | 
24 | install(TARGETS ter DESTINATION bin)
25 | 
26 | add_custom_target("uninstall" COMMENT "Uninstall installed files")
27 | add_custom_command(
28 |     TARGET "uninstall"
29 |     POST_BUILD
30 |     COMMENT "Uninstall files with install_manifest.txt"
31 |     COMMAND xargs rm -vf < install_manifest.txt || echo Nothing in
32 |             install_manifest.txt to be uninstalled!
33 | )
34 | 


--------------------------------------------------------------------------------
/src/tokenizer/Token.cpp:
--------------------------------------------------------------------------------
 1 | #include "Token.hpp"
 2 | #include <sstream>
 3 | 
 4 | Token::Token(TokenType type, std::string lexeme, std::any literal, int line) : 
 5 |   type(type), lexeme(lexeme), literal(literal), line(line) {}
 6 | 
 7 | std::string Token::toString(){
 8 |   std::stringstream ss_literal;
 9 |   if(literal.has_value()){
10 |     const std::type_info& type_any = literal.type();
11 | 
12 |     if(type_any == typeid(std::string)){
13 |       ss_literal << std::any_cast<std::string>(literal);
14 |     }else if(type_any == typeid(int)){
15 |       ss_literal << std::any_cast<int>(literal);
16 |     }else if(type_any == typeid(double)){
17 |       ss_literal << std::any_cast<double>(literal);
18 |     }else{
19 |       ss_literal << "null";
20 |     }
21 |   }else{
22 |     ss_literal << "[no literal]";
23 |   }
24 |   return lexeme + " " + ss_literal.str();
25 | }
26 | 
27 | bool Token::operator <(const Token& obj) const{
28 |   return obj.lexeme < this->lexeme;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/interpreter/Class.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "Class.hpp"
 4 | #include "Instance.hpp"
 5 | #include "Interpreter.hpp"
 6 | 
 7 | Class::Class(const std::string& name, std::unordered_map<std::string, std::shared_ptr<Function>> methods) :
 8 |   name(name), methods(methods) {}
 9 | 
10 | std::any Class::call(Interpreter &interpreter, std::vector<std::any> arguments){
11 |   if(arguments.size() == 0 && interpreter.global != nullptr){
12 |     std::cout << "<call from class>\n";
13 |   }
14 | 
15 |   auto instance = std::make_shared<Instance>(std::make_shared<Class>(*this));
16 |   return instance;
17 | }
18 | 
19 | std::string Class::toString(){
20 |   return "<class " + this->name + ">";
21 | }
22 | 
23 | int Class::arity(){
24 |   return 0;
25 | }
26 | 
27 | std::optional<std::shared_ptr<Function>> Class::findMethod(const std::string& l_name) {
28 |   auto it = methods.find(l_name);
29 |   if(it != methods.end()){
30 |     return it->second;
31 |   }
32 |   return std::nullopt;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/utils/Debug.cpp:
--------------------------------------------------------------------------------
 1 | #include "Debug.hpp"
 2 | #include <iostream>
 3 | 
 4 | void Debug::report(int line, const std::string& where, const std::string& message){
 5 |   hadError = true;
 6 |   //std::cerr << "[" + Debug::filename + "] " << "error: line: " << line << where << ": " << message << '\n';
 7 |   std::cerr << "error: line: " << line << where << ": " << message << '\n';
 8 | } 
 9 | 
10 | void Debug::error(int line, const std::string& message){
11 |   report(line, "", message);
12 | }
13 | 
14 | void Debug::error(Token token, const std::string& message){
15 |   if(token.type == TokenType::TER_EOF){
16 |     report(token.line, " at end ", message);
17 |   }else{
18 |     report(token.line, " at " + token.lexeme, message);
19 |   }
20 | }
21 | 
22 | void Debug::runtimeError(const RuntimeError& error){
23 |   //std::cerr << "[" + Debug::filename + "] " << "[line " << error.token.line << "] Error: " << error.what() << '\n';
24 |   std::cerr << "[line " << error.token.line << "] Error: " << error.what() << '\n';
25 | }
26 | 


--------------------------------------------------------------------------------
/src/interpreter/Function.cpp:
--------------------------------------------------------------------------------
 1 | #include "Function.hpp"
 2 | #include "Interpreter.hpp"
 3 | 
 4 | Function::Function(std::shared_ptr<Statement::Function> declaration,
 5 |     std::shared_ptr<Env> closure) : declaration{std::move(declaration)},
 6 |     closure{std::move(closure)} {}
 7 | 
 8 | int Function::arity(){
 9 |   return static_cast<int>(declaration->params.size());
10 | }
11 | 
12 | std::any Function::call(Interpreter &interpreter, std::vector<std::any> arguments){
13 |   auto newEnv = std::make_shared<Env>(closure.lock());
14 |   int size = static_cast<int>(declaration->params.size());
15 |   for(int i = 0; i < size; i++){
16 |     newEnv->define(declaration->params[static_cast<size_t>(i)].lexeme, arguments[static_cast<size_t>(i)]);
17 |   }
18 | 
19 |   try {
20 |     interpreter.executeBlock(declaration->body, newEnv);
21 |   } catch (Return returnObject) {
22 |     return returnObject.value;
23 |   }
24 |   return nullptr;
25 | }
26 | 
27 | std::string Function::toString(){
28 |   return "<function " + declaration->name.lexeme + ">";
29 | }
30 | 


--------------------------------------------------------------------------------
/src/interpreter/Instance.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "Instance.hpp"
 4 | #include "../utils/RuntimeError.hpp"
 5 | #include "Class.hpp"
 6 | 
 7 | Instance::Instance(std::shared_ptr<Class> klass) : klass{std::move(klass)} {}
 8 | 
 9 | std::string Instance::toString(){
10 |   return "<" + klass->name + " class instance>";
11 | }
12 | 
13 | std::any Instance::get(const Token& name){
14 |   if(fields.find(name.lexeme) != fields.end()){
15 |     return fields[name.lexeme];
16 |   }
17 | 
18 |   auto method = klass->findMethod(name.lexeme);
19 |   if(method.has_value()){
20 |     return method.value();
21 |   }
22 | 
23 |   throw RuntimeError(name, "Undefinied property '" + name.lexeme + "'.");
24 | }
25 | 
26 | void Instance::set(const Token& name, std::any value){
27 |   fields[name.lexeme] = std::move(value);
28 | }
29 | 
30 | int Instance::arity(){
31 |   return 0;
32 | }
33 | 
34 | std::any Instance::call(Interpreter &interpreter, std::vector<std::any> arguments){
35 |   if(arguments.size() == 0 && interpreter.global != nullptr){
36 |     std::cout << "<call from class instance>\n";
37 |   }
38 |   return {};
39 | }
40 | 
41 | 
42 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "Ter.hpp"
 4 | #include "utils/Helpers.hpp"
 5 | 
 6 | void help(const std::string& prog){
 7 |   std::cerr << "Ter/Terlang v0.1.6\n\n";
 8 |   std::cerr << "Usage: \n\t" <<
 9 |     prog << " [filename].ter\n\t" << 
10 |     prog << " -e '<script>'\n";
11 | }
12 | 
13 | int main(int argc, char **argv){
14 | 
15 |   if(argc >= 2){
16 |     std::vector<std::string> args;
17 |     for(int i = 0; i < argc; ++i){
18 |       args.emplace_back(argv[i]);
19 |     }
20 | 
21 |     Helpers::get_instance().set_args(argc, args);
22 | 
23 |     const std::string arg1 = argv[1];
24 | 
25 |     if(arg1 == "-e"){
26 |       if(argc != 3 || std::string(argv[2]).empty()) {
27 |         std::cerr << "Error: Missing script argument after -e\n";
28 |         return EXIT_FAILURE;
29 |       }
30 |       Ter::run_script(argv[2]);
31 |       return EXIT_SUCCESS;
32 |     }
33 | 
34 |     const std::string filename = argv[1];
35 |     const std::string hext = "\x2e\x74\x65\x72";
36 | 
37 |     if(filename.length() >= 4 && filename.substr(filename.length() - 4) == hext){
38 |       Ter::run_file(argv[1]);
39 |       return EXIT_SUCCESS;
40 |     }
41 | 
42 |     help(argv[0]);
43 |     return EXIT_FAILURE;
44 |   }
45 | 
46 |   Ter::repl();
47 |   return EXIT_SUCCESS;
48 | }
49 | 
50 | 


--------------------------------------------------------------------------------
/src/interpreter/BuiltinFactory.cpp:
--------------------------------------------------------------------------------
 1 | #include "BuiltinFactory.hpp"
 2 | #include "Builtin.hpp"
 3 | 
 4 | // Map to store built-in function factories
 5 | std::unordered_map<std::type_index, std::function<std::shared_ptr<Callable>()>> builtinFactory = {
 6 |     {typeid(std::shared_ptr<Clock>), [](){ return std::make_shared<Clock>(); }},
 7 |     {typeid(std::shared_ptr<Rand>), [](){ return std::make_shared<Rand>(); }},
 8 |     {typeid(std::shared_ptr<GetEnv>), [](){ return std::make_shared<GetEnv>(); }},
 9 |     {typeid(std::shared_ptr<ToString>), [](){ return std::make_shared<ToString>(); }},
10 |     {typeid(std::shared_ptr<Args>), [](){ return std::make_shared<Args>(); }},
11 |     {typeid(std::shared_ptr<Exec>), [](){ return std::make_shared<Exec>(); }},
12 |     {typeid(std::shared_ptr<Input>), [](){ return std::make_shared<Input>(); }}
13 | };
14 | 
15 | // Map of built-in function names
16 | std::unordered_map<std::string, std::type_index> builtinNames = {
17 |     {"clock", typeid(std::shared_ptr<Clock>)},
18 |     {"rand", typeid(std::shared_ptr<Rand>)},
19 |     {"getenv", typeid(std::shared_ptr<GetEnv>)},
20 |     {"to_string", typeid(std::shared_ptr<ToString>)},
21 |     {"args", typeid(std::shared_ptr<Args>)},
22 |     {"exec", typeid(std::shared_ptr<Exec>)},
23 |     {"input", typeid(std::shared_ptr<Input>)}
24 | };
25 | 


--------------------------------------------------------------------------------
/src/parser/IncludeRun.cpp:
--------------------------------------------------------------------------------
 1 | #include <filesystem>
 2 | #include <fstream>
 3 | #include <algorithm>
 4 | #include <iostream>
 5 | 
 6 | #include "IncludeRun.hpp"
 7 | #include "../utils/Debug.hpp"
 8 | #include "../tokenizer/Scanner.hpp"
 9 | 
10 | namespace fs = std::filesystem;
11 | 
12 | std::vector<Token> IncludeRun::tokens;
13 | 
14 | void IncludeRun::scanFile(std::string path){
15 |   path.erase(remove( path.begin(), path.end(), '\"' ),path.end());
16 |   Debug::filename = path;
17 | 
18 |   if(!fs::exists(path)){
19 |     std::cerr << "File '" << path << "' not found.\n";
20 |     std::exit(66);
21 |   }
22 | 
23 |   std::ifstream file(path, std::ios::binary | std::ios::ate);
24 |   if(!file){
25 |     std::cerr << "Permission error opening file.\n";
26 |     std::exit(66);
27 |   }
28 | 
29 |   std::streamsize size = file.tellg();
30 |   file.seekg(0, std::ios::beg);
31 |   std::vector<char> buffer(static_cast<size_t>(size));
32 | 
33 |   if(!file.read(buffer.data(), size)){
34 |     std::cerr << "Error reading file.\n";
35 |     std::exit(77);
36 |   }
37 | 
38 |   std::string content(buffer.begin(), buffer.end());
39 |   run(content);
40 |   if(Debug::hadError){ std::exit(65); }
41 |   if(Debug::hadRuntimeError){ std::exit(70); }
42 | }
43 | 
44 | void IncludeRun::run(const std::string& source){
45 |   Scanner scanner(source);
46 |   IncludeRun::tokens = scanner.scanTokens();
47 |   if(Debug::hadError){ return; }
48 | }
49 | 
50 | 
51 | std::vector<Token> IncludeRun::getTokens(){
52 |   return IncludeRun::tokens;
53 | }
54 | 


--------------------------------------------------------------------------------
/src/tokenizer/Scanner.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <unordered_map>
 5 | #include "Token.hpp"
 6 | 
 7 | class Scanner {
 8 |   private:
 9 |     int start = 0;
10 |     int current = 0;
11 |     int line = 1;
12 |     std::string source;
13 |     std::vector<Token> tokens;
14 |     std::unordered_map<std::string, TokenType> keywords = {
15 |       {"include",TokenType::INCLUDE},
16 |       {"and",    TokenType::AND},
17 |       {"class",  TokenType::CLASS},
18 |       {"else",   TokenType::ELSE},
19 |       {"false",  TokenType::FALSE},
20 |       {"for",    TokenType::FOR},
21 |       {"set",    TokenType::SET},
22 |       {"if",     TokenType::IF},
23 |       {"nil",    TokenType::NIL},
24 |       {"or",     TokenType::OR},
25 |       {"out",     TokenType::OUT},
26 |       {"output",  TokenType::OUTPUT},
27 |       {"return", TokenType::RETURN},
28 |       {"super",  TokenType::SUPER},
29 |       {"this",   TokenType::THIS},
30 |       {"true",   TokenType::TRUE},
31 |       {"auto",    TokenType::AUTO},
32 |       {"while",  TokenType::WHILE}
33 |     };
34 | 
35 |     bool isAlpha(char c);
36 |     bool isDigit(char c);
37 |     bool isAlphaNumeric(char c);
38 |     bool match(char expected);
39 |     void scanToken();
40 |     char advance();
41 |     void addToken(TokenType type);
42 |     void addToken(TokenType type, std::any literal);
43 |     char peek();
44 |     char peekNext();
45 |     void string();
46 |     void number();
47 |     void identifier();
48 | 
49 |   public:
50 |     Scanner(const std::string&);
51 |     bool isAtEnd();
52 |     std::vector<Token> scanTokens();
53 | };
54 | 


--------------------------------------------------------------------------------
/src/interpreter/Builtin.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Callable.hpp"
 3 | #include "Interpreter.hpp"
 4 | 
 5 | class Clock : public Callable {
 6 |   public:
 7 |     int arity() override;
 8 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
 9 |     std::string toString() override;
10 | };
11 | 
12 | class Rand : public Callable {
13 |   public:
14 |     int arity() override;
15 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
16 |     std::string toString() override;
17 | };
18 | 
19 | class GetEnv : public Callable {
20 |   public:
21 |     int arity() override;
22 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
23 |     std::string toString() override;
24 | };
25 | 
26 | class ToString : public Callable {
27 |   public:
28 |     int arity() override;
29 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
30 |     std::string toString() override;
31 | };
32 | 
33 | class Args : public Callable {
34 |   public:
35 |     int arity() override;
36 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
37 |     std::string toString() override;
38 | };
39 | 
40 | class Exec : public Callable {
41 |   public:
42 |     int arity() override;
43 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
44 |     std::string toString() override;
45 | };
46 | 
47 | class Input : public Callable {
48 |   public:
49 |     int arity() override;
50 |     std::any call(Interpreter &interpreter, std::vector<std::any> arguments) override;
51 |     std::string toString() override;
52 | };
53 | 


--------------------------------------------------------------------------------
/src/interpreter/Environment.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "Environment.hpp"
 4 | #include "../utils/RuntimeError.hpp"
 5 | 
 6 | Env::Env() : enclosing{nullptr} {}
 7 | 
 8 | Env::Env(std::shared_ptr<Env> enclosing ) : enclosing{std::move(enclosing)} {}
 9 | 
10 | void Env::define(const std::string& name, std::any value){
11 |   auto elem = values.find(name);
12 |   if(elem != values.end()){
13 |     std::cerr << "[Error]: the name '" + name + "' for identifier was repeated.\n";
14 |     std::exit(65);
15 |   }
16 | 
17 |   values[name] = std::move(value);
18 | }
19 | 
20 | std::any Env::get(const Token& name){
21 |   auto elem = values.find(name.lexeme);
22 |   if(elem != values.end()){
23 |     return elem->second;
24 |   }
25 | 
26 |   if(enclosing != nullptr){
27 |     return enclosing->get(name);
28 |   }
29 | 
30 |   throw RuntimeError(name, "Undefined variable: '" + name.lexeme + "'.");
31 | }
32 | 
33 | 
34 | void Env::assign(const Token& name, std::any value){
35 |   auto elem = values.find(name.lexeme);
36 |   if(elem != values.end()){
37 |     elem->second = std::move(value);
38 |     return;
39 |   }
40 | 
41 |   if(enclosing != nullptr){
42 |     return enclosing->assign(name, std::move(value));
43 |   }
44 | 
45 |   throw RuntimeError(name, "Undefined variable: '" + name.lexeme + "'.");
46 | }
47 | 
48 | std::any Env::getAt(int distance, const std::string& name){
49 |   return anchestor(distance)->values[name];
50 | }
51 | 
52 | void Env::assignAt(int distance, Token& name, std::any value){
53 |   anchestor(distance)->values[name.lexeme] = std::move(value);
54 | }
55 | 
56 | std::shared_ptr<Env> Env::anchestor(int distance){
57 |   std::shared_ptr<Env> currentEnv = shared_from_this();
58 |   for(int i = 0; i < distance; i++){
59 |     currentEnv = currentEnv->enclosing;
60 |   }
61 |   return currentEnv;
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | TERLANG="../build/ter"
 4 | if [ ! -f "$TERLANG" ]; then
 5 |     echo "Error: terlang interpreter not found at $TERLANG"
 6 |     echo "Please build the project first"
 7 |     exit 1
 8 | fi
 9 | 
10 | total_tests=0
11 | passed_tests=0
12 | failed_tests=0
13 | 
14 | echo "Running tests..."
15 | echo "----------------"
16 | 
17 | for ter_file in *.ter; do
18 |     # Only if there is no .ter files
19 |     [ -f "$ter_file" ] || continue
20 | 
21 |     ((total_tests++))
22 | 
23 |     out_file="${ter_file}.result"
24 |     arg_file="${ter_file}.args"
25 |     err_file="${ter_file}.error"
26 | 
27 |     # Run the test and capture output
28 |     if [ ! -f "$arg_file" ]; then
29 |         actual_output=$($TERLANG "$ter_file" 2>&1)
30 |     else
31 |         actual_output=$($TERLANG "$ter_file" $(cat "$arg_file") 2>&1)
32 |     fi
33 |     exit_code=$?
34 |     actual_output_escaped=$(echo -n "$actual_output" | sed ':a;N;$!ba;s/\n/\\n/g')
35 | 
36 |     # Prepare expected output
37 |     expected_output=""
38 |     if [ -f "$out_file" ]; then
39 |         expected_output+=$(cat "$out_file" | sed ':a;N;$!ba;s/\n/\\n/g')
40 |     fi
41 |     if [ -f "$err_file" ]; then
42 |         expected_output+=$(cat "$err_file" | sed ':a;N;$!ba;s/\n/\\n/g')
43 |     fi
44 |     
45 |     # Compare actual and expected output
46 |     if [ "$exit_code" -ne 0 ] && [ ! -f "$err_file" ] ; then
47 |         echo "Error at test $ter_file (non-zero exit code: $exit_code)"
48 |         echo "Error:    '$actual_output'"
49 |         ((failed_tests++))
50 |     elif [ "$actual_output_escaped" != "$expected_output" ]; then
51 |         echo "Error at test $ter_file"
52 |         echo "Expected: '$(cat "$out_file")'"
53 |         echo "Found:    '$actual_output'"
54 |         ((failed_tests++))
55 |     else
56 |         ((passed_tests++))
57 |     fi
58 | done
59 | 
60 | echo "----------------"
61 | echo "Test summary:"
62 | echo "Total tests: $total_tests"
63 | echo "Passed:      $passed_tests"
64 | echo "Failed:      $failed_tests"
65 | 
66 | if [ "$failed_tests" -gt 0 ]; then
67 |     exit 1
68 | fi
69 | exit 0
70 | 


--------------------------------------------------------------------------------
/tests/run.bat:
--------------------------------------------------------------------------------
 1 | @echo off
 2 | setlocal enabledelayedexpansion
 3 | 
 4 | :: Bat version is simpler, it does not check exit codes.
 5 | :: Also newlines are disregarded when comparing results.
 6 | 
 7 | set TERLANG=..\build\Debug\ter.exe
 8 | if not exist "%TERLANG%" (
 9 |     echo Error: terlang interpreter not found at %TERLANG%
10 |     echo Please build the project first
11 |     exit /b 1
12 | )
13 | 
14 | set total_tests=0
15 | set passed_tests=0
16 | set failed_tests=0
17 | 
18 | echo Running tests...
19 | echo --------------------------------
20 | 
21 | for %%f in (*.ter) do (
22 |     set /a total_tests+=1
23 | 
24 |     set ter_file=%%f
25 |     set out_file=%%f.result
26 |     set arg_file=%%f.args
27 |     set err_file=%%f.error
28 | 
29 |     :: Run the test and capture output
30 |     set actual_output=
31 |     if not exist "!arg_file!" (
32 |         for /f "delims=" %%o in ('%TERLANG% "!ter_file!" 2^>^&1') do set actual_output=!actual_output!%%o
33 |     ) else (
34 |         :: set /p args=< arg_file
35 |         for /f "delims=" %%a in (!arg_file!) do set args=!args! %%a
36 |         for /f "delims=" %%o in ('%TERLANG% "!ter_file!" !args! 2^>^&1') do set actual_output=!actual_output!%%o
37 |     )
38 |     set actual_output_escaped=!actual_output!
39 | 
40 |     :: Prepare expected output
41 |     set expected_output=
42 |     if exist "!out_file!" (
43 |         for /f "delims=" %%e in (!out_file!) do set expected_output=!expected_output!%%e
44 |     )
45 |     if exist "!err_file!" (
46 |         for /f "delims=" %%e in (!err_file!) do set expected_output=!expected_output!%%e
47 |     )
48 | 
49 |     :: Compare actual and expected output
50 |     if "!actual_output_escaped!" equ "!expected_output!" (
51 |         set /a passed_tests+=1
52 |     ) else (
53 |         echo Error at test !ter_file!
54 |         echo Expected: '!expected_output!'
55 |         echo Found:    '!actual_output!'
56 |         set /a failed_tests+=1
57 |     )
58 | )
59 | 
60 | echo --------------------------------
61 | echo Test summary:
62 | echo Total tests: %total_tests%
63 | echo Passed:      %passed_tests%
64 | echo Failed:      %failed_tests%
65 | 
66 | if %failed_tests% gtr 0 (
67 |     exit /b 1
68 | )
69 | exit /b 0
70 | 


--------------------------------------------------------------------------------
/src/Ter.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <filesystem>
 3 | #include <vector>
 4 | #include <fstream>
 5 | 
 6 | #include "Ter.hpp"
 7 | #include "utils/Debug.hpp"
 8 | #include "tokenizer/Scanner.hpp"
 9 | #include "parser/Parser.hpp"
10 | #include "interpreter/Interpreter.hpp"
11 | #include "interpreter/Resolver.hpp"
12 | 
13 | namespace fs = std::filesystem;
14 | 
15 | Interpreter interpreter{};
16 | 
17 | void Ter::run_file(const std::string& path){
18 | 
19 |   Debug::filename = path;
20 | 
21 |   if(!fs::exists(path)){
22 |     std::cerr << "File not found.\n";
23 |     std::exit(66);
24 |   }
25 | 
26 |   std::ifstream file(path, std::ios::binary | std::ios::ate);
27 |   if(!file){
28 |     std::cerr << "Permission error opening file.\n";
29 |     std::exit(66);
30 |   }
31 | 
32 |   std::streamsize size = file.tellg();
33 |   file.seekg(0, std::ios::beg);
34 |   std::vector<char> buffer(static_cast<size_t>(size));
35 | 
36 |   if(!file.read(buffer.data(), size)){
37 |     std::cerr << "Error reading file.\n";
38 |     std::exit(77);
39 |   }
40 | 
41 |   std::string content(buffer.begin(), buffer.end());
42 |   run(content);
43 |   if(Debug::hadError){ std::exit(65); }
44 |   if(Debug::hadRuntimeError){ std::exit(70); }
45 | }
46 | 
47 | void Ter::repl(){
48 |   std::string line;
49 |   std::cout << "ter> ";
50 |   for(;;){
51 |     if(!std::getline(std::cin, line) || line == "exit"){
52 |       break;
53 |     }
54 |     run(line);
55 |     if(Debug::hadError){ std::exit(65); }
56 |     if(Debug::hadRuntimeError){ std::exit(70); }
57 |     std::cout << "ter> ";
58 |   }
59 | }
60 | 
61 | void Ter::run_script(const std::string& script){
62 |   run(script);
63 |   if(Debug::hadError){ std::exit(65); }
64 |   if(Debug::hadRuntimeError){ std::exit(70); }
65 | }
66 | 
67 | void Ter::run(const std::string& source){
68 |   Scanner scanner(source);
69 |   std::vector<Token> tokens = scanner.scanTokens();
70 |   if(Debug::hadError){ return; }
71 |   Debug::filename = source;
72 | 
73 |   //Parser parser{tokens};
74 |   //std::vector<std::shared_ptr<Statement::Stmt>> statements = parser.parse();
75 |   auto parser = std::make_unique<Parser>(tokens);
76 | 
77 |   std::vector<std::shared_ptr<Statement::Stmt>> statements = parser->parse();
78 |   if(Debug::hadError){ return; }
79 | 
80 |   interpreter.lateInitializator();
81 |   Resolver resolver{interpreter};
82 |   resolver.resolve(statements);
83 |   if(Debug::hadError){ return; }
84 | 
85 |   interpreter.interpret(statements);
86 |   if(Debug::hadError){ return; }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/parser/Visitor.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <any>
 4 | #include <memory>
 5 | 
 6 | struct Binary;
 7 | struct Grouping;
 8 | struct Literal;
 9 | struct Unary;
10 | struct Variable;
11 | struct Assign;
12 | struct Logical;
13 | struct Call;
14 | struct Get;
15 | struct Set;
16 | struct Array;
17 | struct Callist;
18 | 
19 | struct ExprVisitor {
20 |   virtual std::any visitBinaryExpr(std::shared_ptr<Binary> expr) = 0;
21 |   virtual std::any visitGroupingExpr(std::shared_ptr<Grouping> expr) = 0;
22 |   virtual std::any visitLiteralExpr(std::shared_ptr<Literal> expr) = 0;
23 |   virtual std::any visitUnaryExpr(std::shared_ptr<Unary> expr) = 0;
24 |   virtual std::any visitVariableExpr(std::shared_ptr<Variable> expr) = 0;
25 |   virtual std::any visitAssignExpr(std::shared_ptr<Assign> expr) = 0;
26 |   virtual std::any visitLogicalExpr(std::shared_ptr<Logical> expr) = 0;
27 |   virtual std::any visitCallExpr(std::shared_ptr<Call> expr) = 0;
28 |   virtual std::any visitGetExpr(std::shared_ptr<Get> expr) = 0;
29 |   virtual std::any visitSetExpr(std::shared_ptr<Set> expr) = 0;
30 |   virtual std::any visitArrayExpr(std::shared_ptr<Array> expr) = 0;
31 |   virtual std::any visitCallistExpr(std::shared_ptr<Callist> expr) = 0;
32 |   virtual ~ExprVisitor() = default;
33 | };
34 | 
35 | struct Expr {
36 |   virtual std::any accept(ExprVisitor &visitor) = 0;
37 | };
38 | 
39 | namespace Statement {
40 | 
41 |   struct Expression;
42 |   struct Print;
43 |   struct Out;
44 |   struct Var;
45 |   struct Block;
46 |   struct If;
47 |   struct While;
48 |   struct Function;
49 |   struct Return;
50 |   struct Class;
51 |   struct Include;
52 | 
53 |   struct StmtVisitor {
54 |     virtual std::any visitExpressionStmt(std::shared_ptr<Expression> stmt) = 0;
55 |     virtual std::any visitPrintStmt(std::shared_ptr<Print> stmt) = 0;
56 |     virtual std::any visitOutStmt(std::shared_ptr<Out> stmt) = 0;
57 |     virtual std::any visitVarStmt(std::shared_ptr<Var> stmt) = 0;
58 |     virtual std::any visitBlockStmt(std::shared_ptr<Block> stmt) = 0;
59 |     virtual std::any visitIfStmt(std::shared_ptr<If> stmt) = 0;
60 |     virtual std::any visitWhileStmt(std::shared_ptr<While> stmt) = 0;
61 |     virtual std::any visitFunctionStmt(std::shared_ptr<Function> stmt) = 0;
62 |     virtual std::any visitReturnStmt(std::shared_ptr<Return> stmt) = 0;
63 |     virtual std::any visitClassStmt(std::shared_ptr<Class> stmt) = 0;
64 |     virtual std::any visitIncludeStmt(std::shared_ptr<Include> stmt) = 0;
65 |     virtual ~StmtVisitor() = default;
66 |   };
67 | 
68 |   struct Stmt {
69 |     virtual std::any accept(StmtVisitor& visitor) = 0;
70 |   };
71 | }
72 | 


--------------------------------------------------------------------------------
/src/parser/Parser.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <vector>
 5 | #include <stdexcept>
 6 | 
 7 | #include "../tokenizer/Token.hpp"
 8 | #include "Visitor.hpp"
 9 | 
10 | class Parser {
11 |   private:
12 |     struct ParseError : public std::runtime_error {
13 |       using std::runtime_error::runtime_error;
14 |     };
15 | 
16 |     //const std::vector<Token> tokens;
17 |     std::vector<Token> tokens;
18 |     int current = 0;
19 |     std::vector<std::shared_ptr<Statement::Stmt>> statements;
20 |     std::vector<std::string> includedFiles;
21 | 
22 |     ParseError error(const Token&, const std::string&);
23 | 
24 |     void synchronize();
25 | 
26 |     bool isAtEnd();
27 |     bool check(const TokenType&);
28 |     template<class...T>
29 |     bool match(T...types);
30 | 
31 |     template<class...T>
32 |     void matchVoid(T...types);
33 | 
34 |     Token previous();
35 |     Token peek();
36 |     Token advance();
37 |     Token consume(const TokenType&, const std::string&);
38 | 
39 |     std::shared_ptr<Expr> expression();
40 |     std::shared_ptr<Expr> bitwise();
41 |     std::shared_ptr<Expr> equality();
42 |     std::shared_ptr<Expr> comparison();
43 |     std::shared_ptr<Expr> shift();
44 |     std::shared_ptr<Expr> term();
45 |     std::shared_ptr<Expr> factor();
46 |     std::shared_ptr<Expr> unary();
47 |     std::shared_ptr<Expr> primary();
48 |     std::shared_ptr<Expr> assignment();
49 |     std::shared_ptr<Expr> logicalOr();
50 |     std::shared_ptr<Expr> logicalAnd();
51 |     std::shared_ptr<Expr> call();
52 |     std::shared_ptr<Expr> finishCall(std::shared_ptr<Expr> callee);
53 |     std::shared_ptr<Expr> arrayList();
54 |     std::shared_ptr<Expr> callist();
55 |     std::shared_ptr<Expr> finishCallist(std::shared_ptr<Expr> name);
56 | 
57 |     std::shared_ptr<Statement::Stmt> statement();
58 |     std::shared_ptr<Statement::Stmt> printStatement();
59 |     std::shared_ptr<Statement::Stmt> outStatement();
60 |     std::shared_ptr<Statement::Stmt> expressionStatement();
61 |     std::shared_ptr<Statement::Stmt> declaration();
62 |     std::shared_ptr<Statement::Stmt> varDeclaration();
63 |     std::vector<std::shared_ptr<Statement::Stmt>> block();
64 |     std::shared_ptr<Statement::Stmt> IfStatement();
65 |     std::shared_ptr<Statement::Stmt> whileStatement();
66 |     std::shared_ptr<Statement::Stmt> forStatement();
67 |     std::shared_ptr<Statement::Stmt> returnStatement();
68 |     std::shared_ptr<Statement::Stmt> classDeclaration();
69 |     std::shared_ptr<Statement::Stmt> includeStatement();
70 | 
71 |     std::shared_ptr<Statement::Function> function(std::string kind);
72 | 
73 |   public:
74 |     Parser(const std::vector<Token>&);
75 |     std::vector<std::shared_ptr<Statement::Stmt>> parse();
76 | };
77 | 


--------------------------------------------------------------------------------
/src/interpreter/Resolver.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <map>
 5 | #include "Interpreter.hpp"
 6 | 
 7 | class Resolver : public ExprVisitor, public Statement::StmtVisitor {
 8 | 
 9 |   private:
10 |     Interpreter& interpreter;
11 |     std::vector<std::map<std::string, bool>> scopes;
12 |     std::vector<std::map<Token, int>> identifiers; 
13 |     enum class FType{
14 |       NONE,
15 |       FUNCTION,
16 |       METHOD
17 |     };
18 | 
19 |     FType currentFunction = FType::NONE;
20 | 
21 |     void resolve(std::shared_ptr<Statement::Stmt> statement);
22 |     void resolve(std::shared_ptr<Expr> expression);
23 |     void beginScope();
24 |     void endScope();
25 |     void declare(Token& name);
26 |     void define(Token& name);
27 |     void resolveLocal(std::shared_ptr<Expr> expr, Token& name);
28 |     void resolveFunction(std::vector<Token> params, std::vector<std::shared_ptr<Statement::Stmt>> body, FType type);
29 | 
30 |   public:
31 |     Resolver(Interpreter &interpreter);
32 |     void resolve(std::vector<std::shared_ptr<Statement::Stmt>> &statements);
33 |     std::any visitBinaryExpr(std::shared_ptr<Binary> expr) override;
34 |     std::any visitGroupingExpr(std::shared_ptr<Grouping> expr) override;
35 |     std::any visitLiteralExpr(std::shared_ptr<Literal> expr) override;
36 |     std::any visitUnaryExpr(std::shared_ptr<Unary> expr) override;
37 |     std::any visitExpressionStmt(std::shared_ptr<Statement::Expression> stmt) override;
38 |     
39 |     std::any visitPrintStmt(std::shared_ptr<Statement::Print> stmt) override;   
40 |     std::any visitOutStmt(std::shared_ptr<Statement::Out> stmt) override;   
41 | 
42 |     std::any visitVariableExpr(std::shared_ptr<Variable> expr) override;
43 |     std::any visitAssignExpr(std::shared_ptr<Assign> expr) override;
44 |     std::any visitLogicalExpr(std::shared_ptr<Logical> expr) override;
45 |     std::any visitCallExpr(std::shared_ptr<Call> expr) override;
46 |     std::any visitVarStmt(std::shared_ptr<Statement::Var> stmt) override;
47 |     std::any visitBlockStmt(std::shared_ptr<Statement::Block> stmt) override;
48 |     std::any visitIfStmt(std::shared_ptr<Statement::If> stmt) override;
49 |     std::any visitWhileStmt(std::shared_ptr<Statement::While> stmt) override;
50 |     std::any visitFunctionStmt(std::shared_ptr<Statement::Function> stmt) override;
51 |     std::any visitReturnStmt(std::shared_ptr<Statement::Return> stmt) override;
52 |     std::any visitClassStmt(std::shared_ptr<Statement::Class> stmt) override;
53 |     std::any visitIncludeStmt(std::shared_ptr<Statement::Include> stmt) override;
54 |     std::any visitGetExpr(std::shared_ptr<Get> expr) override;
55 |     std::any visitSetExpr(std::shared_ptr<Set> expr) override;
56 |     std::any visitArrayExpr(std::shared_ptr<Array> expr) override;
57 |     std::any visitCallistExpr(std::shared_ptr<Callist> expr) override;
58 | };
59 | 


--------------------------------------------------------------------------------
/src/parser/Stmt.cpp:
--------------------------------------------------------------------------------
 1 | #include "Stmt.hpp"
 2 | 
 3 | namespace Statement {
 4 |   Expression::Expression(std::shared_ptr<Expr> expression) : expression(expression) {}
 5 | 
 6 |   std::any Expression::accept(StmtVisitor& visitor){
 7 |     return visitor.visitExpressionStmt(shared_from_this());
 8 |   }
 9 | 
10 |   Print::Print(std::shared_ptr<Expr> expression) : expression(expression) {}
11 | 
12 |   std::any Print::accept(StmtVisitor& visitor){
13 |     return visitor.visitPrintStmt(shared_from_this());
14 |   }
15 | 
16 |   Out::Out(std::shared_ptr<Expr> expression) : expression(expression) {}
17 | 
18 |   std::any Out::accept(StmtVisitor& visitor){
19 |     return visitor.visitOutStmt(shared_from_this());
20 |   }
21 | 
22 |   Var::Var(Token name, std::shared_ptr<Expr> init) : name(name), init(init) {}
23 | 
24 |   std::any Var::accept(StmtVisitor &visitor){
25 |     return visitor.visitVarStmt(shared_from_this());
26 |   }
27 | 
28 |   Block::Block(std::vector<std::shared_ptr<Stmt>> statements) : statements(statements) {}
29 | 
30 |   std::any Block::accept(StmtVisitor &visitor){
31 |     return visitor.visitBlockStmt(shared_from_this());
32 |   }
33 | 
34 |   If::If(std::shared_ptr<Expr> condition, std::shared_ptr<Stmt> thenBranch,
35 |       std::shared_ptr<Stmt> elseBranch) : condition{std::move(condition)},
36 |     thenBranch{std::move(thenBranch)}, elseBranch{std::move(elseBranch)} {}
37 | 
38 |   std::any If::accept(StmtVisitor &visitor){
39 |     return visitor.visitIfStmt(shared_from_this());
40 |   }
41 | 
42 |   While::While(std::shared_ptr<Expr> condition, std::shared_ptr<Stmt> body) :
43 |     condition{std::move(condition)}, body{std::move(body)} {}
44 | 
45 |   std::any While::accept(StmtVisitor &visitor){
46 |     return visitor.visitWhileStmt(shared_from_this());
47 |   }
48 | 
49 | 
50 |   Function::Function(Token name, 
51 |       std::vector<Token> params, 
52 |       std::vector<std::shared_ptr<Stmt>> body) :
53 |     name{std::move(name)},
54 |     params{std::move(params)},
55 |     body{std::move(body)} {}
56 | 
57 |   std::any Function::accept(StmtVisitor &visitor){
58 |     return visitor.visitFunctionStmt(shared_from_this());
59 |   }
60 | 
61 |   Return:: Return(Token keyword, std::shared_ptr<Expr> value) :
62 |     keyword{std::move(keyword)}, value{std::move(value)} {}
63 | 
64 |   std::any Return::accept(StmtVisitor &visitor){
65 |     return visitor.visitReturnStmt(shared_from_this());
66 |   }
67 | 
68 | 
69 |   Class::Class(Token name, std::vector<std::shared_ptr<Function>> methods) :
70 |     name(name), methods(methods) {}
71 | 
72 |   std::any Class::accept(StmtVisitor &visitor){
73 |     return visitor.visitClassStmt(shared_from_this());
74 |   }
75 | 
76 |   Include::Include(Token keyword, std::string path) : 
77 |     keyword{std::move(keyword)}, path{std::move(path)} {}
78 | 
79 |   std::any Include::accept(StmtVisitor &visitor){
80 |     return visitor.visitIncludeStmt(shared_from_this());
81 |   }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/interpreter/Interpreter.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <unordered_map>
 5 | 
 6 | #include "Environment.hpp"
 7 | #include "../parser/Stmt.hpp"
 8 | 
 9 | struct Return {
10 |   std::any value;
11 | };
12 | 
13 | class Interpreter : public ExprVisitor, public Statement::StmtVisitor {
14 |   public:
15 |     void lateInitializator();
16 |     std::any visitBinaryExpr(std::shared_ptr<Binary> expr) override;
17 |     std::any visitGroupingExpr(std::shared_ptr<Grouping> expr) override;
18 |     std::any visitLiteralExpr(std::shared_ptr<Literal> expr) override;
19 |     std::any visitUnaryExpr(std::shared_ptr<Unary> expr) override;
20 |     Interpreter();
21 |     void interpret(std::vector<std::shared_ptr<Statement::Stmt>> &statements);
22 |     void execute(std::shared_ptr<Statement::Stmt> statement);
23 |     void executeBlock(const std::vector<std::shared_ptr<Statement::Stmt>> &statements, std::shared_ptr<Env> new_env);
24 |     void resolve(std::shared_ptr<Expr> expr, int depth);
25 | 
26 |     std::any visitExpressionStmt(std::shared_ptr<Statement::Expression> stmt) override;
27 |     std::any visitPrintStmt(std::shared_ptr<Statement::Print> stmt) override;   
28 |     std::any visitOutStmt(std::shared_ptr<Statement::Out> stmt) override;   
29 | 
30 |     std::any visitVariableExpr(std::shared_ptr<Variable> expr) override;
31 |     std::any visitAssignExpr(std::shared_ptr<Assign> expr) override;
32 |     std::any visitLogicalExpr(std::shared_ptr<Logical> expr) override;
33 |     std::any visitCallExpr(std::shared_ptr<Call> expr) override;
34 |     std::any visitGetExpr(std::shared_ptr<Get> expr) override;
35 |     std::any visitSetExpr(std::shared_ptr<Set> expr) override;
36 |     std::any visitArrayExpr(std::shared_ptr<Array> expr) override;
37 |     std::any visitCallistExpr(std::shared_ptr<Callist> expr) override;
38 | 
39 |     std::any visitVarStmt(std::shared_ptr<Statement::Var> stmt) override;
40 |     std::any visitBlockStmt(std::shared_ptr<Statement::Block> stmt) override;
41 |     std::any visitIfStmt(std::shared_ptr<Statement::If> stmt) override;
42 |     std::any visitWhileStmt(std::shared_ptr<Statement::While> stmt) override;
43 |     std::any visitFunctionStmt(std::shared_ptr<Statement::Function> stmt) override;
44 |     std::any visitReturnStmt(std::shared_ptr<Statement::Return> stmt) override;
45 |     std::any visitClassStmt(std::shared_ptr<Statement::Class> stmt) override;
46 |     std::any visitIncludeStmt(std::shared_ptr<Statement::Include> stmt) override;
47 | 
48 |     std::shared_ptr<Env> global = std::make_shared<Env>();
49 | 
50 |   private:
51 |     void checkNumberOperand(const Token& oper, const std::any& operand);
52 |     void checkNumberOperands(const Token& oper, const std::any& left, const std::any& right);
53 |     int64_t doubleToInt(const Token& oper, const std::any& value);
54 |     bool isTruthy(const std::any& object);
55 |     bool isEqual(const std::any& a, const std::any& b);
56 |     std::string stringify(const std::any& object);
57 |     std::any evaluate(std::shared_ptr<Expr> expr);
58 | 
59 |     std::unordered_map<std::shared_ptr<Expr>, int> locals;
60 |     std::shared_ptr<Env> curr_env = global;
61 |     std::any lookUpVariable(Token& name, std::shared_ptr<Expr> expr);
62 | };
63 | 
64 | 


--------------------------------------------------------------------------------
/src/parser/Expr.cpp:
--------------------------------------------------------------------------------
 1 | #include "Expr.hpp"
 2 | 
 3 | Binary::Binary(std::shared_ptr<Expr> left, Token oper, std::shared_ptr<Expr> right) : 
 4 |   left{std::move(left)}, oper{std::move(oper)}, right{std::move(right)} {}
 5 | 
 6 | std::any Binary::accept(ExprVisitor &visitor){
 7 |   return visitor.visitBinaryExpr(shared_from_this());
 8 | }
 9 | 
10 | Grouping::Grouping(std::shared_ptr<Expr> expression) :
11 |   expression{std::move(expression)} {}
12 | 
13 | std::any Grouping::accept(ExprVisitor &visitor){
14 |   return visitor.visitGroupingExpr(shared_from_this());
15 | }
16 | 
17 | Literal::Literal(std::any value) : 
18 |   value{std::move(value)} {}
19 | 
20 | std::any Literal::accept(ExprVisitor &visitor){
21 |   return visitor.visitLiteralExpr(shared_from_this());
22 | }
23 | 
24 | Unary::Unary(Token oper, std::shared_ptr<Expr> right, bool isPost) : 
25 |   oper{std::move(oper)}, right{std::move(right)}, isPostOperator{isPost} {}
26 | 
27 | std::any Unary::accept(ExprVisitor &visitor){
28 |   return visitor.visitUnaryExpr(shared_from_this());
29 | }
30 | 
31 | Variable::Variable(Token name) : name(name) {}
32 | 
33 | std::any Variable::accept(ExprVisitor& visitor){
34 |   return visitor.visitVariableExpr(shared_from_this());
35 | }
36 | 
37 | Assign::Assign(Token name, std::shared_ptr<Expr> value) : 
38 |   name{std::move(name)}, value{std::move(value)} {}
39 | 
40 | std::any Assign::accept(ExprVisitor &visitor){
41 |   return visitor.visitAssignExpr(shared_from_this());
42 | }
43 | 
44 | Logical::Logical(std::shared_ptr<Expr> left,
45 |       Token oper, 
46 |      std::shared_ptr<Expr> right ) : left{std::move(left)},
47 |      oper{std::move(oper)}, right{std::move(right)} {}
48 | 
49 | std::any Logical::accept(ExprVisitor &visitor){
50 |   return visitor.visitLogicalExpr(shared_from_this());
51 | }
52 | 
53 | Call::Call(std::shared_ptr<Expr> callee, Token paren, std::vector<std::shared_ptr<Expr>> arguments) : 
54 |   callee{std::move(callee)}, 
55 |   paren{std::move(paren)},
56 |   arguments{std::move(arguments)} {}
57 | 
58 | std::any Call::accept(ExprVisitor &visitor){
59 |   return visitor.visitCallExpr(shared_from_this());
60 | }
61 | 
62 | Get::Get(std::shared_ptr<Expr> object, Token name) :
63 |   object{std::move(object)}, name{std::move(name)} {}
64 | 
65 | std::any Get::accept(ExprVisitor &visitor){
66 |   return visitor.visitGetExpr(shared_from_this());
67 | }
68 | 
69 | Set::Set(std::shared_ptr<Expr> object, Token name, std::shared_ptr<Expr> value) :
70 |   object{std::move(object)}, name{std::move(name)}, value{std::move(value)} {}
71 | 
72 | std::any Set::accept(ExprVisitor &visitor){
73 |   return visitor.visitSetExpr(shared_from_this());
74 | }
75 | 
76 | Array::Array(std::vector<std::shared_ptr<Expr>> values) :
77 |   values{std::move(values)} {}
78 | 
79 |   std::any Array::accept(ExprVisitor &visitor) {
80 |     return visitor.visitArrayExpr(shared_from_this());
81 |   }
82 | 
83 | Callist::Callist(std::shared_ptr<Expr> name, std::shared_ptr<Expr> index,
84 |     std::shared_ptr<Expr> value, Token paren) :
85 |   name{std::move(name)}, index{std::move(index)}, value{std::move(value)},
86 |   paren{std::move(paren)} {}
87 | 
88 |   std::any Callist::accept(ExprVisitor &visitor) {
89 |     return visitor.visitCallistExpr(shared_from_this());
90 |   }
91 | 


--------------------------------------------------------------------------------
/src/parser/Stmt.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "Visitor.hpp"
  4 | #include "../tokenizer/Token.hpp"
  5 | #include <vector>
  6 | 
  7 | namespace Statement {
  8 | 
  9 |   struct Expression final: Stmt, public std::enable_shared_from_this<Expression>{
 10 |     const std::shared_ptr<Expr> expression;
 11 | 
 12 |     Expression(std::shared_ptr<Expr> expression);
 13 |     std::any accept(StmtVisitor& visitor) override;
 14 |     ~Expression() =  default;
 15 |   };
 16 | 
 17 |   struct Print final: Stmt, public std::enable_shared_from_this<Print>{
 18 |     const std::shared_ptr<Expr> expression;
 19 | 
 20 |     Print(std::shared_ptr<Expr> expression);
 21 |     std::any accept(StmtVisitor& visitor) override;
 22 |     ~Print() = default;
 23 |   };
 24 | 
 25 |   struct Out final: Stmt, public std::enable_shared_from_this<Out>{
 26 |     const std::shared_ptr<Expr> expression;
 27 | 
 28 |     Out(std::shared_ptr<Expr> expression);
 29 |     std::any accept(StmtVisitor& visitor) override;
 30 |     ~Out() = default;
 31 |   };
 32 | 
 33 |   struct Var final: Stmt, public std::enable_shared_from_this<Var> {
 34 |     Token name;
 35 |     std::shared_ptr<Expr> init;
 36 | 
 37 |     Var(Token name, std::shared_ptr<Expr> init);
 38 |     std::any accept(StmtVisitor &visitor) override;
 39 |     ~Var() = default;
 40 |   };
 41 | 
 42 |   struct Block final: Stmt, public std::enable_shared_from_this<Block> {
 43 |     std::vector<std::shared_ptr<Stmt>> statements;
 44 | 
 45 |     Block(std::vector<std::shared_ptr<Stmt>> statements);
 46 |     std::any accept(StmtVisitor &visitor) override;
 47 |     ~Block() = default;
 48 |   };
 49 | 
 50 |   struct If final: Stmt, public std::enable_shared_from_this<If> {
 51 |     std::shared_ptr<Expr> condition;
 52 |     std::shared_ptr<Stmt> thenBranch;
 53 |     std::shared_ptr<Stmt> elseBranch;
 54 | 
 55 |     If(std::shared_ptr<Expr> condition, std::shared_ptr<Stmt> thenBranch,
 56 |         std::shared_ptr<Stmt> elseBranch);
 57 |     std::any accept(StmtVisitor &visitor) override;
 58 |     ~If() = default;
 59 |   };
 60 | 
 61 |   struct While final: Stmt, public std::enable_shared_from_this<While> {
 62 |     std::shared_ptr<Expr> condition;
 63 |     std::shared_ptr<Stmt> body;
 64 | 
 65 |     While(std::shared_ptr<Expr> condition, std::shared_ptr<Stmt> body);
 66 |     std::any accept(StmtVisitor& visitor) override;
 67 |     ~While() = default;
 68 |   };
 69 | 
 70 |   struct Function final: Stmt, public std::enable_shared_from_this<Function> {
 71 |     Token name;
 72 |     std::vector<Token> params;
 73 |     std::vector<std::shared_ptr<Stmt>> body;
 74 |     Function(Token name, std::vector<Token> params, std::vector<std::shared_ptr<Stmt>> body);
 75 |     std::any accept(StmtVisitor &visitor) override;
 76 |     ~Function() = default;
 77 |   };
 78 | 
 79 |   struct Return final: Stmt, public std::enable_shared_from_this<Return> {
 80 |     Token keyword;
 81 |     std::shared_ptr<Expr> value;
 82 |     Return(Token keyword, std::shared_ptr<Expr> value);
 83 |     std::any accept(StmtVisitor &visitor) override;
 84 |   };
 85 | 
 86 |   struct Class final: Stmt, public std::enable_shared_from_this<Class> {
 87 |     Token name;
 88 |     std::vector<std::shared_ptr<Function>> methods;
 89 | 
 90 |     Class(Token name, std::vector<std::shared_ptr<Function>> methods);
 91 |     std::any accept(StmtVisitor& visitor) override;
 92 |     ~Class() = default;
 93 |   };
 94 | 
 95 |   struct Include final: Stmt, public std::enable_shared_from_this<Include> {
 96 |     Token keyword;
 97 |     std::string path;
 98 | 
 99 |     Include(Token keyword, std::string path);
100 |     std::any accept(StmtVisitor& visitor) override;
101 |     ~Include() = default;
102 |   };
103 | 
104 | }
105 | 
106 | 


--------------------------------------------------------------------------------
/src/parser/Expr.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <vector>
  4 | #include "Visitor.hpp"
  5 | #include "../tokenizer/Token.hpp"
  6 | 
  7 | struct Binary final : Expr, public std::enable_shared_from_this<Binary> {
  8 |   std::shared_ptr<Expr> left;
  9 |   Token oper;
 10 |   std::shared_ptr<Expr> right;
 11 | 
 12 |   Binary(std::shared_ptr<Expr> left, Token oper, std::shared_ptr<Expr> right);
 13 |   std::any accept(ExprVisitor &visitor) override;
 14 |   ~Binary() = default;
 15 | };
 16 | 
 17 | struct Grouping final: Expr, public std::enable_shared_from_this<Grouping> {
 18 |   std::shared_ptr<Expr> expression;
 19 | 
 20 |   Grouping(std::shared_ptr<Expr> expression);
 21 |   std::any accept(ExprVisitor &visitor) override;
 22 |   ~Grouping() = default;
 23 | };
 24 | 
 25 | struct Literal final: Expr, public std::enable_shared_from_this<Literal> {
 26 |   std::any value;
 27 | 
 28 |   Literal(std::any value);
 29 |   std::any accept(ExprVisitor &visitor) override;
 30 |   ~Literal() = default;
 31 | };
 32 | 
 33 | struct Unary final: Expr, public std::enable_shared_from_this<Unary> {
 34 |   Token oper;
 35 |   std::shared_ptr<Expr> right;
 36 |   bool isPostOperator;
 37 | 
 38 |   Unary(Token oper, std::shared_ptr<Expr> right, bool isPostOperator);
 39 |   std::any accept(ExprVisitor &visitor) override;
 40 |   ~Unary() = default;
 41 | };
 42 | 
 43 | struct Variable final: Expr, public std::enable_shared_from_this<Variable> {
 44 |   Token name;
 45 |   Variable(Token name);
 46 |   std::any accept(ExprVisitor &visitor) override;
 47 |   ~Variable() = default;
 48 | };
 49 | 
 50 | struct Assign final: Expr, public std::enable_shared_from_this<Assign> {
 51 |   Token name;
 52 |   std::shared_ptr<Expr> value;
 53 | 
 54 |   Assign(Token name, std::shared_ptr<Expr> value);
 55 |   std::any accept(ExprVisitor &visitor) override;
 56 |   ~Assign() = default;
 57 | };
 58 | 
 59 | struct Logical final: Expr, public std::enable_shared_from_this<Logical> {
 60 |   std::shared_ptr<Expr> left;
 61 |   Token oper;
 62 |   std::shared_ptr<Expr> right;
 63 |   
 64 |   Logical(std::shared_ptr<Expr> left,
 65 |       Token oper, 
 66 |      std::shared_ptr<Expr> right );
 67 |   
 68 |   std::any accept(ExprVisitor &visitor) override;
 69 |   ~Logical() = default;
 70 | };
 71 | 
 72 | struct Call final: Expr, public std::enable_shared_from_this<Call> {
 73 |   std::shared_ptr<Expr> callee;
 74 |   Token paren;
 75 |   std::vector<std::shared_ptr<Expr>> arguments;
 76 | 
 77 |   Call(std::shared_ptr<Expr> callee, Token paren, std::vector<std::shared_ptr<Expr>> arguments);
 78 |   std::any accept(ExprVisitor &visitor) override;
 79 |   ~Call() = default;
 80 | };
 81 | 
 82 | struct Get final: Expr, public std::enable_shared_from_this<Get> {
 83 |   std::shared_ptr<Expr> object;
 84 |   Token name;
 85 | 
 86 |   Get(std::shared_ptr<Expr> object, Token name);
 87 |   std::any accept(ExprVisitor &visitor) override;
 88 |   ~Get() = default;
 89 | };
 90 | 
 91 | 
 92 | struct Set final: Expr, public std::enable_shared_from_this<Set> {
 93 |   std::shared_ptr<Expr> object;
 94 |   Token name;
 95 |   std::shared_ptr<Expr> value;
 96 | 
 97 |   Set(std::shared_ptr<Expr> object, Token name, std::shared_ptr<Expr> value);
 98 |   std::any accept(ExprVisitor &visitor) override;
 99 |   ~Set() = default;
100 | };
101 | 
102 | struct Array final: Expr, public std::enable_shared_from_this<Array> {
103 |   std::vector<std::shared_ptr<Expr>> values;
104 | 
105 |   Array(std::vector<std::shared_ptr<Expr>> values);
106 |   std::any accept(ExprVisitor &visitor) override;
107 |   ~Array() = default;
108 | };
109 | 
110 | struct Callist final: Expr, public std::enable_shared_from_this<Callist> {
111 |   std::shared_ptr<Expr> name;
112 |   std::shared_ptr<Expr> index;
113 |   std::shared_ptr<Expr> value;
114 |   Token paren;
115 | 
116 |   Callist(std::shared_ptr<Expr> name, std::shared_ptr<Expr> index, std::shared_ptr<Expr> value, Token paren);
117 |   std::any accept(ExprVisitor &visitor) override;
118 |   ~Callist() = default;
119 | };
120 | 


--------------------------------------------------------------------------------
/src/interpreter/Builtin.cpp:
--------------------------------------------------------------------------------
  1 | #include "Builtin.hpp"
  2 | #include "ArrayType.hpp"
  3 | #include <chrono>
  4 | #include <iostream>
  5 | #include <random>
  6 | #include "../utils/Helpers.hpp"
  7 | 
  8 | void builtinError(const std::string& nameBuiltin){
  9 |     std::cerr << "Builtin '" << nameBuiltin << "' function error.\n";
 10 |     std::exit(1);
 11 | }
 12 | 
 13 | // ------ Clock -----------
 14 | int Clock::arity(){
 15 |   return 0;
 16 | }
 17 | 
 18 | std::any Clock::call(Interpreter &interpreter, std::vector<std::any> arguments){
 19 |   if(arguments.size() > (size_t)arity() && interpreter.global != nullptr){
 20 |     builtinError("clock");
 21 |   }
 22 |   auto now = std::chrono::system_clock::now();
 23 |   auto duration = now.time_since_epoch();
 24 |   auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
 25 |   double c = static_cast<double>(millis) / 1000.0;
 26 |   return std::any_cast<double>(c);
 27 | }
 28 | 
 29 | std::string Clock::toString(){
 30 |   return "<function builtin>";
 31 | }
 32 | 
 33 | // ------ RAND -----------
 34 | int Rand::arity(){
 35 |   return 2;
 36 | }
 37 | 
 38 | std::any Rand::call(Interpreter &interpreter, std::vector<std::any> arguments){
 39 |   if(arguments.size() != (size_t)arity() && interpreter.global != nullptr){
 40 |     builtinError("rand");
 41 |   }
 42 | 
 43 |   for(size_t i = 0; i < (size_t)arity(); i++){
 44 |     if(!arguments[i].has_value() || (arguments[i].type() != typeid(double))){
 45 |       builtinError("rand");
 46 |     }
 47 |   }
 48 | 
 49 |   double a = std::any_cast<double>(arguments[0]);
 50 |   double b = std::any_cast<double>(arguments[1]);
 51 | 
 52 |   std::random_device rd;
 53 |   std::mt19937 gen(rd());
 54 | 
 55 |   std::uniform_int_distribution<> dist(static_cast<int>(a), static_cast<int>(b));
 56 | 
 57 |   double random_number = dist(gen);
 58 | 
 59 |   return std::any_cast<double>(random_number);
 60 | }
 61 | 
 62 | std::string Rand::toString(){
 63 |   return "<function builtin>";
 64 | }
 65 | 
 66 | // ------ GetEnv -----------
 67 | int GetEnv::arity(){
 68 |   return 1;
 69 | }
 70 | 
 71 | std::any GetEnv::call(Interpreter &interpreter, std::vector<std::any> arguments){
 72 |   if(arguments.size() > (size_t)arity() && interpreter.global != nullptr){
 73 |     builtinError("getenv");
 74 |   }
 75 | 
 76 |   std::string name = std::any_cast<std::string>(arguments[0]);
 77 |   std::string envname = std::getenv(name.data());
 78 | 
 79 |   return std::any_cast<std::string>(envname);
 80 | }
 81 | 
 82 | std::string GetEnv::toString(){
 83 |   return "<function builtin>";
 84 | }
 85 | 
 86 | // ------ ToString -----------
 87 | int ToString::arity(){
 88 |   return 1;
 89 | }
 90 | 
 91 | std::any ToString::call(Interpreter &interpreter, std::vector<std::any> arguments){
 92 |   if(arguments.size() > (size_t)arity() && interpreter.global != nullptr){
 93 |     builtinError("to_string");
 94 |   }
 95 | 
 96 |   if(!arguments[0].has_value() || arguments[0].type() != typeid(double)){
 97 |     builtinError("to_string");
 98 |   }
 99 | 
100 |   int terint = static_cast<int>(std::any_cast<double>(arguments[0]));
101 |   std::string str = std::to_string(std::any_cast<int>(terint));
102 | 
103 |   return std::any_cast<std::string>(str);
104 | }
105 | 
106 | std::string ToString::toString(){
107 |   return "<function builtin>";
108 | }
109 | 
110 | // ------ Args -----------
111 | int Args::arity(){
112 |   return 0;
113 | }
114 | 
115 | std::any Args::call(Interpreter &interpreter, std::vector<std::any> arguments){
116 |   if(arguments.size() > (size_t)arity() && interpreter.global != nullptr){
117 |     builtinError("args");
118 |   }
119 | 
120 |   std::vector<std::string> args = Helpers::get_instance().get_args();
121 |   auto arr = std::make_shared<ArrayType>();
122 | 
123 |   for(size_t i = 0; i < args.size(); ++i){
124 |     if(i != 0 && i != 1){
125 |       arr->append(args[i]);
126 |     }
127 |   }
128 | 
129 |   return std::any(arr);
130 | }
131 | 
132 | std::string Args::toString(){
133 |   return "<function builtin>";
134 | }
135 | 
136 | // ------ Exec -----------
137 | int Exec::arity(){
138 |   return 1;
139 | }
140 | 
141 | std::any Exec::call(Interpreter &interpreter, std::vector<std::any> arguments){
142 |   if(arguments.size() > (size_t)arity() && interpreter.global != nullptr){
143 |     builtinError("exec");
144 |   }
145 | 
146 |   std::string name = std::any_cast<std::string>(arguments[0]);
147 |   int run = std::system(name.data());
148 |   
149 |   if(run != 0){
150 |     builtinError("exec[system]");
151 |   }
152 | 
153 |   std::string str_run = {};
154 | 
155 |   return std::any_cast<std::string>(str_run);
156 | }
157 | 
158 | std::string Exec::toString(){
159 |   return "<function builtin>";
160 | }
161 | 
162 | // ------ Input -----------
163 | int Input::arity() {
164 |   return 0;
165 | }
166 | 
167 | std::any Input::call(Interpreter &interpreter, std::vector<std::any> arguments) {
168 |   if (arguments.size() > (size_t)arity() && interpreter.global != nullptr) {
169 |     builtinError("input");
170 |   }
171 | 
172 |   std::string input;
173 |   std::getline(std::cin, input);
174 | 
175 |   return std::any(input);
176 | }
177 | 
178 | std::string Input::toString() {
179 |   return "<function builtin>";
180 | }
181 | 


--------------------------------------------------------------------------------
/src/tokenizer/Scanner.cpp:
--------------------------------------------------------------------------------
  1 | #include "Scanner.hpp"
  2 | #include "../utils/Debug.hpp"
  3 | 
  4 | Scanner::Scanner(const std::string& source) : source(source) {}
  5 | 
  6 | std::vector<Token> Scanner::scanTokens(){
  7 |   while(!isAtEnd()){
  8 |     start = current;
  9 |     scanToken();
 10 |   }
 11 |   tokens.emplace_back(TokenType::TER_EOF, "", nullptr, line);
 12 |   return tokens;
 13 | }
 14 | 
 15 | bool Scanner::isAtEnd(){
 16 |   return current >= static_cast<int>(source.length());
 17 | }
 18 | 
 19 | void Scanner::addToken(TokenType type){
 20 |   addToken(type, nullptr);
 21 | }
 22 | 
 23 | void Scanner::addToken(TokenType type, std::any literal){
 24 |   std::string text{source.substr(static_cast<size_t>(start), static_cast<size_t>(current - start))};
 25 |   tokens.emplace_back(type, text, literal, line);
 26 | }
 27 | 
 28 | void Scanner::identifier(){
 29 |   while(isAlphaNumeric(peek())) advance();
 30 |   std::string text{source.substr(static_cast<size_t>(start), static_cast<size_t>(current - start))};
 31 |   auto it = keywords.find(text);
 32 |   TokenType type = it == keywords.end() ? TokenType::IDENTIFIER : it->second;
 33 |   addToken(type);
 34 | }
 35 | 
 36 | void Scanner::number(){
 37 |   while(isDigit(peek())) advance();
 38 | 
 39 |   if(peek() == '.' && isDigit(peekNext())){
 40 |     advance();
 41 |     while(isDigit(peek())) advance();
 42 |   }
 43 | 
 44 |   std::string text{source.substr(static_cast<size_t>(start), static_cast<size_t>(current - start))};
 45 |   double number = std::stod(std::string{text});
 46 |   addToken(TokenType::NUMBER, number);
 47 | }
 48 | 
 49 | void Scanner::string(){
 50 |   while(peek() != '"' && !isAtEnd()){
 51 |     if(peek() == '\n'){ line++; }
 52 |     advance();
 53 |   }
 54 | 
 55 |   if(isAtEnd()){
 56 |     Debug::error(line, "Unterminated string.");
 57 |     return;
 58 |   }
 59 | 
 60 |   advance();
 61 | 
 62 |   std::string value{source.substr(static_cast<size_t>(start + 1), static_cast<size_t>(current - start - 2))};
 63 |   addToken(TokenType::STRING, value);
 64 | }
 65 | 
 66 | bool Scanner::match(char expected){
 67 |   if (isAtEnd() || source.at(static_cast<size_t>(current)) != expected) return false;
 68 |   current++;
 69 |   return true;
 70 | }
 71 | 
 72 | char Scanner::peek(){
 73 |   if(isAtEnd()) return '\0';
 74 |   return source.at(static_cast<size_t>(current));
 75 | }
 76 | 
 77 | char Scanner::peekNext(){
 78 |   if(current + 1 > static_cast<int>(source.length())) return '\0';
 79 |   return source.at(static_cast<size_t>(current + 1));
 80 | }
 81 | 
 82 | bool Scanner::isAlpha(char c){
 83 |   return (c >= 'a' && c <= 'z') || 
 84 |     (c >= 'A' && c <= 'Z') || 
 85 |     c == '_';
 86 | }
 87 | 
 88 | bool Scanner::isAlphaNumeric(char c){
 89 |   return isAlpha(c) || isDigit(c);
 90 | }
 91 | 
 92 | bool Scanner::isDigit(char c){
 93 |   return c >= '0' && c <= '9';
 94 | }
 95 | 
 96 | char Scanner::advance(){
 97 |   return source[static_cast<size_t>(current++)];
 98 | }
 99 | 
100 | void Scanner::scanToken(){
101 |   char c = advance();
102 |   switch(c){
103 |     case '&': addToken(TokenType::AMPERSAND); break;
104 |     case '^': addToken(TokenType::CARET); break;
105 |     case '|': addToken(TokenType::VBAR); break;
106 |     case '~': addToken(TokenType::TILDE); break;
107 |     case '%': addToken(TokenType::PERCENT); break;
108 |     case '(': addToken(TokenType::LEFT_PAREN); break;
109 |     case ')': addToken(TokenType::RIGHT_PAREN); break;
110 |     case '{': addToken(TokenType::LEFT_BRACE); break;
111 |     case '}': addToken(TokenType::RIGHT_BRACE); break;
112 |     case ',': addToken(TokenType::COMMA); break;
113 |     case '.': addToken(TokenType::DOT); break;
114 |     case '-': 
115 |               if(match('-')){
116 |                 addToken(TokenType::MINUS_MINUS);
117 |               }else{
118 |                 addToken(TokenType::MINUS); 
119 |               }
120 |               break;
121 |     case '+': 
122 |               if(match('+')){
123 |                 addToken(TokenType::PLUS_PLUS); 
124 |               }else{
125 |                 addToken(TokenType::PLUS); 
126 |               }
127 |               break;
128 |     case ';': addToken(TokenType::SEMICOLON); break;
129 |     case '*': addToken(TokenType::STAR); break;
130 |     case '[': addToken(TokenType::LEFT_BRACKET); break;
131 |     case ']': addToken(TokenType::RIGHT_BRACKET); break;
132 |     case '!':
133 |               addToken(match('=') ? TokenType::BANG_EQUAL : TokenType::BANG); break;
134 |     case '=':
135 |               addToken(match('=') ? TokenType::EQUAL_EQUAL : TokenType::EQUAL); break;
136 |     case '<':
137 |               if (match('=')) {
138 |                 addToken(TokenType::LESS_EQUAL);
139 |               }else if (match('<')) {
140 |                 addToken(TokenType::LESS_LESS);
141 |               }else {
142 |                 addToken(TokenType::LESS);
143 |               }
144 |               break;
145 |     case '>':
146 |               if (match('=')) {
147 |                 addToken(TokenType::GREATER_EQUAL);
148 |               }else if (match('>')) {
149 |                 addToken(TokenType::GREATER_GREATER);
150 |               }else {
151 |                 addToken(TokenType::GREATER);
152 |               }
153 |               break;
154 |     case '/':
155 |               if(match('/')){
156 |                 while(peek() != '\n' && !isAtEnd()){
157 |                   advance();
158 |                 }
159 |               }else if(match('*')){
160 |                 while(!isAtEnd()){
161 |                   if(peek() == '\n') line++;
162 |                   if(match('*') && peek() == '/'){
163 |                     advance();
164 |                     return;
165 |                   }
166 |                   advance();
167 |                 }
168 |                 Debug::error(line, "Expected '*/' to close multiline comment.");
169 |               }else{
170 |                 addToken(TokenType::SLASH);
171 |               }
172 |               break;
173 |     case ' ':
174 |     case '\r':
175 |     case '\t':
176 |               break;
177 |     case '\n':
178 |               line++;
179 |               break;
180 |     case '"':
181 |               string();
182 |               break;
183 |     default:
184 |               if(isDigit(c)){
185 |                 number();
186 |               }else if(isAlpha(c)){
187 |                 identifier();
188 |               }else{
189 |                 Debug::error(line, "Unexpected character.");
190 |               }
191 |               break;
192 |   } 
193 | }
194 | 


--------------------------------------------------------------------------------
/src/interpreter/Resolver.cpp:
--------------------------------------------------------------------------------
  1 | #include "Resolver.hpp"
  2 | #include "../utils/Debug.hpp"
  3 | #include "../parser/Expr.hpp"
  4 | 
  5 | Resolver::Resolver(Interpreter& interpreter) :
  6 |   interpreter(interpreter) {}
  7 | 
  8 | void Resolver::resolve(std::shared_ptr<Statement::Stmt> statement){
  9 |   statement->accept(*this);
 10 | }
 11 | 
 12 | void Resolver::resolve(std::shared_ptr<Expr> expression){
 13 |   expression->accept(*this);
 14 | }
 15 | 
 16 | void Resolver::beginScope(){
 17 |   identifiers.push_back(std::map<Token, int>{});
 18 |   scopes.push_back(std::map<std::string, bool>{});
 19 | }
 20 | 
 21 | void Resolver::endScope(){
 22 |   identifiers.pop_back();
 23 |   scopes.pop_back();
 24 | }
 25 | 
 26 | void Resolver::declare(Token& name){
 27 |   if(scopes.empty() && identifiers.empty()) return;
 28 |   std::map<Token, int> currentBlock = identifiers.back();
 29 |   std::map<std::string, bool> currentScope = scopes.back();
 30 |   if(currentScope.find(name.lexeme) != currentScope.end()){
 31 |     Debug::error(name, "Multiples variables with same name not allowed.");
 32 |   }
 33 |   currentBlock[name] = 0;
 34 |   currentScope[name.lexeme] = false;
 35 | }
 36 | 
 37 | void Resolver::define(Token& name){
 38 |   if(scopes.empty() && identifiers.empty()) return;
 39 |   scopes.back()[name.lexeme] = true;
 40 | }
 41 | 
 42 | void Resolver::resolveLocal(std::shared_ptr<Expr> expr, Token& name){
 43 |   int scopeSize = static_cast<int>(scopes.size()) - 1;
 44 |   for(int i = scopeSize; i >= 0; i--){
 45 |     if(scopes[static_cast<size_t>(i)].find(name.lexeme) != scopes[static_cast<size_t>(i)].end()) {
 46 |       identifiers[static_cast<size_t>(i)].erase(name);
 47 |       interpreter.resolve(expr, scopeSize - i);
 48 |       return;
 49 |     }
 50 |   }
 51 | }
 52 | 
 53 | void Resolver::resolveFunction(std::vector<Token> params, std::vector<std::shared_ptr<Statement::Stmt>> body, FType type){
 54 |   FType enclosingFunction = currentFunction;
 55 |   currentFunction = type;
 56 |   beginScope();
 57 |   for(Token& param : params){
 58 |     declare(param);
 59 |     define(param);
 60 |   }
 61 |   resolve(body);
 62 |   endScope();
 63 |   currentFunction = enclosingFunction;
 64 | }
 65 | 
 66 | 
 67 | void Resolver::resolve(std::vector<std::shared_ptr<Statement::Stmt>> &statements){
 68 |   for(std::shared_ptr<Statement::Stmt> &statement : statements){
 69 |     resolve(statement);
 70 |   }
 71 | }
 72 | 
 73 | std::any Resolver::visitBinaryExpr(std::shared_ptr<Binary> expr){
 74 |   resolve(expr->left);
 75 |   resolve(expr->right);
 76 |   return {};
 77 | }
 78 | 
 79 | std::any Resolver::visitGroupingExpr(std::shared_ptr<Grouping> expr){
 80 |   resolve(expr->expression);
 81 |   return {};
 82 | }
 83 | 
 84 | std::any Resolver::visitLiteralExpr(std::shared_ptr<Literal> expr){
 85 |   if(expr.get() != 0){}
 86 |   return {};
 87 | }
 88 | 
 89 | std::any Resolver::visitUnaryExpr(std::shared_ptr<Unary> expr){
 90 |   resolve(expr->right);
 91 |   return {};
 92 | }
 93 | 
 94 | std::any Resolver::visitExpressionStmt(std::shared_ptr<Statement::Expression> stmt){
 95 |   resolve(stmt->expression);
 96 |   return {};
 97 | }
 98 | 
 99 | std::any Resolver::visitPrintStmt(std::shared_ptr<Statement::Print> stmt){
100 |   resolve(stmt->expression);
101 |   return {};
102 | }
103 | 
104 | std::any Resolver::visitOutStmt(std::shared_ptr<Statement::Out> stmt){
105 |   resolve(stmt->expression);
106 |   return {};
107 | }
108 | 
109 | std::any Resolver::visitVariableExpr(std::shared_ptr<Variable> expr){
110 |   if(!scopes.empty()){
111 |     auto &currentScope = scopes.back();
112 |     auto elem = currentScope.find(expr->name.lexeme);
113 |     if(elem != currentScope.end() && elem->second == false){
114 |       Debug::error(expr->name, "Can't read local variable in this own initializer.");
115 |     }
116 |   }
117 |   resolveLocal(expr, expr->name);
118 |   return {};
119 | }
120 | 
121 | std::any Resolver::visitAssignExpr(std::shared_ptr<Assign> expr){
122 |   resolve(expr->value);
123 |   resolveLocal(expr, expr->name);
124 |   return {};
125 | }
126 | 
127 | std::any Resolver::visitLogicalExpr(std::shared_ptr<Logical> expr){
128 |   resolve(expr->left);
129 |   resolve(expr->right);
130 |   return {};
131 | }
132 | 
133 | std::any Resolver::visitCallExpr(std::shared_ptr<Call> expr){
134 |   resolve(expr->callee);
135 |   for(std::shared_ptr<Expr>& argument : expr->arguments){
136 |     resolve(argument);
137 |   }
138 |   return {};
139 | }
140 | 
141 | std::any Resolver::visitVarStmt(std::shared_ptr<Statement::Var> stmt){
142 |   declare(stmt->name);
143 |   if(stmt->init != nullptr) resolve(stmt->init);
144 |   define(stmt->name);
145 |   return {};
146 | }
147 | 
148 | std::any Resolver::visitBlockStmt(std::shared_ptr<Statement::Block> stmt){
149 |   beginScope();
150 |   resolve(stmt->statements);
151 |   endScope();
152 |   return {};
153 | }
154 | 
155 | std::any Resolver::visitIfStmt(std::shared_ptr<Statement::If> stmt){
156 |   resolve(stmt->condition);
157 |   resolve(stmt->thenBranch);
158 |   if(stmt->elseBranch != nullptr) resolve(stmt->elseBranch);
159 |   return {};
160 | }
161 | 
162 | std::any Resolver::visitWhileStmt(std::shared_ptr<Statement::While> stmt){
163 |   resolve(stmt->condition);
164 |   resolve(stmt->body);
165 |   return {};
166 | }
167 | 
168 | std::any Resolver::visitFunctionStmt(std::shared_ptr<Statement::Function> stmt){
169 |   declare(stmt->name);
170 |   define(stmt->name);
171 |   resolveFunction(stmt->params, stmt->body, FType::FUNCTION);
172 |   return {};
173 | }
174 | 
175 | std::any Resolver::visitReturnStmt(std::shared_ptr<Statement::Return> stmt){
176 |   if(currentFunction == FType::NONE){
177 |     Debug::error(stmt->keyword, "Can't return from top level code.");
178 |   }
179 |   if(stmt->value != nullptr) resolve(stmt->value);
180 |   return {};
181 | }
182 | 
183 | std::any Resolver::visitClassStmt(std::shared_ptr<Statement::Class> stmt){
184 |   declare(stmt->name);
185 |   define(stmt->name);
186 |   
187 |   for(const auto& method : stmt->methods){
188 |     std::vector<Token> params = method->params;
189 |     std::vector<std::shared_ptr<Statement::Stmt>> body = method->body;
190 | 
191 |     FType declaration = FType::METHOD;
192 |     resolveFunction(params, body, declaration);
193 |   }
194 | 
195 |   return {};
196 | }
197 | 
198 | std::any Resolver::visitGetExpr(std::shared_ptr<Get> expr){
199 |   resolve(expr->object);
200 |   return {};
201 | }
202 | 
203 | std::any Resolver::visitSetExpr(std::shared_ptr<Set> expr){
204 |   resolve(expr->value);
205 |   resolve(expr->object);
206 |   return {};
207 | }
208 | 
209 | std::any Resolver::visitIncludeStmt(std::shared_ptr<Statement::Include> stmt){
210 |   if(stmt->path != ""){
211 |     return {};
212 |   }
213 |   return {};
214 | }
215 | 
216 | std::any Resolver::visitArrayExpr(std::shared_ptr<Array> expr) {
217 |   for (std::shared_ptr<Expr> value : expr->values) {
218 |     resolve(value);
219 |   }
220 |   return {};
221 | }
222 | 
223 | std::any Resolver::visitCallistExpr(std::shared_ptr<Callist> expr) {
224 |   resolve(expr->name);
225 |   resolve(expr->index);
226 |   if (expr->value != nullptr) resolve(expr->value);
227 |   return {};
228 | }
229 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # [Ter/Terlang](./README.md)
  3 | > Programming language for scripting with syntax similar to C++
  4 | 
  5 | ![Ter/Terlang](./logo-ter-terlang.png) 
  6 | 
  7 | ---
  8 | 
  9 | ## Summary
 10 | 1. [Building and Installing on UNIX-style systems](#building-on-unix-style-systems)
 11 | 2. [Building and Installing on Windows](#building-and-installing-on-windows)
 12 | 3. [Only installing on Windows or Ubuntu](#only-installing-on-windows-or-ubuntu)
 13 | 4. [Using](#using)
 14 | 5. [Tutorials](#tutorials)
 15 | 6. [Extensions and LICENSE](#extensions-and-license)
 16 | 
 17 | ---
 18 | 
 19 | ### Dependencies
 20 | + [GNU GCC](https://gcc.gnu.org/), [Clang](https://clang.llvm.org/) or [MSVC](https://learn.microsoft.com/en-us/cpp/?view=msvc-170)
 21 | + [CMake](https://cmake.org/)
 22 | > C++23
 23 | 
 24 | ### Building on UNIX-style systems
 25 | > macOS, GNU/Linux, BSD-Like, Haiku and others.
 26 | 
 27 | ```bash
 28 | git clone https://github.com/terroo/terlang
 29 | cd terlang
 30 | cmake -B build .
 31 | cmake --build build
 32 | sudo cmake --install build
 33 | ```
 34 | 
 35 | REPL:
 36 | > To test the `ter` command.
 37 | ```cpp
 38 | $ ter
 39 | ter> output("Hello Ter!")
 40 | ```
 41 | 
 42 | ---
 43 | 
 44 | ### Building and Installing on Windows
 45 | With MSVC!
 46 | > Open PowerShell (Run as Administrator) from the Windows Start Menu
 47 | 
 48 | ```bash
 49 | git clone https://github.com/terroo/terlang
 50 | cd terlang\
 51 | cmake -B build .
 52 | cmake --build build
 53 | 
 54 | # Create destination folders and subfolders
 55 | New-Item -Path "C:\Program Files\Terlang\bin" -ItemType Directory -Force
 56 | 
 57 | # Move to destination folder
 58 | Move-Item -Path "build\Debug\ter.exe" -Destination "C:\Program Files\Terlang\bin\ter.exe"
 59 | 
 60 | # Create an environment variable for system "Path"
 61 | [System.Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files\Terlang\bin", [System.EnvironmentVariableTarget]::Machine)
 62 | ```
 63 | 
 64 | Close PowerShell, then reopen and run:
 65 | > To test the `ter` command.
 66 | ```cpp
 67 | ter --version
 68 | Ter/Terlang v0.1.1
 69 | 
 70 | Usage: 
 71 | 	ter [filename].ter
 72 | 	ter -e '<script>'
 73 | ```
 74 | 
 75 | ---
 76 | 
 77 | ### Only installing on Windows or Ubuntu
 78 | 
 79 | Windows:
 80 | ```bash
 81 | Invoke-WebRequest -Uri "https://github.com/terroo/terlang/releases/download/v0.0.1/terlang-windows-0.0.1.zip"
 82 | ```
 83 | + Unzip
 84 | + Create folders and subfolders: `C:\Program Files\Terlang\bin`
 85 | + Move the `.exe` to the `bin\` subfolder
 86 | + Add the path as an environment variable to just the `ter` command in *PowerShell* or *CMD*
 87 | 
 88 | Ubuntu:
 89 | ```bash
 90 | wget https://github.com/terroo/terlang/releases/download/v0.0.1/terlang-ubuntu-24-04-0.0.1.zip
 91 | unzip terlang-ubuntu-24-04-0.0.1.zip
 92 | sudo mv ter /usr/local/bin
 93 | ```
 94 | 
 95 | And test:
 96 | ```cpp
 97 | ter --version
 98 | Ter/Terlang v0.1.1
 99 | 
100 | Usage: 
101 | 	ter [filename].ter
102 | 	ter -e '<script>'
103 | ```
104 | 
105 | ---
106 | 
107 | ## Using
108 | > `vim hello.ter`
109 | 
110 | #### 01. Hello, World!
111 | ```cpp
112 | // Comment line
113 | auto hello = "Hello, Terlang! 😃 ";
114 | output(hello);
115 | /*
116 |   Multiline
117 |   comments
118 | */
119 | ```
120 | > Semicolon is optional: `auto hello = "Hello, Terlang!"`. Literally skipping the line: `out("Hello\n")`
121 | 
122 | Run:
123 | ```bash
124 | ter hello.ter
125 | ```
126 | > Output: `Hello, Terlang! 😃`
127 | 
128 | #### 02. Arrays
129 | ```cpp
130 | auto list = {13, 2, 8, 4, 17, 12, 11, 9};
131 | output(list[6]); // 11
132 | ```
133 | 
134 | #### 03. Loops
135 | ```cpp
136 | for(auto i = 0; i < 5; ++i){ // Or i++
137 |   out(to_string(i) + " | ")
138 | }
139 | out("\n")
140 | // 0 | 1 | 2 | 3 | 4 |
141 | 
142 | 
143 | auto i = 0;
144 | while(i < 5){
145 |   out(to_string(i) + " | ")
146 |   ++i;
147 | }
148 | out("\n")
149 | // 0 | 1 | 2 | 3 | 4 |
150 | ```
151 | 
152 | #### 05. Includes
153 | 
154 | > `main.ter`
155 | ```cpp
156 | include("./library.ter")
157 | output(value); // 18
158 | ```
159 | 
160 | > `library.ter`
161 | ```cpp
162 | auto value = 18;
163 | ```
164 | 
165 | #### 06. Functions
166 | ```cpp
167 | set print(str){
168 |   output(str);
169 | }
170 | 
171 | set add(x, y){
172 |   return x + y;
173 | }
174 | 
175 | set increment(a){
176 |   return ++a;
177 | }
178 | 
179 | print("My content"); // My content
180 | output(add(3, 9)); // 12
181 | 
182 | auto result = increment(6);
183 | output(result); // 7
184 | ```
185 | 
186 | #### 07. Classes
187 | ```cpp
188 | class Animal {
189 |   cat(name){
190 |     output("Cat name is: " + name);
191 |   }
192 | 
193 |   dog(){
194 |     output("I am dog!");
195 |   }
196 | 
197 |   descAnimal(human){
198 |     return "Human: " + human;
199 |   }
200 | }
201 | 
202 | Animal().cat("Bob");
203 | 
204 | auto obj = Animal();
205 | obj.dog();
206 | 
207 | output(obj.descAnimal("Peter"));
208 | ```
209 | > Output:
210 | ```bash
211 | Cat name is: Bob
212 | I am dog!
213 | Human: Peter
214 | ```
215 | 
216 | #### 08. Builtin Functions
217 | ```cpp
218 | // Rand number
219 | auto num = rand(5, 15);
220 | output(num) // Number between 5 and 15
221 | 
222 | // Clock
223 | auto myclock = clock();
224 | output(myclock); // Ex.: 1732022610.561000
225 | 
226 | // Environment variables
227 | auto home = getenv("HOME");
228 | output(home); // Ex.: /home/user
229 | 
230 | auto shell = getenv("SHELL")
231 | output(shell); // Ex.: /bin/bash
232 | 
233 | // Exec shell
234 | exec("ls")
235 | 
236 | // Compiling C++ code
237 | exec("g++ main.cpp")
238 | exec("./a.out")
239 | ```
240 | 
241 | ---
242 | 
243 | ## 09. Command line arguments
244 | > `params.ter`
245 | ```cpp
246 | auto params = args()
247 | output(params)
248 | ```
249 | 
250 | Example 01, **withOUT** params:
251 | ```bash
252 | ter params.ter 
253 | []
254 | ```
255 | 
256 | Example 02, **WITH** params:
257 | ```bash
258 | ter params.ter first second --third "My Four"
259 | [first, second, --third, My Four]
260 | ```
261 | 
262 | Example 02, **WITH ESPECIFIC** param:
263 | > `params.ter`
264 | ```cpp
265 | auto params = args()
266 | output(params[0])
267 | ```
268 | ```bash
269 | ter params.ter file.txt
270 | file.txt
271 | ```
272 | 
273 | ---
274 | 
275 | ## 10. Run from command line
276 | ```bash
277 | ter -e 'output("Hello, Word!")'
278 | ter -e 'auto x = 9 output(x)'
279 | ter -e 'auto var = 42;out(to_string(var) + "\n")'
280 | ter -e "$(cat build.ter)"
281 | ```
282 | 
283 | ---
284 | 
285 | ## 11. Using [Emscripten](https://emscripten.org/)
286 | Compiling:
287 | ```bash
288 | emmake cmake -B web .
289 | cd web
290 | emmake make
291 | ```
292 | 
293 | Testing:
294 | ```bash
295 | node ter.js -e 'output("Hello, Word!")'
296 | node ter.js -e 'auto var = 42;out(to_string(var) + "\n")'
297 | node ter.js -e "$(cat build.ter)"
298 | ```
299 | 
300 | ---
301 | 
302 | ## Tutorials
303 | From [video](https://youtu.be/0sKCWJawDZ8).
304 | 
305 | Helper:
306 | ```bash
307 | ter --help
308 | ```
309 | > Stay tuned for the version: `ter --version`
310 | 
311 | ---
312 | 
313 | ## Extensions and LICENSE
314 | [Syntax highlight for Vim](https://github.com/terroo/ter-vim)
315 | 
316 | [Syntax highlight for Neovim](https://github.com/terroo/ter-vim)
317 | 
318 | [Syntax highlight for VS Code](https://marketplace.visualstudio.com/items?itemName=SaymonMacedo.terlang)
319 | > Created by Saymon Macedo.
320 | > 
321 | > [My alternative version](https://marketplace.visualstudio.com/items?itemName=marcoscode.ter)
322 | 
323 | ---
324 | 
325 | ## [Speed test](https://terminalroot.com.br/2023/01/testei-o-desempenho-de-10-linguagens-de-programacao-ranking-final.html)
326 | > Based on [these tests](https://github.com/terroo/langs-test-loop) that were done.
327 | 
328 | > `speed.ter`
329 | ```cpp
330 | for(auto i = 0; i < 1000000; ++i){
331 |   out("Ok" + to_string(i) + "\r")
332 | }
333 | ```
334 | 
335 | Run `time ter speed.ter` and result:
336 | ```bash
337 | Ok999999
338 | real	0m2,632s
339 | user	0m2,500s
340 | sys	0m0,110s
341 | ```
342 | 
343 | ---
344 | 
345 | [LICENSE GNU GPLv3](./LICENSE)
346 | 


--------------------------------------------------------------------------------
/src/parser/Parser.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm>
  3 | 
  4 | #include "Parser.hpp"
  5 | #include "Expr.hpp"
  6 | #include "../utils/Debug.hpp"
  7 | #include "Stmt.hpp"
  8 | #include "IncludeRun.hpp"
  9 | 
 10 | #define assert(E)
 11 | 
 12 | Parser::Parser(const std::vector<Token>& tokens) : tokens(tokens) {}
 13 | 
 14 | std::vector<std::shared_ptr<Statement::Stmt>> Parser::parse(){
 15 |   statements.clear();
 16 |   try {
 17 |     while(!isAtEnd()){
 18 |       statements.push_back(declaration());
 19 |     }
 20 |   }catch(const std::exception& e) {
 21 |     std::cerr << "[Exception parse]: " << e.what() << '\n'; 
 22 |   }
 23 |   return statements;
 24 | }
 25 | 
 26 | std::shared_ptr<Expr> Parser::expression(){
 27 |   return assignment();
 28 | }
 29 | 
 30 | std::shared_ptr<Expr> Parser::bitwise(){
 31 |   std::shared_ptr<Expr> expr = equality();
 32 |   while(match(TokenType::AMPERSAND, TokenType::CARET, TokenType::VBAR)){
 33 |     Token oper = previous();
 34 |     std::shared_ptr<Expr> right = equality();
 35 |     expr = std::make_shared<Binary>(expr, oper, right);
 36 |   }
 37 |   return expr;
 38 | }
 39 | 
 40 | std::shared_ptr<Expr> Parser::equality(){
 41 |   std::shared_ptr<Expr> expr = comparison();
 42 |   while(match(TokenType::BANG_EQUAL, TokenType::EQUAL_EQUAL)){
 43 |     Token oper = previous();
 44 |     std::shared_ptr<Expr> right = comparison();
 45 |     expr = std::make_shared<Binary>(expr, oper, right);
 46 |   }
 47 |   return expr;
 48 | }
 49 | 
 50 | std::shared_ptr<Expr> Parser::comparison(){
 51 |   std::shared_ptr<Expr> expr = shift();
 52 |   while(match(TokenType::GREATER, TokenType::GREATER_EQUAL, TokenType::LESS, TokenType::LESS_EQUAL)){
 53 |     Token oper = previous();
 54 |     std::shared_ptr<Expr> right = shift();
 55 |     expr = std::make_shared<Binary>(expr, oper, right);
 56 |   }
 57 |   return expr;
 58 | }
 59 | 
 60 | std::shared_ptr<Expr> Parser::shift(){
 61 |   std::shared_ptr<Expr> expr = term();
 62 |   while(match(TokenType::GREATER_GREATER, TokenType::LESS_LESS)){
 63 |     Token oper = previous();
 64 |     std::shared_ptr<Expr> right = term();
 65 |     expr = std::make_shared<Binary>(expr, oper, right);
 66 |   }
 67 |   return expr;
 68 | }
 69 | 
 70 | std::shared_ptr<Expr> Parser::term(){
 71 |   std::shared_ptr<Expr> expr = factor();
 72 |   while(match(TokenType::MINUS, TokenType::PLUS)){
 73 |     Token oper = previous();
 74 |     std::shared_ptr<Expr> right = factor();
 75 |     expr = std::make_shared<Binary>(expr, oper, right);
 76 |   }
 77 |   return expr;
 78 | }
 79 | 
 80 | std::shared_ptr<Expr> Parser::factor(){
 81 |   std::shared_ptr<Expr> expr = unary();
 82 |   while(match(TokenType::SLASH, TokenType::STAR, TokenType::PERCENT)){
 83 |     Token oper = previous();
 84 |     std::shared_ptr<Expr> right = unary();
 85 |     expr = std::make_shared<Binary>(expr, oper, right);
 86 |   }
 87 |   return expr;
 88 | }
 89 | 
 90 | std::shared_ptr<Expr> Parser::unary(){
 91 |   while(match(TokenType::BANG, TokenType::MINUS,
 92 |         TokenType::PLUS_PLUS, TokenType::MINUS_MINUS, TokenType::TILDE)){
 93 |     Token oper = previous(); // ++
 94 |     std::shared_ptr<Expr> right = unary(); // var name
 95 | 
 96 |     if(previous().lexeme == "++" || previous().lexeme == "--") { // to optimize
 97 |       Debug::error(previous(), "Invalid operator: postfix increment/decrement followed by prefix.");
 98 |     }
 99 |     matchVoid(TokenType::SEMICOLON);
100 | 
101 |     return std::make_shared<Unary>(oper, right, false);
102 |   }
103 |   return call();
104 | }
105 | 
106 | std::shared_ptr<Expr> Parser::primary(){
107 |   if(match(TokenType::LEFT_BRACE)) return arrayList();
108 |   if(match(TokenType::FALSE)) return std::make_shared<Literal>(false);
109 |   if(match(TokenType::TRUE)) return std::make_shared<Literal>(true);
110 |   if(match(TokenType::NIL)) return std::make_shared<Literal>(nullptr);
111 |   if(match(TokenType::IDENTIFIER)){ 
112 |     std::shared_ptr<Expr> left = std::make_shared<Variable>(previous());
113 |     if (match(TokenType::PLUS_PLUS, TokenType::MINUS_MINUS)) {
114 |       Token oper = previous();
115 |       matchVoid(TokenType::SEMICOLON);
116 |       return std::make_shared<Unary>(oper, left, true);
117 |     }
118 |     return left;
119 |   }
120 | 
121 |   if(match(TokenType::NUMBER, TokenType::STRING)){
122 |     return std::make_shared<Literal>(previous().literal);
123 |   }
124 | 
125 |   if(match(TokenType::LEFT_PAREN)){
126 |     std::shared_ptr<Expr> expr = expression();
127 |     consume(TokenType::RIGHT_PAREN, "Expected ')' after expression.");
128 |     return std::make_shared<Grouping>(expr);
129 |   }
130 | 
131 |   throw error(peek(), "Expected expression.");
132 | }
133 | 
134 | template<class...T>
135 | bool Parser::match(T...types){
136 |   assert((... && std::is_same_v<T, TokenType>)); 
137 |   if((... || check(types))){
138 |     advance();
139 |     return true;
140 |   }
141 |   return false;
142 | }
143 | 
144 | template<class...T>
145 | void Parser::matchVoid(T...types){
146 |   assert((... && std::is_same_v<T, TokenType>)); 
147 |   if((... || check(types))){
148 |     advance();
149 |   }
150 | }
151 | 
152 | Token Parser::consume(const TokenType& token, const std::string& message){
153 |   if(check(token)) return advance();
154 |   throw error(peek(), message);
155 | }
156 | 
157 | bool Parser::check(const TokenType& type){
158 |   if(isAtEnd()) return false;
159 |   return peek().type == type;
160 | }
161 | 
162 | bool Parser::isAtEnd(){
163 |   return peek().type == TokenType::TER_EOF;
164 | }
165 | 
166 | Token Parser::advance(){
167 |   if(!isAtEnd()) current++;
168 |   return previous();
169 | }
170 | 
171 | Token Parser::peek(){
172 |   return tokens.at(static_cast<size_t>(current));
173 | }
174 | 
175 | Token Parser::previous(){
176 |   return tokens.at(static_cast<size_t>(current - 1));
177 | }
178 | 
179 | Parser::ParseError Parser::error(const Token& token, const std::string& message){
180 |   Debug::error(token, message);
181 |   return ParseError("");
182 | }
183 | 
184 | void Parser::synchronize(){
185 |   advance();
186 |   while(!isAtEnd()){
187 |     if(previous().type == TokenType::SEMICOLON) return;
188 |     if(previous().lexeme == "\n") return;
189 |     switch (peek().type) {
190 |       //case TokenType::INCLUDE:
191 |       case TokenType::CLASS:
192 |       case TokenType::SET:
193 |       case TokenType::AUTO:
194 |       case TokenType::FOR:
195 |       case TokenType::IF:
196 |       case TokenType::WHILE:
197 |       case TokenType::OUT:
198 |       case TokenType::OUTPUT:
199 |       case TokenType::RETURN:
200 |       default:
201 |         return;
202 |     }
203 |   }
204 |   advance();
205 | }
206 | 
207 | std::shared_ptr<Statement::Stmt> Parser::statement(){
208 |   if(match(TokenType::INCLUDE)) return includeStatement();
209 |   if(match(TokenType::OUTPUT)) return printStatement();
210 |   if(match(TokenType::OUT)) return outStatement();
211 |   if(match(TokenType::IF)) return IfStatement();
212 |   if(match(TokenType::RETURN)) return returnStatement();
213 |   if(match(TokenType::WHILE)) return whileStatement();
214 |   if(match(TokenType::FOR)) return forStatement();
215 |   if(match(TokenType::LEFT_BRACE)) return std::make_shared<Statement::Block>(block());
216 |   return expressionStatement();
217 | }
218 | 
219 | std::shared_ptr<Statement::Stmt> Parser::printStatement(){
220 |   std::shared_ptr<Expr> value = expression();
221 |   //consume(TokenType::SEMICOLON, "Expected ';' after value."); // MOD
222 |   matchVoid(TokenType::SEMICOLON);
223 |   return std::make_shared<Statement::Print>(value);
224 | }
225 | 
226 | std::shared_ptr<Statement::Stmt> Parser::outStatement(){
227 |   std::shared_ptr<Expr> value = expression();
228 |   //consume(TokenType::SEMICOLON, "Expected ';' after value.");
229 |   matchVoid(TokenType::SEMICOLON);
230 |   return std::make_shared<Statement::Out>(value);
231 | }
232 | 
233 | std::shared_ptr<Statement::Stmt> Parser::expressionStatement(){
234 |   std::shared_ptr<Expr> expr = expression();
235 |   //consume(TokenType::SEMICOLON, "Expected ';' after value.");
236 |   return std::make_shared<Statement::Expression>(expr);
237 | }
238 | 
239 | std::shared_ptr<Statement::Stmt> Parser::declaration(){
240 |   try {
241 |     if(match(TokenType::SET)) return function("function");
242 |     if(match(TokenType::CLASS)) return classDeclaration();
243 |     if(match(TokenType::AUTO)) return varDeclaration();
244 |     return statement();
245 |   } catch (const std::exception& e) {
246 |     synchronize();
247 |     return nullptr;
248 |   }
249 | }
250 | 
251 | std::shared_ptr<Statement::Stmt> Parser::varDeclaration(){
252 |   Token name = consume(TokenType::IDENTIFIER, "Expected variable name.");
253 |   std::shared_ptr<Expr> init = nullptr;
254 |   if(match(TokenType::EQUAL)){
255 |     init = expression();
256 |   }
257 |   //consume(TokenType::SEMICOLON, "Expected ';' after variable declaration."); // MOD
258 |   matchVoid(TokenType::SEMICOLON);
259 |   return std::make_shared<Statement::Var>(name, init);
260 | }
261 | 
262 | std::shared_ptr<Expr> Parser::assignment(){
263 |   std::shared_ptr<Expr> expr = logicalOr();
264 |   if(match(TokenType::EQUAL)){
265 |     Token equals = previous();
266 |     std::shared_ptr<Expr> value = assignment();
267 |     if(Variable *e = dynamic_cast<Variable*>(expr.get())){
268 |       Token name = e->name;
269 |       return std::make_shared<Assign>(std::move(name), value);
270 |     }else if(Get *get = dynamic_cast<Get*>(expr.get())){
271 |       return std::make_shared<Set>(get->object, get->name, value);
272 |     }else if (Callist *s = dynamic_cast<Callist*>(expr.get())) {
273 |       return std::make_shared<Callist>(s->name, s->index, value, s->paren);
274 |     }
275 |     error(std::move(equals), "Invalid assignment target.");
276 |   }
277 |   return expr;
278 | }
279 | 
280 | std::vector<std::shared_ptr<Statement::Stmt>> Parser::block(){
281 |   std::vector<std::shared_ptr<Statement::Stmt>> localStatements;
282 |   while(!check(TokenType::RIGHT_BRACE) && !isAtEnd()){
283 |     localStatements.push_back(declaration());
284 |   }
285 |   consume(TokenType::RIGHT_BRACE, "Expected '}' after block.");
286 |   return localStatements;
287 | }
288 | 
289 | std::shared_ptr<Statement::Stmt> Parser::IfStatement(){
290 |   consume(TokenType::LEFT_PAREN, "Expected '(' after 'if'.");
291 |   std::shared_ptr<Expr> condition = expression();
292 |   consume(TokenType::RIGHT_PAREN, "Expected ')' after 'if' condition.");
293 |   std::shared_ptr<Statement::Stmt> thenBranch = statement();
294 |   std::shared_ptr<Statement::Stmt> elseBranch = nullptr;
295 |   if(match(TokenType::ELSE)){
296 |     elseBranch = statement();
297 |   }
298 |   return std::make_shared<Statement::If>(condition, thenBranch, elseBranch);
299 |   return {};
300 | }
301 | 
302 | std::shared_ptr<Expr> Parser::logicalOr(){
303 |   std::shared_ptr<Expr> expr = logicalAnd();
304 |   while(match(TokenType::OR)){
305 |     Token oper = previous();
306 |     std::shared_ptr<Expr> right = logicalAnd();
307 |     expr = std::make_shared<Logical>(expr, std::move(oper), right);
308 |   }
309 |   return expr;
310 | }
311 | 
312 | std::shared_ptr<Expr> Parser::logicalAnd(){
313 |   std::shared_ptr<Expr> expr = bitwise();
314 |   while(match(TokenType::AND)){
315 |     Token oper = previous();
316 |     std::shared_ptr<Expr> right = bitwise();
317 |     expr = std::make_shared<Logical>(expr, std::move(oper), right);
318 |   }
319 |   return expr;
320 | }
321 | 
322 | std::shared_ptr<Statement::Stmt> Parser::whileStatement(){
323 |   consume(TokenType::LEFT_PAREN, "Expected '(' after 'while'.");
324 |   std::shared_ptr<Expr> condition = expression();
325 |   consume(TokenType::RIGHT_PAREN, "Expected ')' after 'while' condition.");
326 |   std::shared_ptr<Statement::Stmt> body = statement();
327 |   return std::make_shared<Statement::While>(condition, body);
328 | }
329 | 
330 | std::shared_ptr<Statement::Stmt> Parser::forStatement(){
331 |   consume(TokenType::LEFT_PAREN, "Expected '(' after 'for'.");
332 | 
333 |   std::shared_ptr<Statement::Stmt> init;
334 |   if(match(TokenType::SEMICOLON)){
335 |     init = nullptr;
336 |   }else if(match(TokenType::AUTO)){
337 |     init = varDeclaration();
338 |   }else{
339 |     init = expressionStatement();
340 |   }
341 | 
342 |   std::shared_ptr<Expr> condition = nullptr;
343 |   if(!check(TokenType::SEMICOLON)){
344 |     condition = expression();
345 |   }
346 |   consume(TokenType::SEMICOLON, "Expected ';' after for condition.");
347 | 
348 |   std::shared_ptr<Expr> increment = nullptr;
349 |   if(!check(TokenType::RIGHT_PAREN)){
350 |     increment = expression();
351 |   }
352 |   consume(TokenType::RIGHT_PAREN, "Expected ')' after loop condition.");
353 | 
354 |   std::shared_ptr<Statement::Stmt> body = statement();
355 |   if(increment != nullptr){
356 |     body = std::make_shared<Statement::Block>(
357 |         std::vector<std::shared_ptr<Statement::Stmt>> {
358 |         body, std::make_shared<Statement::Expression>(increment)
359 |         } 
360 |         );
361 |   }
362 | 
363 |   if(condition == nullptr){
364 |     condition = std::make_shared<Literal>(true);
365 |   }
366 |   body = std::make_shared<Statement::While>(condition, body);
367 | 
368 |   if(init != nullptr){
369 |     body = std::make_shared<Statement::Block>(
370 |         std::vector<std::shared_ptr<Statement::Stmt>>{
371 |         init, body
372 |         }
373 |         );
374 |   }
375 | 
376 |   return body;
377 | }
378 | 
379 | std::shared_ptr<Expr> Parser::call(){
380 |   //std::shared_ptr<Expr> expr = primary();
381 |   std::shared_ptr<Expr> expr = callist();
382 |   while(true){
383 |     if(match(TokenType::LEFT_PAREN)){
384 |       expr = finishCall(expr);
385 |     }else if(match(TokenType::DOT)){
386 |       Token name = consume(TokenType::IDENTIFIER, "Expected property name after '.'");
387 |       expr = std::make_shared<Get>(expr, name);
388 |     }else{
389 |       break;
390 |     }
391 |   }
392 |   return expr;
393 | }
394 | 
395 | std::shared_ptr<Expr> Parser::finishCall(std::shared_ptr<Expr> callee){
396 |   std::vector<std::shared_ptr<Expr>> arguments;
397 |   if(!check(TokenType::RIGHT_PAREN)){
398 |     do {
399 |       if(arguments.size() >= 255){
400 |         error(peek(), "Can't have more than 255 arguments.");
401 |       }
402 |       arguments.push_back(expression());
403 |     } while(match(TokenType::COMMA));
404 |   }
405 |   Token paren = consume(TokenType::RIGHT_PAREN, "Expected ')' after arguments.");
406 | 
407 |   matchVoid(TokenType::SEMICOLON);
408 |   return std::make_shared<Call>(callee, paren, arguments);
409 | }
410 | 
411 | std::shared_ptr<Statement::Stmt> Parser::returnStatement(){
412 |   Token keyword = previous();
413 |   std::shared_ptr<Expr> value = nullptr;
414 |   //if(!check(TokenType::SEMICOLON)){
415 |   value = expression();
416 |   matchVoid(TokenType::SEMICOLON);
417 |   //}
418 |   //consume(TokenType::SEMICOLON, "Expected ';' after return value.");
419 |   return std::make_shared<Statement::Return>(keyword, value);
420 | }
421 | 
422 | std::shared_ptr<Statement::Function> Parser::function(std::string kind){
423 |   Token funcName = consume(TokenType::IDENTIFIER, "Expected " + kind + " name.");
424 |   consume(TokenType::LEFT_PAREN, "Expected '(' after " + kind + " name.");
425 |   std::vector<Token> parameters;
426 |   if(!check(TokenType::RIGHT_PAREN)){
427 |     do {
428 |       if(parameters.size() >= 255){
429 |         error(peek(), "Can't have more than 255 arguments.");
430 |       }
431 |       parameters.push_back(
432 |           consume(TokenType::IDENTIFIER, "Expected parameter name.")
433 |           );
434 |     } while(match(TokenType::COMMA));
435 |   }
436 |   consume(TokenType::RIGHT_PAREN, "Expected ')' after parameters.");
437 |   consume(TokenType::LEFT_BRACE, "Expected '{' before " + kind + " body.");
438 |   std::vector<std::shared_ptr<Statement::Stmt>> body = block();
439 |   return std::make_shared<Statement::Function>(
440 |       std::move(funcName), std::move(parameters), std::move(body)
441 |       );
442 | }
443 | 
444 | std::shared_ptr<Statement::Stmt> Parser::classDeclaration(){
445 |   Token name = consume(TokenType::IDENTIFIER, "Expected class name");
446 |   consume(TokenType::LEFT_BRACE, "Expected '{' before class body.");
447 | 
448 |   std::vector<std::shared_ptr<Statement::Function>> methods;
449 |   while(!check(TokenType::RIGHT_BRACE) && !isAtEnd()){
450 |     methods.push_back(function("method"));
451 |   }
452 |   consume(TokenType::RIGHT_BRACE, "Expected '}' after class body");
453 |   return std::make_shared<Statement::Class>(name, std::move(methods));
454 | }
455 | 
456 | std::shared_ptr<Statement::Stmt> Parser::includeStatement() {
457 |   Token keyword = previous();
458 | 
459 |   consume(TokenType::LEFT_PAREN, "Expect '(' after 'include' keyword.");
460 |   Token path = consume(TokenType::STRING, "Expect 'path' as a string inside 'include' statement.");
461 |   consume(TokenType::RIGHT_PAREN, "Expect ')' after path in 'include' statement.");
462 |   matchVoid(TokenType::SEMICOLON);
463 | 
464 |   if (std::find(includedFiles.begin(), includedFiles.end(), path.lexeme) != includedFiles.end()) {
465 |     Debug::error(path, "Duplicate header file.");
466 |   }
467 |   includedFiles.push_back(path.lexeme);
468 | 
469 |   IncludeRun::scanFile(path.lexeme);
470 |   const std::vector<Token>& tempTokens = IncludeRun::getTokens();
471 | 
472 |   Parser includedParser(tempTokens);
473 |   std::vector<std::shared_ptr<Statement::Stmt>> includedStatements = includedParser.parse();
474 | 
475 |   for (const auto& stmt : includedStatements) {
476 |     statements.push_back(stmt);
477 |   }
478 | 
479 |   return std::make_shared<Statement::Include>(keyword, path.lexeme);
480 | }
481 | 
482 | std::shared_ptr<Expr> Parser::arrayList() {
483 |   std::vector<std::shared_ptr<Expr>> values = {};
484 |   if (match(TokenType::RIGHT_BRACE)) {
485 |     return std::make_shared<Array>(values);
486 |   } else {
487 |     do {
488 |       if (values.size() >= 255) {
489 |         error(peek(), "Can't have more than 255 elements in a array.");
490 |       }
491 |       std::shared_ptr<Expr> value = logicalOr();
492 |       values.push_back(value);
493 |     } while (match(TokenType::COMMA));
494 |   }
495 |   consume(TokenType::RIGHT_BRACE, "Expect '}' at end of array.");
496 |   return std::make_shared<Array>(values);
497 | }
498 | 
499 | std::shared_ptr<Expr> Parser::finishCallist(std::shared_ptr<Expr> name) {
500 |   std::shared_ptr<Expr> index = logicalOr();
501 |   Token paren = consume(TokenType::RIGHT_BRACKET,
502 |       "Expect ']' after arguments.");
503 |   return std::make_shared<Callist>(name, index, nullptr, paren);
504 | }
505 | 
506 | std::shared_ptr<Expr> Parser::callist() {
507 |   std::shared_ptr<Expr> expr = primary();
508 |   while (true) {
509 |     if (match(TokenType::LEFT_BRACKET)) {
510 |       expr = finishCallist(expr);
511 |     } else {
512 |       break;
513 |     }
514 |   }
515 |   return expr;
516 | }
517 | 


--------------------------------------------------------------------------------
/src/interpreter/Interpreter.cpp:
--------------------------------------------------------------------------------
  1 | #include <cmath>
  2 | #include <iostream>
  3 | 
  4 | #include "Interpreter.hpp"
  5 | #include "BuiltinFactory.hpp"
  6 | #include "../parser/Expr.hpp"
  7 | #include "../utils/Debug.hpp"
  8 | #include "../parser/Stmt.hpp"
  9 | #include "Function.hpp"
 10 | #include "Class.hpp"
 11 | #include "Instance.hpp"
 12 | #include "ArrayType.hpp"  
 13 | #include "../utils/RuntimeError.hpp"
 14 | 
 15 | Interpreter::Interpreter(){}
 16 | 
 17 | /* Do not initialize built-ins in constructor.
 18 |    It was causing Static Initialization Order Fiasco (SIOF).
 19 |    Late initialization to be done manually before first use of the class. */
 20 | void Interpreter::lateInitializator()
 21 | {
 22 |   for(const auto& [name, type] : builtinNames){
 23 |     auto it = builtinFactory.find(type);
 24 |     if(it != builtinFactory.end()){
 25 |       global->define(name, it->second());
 26 |     }
 27 |   }
 28 | }
 29 | 
 30 | std::any Interpreter::visitLiteralExpr(std::shared_ptr<Literal> expr){
 31 |   return expr->value;
 32 | }
 33 | 
 34 | std::any Interpreter::visitUnaryExpr(std::shared_ptr<Unary> expr){
 35 |   int64_t i_right;
 36 |   std::any right = evaluate(expr->right);
 37 | 
 38 |   switch(expr->oper.type){
 39 | 
 40 |     case TokenType::PLUS_PLUS:
 41 |       checkNumberOperand(expr->oper, right);
 42 |       right = std::any_cast<double>(right) + 1;
 43 |       if (auto varExpr = std::dynamic_pointer_cast<Variable>(expr->right)) {
 44 |         curr_env->assign(varExpr->name, right);
 45 |       }
 46 |       if (expr->isPostOperator) {
 47 |         return std::any_cast<double>(right) - 1;
 48 |       }
 49 |       return right;
 50 | 
 51 |     case TokenType::MINUS_MINUS:
 52 |       checkNumberOperand(expr->oper, right);
 53 |       right = std::any_cast<double>(right) - 1;
 54 |       if (auto varExpr = std::dynamic_pointer_cast<Variable>(expr->right)) {
 55 |         curr_env->assign(varExpr->name, right);
 56 |       }
 57 |       if (expr->isPostOperator) {
 58 |         return std::any_cast<double>(right) + 1;
 59 |       }
 60 |       return right;
 61 | 
 62 |     case TokenType::BANG:
 63 |       return !isTruthy(right);
 64 |     case TokenType::MINUS:
 65 |       checkNumberOperand(expr->oper, right);
 66 |       return -std::any_cast<double>(right);
 67 |     case TokenType::TILDE:
 68 |       i_right = doubleToInt(expr->oper,right);
 69 |       return static_cast<double>(~i_right);
 70 |     default:
 71 |       return {};
 72 |   }
 73 | }
 74 | 
 75 | bool Interpreter::isTruthy(const std::any& object){
 76 |   if(object.type() == typeid(nullptr)) return false;
 77 |   if(object.type() == typeid(bool)){
 78 |     return std::any_cast<bool>(object);
 79 |   }
 80 |   return true;
 81 | }
 82 | 
 83 | void Interpreter::checkNumberOperand(const Token& oper, const std::any& operand){
 84 |   if(operand.type() == typeid(double)) return;
 85 |   throw RuntimeError{oper, "Operand must be a number."};
 86 | }
 87 | 
 88 | void Interpreter::checkNumberOperands(const Token& oper, const std::any& left, const std::any& right){
 89 |   if(left.type() == typeid(double) && right.type() == typeid(double)) return;
 90 |   throw RuntimeError{oper, "Operand must be a number."};
 91 | }
 92 | 
 93 | int64_t Interpreter::doubleToInt(const Token& oper, const std::any& value) {
 94 |   double integerPart;
 95 |   if(value.type() != typeid(double)) {
 96 |     throw RuntimeError{oper, "Operand must be a number."};
 97 |   }
 98 |   if (modf(std::any_cast<double>(value), &integerPart) != 0.0) {
 99 |     throw RuntimeError{oper, "Operand must be an integer."};
100 |   }
101 |   if (integerPart < static_cast<double>(std::numeric_limits<int64_t>::min()) ||
102 |       integerPart > static_cast<double>(std::numeric_limits<int64_t>::max())) {
103 |     throw RuntimeError{oper, "Value out of int64_t range"};
104 |   }
105 |   return static_cast<int64_t>(integerPart);
106 | }
107 | 
108 | bool Interpreter::isEqual(const std::any& a, const std::any& b){
109 |   if(a.type() == typeid(nullptr) && b.type() == typeid(nullptr)){
110 |     return true;
111 |   }
112 | 
113 |   if(a.type() == typeid(nullptr) || b.type() == typeid(nullptr)){
114 |     return false;
115 |   }
116 | 
117 |   if(a.type() == typeid(double) && b.type() == typeid(double)){
118 |     return std::any_cast<double>(a) == std::any_cast<double>(b);
119 |   }
120 | 
121 |   if(a.type() == typeid(std::string) && b.type() == typeid(std::string)){
122 |     return std::any_cast<std::string>(a) == std::any_cast<std::string>(b);
123 |   }
124 | 
125 |   if(a.type() == typeid(bool) && b.type() == typeid(bool)){
126 |     return std::any_cast<bool>(a) == std::any_cast<bool>(b);
127 |   }
128 | 
129 |   return false;
130 | }
131 | 
132 | std::string Interpreter::stringify(const std::any& object){
133 |   if(object.type() == typeid(nullptr)) return "nil";
134 | 
135 |   if(object.type() == typeid(double)){
136 |     std::string text = std::to_string(std::any_cast<double>(object));
137 |     if(text[text.length() - 7] == '.' && text[text.length() - 6] == '0'){
138 |       text = text.substr(0, text.length() - 7);
139 |     }
140 |     return text;
141 |   }
142 | 
143 |   if (object.type() == typeid(std::string)) {
144 |     std::string result = std::any_cast<std::string>(object);
145 | 
146 |     // Replace the "\n" and "\r" sequences with real newlines and carriage returns
147 |     size_t pos;
148 |     while ((pos = result.find("\\n")) != std::string::npos) {
149 |       result.replace(pos, 2, "\n");
150 |     }
151 |     while ((pos = result.find("\\r")) != std::string::npos) {
152 |       result.replace(pos, 2, "\r");
153 |     }
154 | 
155 |     return result;
156 |   }
157 | 
158 |   if(object.type() == typeid(bool)){
159 |     if(std::any_cast<bool>(object)){
160 |       std::string result{"true"};
161 |       return result;
162 |     }else{
163 |       std::string result{"false"};
164 |       return result;
165 |     }
166 |   }
167 | 
168 |   if(object.type() == typeid(std::shared_ptr<Function>)){
169 |     std::shared_ptr<Callable> function;
170 |     function = std::any_cast<std::shared_ptr<Function>>(object);
171 |     return function->toString();
172 |   }
173 | 
174 |   if(object.type() == typeid(std::shared_ptr<Instance>)){
175 |     auto instance = std::any_cast<std::shared_ptr<Instance>>(object);
176 |     return instance->toString();
177 |   }
178 | 
179 |   if(object.type() == typeid(std::shared_ptr<Callable>)){
180 |     auto callable = std::any_cast<std::shared_ptr<Callable>>(object);
181 |     return callable->toString();
182 |   }
183 | 
184 |   if(object.type() == typeid(std::shared_ptr<Class>)){
185 |     auto klass = std::any_cast<std::shared_ptr<Class>>(object);
186 |     return klass->toString();
187 |   }
188 | 
189 |   if(object.type() == typeid(std::shared_ptr<ArrayType>)){
190 |     std::string result = "[";
191 |     std::shared_ptr<ArrayType> list;
192 |     list = std::any_cast<std::shared_ptr<ArrayType>>(object);
193 |     auto values = list->values;
194 |     for (auto i = values.begin(); i != values.end(); ++i) {
195 |       auto next = i + 1;
196 |       result.append(stringify(*i));
197 |       if (next != values.end()) {
198 |         result.append(", ");
199 |       }
200 |     }
201 |     result.append("]");
202 |     return result;
203 |   }
204 | 
205 |   return "stringify: cannot reconize type";
206 | }
207 | 
208 | std::any Interpreter::visitGroupingExpr(std::shared_ptr<Grouping> expr){
209 |   return evaluate(expr->expression);
210 | }
211 | 
212 | std::any Interpreter::evaluate(std::shared_ptr<Expr> expr){
213 |   return expr->accept(*this);
214 | }
215 | 
216 | std::any Interpreter::visitBinaryExpr(std::shared_ptr<Binary> expr){
217 |   std::any left = evaluate(expr->left);
218 |   std::any right = evaluate(expr->right);
219 |   int64_t i_left, i_right;
220 | 
221 |   switch (expr->oper.type) {
222 |     case TokenType::GREATER:
223 |       checkNumberOperands(expr->oper, left, right);
224 |       return std::any_cast<double>(left) > std::any_cast<double>(right);
225 |     case TokenType::GREATER_EQUAL:
226 |       checkNumberOperands(expr->oper, left, right);
227 |       return std::any_cast<double>(left) >= std::any_cast<double>(right);
228 |     case TokenType::GREATER_GREATER:
229 |       i_left = doubleToInt(expr->oper,left);
230 |       i_right = doubleToInt(expr->oper,right);
231 |       return static_cast<double>(i_left >> i_right);
232 |     case TokenType::LESS:
233 |       checkNumberOperands(expr->oper, left, right);
234 |       return std::any_cast<double>(left) < std::any_cast<double>(right);
235 |     case TokenType::LESS_EQUAL:
236 |       checkNumberOperands(expr->oper, left, right);
237 |       return std::any_cast<double>(left) <= std::any_cast<double>(right);
238 |     case TokenType::LESS_LESS:
239 |       i_left = doubleToInt(expr->oper,left);
240 |       i_right = doubleToInt(expr->oper,right);
241 |       return static_cast<double>(i_left << i_right);
242 |     case TokenType::MINUS:
243 |       checkNumberOperands(expr->oper, left, right);
244 |       return std::any_cast<double>(left) - std::any_cast<double>(right);
245 |     case TokenType::PLUS:
246 | 
247 |       if(left.type() == typeid(double) && right.type() == typeid(double)){
248 |         return std::any_cast<double>(left) + std::any_cast<double>(right);
249 |       }
250 | 
251 |       if(left.type() == typeid(std::string) && right.type() == typeid(std::string)){
252 |         return std::any_cast<std::string>(left) + std::any_cast<std::string>(right);
253 |       }
254 | 
255 |       throw RuntimeError{expr->oper, "Operands not a same type"};
256 | 
257 |     case TokenType::PERCENT:
258 |       checkNumberOperands(expr->oper, left, right);
259 |       return fmod(std::any_cast<double>(left), std::any_cast<double>(right));
260 |     case TokenType::AMPERSAND:
261 |       i_left = doubleToInt(expr->oper,left);
262 |       i_right = doubleToInt(expr->oper,right);
263 |       return static_cast<double>(i_left & i_right);
264 |     case TokenType::CARET:
265 |       i_left = doubleToInt(expr->oper,left);
266 |       i_right = doubleToInt(expr->oper,right);
267 |       return static_cast<double>(i_left ^ i_right);
268 |     case TokenType::VBAR:
269 |       i_left = doubleToInt(expr->oper,left);
270 |       i_right = doubleToInt(expr->oper,right);
271 |       return static_cast<double>(i_left | i_right);
272 |     case TokenType::STAR:
273 |       checkNumberOperands(expr->oper, left, right);
274 |       return std::any_cast<double>(left) * std::any_cast<double>(right);
275 |     case TokenType::SLASH:
276 |       checkNumberOperands(expr->oper, left, right);
277 |       return std::any_cast<double>(left) / std::any_cast<double>(right);
278 |     case TokenType::BANG_EQUAL:
279 |       checkNumberOperands(expr->oper, left, right);
280 |       return !isEqual(left, right);
281 |     case TokenType::EQUAL_EQUAL:
282 |       return isEqual(left, right);
283 |     default:
284 |       return {};
285 |   }
286 | }
287 | 
288 | void Interpreter::interpret(std::vector<std::shared_ptr<Statement::Stmt>> &statements){
289 |   try {
290 |     for(std::shared_ptr<Statement::Stmt> &statement: statements){
291 |       execute(statement);
292 |     }
293 |   }catch(const RuntimeError& e){
294 |     Debug::runtimeError(e);
295 |   }
296 | }
297 | 
298 | void Interpreter::execute(std::shared_ptr<Statement::Stmt> statement){
299 |   statement->accept(*this);
300 | }
301 | 
302 | std::any Interpreter::visitExpressionStmt(std::shared_ptr<Statement::Expression> stmt){
303 |   std::any value = evaluate(stmt->expression);
304 |   return {};
305 | }
306 | 
307 | std::any Interpreter::visitPrintStmt(std::shared_ptr<Statement::Print> stmt){
308 |   std::any value = evaluate(stmt->expression);
309 |   std::cout << stringify(value) << '\n';
310 |   return {};
311 | }
312 | 
313 | std::any Interpreter::visitOutStmt(std::shared_ptr<Statement::Out> stmt){
314 |   std::any value = evaluate(stmt->expression);
315 |   std::cout << stringify(value);
316 |   return {};
317 | }
318 | 
319 | std::any Interpreter::visitVariableExpr(std::shared_ptr<Variable> expr){
320 |   std::any value = curr_env->get(expr->name);
321 |   if(value.type() == typeid(nullptr)){
322 |     throw RuntimeError(expr->name, "Variable not initialized.");
323 |   }
324 |   return curr_env->get(expr->name);
325 | }
326 | 
327 | std::any Interpreter::visitVarStmt(std::shared_ptr<Statement::Var> stmt){
328 |   std::any value = nullptr;
329 |   if(stmt->init != nullptr){
330 |     value = evaluate(stmt->init);
331 |   }
332 |   curr_env->define(stmt->name.lexeme, std::move(value));
333 |   return {};
334 | }
335 | 
336 | std::any Interpreter::visitAssignExpr(std::shared_ptr<Assign> expr){
337 |   std::any value = evaluate(expr->value);
338 |   auto elem = locals.find(expr);
339 |   if(elem != locals.end()){
340 |     int distance = elem->second;
341 |     curr_env->assignAt(distance, expr->name, value);
342 |   }else{
343 |     global->assign(expr->name, value);
344 |   }
345 |   return value;
346 | }
347 | 
348 | 
349 | void Interpreter::executeBlock(
350 |     const std::vector<std::shared_ptr<Statement::Stmt>> &statements, 
351 |     std::shared_ptr<Env> new_env){
352 | 
353 |   std::shared_ptr<Env> previous = curr_env;
354 |   try{
355 |     curr_env = new_env;
356 |     for(const std::shared_ptr<Statement::Stmt> &statement : statements){
357 |       execute(statement);
358 |     }
359 |   }catch(...) {
360 |     curr_env = previous;
361 |     throw;
362 |   }
363 |   curr_env = previous;
364 | }
365 | 
366 | 
367 | std::any Interpreter::visitBlockStmt(std::shared_ptr<Statement::Block> stmt){
368 |   executeBlock(stmt->statements, std::make_shared<Env>(curr_env));
369 |   return {};
370 | }
371 | 
372 | std::any Interpreter::visitIfStmt(std::shared_ptr<Statement::If> stmt){
373 |   if(isTruthy(evaluate(stmt->condition))){
374 |     execute(stmt->thenBranch);
375 |   }else if(stmt->elseBranch != nullptr){
376 |     execute(stmt->elseBranch);
377 |   }
378 |   return {};
379 | }
380 | 
381 | std::any Interpreter::visitLogicalExpr(std::shared_ptr<Logical> expr){
382 |   std::any left = evaluate(expr->left);
383 |   if(expr->oper.type == TokenType::OR){
384 |     if(isTruthy(left)) return left;
385 |   }else{
386 |     if(!isTruthy(left)) return left;
387 |   }
388 |   return evaluate(expr->right);
389 | }
390 | 
391 | 
392 | std::any Interpreter::visitWhileStmt(std::shared_ptr<Statement::While> stmt){
393 |   while(isTruthy(evaluate(stmt->condition))){
394 |     execute(stmt->body);
395 |   }
396 |   return {};
397 | }
398 | 
399 | std::any Interpreter::visitCallExpr(std::shared_ptr<Call> expr){
400 |   std::any callee = evaluate(expr->callee);
401 |   std::vector<std::any> arguments;
402 | 
403 |   for(std::shared_ptr<Expr> &argument : expr->arguments){
404 |     arguments.push_back(evaluate(argument));
405 |   }
406 | 
407 |   // Check if it is a generic Callable
408 |   if(callee.type() == typeid(std::shared_ptr<Callable>)){
409 |     auto function = std::any_cast<std::shared_ptr<Callable>>(callee);
410 |     return function->call(*this, arguments);
411 |   }
412 | 
413 |   // Checks if it is a user-defined function
414 |   if(callee.type() == typeid(std::shared_ptr<Function>)){
415 |     auto function = std::any_cast<std::shared_ptr<Function>>(callee);
416 |     return function->call(*this, arguments);
417 |   }
418 | 
419 |   // Checks if it is a class (to instantiate objects)
420 |   if(callee.type() == typeid(std::shared_ptr<Class>)){
421 |     auto klass = std::any_cast<std::shared_ptr<Class>>(callee);
422 |     return std::make_shared<Instance>(klass);
423 |   }
424 | 
425 |   throw RuntimeError{expr->paren, "Can only call functions and classes."};
426 | }
427 | 
428 | 
429 | std::any Interpreter::visitFunctionStmt(std::shared_ptr<Statement::Function> stmt){
430 |   auto function = std::make_shared<Function>(stmt, curr_env);
431 |   curr_env->define(stmt->name.lexeme, function);
432 |   return {};
433 | }
434 | 
435 | std::any Interpreter::visitReturnStmt(std::shared_ptr<Statement::Return> stmt){
436 |   std::any value = nullptr;
437 |   if(stmt->value != nullptr){
438 |     value = evaluate(stmt->value);
439 |   }
440 |   throw Return{value};
441 | }
442 | 
443 | std::any Interpreter::lookUpVariable(Token& name, std::shared_ptr<Expr> expr){
444 |   auto elem = locals.find(expr);
445 |   if(elem != locals.end()){
446 |     int distance = elem->second;
447 |     return curr_env->getAt(distance, name.lexeme);
448 |   }else{
449 |     return global->get(name);
450 |   }
451 | }
452 | 
453 | void Interpreter::resolve(std::shared_ptr<Expr> expr, int depth){
454 |   locals[expr] = depth;
455 | }
456 | 
457 | std::any Interpreter::visitClassStmt(std::shared_ptr<Statement::Class> stmt){
458 |   std::any value = nullptr;
459 |   curr_env->define(stmt->name.lexeme, value);
460 | 
461 |   std::unordered_map<std::string, std::shared_ptr<Function>> methods;
462 | 
463 |   for(const auto &method : stmt->methods){
464 |     auto function = std::make_shared<Function>(method, curr_env);
465 |     methods[method->name.lexeme] = function;
466 |   }
467 | 
468 |   auto klass = std::make_shared<Class>(stmt->name.lexeme, methods);
469 |   curr_env->assign(stmt->name, klass);
470 |   return {};
471 | }
472 | 
473 | std::any Interpreter::visitGetExpr(std::shared_ptr<Get> expr){
474 |   std::any object = evaluate(expr->object);
475 |   if(object.type() == typeid(std::shared_ptr<Instance>)){
476 |     auto instance = std::any_cast<std::shared_ptr<Instance>>(object);
477 |     return instance->get(expr->name);
478 |   }
479 | 
480 |   throw RuntimeError(expr->name, "Only instances have properties.");
481 | }
482 | 
483 | std::any Interpreter::visitSetExpr(std::shared_ptr<Set> expr){
484 |   std::any object = evaluate(expr->object);
485 |   if(object.type() != typeid(std::shared_ptr<Instance>)){
486 |     throw RuntimeError(expr->name, "Only instances have properties.");
487 |   }
488 |   std::any value = evaluate(expr->value);
489 |   auto instance = std::any_cast<std::shared_ptr<Instance>>(object);
490 |   instance->set(expr->name, value);
491 |   return value;
492 | }
493 | 
494 | 
495 | std::any Interpreter::visitIncludeStmt(std::shared_ptr<Statement::Include> stmt){
496 |   if(stmt->keyword.type != TokenType::INCLUDE){
497 |     return {};
498 |   }
499 |   return {};
500 | }
501 | 
502 | std::any Interpreter::visitArrayExpr(std::shared_ptr<Array> expr){
503 |   auto list = std::make_shared<ArrayType>();
504 |   for (std::shared_ptr<Expr> &value : expr->values) {
505 |     list->append(evaluate(value));
506 |   }
507 |   return list;
508 | }
509 | 
510 | std::any Interpreter::visitCallistExpr(std::shared_ptr<Callist> expr){
511 |   std::any name = evaluate(expr->name);
512 |   std::any index = evaluate(expr->index);
513 |   if(name.type() == typeid(std::shared_ptr<ArrayType>)){
514 |     if(index.type() == typeid(double)){
515 |       std::shared_ptr<ArrayType> list;
516 |       double castedIndex;
517 |       list = std::any_cast<std::shared_ptr<ArrayType>>(name);
518 |       castedIndex = std::any_cast<double>(index);
519 |       if(expr->value != nullptr){
520 |         std::any value = evaluate(expr->value);
521 |         if(list->setAtIndex(static_cast<int>(castedIndex), value)) {
522 |           return value; 
523 |         }else{
524 |           throw RuntimeError{expr->paren, "Index out of range."};
525 |         }
526 |       }else{
527 |         if(castedIndex >= list->length() || castedIndex < 0){
528 |           return nullptr;
529 |         }
530 |         return list->getEleAt(static_cast<int>(castedIndex));
531 |       }
532 |     }else{
533 |       throw RuntimeError{expr->paren, "Index should be of type int."};
534 |     }
535 |   }else{
536 |     throw RuntimeError{expr->paren, "Only arrays can be callist."};
537 |   }
538 |   return {};
539 | }
540 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------