ADD: if macro and comparison functions.

examples/cmp.fk

@@ -0,0 +1,35 @@
+(assert= true (> 5 2))
+(assert= false (> 5 5))
+(assert= false (> 5 8))
+(assert= true (>= 5 2))
+(assert= true (>= 5 5))
+(assert= false (>= 5 8))
+(assert= true (< 1 2))
+(assert= false (< 3 3))
+(assert= false (< 5 2))
+(assert= true (<= 1 2))
+(assert= true (<= 3 3))
+(assert= false (<= 5 2))
+
+(assert= true (> 5. 2.))
+(assert= false (> 5. 5.))
+(assert= false (> 5. 8.))
+(assert= true (>= 5. 2.))
+(assert= true (>= 5. 5.))
+(assert= false (>= 5. 8.))
+(assert= true (< 1. 2.))
+(assert= false (< 3. 3.))
+(assert= false (< 5. 2.))
+(assert= true (<= 1. 2.))
+(assert= true (<= 3. 3.))
+(assert= false (<= 5. 2.))
+
+(assert= true (= 12 12))
+(assert= false (= 1 3))
+(assert= false (<> 16 16))
+(assert= true (<> 19 7))
+
+(assert= true (= 12. 12.))
+(assert= false (= 1. 3.))
+(assert= false (<> 1.6 1.6))
+(assert= true (<> 19. 7.))

examples/if.fk

@@ -0,0 +1,5 @@
+($ a (if true 12 78))
+($ b (if false 46 966))
+
+(assert= 12 a)
+(assert= 966 b)

examples/int.fk

@@ -0,0 +1,25 @@
+(assert= 3 (+ 3))
+(assert= 6 (+ 1 2 3))
+(assert= 0 (+))
+
+(assert= -3 (- 3))
+(assert= 4 (- 7 3))
+(assert= -4 (- 1 2 3))
+(assert= 0 (-))
+
+(assert= 1 (*))
+(assert= 2 (* 2))
+(assert= 14 (* 2 7))
+
+(assert= 1 (/))
+(assert= 0 (/ 5))
+(assert= 2 (/ 5 2))
+(assert= 6 (/ 18 3))
+
+(assert= 1 (%))
+(assert= 3 (% 7 4))
+
+(assert= 1 (^))
+(assert= 128 (^ 2 7))
+
+(assert= 8 (* 2 (+ 1 3)))

libstd/commons.hpp

@@ -1,6 +1,7 @@
 #ifndef fkstd_COMMONS_HPP
 #define fkstd_COMMONS_HPP
 
+#include <cmath>
 #include "../src/Module.hpp"
 #include "../src/Constant.hpp"
 

libstd/fun.cpp

@@ -1,8 +1,26 @@
 #include "fun.hpp"
 
+#define NUM_BINOP(OP)\
+  auto lhs = args[0];                                                   \
+  auto rhs = args[1];                                                   \
+  bool res = false;                                                     \
+                                                                        \
+  if (lhs->type() == TYPE_INT)                                          \
+    {                                                                   \
+      res = std::get<int>(lhs->value()) OP std::get<int>(rhs->value());  \
+    }                                                                   \
+                                                                        \
+  if (lhs->type() == TYPE_FLOAT)                                        \
+    {                                                                   \
+      res = std::get<float>(lhs->value()) OP std::get<float>(rhs->value()); \
+    }                                                                   \
+                                                                        \
+  return std::make_shared<Constant>(TYPE_BOOL, res, loc)
+
+
 namespace fkstd
 {
-  STDRET assert_eq(STDARGS args)
+  STDRET assert_eq(Loc loc, STDARGS args)
   {
     auto oracle = args[0];
     auto expr = args[1];
@@ -16,13 +34,13 @@ namespace fkstd
            << expr->string()
            << "'";
 
-        oracle->loc().error<assert_error>(LOG_ERROR, ss.str());
+        loc.error<assert_error>(LOG_ERROR, ss.str());
       }
 
-    return std::make_shared<Constant>(TYPE_BOOL, true, oracle->loc());
+    return std::make_shared<Constant>(TYPE_BOOL, true, loc);
   }
 
-  STDRET println(STDARGS args)
+  STDRET println(Loc loc, STDARGS args)
   {
     std::string sep;
 
@@ -32,8 +50,6 @@ namespace fkstd
         sep = " ";
       }
 
-    Loc loc {"???"};
-
     if (args.size() > 0)
       {
         loc = args.front()->loc();
@@ -43,4 +59,140 @@ namespace fkstd
 
     return std::make_shared<Constant>(TYPE_INT, 0, loc);
   }
+
+  STDRET add_int(Loc loc, STDARGS args)
+  {
+    int result = 0;
+
+    for (auto arg: args)
+      {
+        result += std::get<int>(arg->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_INT, result, loc);
+  }
+
+  STDRET sub_int(Loc loc, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_INT, 0, loc);
+      }
+
+    if (args.size() == 1)
+      {
+        return std::make_shared<Constant>(TYPE_INT,
+                                          -std::get<int>(args[0]->value()),
+                                          loc);
+      }
+
+    int result = std::get<int>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result -= std::get<int>(args[i]->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_INT, result, loc);
+  }
+
+  STDRET mul_int(Loc loc, STDARGS args)
+  {
+    int result = 1;
+
+    for (auto arg: args)
+      {
+        result *= std::get<int>(arg->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_INT, result, loc);
+  }
+
+  STDRET div_int(Loc loc, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_INT, 1, loc);
+      }
+
+    if (args.size() == 1)
+      {
+        return std::make_shared<Constant>(TYPE_INT,
+                                          1/std::get<int>(args[0]->value()),
+                                          loc);
+      }
+
+    int result = std::get<int>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result /= std::get<int>(args[i]->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_INT, result, loc);
+  }
+
+  STDRET mod_int(Loc loc, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_INT, 1, loc);
+      }
+
+    int result = std::get<int>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result %= std::get<int>(args[i]->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_INT, result, loc);
+  }
+
+  STDRET pow_int(Loc loc, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_INT, 1, loc);
+      }
+
+    int result = std::get<int>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = std::pow(result, std::get<int>(args[i]->value()));
+      }
+
+    return std::make_shared<Constant>(TYPE_INT, result, loc);
+  }
+
+  STDRET lt(Loc loc, STDARGS args)
+  {
+    NUM_BINOP(<);
+  }
+
+  STDRET le(Loc loc, STDARGS args)
+  {
+    NUM_BINOP(<=);
+  }
+
+  STDRET gt(Loc loc, STDARGS args)
+  {
+    NUM_BINOP(>);
+  }
+
+  STDRET ge(Loc loc, STDARGS args)
+  {
+    NUM_BINOP(>=);
+  }
+
+  STDRET eq(Loc loc, STDARGS args)
+  {
+    NUM_BINOP(==);
+  }
+
+  STDRET ne(Loc loc, STDARGS args)
+  {
+    NUM_BINOP(!=);
+  }
 }

libstd/fun.hpp

@@ -4,8 +4,22 @@
 
 namespace fkstd
 {
-  STDRET assert_eq(STDARGS args);
+  STDRET assert_eq(Loc loc, STDARGS args);
-  STDRET println(STDARGS args);
+  STDRET println(Loc loc, STDARGS args);
+
+  STDRET add_int(Loc loc, STDARGS args);
+  STDRET sub_int(Loc loc, STDARGS args);
+  STDRET mul_int(Loc loc, STDARGS args);
+  STDRET div_int(Loc loc, STDARGS args);
+  STDRET mod_int(Loc loc, STDARGS args);
+  STDRET pow_int(Loc loc, STDARGS args);
+
+  STDRET lt(Loc loc, STDARGS args);
+  STDRET le(Loc loc, STDARGS args);
+  STDRET gt(Loc loc, STDARGS args);
+  STDRET ge(Loc loc, STDARGS args);
+  STDRET eq(Loc loc, STDARGS args);
+  STDRET ne(Loc loc, STDARGS args);
 }
 
 #endif

libstd/lib.cpp

@@ -6,8 +6,21 @@ extern "C" void lib(Module& mod)
 {
   mod.register_function("assert=", fkstd::assert_eq);
   mod.register_function("println", fkstd::println);
+  mod.register_function("+", fkstd::add_int);
+  mod.register_function("-", fkstd::sub_int);
+  mod.register_function("*", fkstd::mul_int);
+  mod.register_function("/", fkstd::div_int);
+  mod.register_function("%", fkstd::mod_int);
+  mod.register_function("^", fkstd::pow_int);
+  mod.register_function("<", fkstd::lt);
+  mod.register_function("<=", fkstd::le);
+  mod.register_function(">", fkstd::gt);
+  mod.register_function(">=", fkstd::ge);
+  mod.register_function("=", fkstd::eq);
+  mod.register_function("<>", fkstd::ne);
 
   mod.register_macro("assert-static-fail", fkstd::assert_static_fail);
   mod.register_macro(":", fkstd::block);
   mod.register_macro("$", fkstd::decl);
+  mod.register_macro("if", fkstd::if_macro);
 }

libstd/macro.cpp

@@ -62,4 +62,23 @@ namespace fkstd
 
     compiler.sym()->leave_scope();
   }
+
+  void if_macro(Compiler& compiler,
+                std::shared_ptr<Node> node,
+                std::shared_ptr<Program> program)
+  {
+    auto if_expr = node->child(1);
+    auto then_expr = node->child(2);
+    auto else_expr = node->child(3);
+
+    compiler.compile_prog(if_expr, program);
+    size_t to_else = program->add(OP_BNE, 0 /*else*/);
+
+    compiler.compile_prog(then_expr, program);
+    size_t to_end = program->add(OP_BR, 0 /* end */);
+
+    program->set_param(to_else, program->size());
+    compiler.compile_prog(else_expr, program);
+    program->set_param(to_end, program->size());
+  }
 }

libstd/macro.hpp

@@ -15,6 +15,10 @@ namespace fkstd
   void block(Compiler& compiler,
              std::shared_ptr<Node> node,
              std::shared_ptr<Program> program);
+
+  void if_macro(Compiler& compiler,
+                std::shared_ptr<Node> node,
+                std::shared_ptr<Program> program);
 }
 
 #endif

src/Compiler.cpp

@@ -83,6 +83,7 @@ namespace fk
       case NODE_CALL: {
         std::string ident = node->child(0)->repr();
 
+
         if (auto itr=m_macros.find(ident);
             itr != std::end(m_macros))
           {

src/Module.hpp

@@ -29,7 +29,7 @@ namespace fk
   private:
     std::filesystem::path m_source_path;
     std::string m_source;
-    Loc m_loc {m_source_path};
+    Loc m_loc {m_source_path, 1};
     std::shared_ptr<Lexer> m_lexer = std::make_shared<Lexer>(m_loc);
     std::shared_ptr<Parser> m_parser = std::make_shared<Parser>(*m_lexer);
     std::shared_ptr<SymTable> m_sym = std::make_shared<SymTable>();

src/NativeFunction.cpp

@@ -12,8 +12,9 @@ namespace fk
   }
 
   std::shared_ptr<Constant>
-  NativeFunction::call(std::vector<std::shared_ptr<Constant>> args)
+  NativeFunction::call(Loc const& loc,
+                       std::vector<std::shared_ptr<Constant>> args)
   {
-    return m_native(args);
+    return m_native(loc, args);
   }
 }

src/NativeFunction.hpp

@@ -7,7 +7,7 @@
 namespace fk
 {
   using native_t = std::function
-    <std::shared_ptr<Constant>(std::vector<std::shared_ptr<Constant>>)>;
+    <std::shared_ptr<Constant>(Loc, std::vector<std::shared_ptr<Constant>>)>;
 
   class NativeFunction
   {
@@ -16,7 +16,7 @@ namespace fk
     virtual ~NativeFunction();
 
     std::shared_ptr<Constant>
-    call(std::vector<std::shared_ptr<Constant>> args);
+    call(Loc const& loc, std::vector<std::shared_ptr<Constant>> args);
 
   private:
     native_t m_native;

src/Program.cpp

@@ -16,6 +16,12 @@ namespace fk
     return m_instrs.size() - 1;
   }
 
+  void Program::set_param(size_t index, addr_t param)
+  {
+    assert(index < m_instrs.size());
+    m_instrs[index].param = param;
+  }
+
   Instr Program::instr(size_t index) const
   {
     assert(index < size());
@@ -32,7 +38,9 @@ namespace fk
   {
     for (size_t i=0; i<m_consts.size(); i++)
       {
-        if (m_consts[i]->equals(*constant))
+        if (m_consts[i]->equals(*constant)
+            && m_consts[i]->loc().line() == constant->loc().line()
+            && m_consts[i]->loc().path() == constant->loc().path())
           {
             return i;
           }

src/Program.hpp

@@ -24,6 +24,8 @@ namespace fk
     size_t const_size() const { return m_consts.size(); }
 
     size_t add(Opcode opcode, addr_t param=NO_PARAM);
+    void set_param(size_t index, addr_t param);
+
     Instr instr(size_t index) const;
     std::shared_ptr<Constant> get_const(addr_t addr) const;
 

src/VM.cpp

@@ -27,6 +27,25 @@ namespace fk
 
         switch (instr.opcode)
           {
+          case OP_BR: {
+            m_pc = instr.param;
+          } break;
+
+          case OP_BNE: {
+            auto cond_val = frame().program->get_const(pop());
+            bool cond = std::get<bool>(cond_val->value());
+
+            if (!cond)
+              {
+                m_pc = instr.param;
+              }
+            else
+              {
+                m_pc++;
+              }
+
+          } break;
+
           case OP_MAKE_FUNCTION: {
             auto p = frame().program->get_const(pop());
             auto prog = std::get<std::shared_ptr<Program>>(p->value());
@@ -101,13 +120,19 @@ namespace fk
                 args.insert(std::begin(args),
                             frame().program->get_const(addr));
               }
+            auto ref_val = frame().program->get_const(pop());
+            Loc loc = ref_val->loc();
 
-            auto ref = std::get<size_t>(frame().program
+            if (instr.param > 0)
-                                        ->get_const(pop())->value());
+              {
+                loc = args.front()->loc();
+              }
+
+            auto ref = std::get<size_t>(ref_val->value());
             auto fun = std::get<std::shared_ptr<NativeFunction>>
               (load_global(ref));
 
-            push(frame().program->add(fun->call(args)));
+            push(frame().program->add(fun->call(loc, args)));
 
             m_pc++;
           } break;

src/opcodes.hpp

@@ -3,7 +3,8 @@
 
 #define OPCODES(G) G(OP_LOAD_CONST), G(OP_POP), G(OP_CALL_NATIVE), \
     G(OP_LOAD_GLOBAL), G(OP_LOAD_LOCAL), G(OP_STORE_LOCAL), \
-    G(OP_MAKE_FUNCTION), G(OP_CALL_REF), G(OP_RET)
+    G(OP_MAKE_FUNCTION), G(OP_CALL_REF), G(OP_RET), G(OP_BNE), \
+    G(OP_BR)
 
 #include "commons.hpp"