Embedded Scripting Languages

cmake_minimum_required(VERSION 3.0)
project(duktape-cc-trial)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

include(lua-lib.cmake)

#-----  Target Definitions ----------------------------#

       add_executable( embed-lua-sol embed-lua-sol.cpp)
target_link_libraries( embed-lua-sol lua::lualib )

# Lua REPL executable built from static library liblua.a (Linux)
# Note: the main() function is in the file main.c in the lua sources directory
       add_executable( lua-repl $<TARGET_OBJECTS:lua::lualib> )
target_link_libraries( lua-repl m pthread )

include(FetchContent)

# Note: the 'add_subriectory' line was commented becuyase 
#       library that will be downloaded does not have 
#       a CMakeListst.txt file at the root directory. 
macro(Download_Library_Git  NAME TAG REPOSITORY_URL)
    FetchContent_Declare(
        ${NAME}
        GIT_REPOSITORY  ${REPOSITORY_URL}
        GIT_TAG         ${TAG}
    )
    FetchContent_GetProperties(${NAME})
    if(NOT cpputest_POPULATED)
        FetchContent_Populate(${NAME})
        message("${NAME}_SOURCE_DIR} = ${${NAME}_SOURCE_DIR}")        

        # => Disable following line: the library does not have a CMakeLists.txt
        #    at the root directory.
        # add_subdirectory(${${NAME}_SOURCE_DIR} ${${NAME}_BINARY_DIR})
    endif()
endmacro()


# ====>> Download Lua library <<==========================#

Download_Library_Git( lua                       
                      v5.3.5
                      https://github.com/lua/lua
                    )

file(GLOB_RECURSE lua_sources "${lua_SOURCE_DIR}/*.c")
file(GLOB_RECURSE lua_headers" ${lua_SOURCE_DIR}/*.h")

message( [TRACE] " lua_SOURCE_DIR = ${lua_SOURCE_DIR} ")

               add_library( lua STATIC ${lua_sources} ${lua_headers} )
target_include_directories( lua PUBLIC ${lua_SOURCE_DIR} )

add_library( lua::lualib  ALIAS lua)

# ====>> Download Sol C++ binding library <<====================#

FetchContent_Declare( sol2 
                      GIT_REPOSITORY  https://github.com/ThePhD/sol2
                      GIT_TAG         v3.2.0
                    )

FetchContent_MakeAvailable( sol2 )
include_directories( ${sol2_SOURCE_DIR}/include )

add_rules("mode.debug", "mode.release")

includes_lua = false 

add_requires("sol2 v3.2.1")

target("embed-lua-sol")
  set_kind("binary")
  set_languages("c++17")
  add_files("./embed-lua-sol.cpp")
  add_packages("sol2")  

#include <iostream>
#include <string> 
#include <vector> 
#include <algorithm>

#include <sol/sol.hpp>


class Counter {
private: 
    std::string m_name;
    int         m_counter;

public: 

    // Ctor [1] => Default ctor 
    Counter(): Counter("untitled", 0) { }

    // Ctor [2]
    Counter(std::string name, int counter)
      : m_name{std::move(name)}, m_counter{counter}
    { 
        std::cout << " [TRACE] Counter created with =>  { " 
                  <<   " name = " << m_name 
                  << " ; counter = " << m_counter 
                  << " } \n";
    }

    int getCounter() const { return m_counter; }
    void setCounter(int n) {       
      m_counter = n; 
      std::cout << " [TRACE] I was set to value " << n << std::endl;
    }

    void increment() {       
      m_counter++; 
      std::cout << " [TRACE] increment event =>> counter = {  " 
                << m_name << " ; " << m_counter 
                << " } " << std::endl;
    }    
};

double add_fun(double a, double b)
{
    std::cout << " [TRACE] addfun() => a = " << a 
              << " ; b = " << b << std::endl;
    return a + b;             
}

void sol_eval(sol::state& ctx, std::string code)
{
    try {
        ctx.script( std::move(code) );        
    } catch ( sol::error const& ex) {
        std::cerr << " [SOL ERROR] " << ex.what() << "\n";
    }
}


int main()
{
    // Create an instance of lua Engine (aka virtual Machine)
    sol::state ctx{};

    // Load basic libraries (such as print)
    ctx.open_libraries(sol::lib::base, sol::lib::coroutine, sol::lib::string, sol::lib::io);    

    // Register function pointer 
    ctx.set_function("add_fun", &add_fun);

    // Register lambda object 
    ctx.set_function("make_vector", [](int n ) -> std::vector<int> {
        auto vec = std::vector<int>(n);
        for(int i = 0; i < n; i++ ) vec[i]= i * 3;
        return vec;
    });

    // Set variables in the Lua engine 
    ctx["points"]    = 2000;
    ctx.set("character", "<Marcus Tulius Cicero>");

    /* ===========>>> E X P E  R I M E N T / 1  <<=========*/
    std::puts("\n [EXPERIMENT 1] ==>> Evaluating string as code ");
    {
        // ===>>> Eval code as string <<=== 
        // Throws exception sol::error 
        ctx.script(R"(
            print(" [LUA] Hello world lua "); 

            x = add_fun(10, 20);
            print("\n  [LUA] result =  " .. x);

            v = make_vector(5);
            print("\n  [LUA] Printing a vector ");

            for i = 1, 5 do 
                print("   -> v[" .. i .. " ] = " .. v[i] );
            end 

            print("  [LUA] VAR points    = " .. points );
            print("  [LUA] VAR character = " .. character );
        )");

    }

    /* ===========>>> E X P E  R I M E N T / 2  <<=========*/
    std::puts("\n\n [EXPERIMENT 2] ==>> Reading configuration ");
    {
        ctx.script(R"(
            -- Simulation of user configuration from script     
            asset_path   = "C:\\\\Users\\myuser\\data\\files\\";
            user_credits = 2000;
            width        = 200.561;        
        )");

        auto asset_path = ctx.get<std::string>("asset_path");
        int user_credits = ctx["user_credits"];

        std::cout << "  [*] => asset_path = " << asset_path << "\n";
        std::cout << "  [*] => user_credits = " << user_credits << "\n";

    }

    /* ===========>>> E X P E  R I M E N T / 3  <<=========*/
    std::puts("\n\n [EXPERIMENT 3] ==>> Register C++ classes ");

    struct StatefulFunctor {
        int state = 0;
        StatefulFunctor(int state): state(state){ }
        int operator()(){ 

            std::cout << "  *=>> [StatefulFunctor] My new state is = " 
                      << this->state << "\n";
            return state++; 
        }
    };

    auto stateful = StatefulFunctor(10);
    ctx.set_function("stateful", stateful);

    ctx.script(R"(
        stateful();
        stateful();
        stateful();
    )");


    ctx.new_usertype<Counter>(
        // Class name 
         "Counter"          

        //  --- Register methods  ------ //
        ,"getCounter", &Counter::getCounter
        ,"setCounter", &Counter::setCounter
        ,"increment",  &Counter::increment

        // --- Register properties  ---- //
        , "value",     sol::property( &Counter::getCounter
                                    , &Counter::setCounter)
    );


    sol_eval(ctx, R"(
        print("\n ----->>> Calling C++ classes from Lua <----- ");

        -- Create new instance (object) of C++ class Counter 
        counter = Counter.new();
        counter:increment();
        counter:increment(); 
        counter:increment();

        x = counter:getCounter(); 
        print("  [*] value of counter is equal to = " .. x);

        counter.value = 2000;
        print(" [*] Counter value is equal to = " .. counter.value );
    )");

    Counter* ptr = ctx.get<Counter*>("counter");

    std::cout << " [FROM C++] counter value = " 
              << ptr->getCounter() 
              << "\n";

    return 0;
}

$ git clone https://gist.github.com/17a37d905d3d71c0ae66661a189481b5 lua-sol && cd lua-sol 
$ cmake --config Debug -H. -B_build 
$ cmake --build _build --target 

$ git clone https://gist.github.com/17a37d905d3d71c0ae66661a189481b5 lua-sol && cd lua-sol 
$ cmake --config Release -H. -B_build 
$ cmake --build _build --target 

# Confirm whether the executable is statically linked against LuaLib 
$ ldd _build/embed-lua-sol 
       linux-vdso.so.1 (0x00007ffdf0fc4000)
       libstdc++.so.6 => /lib64/libstdc++.so.6 (0x00007fe4490e6000)
       libm.so.6 => /lib64/libm.so.6 (0x00007fe448fa0000)
       libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007fe448f85000)
       libc.so.6 => /lib64/libc.so.6 (0x00007fe448dbb000)
       /lib64/ld-linux-x86-64.so.2 (0x00007fe4492fa000)

  # Static library 
  $ file _build/liblua.a 
 _build/liblua.a: current ar archive

$ _build/embed-lua-sol 

[EXPERIMENT 1] ==>> Evaluating string as code 
[LUA] Hello world lua 
[TRACE] addfun() => a = 10 ; b = 20

 [LUA] result =  30.0

 [LUA] Printing a vector 
  -> v[1 ] = 0
  -> v[2 ] = 3
  -> v[3 ] = 6
  -> v[4 ] = 9
  -> v[5 ] = 12
 [LUA] VAR points    = 2000
 [LUA] VAR character = <Marcus Tulius Cicero>


[EXPERIMENT 2] ==>> Reading configuration 
 [*] => asset_path = C:\\Users\myuser\data\files\
 [*] => user_credits = 2000


[EXPERIMENT 3] ==>> Register C++ classes 
 *=>> [StatefulFunctor] My new state is = 10
 *=>> [StatefulFunctor] My new state is = 11
 *=>> [StatefulFunctor] My new state is = 12

----->>> Calling C++ classes from Lua <----- 
[TRACE] Counter created with =>  {  name = untitled ; counter = 0 } 
[TRACE] increment event =>> counter = {  untitled ; 1 } 
[TRACE] increment event =>> counter = {  untitled ; 2 } 
[TRACE] increment event =>> counter = {  untitled ; 3 } 
 [*] value of counter is equal to = 3
[TRACE] I was set to value 2000
[*] Counter value is equal to = 2000
[FROM C++] counter value = 2000

$ rlwrap  _build/lua-repl 
Lua 5.3.5  Copyright (C) 1994-2018 Lua.org, PUC-Rio
> 
> 

> print(" Hello world Lua / Luna / Moon REPL ")
 Hello world Lua / Luna / Moon REPL 

> for i = 1, 5 do print(" i = " .. i ) end
 i = 1
 i = 2
 i = 3
 i = 4
 i = 5


function myfunction(a, b) 
  return math.sin(a) * math.exp(b) / a - a * b 
end 

> myfunction(3.5, 2.0)
-7.7405591279893

function add (a)
   local sum = 0
   for i,v in ipairs(a) do
      sum = sum + v
   end
   return sum
end

> add({ 2.5, 10.2, -2.51, 8.251, 10.56})
29.001

function add (a)
      local sum = 0
      for i,v in ipairs(a) do
        sum = sum + v
      end
return su

 $ >> xmake build -P . -v 

[ 25%]: ccache compiling.release embed-lua-sol.cpp
/usr/bin/gcc -c -m64 -fvisibility=hidden -fvisibility-inlines-hidden -O3 -std=c++17 \
        -isystem /home/user/.xmake/packages/s/sol2/v3.2.1/5fa1980e381b40ed942748bdef09488a/include \
        -isystem /home/user/.xmake/packages/l/lua/v5.4.4/4de5c31814a64c0d9242d1e524082873/include/lua \
         -DNDEBUG -o build/.objs/embed-lua-sol/linux/x86_64/release/embed-lua-sol.cpp.o embed-lua-sol.cpp

[ 50%]: linking.release embed-lua-sol
/usr/bin/g++ -o build/linux/x86_64/release/embed-lua-sol build/.objs/embed-lua-sol/linux/x86_64/release/embed-lua-sol.cpp.o \
     -m64 -L/home/user/.xmake/packages/l/lua/v5.4.4/4de5c31814a64c0d9242d1e524082873/lib -s -llua -ldl -lm
[100%]: build ok!

 $ >> xmake project -v -k cmake -P . # Overrides CMakeLists.txt if it already exists

configure
{
    plat = linux
    buildir = build
    arch = x86_64
    mode = release
    ccache = true
    ndk_stdcxx = true
    host = linux
    kind = static
}
create ok!

$ >> xmake run -P .

[EXPERIMENT 1] ==>> Evaluating string as code 
[LUA] Hello world lua 
[TRACE] addfun() => a = 10 ; b = 20

 [LUA] result =  30.0

 [LUA] Printing a vector 
  -> v[1 ] = 0
  -> v[2 ] = 3
  -> v[3 ] = 6
  -> v[4 ] = 9
  -> v[5 ] = 12
 [LUA] VAR points    = 2000
 [LUA] VAR character = <Marcus Tulius Cicero>


[EXPERIMENT 2] ==>> Reading configuration 
 [*] => asset_path = C:\\Users\myuser\data\files\
 [*] => user_credits = 2000


[EXPERIMENT 3] ==>> Register C++ classes 
 *=>> [StatefulFunctor] My new state is = 10
 *=>> [StatefulFunctor] My new state is = 11
 *=>> [StatefulFunctor] My new state is = 12

----->>> Calling C++ classes from Lua <----- 
[TRACE] Counter created with =>  {  name = untitled ; counter = 0 } 
[TRACE] increment event =>> counter = {  untitled ; 1 } 
[TRACE] increment event =>> counter = {  untitled ; 2 } 
[TRACE] increment event =>> counter = {  untitled ; 3 } 
 [*] value of counter is equal to = 3
[TRACE] I was set to value 2000
[*] Counter value is equal to = 2000
[FROM C++] counter value = 2000

$ mkdir ~/build && cd build 
$ git clone https://github.com/albertodemichelis/squirrel
$ cmake -H. -B_build -DCMAKE_BUILD_TYPE=Debug 
$ cmake --build _build --target

$ _build/bin/sq
Squirrel 3.1 stable Copyright (C) 2003-2017 Alberto Demichelis (64 bits)

sq> print(" === Hello world Squirrel === ")
 === Hello world Squirrel === 

sq> function add_to_10(x){ return x + 10; }

sq>print(add_to_10(25))
35

sq> x <- cos(3.1415 / 2) + 10 

sq>print(" x = " + x.tostring())
 x = 10

sq> for(local i = 0; i < 5; i++) print(" \n [TRACE] i = " + i.tostring());

 [TRACE] i = 0 
 [TRACE] i = 1 
 [TRACE] i = 2 
 [TRACE] i = 3 
 [TRACE] i = 4

cmake_minimum_required (VERSION 3.11)
project(squirrel_squall_test)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED on)
set(BUILD_EXAMPLES off)

# -----------------------------------------------#
include(FetchContent)

FetchContent_Declare(
  squall 
  URL      https://github.com/jonigata/squall/archive/master.zip
  )

FetchContent_MakeAvailable(squall)

#-------- TARGET DEFINITIONS --------------------#
message([TRACE] " squall_SOURCE_DIR = ${squall_SOURCE_DIR}/squall  ")

            add_executable ( squirrel-test squirrel_test.cpp)
     target_link_libraries ( squirrel-test squirrel_static sqstdlib_static)
target_include_directories ( squirrel-test PUBLIC
                               ${squirrel_SOURCE_DIR}/include
                               ${squall_SOURCE_DIR}
                               )

#include <iostream>
#include <string>
#include <algorithm>
#include <vector> 

#include <squall/squall_vmstd.hpp>
#include <squall/squall_klass.hpp>

void some_cpp_fun(int n )
{
    for(int i = 0; i < n; i++)
        std::printf("\n   [some_cpp_function] => i = %d ", i);
}

class ChartXY
{
    int m_width; 
    int m_height;
public:
    ChartXY(): m_width(20), m_height(50) 
    {
        std::cout << " [ChartXY] Ctor() - I was created!. OK. " << std::endl;
    }

    void set_width(int x){ m_width = x; }
    void set_height(int x){ m_height = x; }

    void draw() const 
    { 
        std::printf(" [ChartXY] draw() => Draw chart with: width = %d ; height = %d"
                    , m_width, m_height);
    }
};

int main()
{
    // Create a virtual-machine object for Squirrel language 
    // Note: throws squall::squirrel_error
    squall::VMStd vm; 

    // ------------------------------------------------------------------------//
    // [EXPERIMENT 1] Evaluate scripts provided as strings                     //
    //-------------------------------------------------------------------------//
    std::puts(" =>> [EXPERIMENT] 1 - Evaluating code as string. ");  
    std::puts(" ---------------------------------------------\n");

    try {

        vm.dostring(R"( 
            // --- Squirrel Comment ----- // 
            print(" <SQUIRREL>  =>> Hello world squirrel!");

            function myfunc(x) {  
                local a = x + 5;
                local b = 7 * a + x;
                return b - a + 10;  
            }

            function myfunc2() {
                print(" \n  <SQUIRREL> I was called by the C++ code ");
            }

            print("\n <SQUIRREL> =>> myfunc(4) = " + myfunc(4).tostring() );

            print("\n\n <SQUIRREL> --- For Loop test ---- ");
            for(local i = 0; i < 5; i++) { 
                 print("\n   i = " + i.tostring() );  
            }
        )");

    } catch( squall::squirrel_error const& ex )
    {
        std::cerr << "\n [SQUIRREL ERROR] Error =>  " << ex.what() << std::endl;        
    }

    // ------------------------------------------------------------------------//
    // [EXPERIMENT 2] Evaluate scripts provided as strings                     //
    //-------------------------------------------------------------------------//
    std::puts("\n =>> [EXPERIMENT] 2 - Getting variables defined in the code.");  
    std::puts(" -----------------------------------------------------------\n");

    {
        vm.dostring(R"( 
            // ---- Global varibles for configuration ------ // 
            ::myvar_width <- 100;
            ::myvar_float <- 122.56161;
            ::myvar_string <- "/path/to/interpreter.exe"; 
        )");

        squall::TableBase table = vm.root_table();
        auto myvar_float = table.get<float>("myvar_float");       
        auto myvar_width = table.get<int>("myvar_width");
        auto myvar_string = table.get<std::string>("myvar_string");
        std::cout << "  =>>  myvar_width = " << myvar_width << std::endl;
        std::cout << "  =>>  myvar_float = " << myvar_float << std::endl;
        std::cout << "  =>> myvar_string = " << myvar_string << std::endl;
    } 

    // ------------------------------------------------------------------------//
    // [EXPERIMENT 3] Call functions defined in the script (Virtual Machine )  //
    //-------------------------------------------------------------------------//    
    std::puts("\n\n =>> [EXPERIMENT] 3 - Calling functions defined in the script (VM)");
    std::puts(" ------------------------------------------------------------------\n");    
    // Throws: 'squall::squirrel_error' 
    int result = vm.call<int>("myfunc", 10);
    std::cout << "   =>>> myfunc(4) = " << result << std::endl;

    vm.call<void>("myfunc2");

    // ------------------------------------------------------------------------//
    // [EXPERIMENT 4] Call C++ functions from the script                       //
    //-------------------------------------------------------------------------//    
    std::puts("\n\n =>> [EXPERIMENT] 4 - Calling functions defined in the script (VM)");
    std::puts(" ------------------------------------------------------------------\n");

    // Register C++ function pointer 
    vm.defun("some_cpp_fun", &some_cpp_fun);

    vm.dostring(R"(
        print(" \n [SQUIRREL] => Call C++ function some_cpp_fun() ");
        some_cpp_fun(5);
     )");


    // Register C++ lambda object 
    vm.defun("call_me", [=](std::string const& param) {
        std::cout << "\n [TRACE] call_me() Parameter = " << param << "\n";
        return  " name = " + param;
    });

    vm.dostring(R"(
        local x = call_me("<SQUIRREL-INTERPRETER>");
        print(" [SQUIRREL] \n x <- " + x);
     )");

    // ------------------------------------------------------------------------//
    // [EXPERIMENT 5] Call C++ classes from Squirrel-side                     //
    //-------------------------------------------------------------------------//    
    std::puts("\n\n =>> [EXPERIMENT] 5 - Calling C++ classes from Squirrel        ");
    std::puts(" ------------------------------------------------------------------\n");

    // Create metaobject 'k' that describes ChartXY class 
    squall::Klass<ChartXY> k(vm, "ChartXY");
    k.func("set_width",  &ChartXY::set_width);
    k.func("set_height", &ChartXY::set_height);
    k.func("draw",       &ChartXY::draw);

    vm.dostring(R"( 
        function manipulate_chart(ch){           
            ch.set_width(25);
            ch.set_height(10);
            ch.draw();
        }

        function draw_with(ch, w, h)
        {
            print(" \n [SQUIRREL LOG] Function draw_with called. OK. \n");
            ch.set_width(w);
            ch.set_height(h);
            ch.draw();
        }
     )");

    ChartXY mychart;
    vm.call<void>("manipulate_chart", &mychart);
    vm.call<void>("draw_with", &mychart, 100, 200);

    std::cout << "\n\n";

    squall::TableBase table = vm.root_table();

    // Pass object to Squirrel side 
    table.set("mychart", mychart);

    vm.dostring(R"(
        mychart.set_width(250);
        mychart.set_width(600);
        mychart.draw();
    )");


#if 0  
    // Segmentation Falt Coredump if the C++ object 
    // is created on the Squirrel-side.
    vm.dostring(R"(
        local c = ChartXY();
        c.set_width(150);
        c.set_height(175);
        c.draw();
    )");
#endif 

    return 0;
}

$ cmake -H. -B_build -DCMAKE_BUILD_TYPE=Debug 
$ cmake --build _build --target 

$ ldd _build/squirrel-test 
       linux-vdso.so.1 (0x00007ffe34dd6000)
       libstdc++.so.6 => /lib64/libstdc++.so.6 (0x00007fd3ebd2a000)
       libm.so.6 => /lib64/libm.so.6 (0x00007fd3ebbe4000)
       libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007fd3ebbc9000)
       libc.so.6 => /lib64/libc.so.6 (0x00007fd3eb9ff000)
       /lib64/ld-linux-x86-64.so.2 (0x00007fd3ebf3e000)

$ _build/squirrel-test 

=>> [EXPERIMENT] 1 - Evaluating code as string. 
---------------------------------------------

<SQUIRREL>  =>> Hello world squirrel!
<SQUIRREL> =>> myfunc(4) = 68

<SQUIRREL> --- For Loop test ---- 
  i = 0
  i = 1
  i = 2
  i = 3
  i = 4
=>> [EXPERIMENT] 2 - Getting variables defined in the code.
-----------------------------------------------------------

 =>>  myvar_width = 100
 =>>  myvar_float = 122.562
 =>> myvar_string = /path/to/interpreter.exe


=>> [EXPERIMENT] 3 - Calling functions defined in the script (VM)
------------------------------------------------------------------

  =>>> myfunc(4) = 110

 <SQUIRREL> I was called by the C++ code 

=>> [EXPERIMENT] 4 - Calling functions defined in the script (VM)
------------------------------------------------------------------


[SQUIRREL] => Call C++ function some_cpp_fun() 
  [some_cpp_function] => i = 0 
  [some_cpp_function] => i = 1 
  [some_cpp_function] => i = 2 
  [some_cpp_function] => i = 3 
  [some_cpp_function] => i = 4 
[TRACE] call_me() Parameter = <SQUIRREL-INTERPRETER>
[SQUIRREL] 
x <-  name = <SQUIRREL-INTERPRETER>

=>> [EXPERIMENT] 5 - Calling C++ classes from Squirrel        
------------------------------------------------------------------

[ChartXY] Ctor() - I was created!. OK. 
[ChartXY] draw() => Draw chart with: width = 25 ; height = 10 
[SQUIRREL LOG] Function draw_with called. OK. 
[ChartXY] draw() => Draw chart with: width = 100 ; height = 200

[ChartXY] draw() => Draw chart with: width = 600 ; height = 200

cmake_minimum_required(VERSION 3.0)
project(duktap-embed)

include(FetchContent)

# Download library archive (zip, *.tar.gz, ...) from URL
macro(Download_Library_Url NAME URL)
  FetchContent_Declare(${NAME} URL  ${URL})
  FetchContent_GetProperties(${NAME})
  if(NOT ${NAME}_POPULATED)
    FetchContent_Populate(${NAME})
   # add_subdirectory(${${NAME}_SOURCE_DIR} ${${NAME}_BINARY_DIR})
  endif()
endmacro()


# ====>> Duktape JavaScript Engine Configuration <<===========#

Download_Library_Url(duktape
  "https://duktape.org/duktape-2.5.0.tar.xz"
  )

# FetchContent_MakeAvailable(duktape)

message( [TRACE] " =>> duktape_SOURCE_DIR = ${duktape_SOURCE_DIR} ")


file(GLOB_RECURSE duktape_sources "${duktape_SOURCE_DIR}/src/*.c")
file(GLOB_RECURSE duktape_headers "${duktape_SOURCE_DIR}/src/*.h")

message( [TRACE] " duktape_sources = ${duktape_sources} ")

              add_library (duktape ${duktape_sources} ${duktape_headers} )
target_include_directories(duktape PUBLIC ${duktape_SOURCE_DIR}/src  )

# ----------- DukGlue Library ----------------------------#

FetchContent_Declare(
  dukglue 
  URL       https://github.com/Aloshi/dukglue/archive/master.zip
  )

FetchContent_MakeAvailable(dukglue)

#----- Main Target Definition ----------------------------#
add_executable(duktape-embed duktape-embed.cpp)
target_link_libraries(duktape-embed duktape dukglue)

#include <iostream>
#include <string>
#include <vector>
#include <cassert> 

// Repository: https://github.com/Aloshi/dukglue
#include <dukglue/dukglue.h>

void print_number(int x)
{
  std::cout << " [TRACE] number passed is = " << x << std::endl;
}

void log_text(std::string const& text)
{
    std::cout <<  " =>> [C++-LOG] - " << text << std::endl;
}

int eval_code(duk_context* ctx, std::string const& code)
{
    return duk_peval_string(ctx, code.c_str());
}

void plot_points(std::vector<float> const& points)
{
  std::cout << "  =>> [TRACE] Plot points  =>> ";
  for(auto const& x: points) { std::cout << " x = " << x; }
  std::cout << " \n";
}

class Counter {
private: 
    std::string m_name;
    int         m_counter;

public: 

    // Ctor [1] => Default ctor 
    Counter(): Counter("untitled", 0) { }

    // Ctor [2]
    Counter(std::string name, int counter)
      : m_name{std::move(name)}, m_counter{counter}
    { 
        std::cout << " [TRACE] Counter created with =>  { " 
                  <<   " name = " << m_name 
                  << " ; counter = " << m_counter 
                  << " } \n";
    }

    int getCounter() const { return m_counter; }
    void setCounter(int n) {       
      m_counter = n; 
      std::cout << " [TRACE] I was set to value " << n << std::endl;
    }

    void increment() {       
      m_counter++; 
      std::cout << " [TRACE] increment event =>> counter = {  " 
                << m_name << " ; " << m_counter 
                << " } " << std::endl;
    }    

};


int main()
{
      // Create Duktape Virtual machine 
      duk_context* ctx = duk_create_heap_default();

      /* ========================== EXPERIMENT 1 =============*/
      std::puts("\n === [EXPERIMENT 1] ==>> Register and call C++ functions <<===== ");
      {
          // Register pointer to functions function (function pointer) in 
          // the JS engine (aka virtual machine)
          dukglue_register_function(ctx, &print_number, "print_number"); 
          dukglue_register_function(ctx, log_text, "log_text");
          dukglue_register_function(ctx, plot_points, "plot_points");

          const char* code1 = R"(
              print_number(10);
              log_text(" Hello world from Javascript" ); 
              log_text(" Toke is equal to " + 100 ); 
              log_text( " " + 1000 );      

              plot_points( [ 20.5, 100.23, -125.254, 8.251, 100.0 ]);
          )";

          // Evaluate code, returns false on error 
          auto n = eval_code(ctx, code1);

          if(n) { std::cerr << " [ERROR] A duktape evaluation error has happened. "  << std::endl; }

      }

      /* ========================== EXPERIMENT 2 ====================*/
      std::puts("\n === [EXPERIMENT 2] ==>> Register and call C++ classes <<===== \n");
      {
          // Register class counter 
          dukglue_register_constructor<Counter>(ctx, "Counter");      
          dukglue_register_constructor<Counter, std::string, int>(ctx,  "Counter");     
          dukglue_register_method(ctx, &Counter::getCounter , "getCounter");
          dukglue_register_method(ctx, &Counter::setCounter , "setCounter");
          dukglue_register_method(ctx, &Counter::increment , "increment");

          dukglue_register_property(ctx                   // Pointer to engine (VM)
                                  , &Counter::getCounter  // Getter 
                                  , &Counter::setCounter  // Setter 
                                  , "number"              // Property name 
                                  );

          int ret = eval_code(ctx, R"( 
              var counter = new Counter("mycounter", 10); 

              for(i = 0 ; i < 5; i++) { counter.increment(); }

              var n = counter.getCounter(); 
              log_text(" [BEFORE] Counter value = " + n );

              counter.setCounter(100);
              log_text(" [AFTER 1 ] Counter value = " + counter.getCounter() );

              counter.number = 400;
              log_text(" [AFTER 2] Counter value = " + counter.number );
          )");
          assert( ret == 0 );

      }

      /* ======= Calling Javascript Engine from C++ ====================*/
      // Note: It is useful for reading data or user configuration 
      std::puts("\n === [EXPERIMENT 3] ==>> Calling engine objects from C++ <<===== \n");
      {
          const char* code = R"(
            // Global variables for configuration 
            points = 200; 
            asset_path = "C:\\\\Users\\dummy\\data\\graphics";

            function my_js_function(n){
                log_text( " <my_js_function> =>> n = " + n );
                var k = 20 * n + 100;
                return k; 
            }

          )";
          eval_code(ctx, code);

          // Throws error: DukErrorException
          auto points = dukglue_peval<int>(ctx, "points");
          std::cout << "  [*] =>> points = " << points << std::endl;

          // Throws error: DukErrorException
          auto asset_path = dukglue_peval<std::string>(ctx, "asset_path");
          std::cout << "  [*] =>> asset_path = " << asset_path << std::endl;

          auto jsexpr = dukglue_peval<double>(ctx, "3.51 * 10.52 - 8.251 / 100");
          std::cout << "  [*] jsexpr = " << jsexpr << std::endl;

          // Call Javascript function from C++ 
          auto func = dukglue_peval<DukValue>(ctx, "my_js_function");
          int res = dukglue_pcall<int>(ctx, func, 20);
          std::cout << "  [*] res = " << res << std::endl;

      }

    // Release Javascript engine object (aka virtual machine)
    ::duk_destroy_heap(ctx);

    return 0;
}

$ cmake -H. -B_build -DCMAKE_BUILD_TYPE=Debug
$ cmake --build _build --target 

$ ./build/duktape-embed 

=== [EXPERIMENT 1] ==>> Register and call C++ functions <<===== 
[TRACE] number passed is = 10
=>> [C++-LOG] -  Hello world from Javascript
=>> [C++-LOG] -  Toke is equal to 100
=>> [C++-LOG] -  1000
 =>> [TRACE] Plot points  =>>  x = 20.5 x = 100.23 x = -125.254 x = 8.251 x = 100 

=== [EXPERIMENT 2] ==>> Register and call C++ classes <<===== 

[TRACE] Counter created with =>  {  name = mycounter ; counter = 10 } 
[TRACE] increment event =>> counter = {  mycounter ; 11 } 
[TRACE] increment event =>> counter = {  mycounter ; 12 } 
[TRACE] increment event =>> counter = {  mycounter ; 13 } 
[TRACE] increment event =>> counter = {  mycounter ; 14 } 
[TRACE] increment event =>> counter = {  mycounter ; 15 } 
=>> [C++-LOG] -  [BEFORE] Counter value = 15
[TRACE] I was set to value 100
=>> [C++-LOG] -  [AFTER 1 ] Counter value = 100
[TRACE] I was set to value 400
=>> [C++-LOG] -  [AFTER 2] Counter value = 400

=== [EXPERIMENT 3] ==>> Calling engine objects from C++ <<===== 

 [*] =>> points = 200
 [*] =>> asset_path = C:\\Users\dummy\data\graphics
 [*] jsexpr = 36.8427
=>> [C++-LOG] -  <my_js_function> =>> n = 20
 [*] res = 500

cmake_minimum_required(VERSION 3.0)
project(duktape-cc-trial)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

include(duktape.cmake)

#----- Main Target Definition ----------------------------#
       add_executable( duktape-script duktape-script.cpp)
target_link_libraries( duktape-script duktape-cc )

include(FetchContent)

# Note: the 'add_subriectory' line was commented becuyase 
#       library that will be downloaded does not have 
#       a CMakeListst.txt file at the root directory. 
macro(Download_Library_Git  NAME TAG REPOSITORY_URL)
    FetchContent_Declare(
        ${NAME}
        GIT_REPOSITORY  ${REPOSITORY_URL}
        GIT_TAG         ${TAG}
    )
    FetchContent_GetProperties(${NAME})
    if(NOT cpputest_POPULATED)
        FetchContent_Populate(${NAME})
        message("${NAME}_SOURCE_DIR} = ${${NAME}_SOURCE_DIR}")        

        # => Disable following line: the library does not have a CMakeLists.txt
        #    at the root directory.
        # add_subdirectory(${${NAME}_SOURCE_DIR} ${${NAME}_BINARY_DIR})
    endif()
endmacro()


# ====>> Duktape JavaScript Engine Configuration <<===========#

Download_Library_Git( duktape-cc 
                      51fed200b0c3353a60fa560aa8a13a480f0ec0c7
                      https://github.com/stfwi/duktape-cc/
                    )

file(GLOB_RECURSE duktape_sources "${duktape-cc_SOURCE_DIR}/duktape/*.c")
file(GLOB_RECURSE duktape_headers1 "${duktape-cc_SOURCE_DIR}/duktape/*.hh")
file(GLOB_RECURSE duktape_headers2 "${duktape-cc_SOURCE_DIR}/duktape/*.h")

               add_library( duktape-cc ${duktape_sources} ${duktape_headers1} ${duktape_headers2} )
target_include_directories( duktape-cc PUBLIC ${duktape-cc_SOURCE_DIR} )

#include <iostream> 
#include <string> 
#include <vector> 
#include <fstream>

#include <duktape/duktape.hh>
#include <duktape/mod/mod.stdio.hh>

int main()
{
    std::puts(" [TRACE] Program started Ok. ");

    // Create Duktape Engine object (Virtual Machine)
    auto ctx = duktape::engine{};

    // Load all functions from stdio module 
    // ==> Note: It is necessary for console.log() work 
    duktape::mod::stdio::define_in(ctx);   


    std::puts("\n [EXPERIMENT 1] ======= Evaluate string as code ========");

    ctx.eval<void>(R"( 
        console.log(" [INFO] Hello world Javascript Engine ");

        var i = 0;
        while(i < 5) {
            console.log(" [TRACE] <ducktape>  i = " + i);
            i++;
        }
    )");

    std::puts("\n [EXPERIMENT 2] == Read/write values to the engine the engine =");

    // Write or pass values to the engine. 
    ctx.define("app.version", "0.251");
    ctx.define("user.points", 1000);
    ctx.define("array1", std::vector<double>{ 4.51, 9.25, -25.154, 205.2 });
    ctx.define("array2", std::vector<std::string>{ "C++", "ADA-Spark", "Rust", "Dlang", "OCaml" });

    std::string script_file = "/tmp/myscript.js";

    const char* script_code = R"(
        console.log("  => app.version = " + app.version );
        console.log("  => user.points = " + user.points );
        console.log("  => array1 = " + array1);
        console.log("  => array2 = " + array2);

        myconfig_path = "/Users/data/osx/config";
        user_credits = 1020; 
        vector = [100.25, 90.251, -120.5150];
    )";

    // Write script code to file     
    auto fs = std::ofstream(script_file);
    // Flush forces writing to the IO
    fs << script_code << std::flush;          
    // Execute script from file 
    ctx.include(script_file);

    std::cout << " ---- Read configuration from file " << std::endl; 

    // Throws exception: duktape::detail::basic_script_error<void>
    auto myconfig_path = ctx.eval<std::string>("myconfig_path");
    auto credits       = ctx.eval<int>("user_credits");
    auto vec           = ctx.eval<std::vector<double>>("vector");
    std::cout << "\n\n[*] my_config_path = " << myconfig_path << "\n";
    std::cout << "[*]   user_credits = " << credits << "\n";
    std::cout << "[*] vec[0] = " << vec[0] << " ; vec[1] = " << vec[1] << "\n";    

    return 0;
}

$ cmake -H. -B_build -DCMAKE_BUILD_TYPE=Debug
$ cmake --build _build --target 

 $ _build/duktape-script 
 [TRACE] Program started Ok. 

 [EXPERIMENT 1] ======= Evaluate string as code ========

 [EXPERIMENT 2] == Read/write values to the engine the engine =
 [INFO] Hello world Javascript Engine 
 [TRACE] <ducktape>  i = 0
 [TRACE] <ducktape>  i = 1
 [TRACE] <ducktape>  i = 2
 [TRACE] <ducktape>  i = 3
 [TRACE] <ducktape>  i = 4
  => app.version = 0.251
  => user.points = 1000
  => array1 = 4.51,9.25,-25.154,205.2
  => array2 = C++,ADA-Spark,Rust,Dlang,OCaml
 ---- Read configuration from file 


[*] my_config_path = /Users/data/osx/config
[*]   user_credits = 1020
[*] vec[0] = 100.25 ; vec[1] = 90.251

                 Expr - Expression 
                     |
                     |
      +--------------+-------------------------+
      |                                        |  
  Cons(Expr, Expr)                           Atom - anything that is not a pair (cons cell)
(cons pair,                                    |
 cons linked list         +--------+--------+---+------+-----------+---------+--------------+
 or cons cell   )         |        |        |          |           |         |              |
                        Nil     Number    String    Boolean     Symbol    Keyword       Function 
                      literal   literal   Literal   Literal                                 |
                                                                               -------------+-------------
                                                                               |                         |
                                                                            Native                  Lisp Function
                                                                           Function              implemented in Lisp 

    data Expr =  -- Cons cell  
                 Cons Expr, Expr                      
                 -- Nil literal - represents an empty value 
               | Nil                             
                 -- Boolean literal 
               | Bool Bool                       
                 -- Number literal 
               | Num  Double                     
                 -- String literal 
               | Str  String                     
                 -- Symbol 
               | Sym  String                     
                 -- keyword 
               | Key  String                     
                 -- Native function written in the hosting language 
               | NativeFun ([Expr] -> Expr)     
                  -- Function written in Lisp 
               | LispFunc (environment: Dict<String,Expr>, args: <String>, name: <String>, call:  [Expr] -> Expr)


 Example =>> The pair or cons cell '( hello . 100) is reprented as:

      Cons( Sym("hello"), Num(100))

   Example ->> The list (1 hello "world") is represented as a linked list in the following format:

      Cons( Num(1), Cons( Sym("Hello"), Cons( Str("hello"), Nil )))

           Expression  
               |
               |
   +-----------+------------------------+
   |                                    |
   |                                    |
List of Expr                          Atom - anything that is not a list 
                                        |
               +-------+---------+------+--+---+--------------+----------+
               |       |         |         |        |         |          |
              Nil    Number    String   Boolean   Symbol   Keyword   Function 
            Literal  Literal   Literal   Literal          :keyword    object 
                                        #t (true)                       |
                                        #f (false)           +----------+---------------+
                                                             |                          |
                                                      Native Function            Lisp Function 
                                                    written in C or C++         written in Lisp 
                                                    or in the hosting 
                                                       language 

Haskell-like notation:

   data Expr =  -- List data structure - can be represented by a linked list or vector  
                List [Expr]                     
                -- Nil literal - represents an empty value 
              | Nil                             
                -- Boolean literal 
              | Bool Bool                       
                -- Number literal 
              | Num  Double                     
                -- String literal 
              | Str  String                     
                -- Symbol 
              | Sym  String                     
                -- keyword 
              | Key  String                     
                -- Native function written in the hosting language 
              | NativeFun ([Expr] -> Expr)     
                 -- Function written in Lisp 
              | LispFunc (environment: Dict<String,Expr>, args: <String>, name: <String>, call:  [Expr] -> Expr)

 sexp:  atom | list ; 

 list: "(" sexp* ")" ;

 atom:  SYMBOL 
      | KEYWORD  // Example: :x, :keyword 
      | NUMBER  
      | STRING 
      | BOOLEAN 
      | NIL 
      ; 

NIL: "nil"; 
BOOLEAN: "true" | "false";  

; Lisp test code 
;--------------------------------

(comment "Comment special form is evaluated to nil and discarded.")

;; Create a sample list 
(set mylist (list 10 #t #f "hello world" 
              'hello 'world
              ; Operation 1
              :keyword1 (+ 10 25 6) '(+ 10 25 6) 
              ; Operation 2
              :keyword2 (* 4 2 6)  '(* 4 2 6) 

              ))

; Factorial function 
(set code-fact "
      ; Factorial function 
      (def fact (n)
          (if (= n 1)
              1                    ;; Base case 
              (* n (fact (- n 1))) ;; Recursion case 
           )) 
    ")

;; S-expression for fibbonaci function
(def fib(n)
   (if (< n 2)
     n 
     (+ (fib (- n 1))  (fib (- n 2)) )
    ))

(def make-adder (k)
    (fn (x) (+ k x)))

;; Define a function that adds 10 to a number 
(set add10 (make-adder 10))
;; Defines a function that adds 10 to a number 
(set add50 (make-adder 50))


(set func 
  (let (
          (a (sqrt 125))
          (b (+ 20 a))
          (c (* a b))
        )
        (comment "Create  a function using lexical scope. 
                  The variable (a, b and c) are not visible outside the function. 
                  ")
        (fn (x) (/ (+ a b x) c))
   )
 )

;; Compute many trigonometric properties of an angle 
(def compute-trig (angle-degrees)
    (let (
          (angle (/ (* angle-degrees PI) 180) )
         )
        (list :angle angle-degrees :cos (cos angle) :sin (sin angle) :tan (tan angle))
     )
 )

;; Theoretical GUI DSL (Domain Specific Language)

(div :class "myclass-csss-style"
          :bgcolor "#ff81a" 
          ;; <p>Paragraph 1</p>
          (p "Paragraph 1 ")
          ;; <img  src="http://..../myimage.png" /> 
          (img :src "http://www.mydomain/images/myimage.png" :caption "Image 1 data")
          ;; <button id="btn-submit" class="my-style-button" >Submit</button>
          (button :label "Submit" :id "btn-submit" :class "my-style-button"
                  :onclick (fn (event) (display "Button was clicked") ))
       )

#include <iostream> 
#include <string> 
#include <sstream>
#include <fstream>
#include <cctype>
#include <optional>
#include <cassert>
#include <memory>
#include <vector>
#include <map>
#include <iomanip>
#include <functional>
#include <cmath>
#include <stack>

enum class TokenType {
      SYM    // Symbol 
    , KEYW   // Keyword  Examples => :keyword, :x
    , STR    // String literal 
    , NUM    // Number literal 
    , BOOL   // Boolean 
    , QUOTE  // Quote  
    , RPAREN // '(' Right parenthesis  
    , LPAREN // ')' Left parenthesis 
    , EOFF   //  End of File (It was named 'EOFF' since it conflicts with #define 'EOF')
    , ERR    // Indicates error 
};

struct Token
{
    TokenType   type;
    std::string text;
    int pos;
    int lin;
    int col;

    Token(): 
     type(TokenType::ERR), text(""), pos(0), lin(0), col(0)
    {}

    Token(TokenType type_, std::string const& text_, int pos_, int lin_, int col_):
        type(type_), text(text_), pos(pos_), lin(lin_), col(col_)
    { }

    bool isEOF() { return type == TokenType::EOFF; }
};

bool isNumber(std::string const& text)
{
    if( text[0] != '-' && !std::isdigit(text[0]) )
    { return false; }
    auto n = text.length();
    for(size_t k = 1; k < n; k++){
        if( !std::isdigit( text[k] ) ){ return false;}
    }
    return true;
}

class Tokenizer 
{
    std::istream& _is;
    // Position of cursor in the inout stream 
    int _pos = 0;
    // Current line in the input stream 
    int _lin = 0;
    // Column in the input stream 
    int _col = 0; 
public:
    Tokenizer(std::istream& is): _is(is){ }

    // Read a single character and consumes it from the stream  
    char next() { 
        char chr = _is.get(); 
        _pos++;
        _col++;
        // Assumes that the new line character is just '\n'
        if( chr == '\n' ){
            _col = 0;
            _lin++;    
        }
        return chr;
    }
    // Read next character from input string without reading it 
    char peek(){ 
        return _is.peek();
    } 

    bool isBlankChar(){
        char ch = peek();
        return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
    }

    bool isParenthesis(){
        char ch = peek();
        return ch == '(' || ch == ')';
    }

    // Is end of line     
    bool isEOL(){ return peek() == '\n'; }

    bool isEOF(){ return _is.eof(); }

    void skipBlankChars() {
        while( isBlankChar() ){ next(); }
    }

    void skipLineComment(){
        char ch = peek();
        while( ch != '\n' && !this->isEOF() ){ ch = next(); }
    }


    // Consume stream until a blank character is found 
    std::string consumeUntilBlank()
    {
        // std::fprintf(stderr, " [TRACE] Consuming until blank \n");
        char ch = peek();
        std::string text;
        while( !this->isBlankChar() && !this->isParenthesis()  && !this->isEOF())
        {
            ch = this->next();
            // fprintf(stderr, " [TRACE] ConsumeUntilBlank ch = %d \n", ch);
            text = text + ch;
        }
        // std::fprintf(stderr, " [TRACE] consumeUntilBlank = %s \n", text.c_str());
        return text;
    }

    std::vector<Token> readTokens()
    {
        std::vector<Token> out{};
        Token tok; 
        while( !tok.isEOF() ){
            tok = this->nextToken();
            if( !tok.isEOF() ){ out.push_back(tok); }
        }

        auto stack = std::stack<Token>{};

        // Check if parentheses are balanced 
        for(auto const& tok: out)
        {
            // Push left parentheses to the stack 
            if(tok.type == TokenType::LPAREN){ stack.push(tok);  }
            // If the stack is not empty and current parenthesis is a 
            // right parentheses, if the top of stack is left parentheses 
            // then pop the stack.
            if(tok.type == TokenType::RPAREN )
            {
                if( !stack.empty() && stack.top().type == TokenType::LPAREN )
                     { stack.pop(); }
                else { throw std::runtime_error("Error: unbalanced parentheses."); }
            }
        }
        
        if( !stack.empty() ){ 
            auto tok = stack.top();
            std::fprintf(stderr, " [ERROR] Unbalanced parentheses at line %d and column %d \n", tok.lin, tok.col);
            throw std::runtime_error("Error: unbalanced parentheses."); 
        }

        return out;
    }

    Token nextToken()
    {

        // std::fprintf(stderr, " [TRACE] Removing blank characters \n");
        skipBlankChars();

        char ch = next();
        // std::fprintf(stderr, " [TRACE] nextChar = %c \n", ch);

        if( this->isEOF() ){
            return Token(TokenType::EOFF, "", _pos, _lin, _col);
        }

        // Skip comments 
        if( ch == ';' ){ 
            // std::fprintf(stderr, " [TRACE] Skiping comment \n");
            skipLineComment(); 

            // std::fprintf(stderr, " [TRACE] Skiping comment 2 \n");
            return nextToken();
        }

        if( ch == '(')  { return Token(TokenType::LPAREN, "(", _pos, _lin, _col); }
        if( ch == ')')  { return Token(TokenType::RPAREN, ")", _pos, _lin, _col); }
        if( ch == '\'') { return Token(TokenType::QUOTE, "'",  _pos, _lin, _col); }

        // Boolean value 
        if( ch == '#'){
            auto c = this->next();
            auto text = std::string("#") + c;
            if( c!= 'f' && c !='t' ){
                return Token(TokenType::ERR, std::string("Error - invalid boolean literal => ") + text, _pos, _lin, _col); 
            }
            return Token(TokenType::BOOL, text,  _pos, _lin, _col);
        }

        // String literal 
        if( ch == '"' )
        { 
            // std::fprintf(stderr, " [TRACE] Reading string literal \n");
            std::string out = "";
            int col = _col;
            int pos = _pos;
            int lin = _lin;
            char c = 'x';
            while( c != '"' && !this->isEOF() )
            {
                c  = this->next();
                if(c == '"'){ break; }
                out = out + c;
            }
            if( c!= '"'){ return Token(TokenType::ERR, "Error - non closed quote.", _pos, _lin, _col); }
            else        { return Token(TokenType::STR, out, pos, lin, col); }
        }

        // assert(  )

        int col = _col;
        int pos = _pos;
        int lin = _lin;
        std::string text = ch + this->consumeUntilBlank();

        if( text == ":"){
            return Token(TokenType::ERR, "illegal terminating character after a colon:" ,pos, lin, col); 
        }

        // Keyworkd 
        if( text[0] == ':' )
        {
            // std::fprintf(stderr, " [TRACE] Tokenizer =>> keyword = %s \n", text.c_str() );
            return Token(TokenType::KEYW, text, pos, lin, col);
        }

        if( text == "-"){
            return Token(TokenType::SYM, text, pos, lin, col);
        }

        if( std::isdigit(text[0]) )
        {
            if( isNumber(text) )
                 { return Token(TokenType::NUM, text, pos, lin, col); } 
            else { return Token(TokenType::ERR, std::string("Error - invalid number => ") + text, pos, lin, col); }
        } else if( text[0] == '-' )
        {
            if( isNumber(text) )
                 { return Token(TokenType::NUM, text, pos, lin, col); } 
            else { return Token(TokenType::ERR, std::string("Error - invalid number => ") + text, pos, lin, col); }
        }

        // Anything else is a symbpl 
        return Token(TokenType::SYM, text, pos, lin, col);
    }

};

std::ostream& operator<<(std::ostream& os, TokenType type)
{
    if(type == TokenType::BOOL) { os << "[BOOL]"; }
    if(type == TokenType::EOFF) { os << "[EOF]"; }
    if(type == TokenType::STR) { os << "[STR]"; }
    if(type == TokenType::LPAREN) { os << "[LPAREN]"; }
    if(type == TokenType::RPAREN) { os << "[RPAREN]"; }
    if(type == TokenType::NUM) { os << "[NUM]"; }
    if(type == TokenType::SYM) { os << "[SYM]"; }
    if(type == TokenType::ERR) { os << "[ERR]"; }
    return os;
}

enum class ExprType {
      ERR  // Error  
    , NUM  // Number literal 
    , STR  // String literal 
    , BOOL // Boolean literal 
    , SYM  // Symbol 
    , KEY  // Keyword 
    , NIL  // Nil or Null value 
    , FUN  // Function  
    , LST  // List literal 
};


// Forward declaration 
struct ExprNil;
struct ExprStr;
struct ExprNum;
struct ExprSym;
struct ExprKey;
struct ExprErr;
struct ExprBool;
struct ExprFun;
struct ExprLst;

// Visitor design pattern 
struct IVisitor{
public:
    virtual ~IVisitor() = default;
    virtual void visit(ExprNil& expr) = 0;
    virtual void visit(ExprStr& expr) = 0;
    virtual void visit(ExprNum& expr) = 0;
    virtual void visit(ExprSym& expr) = 0;
    virtual void visit(ExprKey& expr) = 0;
    virtual void visit(ExprBool& expr) = 0;
    virtual void visit(ExprErr& expr) = 0;
    virtual void visit(ExprFun& expr) = 0;
    virtual void visit(ExprLst& expr) = 0;
};

// Lisp-like AST - Abstract syntax tree 
// IEXpr stands for Interface Expression 
struct IExpr 
{
    virtual ~IExpr() = default;
    virtual ExprType type()   const = 0;
    // Returns true if AST node is ATOM
    virtual bool     isAtom() const { return true; }
    // Returns true if AST node is list  
    virtual bool     isList() const { return false; }
    // Returns true if AST node is error  
    virtual bool     isErr()  const { return false; } 
    // Returns true if AST node is symbol 
    virtual bool     isSym()  const { return false; } 
    // Returns true if AST node is string
    virtual bool     isStr()  const { return false; } 
    // Returns true if AST node is keyword
    virtual bool     isKey()  const { return false; } 
    // Returns true if AST node is number  
    virtual bool     isNum()  const { return false; } 
    // Returns true if AST node is boolean 
    virtual bool     isBool()  const { return false; } 
    // Returns true if AST node is nil   
    virtual bool     isNil()  const { return false; } 
    // Returns true if AST node is function 
    virtual bool     isFun()  const { return false; } 

    /// Returns the string value of a node 
    virtual std::string  strValue()  const = 0;
    virtual double       numValue()  const = 0;
    // Evaluates to false if nil or #f and evaluates to true if it is anything else.
    virtual bool         boolValue() const = 0;

    // Method for accepting visitor (Related to visitor design pattern)
    virtual void     accept(IVisitor& v) = 0; 

    // Evaluate AST node and return a value (AST Node) 
    virtual std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) = 0;
};


// Represents a null value (empty value) equivalent to void 
// In Lisp just as other functional-like programming languages
// everything is evaluated to something and can be replaced be a value.
struct ExprNil: public IExpr
{
    ExprNil(){ } 
    ExprType type() const { return ExprType::NIL; } 
    bool isNil()    const { return true; } 

    std::string  strValue()  const { return "";}
    double       numValue()  const { return 0;   }
    bool         boolValue() const { return false;}

    void accept(IVisitor& v) { v.visit(*this); }

    virtual std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
       return std::make_shared<ExprNil>(); 
    }
};


// Represents a string literal 
struct ExprStr: public IExpr
{
    std::string value;
    ExprStr(std::string const& value_): value(value_){ }
    ExprType type() const { return ExprType::STR; } 


    std::string  strValue()  const { return value;}
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return true;}
    bool        isStr()      const { return true; } 
    void accept(IVisitor& v) { v.visit(*this); }

    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
       return std::make_shared<ExprStr>(this->value); 
    }
};

// Represents a number 
struct ExprNum: public IExpr
{
    double value;
    ExprNum(double value_): value(value_){ }
    ExprType type() const { return ExprType::NUM; } 
    bool isNum()    const { return true;  }
    std::string  strValue()  const { return "";}
    double       numValue()  const { return value;   }
    bool         boolValue() const { return true;}
    void accept(IVisitor& v) { v.visit(*this); }

    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
       return std::make_shared<ExprNum>(this->value); 
    }
};

// Represents a boolean literal (logical value)
struct ExprBool: public IExpr  
{
    bool value;
    ExprBool(bool value_): value(value_){ }
    ExprType type() const { return ExprType::BOOL; } 

    bool isBool() const { return true; } 

    std::string  strValue()  const { return "";}
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return value;}
    void accept(IVisitor& v) { v.visit(*this); }

    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
       return std::make_shared<ExprBool>(this->value); 
    }

};

// Represents a lisp symbol
struct ExprSym: public IExpr  
{
    std::string value;
    ExprSym(std::string value_): value(value_){ }
    ExprType type() const { return ExprType::SYM; } 
    bool isSym()    const { return true;  }
    std::string  strValue()  const { return value;}
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return true;}
    void accept(IVisitor& v) { v.visit(*this); }


    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {

        auto it = env.find(value);
        if (it == env.end())
        {
            throw std::runtime_error(" [ERROR] Unbound variable " + value);
            //return std::make_shared<ExprErr>(10, "Error - unbound variable " + value);
           // return nullptr;
        }
        return it->second;
    }
};


// Represents a lisp keyword such as :x, :y, :keyword1
struct ExprKey: public IExpr  
{
    std::string value;
    ExprKey(std::string value_): value(value_){ }
    ExprType type() const { return ExprType::KEY; } 
    bool isKey()    const { return true; }
    std::string  strValue()  const { return value;}
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return true;}
    void accept(IVisitor& v) { v.visit(*this); }


    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
       return std::make_shared<ExprKey>(this->value); 
    }

};



// Represents an Error (Reserved for future use)
struct ExprErr: public IExpr  
{
    int         code;
    std::string info;

    ExprErr(){}
    ExprErr(int code_, std::string const& info_)
        : code(code_), info(info_) { }

    ExprType type() const { return ExprType::ERR; } 
    bool isErr()    const { return true; }

    std::string  strValue()  const { return info;}
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return false;}

    void accept(IVisitor& v) { v.visit(*this); }

    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
       return std::make_shared<ExprErr>(code, info);
    }
};


using LispFunc = std::function<std::shared_ptr<IExpr> (std::vector<std::shared_ptr<IExpr>> const& args)>;
using LispEnv = std::map<std::string, std::shared_ptr<IExpr>>; 


// Represents a function
struct ExprFun: public IExpr
{
    std::string name;
    std::string doc;
    // std::vector<std::string> args;
    // std::shared_ptr<IExpr>   body;
    // ExprFun(std::vector<std::string> const& args_): args(args_) { }
    ExprType type() const { return ExprType::FUN; }
    bool isFun()    const { return true; }
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return true;}

    virtual bool isNativeFun() const = 0;

    void accept(IVisitor& v) { v.visit(*this); }

    virtual std::shared_ptr<IExpr>  call( std::vector<std::shared_ptr<IExpr>>& params
                                        , std::map<std::string, std::shared_ptr<IExpr>>& env_) = 0;

    ~ExprFun() = default;
};


// Non-native lisp function implemented in lisp 
struct ExprFunLisp: public ExprFun 
{
    std::vector<std::string> args;
    std::vector<std::shared_ptr<IExpr>>  body;
    std::map<std::string, std::shared_ptr<IExpr>> env;

    std::string  strValue()  const { return "(function) " + this->name;}
    bool isNativeFun() const { return false; }

    ExprFunLisp(){}
    ExprFunLisp(std::vector<std::string> const& args_, std::vector<std::shared_ptr<IExpr>> const& body_)
        : args(args_), body(body_) {

         }

    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
        // Invoke copy constructor 
       return std::make_shared<ExprFunLisp>(*this); 
    }

    std::shared_ptr<IExpr> 
    call( std::vector<std::shared_ptr<IExpr>>& params
         ,std::map<std::string, std::shared_ptr<IExpr>>& env_)
    {
        if( params.size() != args.size() )
        { throw std::runtime_error("Error: Function call error. "); }

        // Create local environment 
        auto envv = std::map<std::string, std::shared_ptr<IExpr>>{};
        // Copy global environment to temporary environment 
        for(auto& k : env_){ envv[k.first] = k.second; }

        // Copy local environment to temporary environment 
        for(auto& k : env){ envv[k.first] = k.second; }

        // Pass parameters to local environment 
        for(size_t n = 0; n < args.size(); n++ )
        {
            auto a = args[n];
            envv[a] = params[n];   
        }

        auto N = body.size();
        for(size_t n = 0; n < N - 1; n ++ )
        {
            body[n]->eval(envv);
        }
        auto result = body[N - 1]->eval(envv);

        if( result->isFun() 
            && !std::static_pointer_cast<ExprFun>(result)->isNativeFun() )
        {
            auto func = std::static_pointer_cast<ExprFunLisp>(result);
            for(size_t n = 0; n < args.size(); n++ )
            {
                auto a = args[n];
                func->env[a] = params[n];   
            }
        }

        return result;
    }
                                
};


// Native function implemented in C or C++
struct ExprFunNative: public ExprFun 
{
    LispFunc func; 
    std::string  strValue()  const { return "(native function) " + this->name;}
    bool isNativeFun() const { return true; }
    ExprFunNative(LispFunc func_): func(func_){ } 

    std::shared_ptr<IExpr> eval( std::map<std::string, std::shared_ptr<IExpr>>& env) 
    {
        // Invoke copy constructor 
       return std::make_shared<ExprFunNative>(func); 
    }

    std::shared_ptr<IExpr> 
    call( std::vector<std::shared_ptr<IExpr>>& params
         ,std::map<std::string, std::shared_ptr<IExpr>>& env_)

    {
        // std::fprintf(stderr, " [TRACE] Calling native function \n");
        return this->func(params);
    }

};

// Represents a list 
struct ExprLst: public IExpr  
{

    std::vector<std::shared_ptr<IExpr>> lst; 

    ExprLst(std::vector<std::shared_ptr<IExpr>> const& lst_)
        : lst(lst_){ } 

    ExprType type() const { return ExprType::LST; } 
    bool isAtom()   const { return false; } 
    bool isList()   const { return true; }

    std::string  strValue()  const { return "";}
    double       numValue()  const { return -1;   }
    bool         boolValue() const { return true;}

    void accept(IVisitor& v) { v.visit(*this); }

    std::shared_ptr<IExpr> eval(std::map<std::string, std::shared_ptr<IExpr>>& env)
    {
        if (lst.size() == 0)
        {
            return std::make_shared<ExprNil>();
        }

        auto type = lst[0]->type();

        if ( type != ExprType::SYM && type != ExprType::LST  )
        {
            throw std::runtime_error(" [ERROR] =>> Object is not applicable.");
        }

        std::string symbol = lst[0]->strValue();

        // Ignore comment special form
        if(symbol == "comment")
        { return std::make_shared<ExprNil>(); }

        if (symbol == "set")
        {
            if (lst.size() != 3)
            { throw std::runtime_error("Ill-formed syntax for SET special form"); }
            if (lst[1]->type() != ExprType::SYM)
            { throw std::runtime_error("Ill-formed syntax for SET special form. Expected symbol. "); }
            auto res = lst[2]->eval(env); 
            std::string name = lst[1]->strValue();
            std::fprintf(stderr, " [TRACE] Defining symbol = %s . \n", name.c_str());
            env[name] = res; //;std::make_shared<EnvVal>(res);
            return std::make_shared<ExprNil>();
        }

        // Handle special form (if <cond> <then-expr>) or (if <cond> <then-expr> <else-expr>)
        if( symbol == "if" )
        {
            if( lst.size() != 3 && lst.size() != 4) { throw std::runtime_error("Ill-formed syntax for IF special form"); }

            auto cond = lst[1];
            auto cond_result = cond->eval(env);

            if( lst.size() == 3 && !cond_result->boolValue() ) 
            { return std::make_shared<ExprNil>(); }

            if( lst.size() == 4 && !cond_result->boolValue() )
            {
                // Evaluate the else-expr 
                auto res = lst[3]->eval(env); // this->eval( *lst[3] );
                return res;
            }

            assert( cond_result->boolValue() );
            auto res = lst[2]->eval(env); //this->eval( *lst[2] );
            return res;
        }

        // Handle quote special form 
        if( symbol == "quote" || symbol == "$q")
        {
            if( lst.size() != 2 ) 
            { throw std::runtime_error("Ill-formed syntax for QUOTE special form"); }
            auto arg = lst[1];
            return arg;
        }

        // Equivalent to scheme or lisp lambda or scheme lambda 
        // (fn (a0 a1 ... a[N-1]) (expr1) (expr2) ... (expr[K-1]) )
        if( symbol == "fn" )
        {
            if (lst.size() < 3)
            { throw std::runtime_error("Ill-formed syntax for lambda special form"); }

            if( !lst[1]->isList() )
            { throw std::runtime_error("Ill-formed syntax for lambda. Expected arguments."); }

            // Function/lambda arguments   
            auto args = std::static_pointer_cast<ExprLst>(lst[1]);
            // Function/lambda body (list of expressions)
            auto body = lst;
            // Remove first element ('lambda' symbol)
            body.erase(body.begin()); 
            // Remove frst element - function arguments 
            body.erase(body.begin()); 

            std::vector<std::string> _args{};

            for(auto& a: args->lst)
            {
                if( !a->isSym() )            
                { throw std::runtime_error("Ill-formed syntax for lamba. Arguments must be strings.");  }
                _args.push_back( a->strValue() );
            }

            auto fun = std::make_shared<ExprFunLisp>(_args, body);
            return fun;
        }

        /** Sepcial form def 
         * (def function (a0 a1 ... a[N-1]) (expr1) (expr2) ... (expr[K-1]) )
         * 
         *  Example: 
         *   (def addxy(x  y )
         *             (disp x) 
         *             (disp y)
         *              (+ x y))
         * 
         */
        if( symbol == "def" )
        {
            if (lst.size() < 4)
            { throw std::runtime_error("Ill-formed syntax for def() special form"); }
            if( !lst[1]->isSym() )
            { throw std::runtime_error("Ill-formed syntax for def(). Expected function name."); }
            if( !lst[2]->isList() )
            { throw std::runtime_error("Ill-formed syntax for def(). Expected arguments."); }

            // Function name 
            auto name = lst[1]->strValue();
            // Function/lambda arguments   
            auto args = std::static_pointer_cast<ExprLst>(lst[2]);
            // Function/lambda body (list of expressions)
            auto body = lst;
            // Remove first element ('lambda' symbol)
            body.erase(body.begin()); 
            body.erase(body.begin()); 
            body.erase(body.begin()); 

            std::fprintf(stderr, " [TRACE] Defining function = %s . \n", name.c_str());

            std::vector<std::string> _args{};

            for(auto& a: args->lst)
            {
                if( !a->isSym() )            
                { throw std::runtime_error("Ill-formed syntax for lamba. Arguments must be strings.");  }
                _args.push_back( a->strValue() );
            }
            auto fun = std::make_shared<ExprFunLisp>(_args, body);
            fun->name = name;

            env[name] = fun;

            return std::make_shared<ExprNil>();
        }

        // Handle special form (begin (action1 ....) (action 2) (action N-1)) 
        if( symbol == "begin" )
        {
            // arguments 
            auto args = lst;
            // Remove first element 
            args.erase(args.begin());

            if( args.size() == 0)
            { return std::make_shared<ExprNil>(); }

            for(size_t n = 0; n < args.size() - 1; n++)
            {  args[n]->eval(env); }
            // Revaluate last element 
            auto result = args[ args.size() -1 ]->eval(env);
            return result;
        }
        
        /** (let (binding lists) (exp1) (exp2) .... (expN-1) )
         *     
         *  (let ( (a 20)
         *         (b 30 )) 
         *        (display a) (display b) (+ a b) )
         *  
         *  The previous expression evaluates to 30.
         */
        if( symbol == "let" )
        {

            if( lst.size() < 3 )
            { throw std::runtime_error("Error: ill-formed sytax for let expression."); }
            if( !lst[1]->isList() )
            { throw std::runtime_error("Error: ill-formed sytax for let expression. Expected list of bindings."); }

            auto bindings = std::static_pointer_cast<ExprLst>(lst[1])->lst;

            // Create a new temporary environment 
            auto envv = std::map<std::string, std::shared_ptr<IExpr>>{};
            auto envs = std::map<std::string, std::shared_ptr<IExpr>>{};

            // Copy environment     
            for(auto& k : env){ envv[k.first] = k.second; }

            for(auto const& b: bindings){
                if( !b->isList() )
                    { throw std::runtime_error("Error: ill-formed sytax for let expression. Expected list as binding argument."); }
                auto bb = std::static_pointer_cast<ExprLst>(b)->lst;
                if( bb.size() != 2)
                    { throw std::runtime_error("Error: ill-formed sytax for let expression."); }
                if( !bb[0]->isSym() ) 
                    { throw std::runtime_error("Error: ill-formed sytax for let expression. Expected symbol."); }
                auto sym = bb[0]->strValue();
                auto val = bb[1]->eval(envv);
                // Add symbols from let binding to the new temporary environment
                envv[sym] = val;
                envs[sym] = val;
            }

            for(size_t k = 2; k < lst.size() - 1; k ++)
            { lst[k]->eval(envv); }

            auto result = lst[lst.size() - 1]->eval(envv);
            // Implement closure - function cature variables from local environment 
            if( result->isFun() 
                && !std::static_pointer_cast<ExprFun>(result)->isNativeFun() )
            {
                auto func = std::static_pointer_cast<ExprFunLisp>(result);
                func->env = envs;
            }

            return result;
        }

        /** For-loop similar to common lisp => (repeat 10 n (action n)) */
        if( symbol == "repeat" )
        {
            if( lst.size() != 4 ) 
            { throw std::runtime_error("Error: ill-formed syntax for repeat special form. Expected 4 arguments"); }
            if( !lst[2]->isSym() )
            { throw std::runtime_error("Error: ill-formed syntax for repeat special form. Expected symbol."); }
            auto n = lst[1]->eval(env);
            if( !n->isNum() )
            { throw std::runtime_error("Error: expected number as first argument."); }
            auto ntimes = (int) n->numValue();
            if( ntimes < 0)
            { throw std::runtime_error("Error: ill-formed syntax for repeat special form . Iterations cannot be negative."); }

            auto sym = lst[2]->strValue();

            auto action = lst[3];
            // Copy environment 
            auto envv = env;

            for(int k = 0; k < ntimes; k++)
            {
                envv[sym] = std::make_shared<ExprNum>(k);
                action->eval(envv);
            }
            return std::make_shared<ExprNil>();
        }


        // ---------- Function Application --------------------//

        auto it = lst[0]->eval(env);
        if( !it->isFun() ){ throw std::runtime_error("Error - object not callable.");  }
        auto function = std::static_pointer_cast<ExprFun>(it);

        // Function arguments
        auto args = lst;
        // Remove first element
        args.erase(args.begin());

        std::vector<std::shared_ptr<IExpr>> evaluatedArgs;

        // evaluatedArgs.reserve(args.size());
        for (auto const &arg : args)
        {
            auto res = arg->eval(env); 
            evaluatedArgs.push_back(res);
        }

        auto result = function->call(evaluatedArgs, env);
        return result;
    }
};


// Parser 
auto readTokens(std::vector<Token>& tokens) -> std::shared_ptr<IExpr> 
{
    // auto tokens = tokens_;
    if( tokens.size() == 0){
        throw std::runtime_error("Error: Unexpected EOF - End of File");
    }

    auto tok = tokens[0];    
    // Remove first element of vector 
    tokens.erase(tokens.begin());

    // std::cout << " [readToken] " << tok.type << " ; " << tok.text 
    //           << " ; line = " << tok.lin << " ; col = " << tok.col 
    //           << "\n";

    if( tok.type == TokenType::ERR )
    {
        throw std::runtime_error("[ERROR] " + tok.text);
    }

    if( tok.type == TokenType::QUOTE )
    {
        auto lst = std::vector<std::shared_ptr<IExpr>>{};
        lst.push_back( std::make_shared<ExprSym>("quote") );
        auto next = readTokens(tokens);
        lst.push_back(next);
        return std::make_shared<ExprLst>(lst);
    }

    if( tok.type == TokenType::LPAREN  )
    {
        auto lst = std::vector<std::shared_ptr<IExpr>>{};

        while( tokens[0].type != TokenType::RPAREN )
        {
            auto expr = readTokens(tokens);
            lst.push_back( expr );
        }
        // Drop off ')' right parentheis
        tokens.erase(tokens.begin());

        return std::make_shared<ExprLst>(lst);
    }

    if( tok.type == TokenType::RPAREN  )
    {
        throw std::runtime_error("Error: Unexpected ')' right parenthesis ");
    }

    if( tok.type == TokenType::NUM)
    {
        return std::make_shared<ExprNum>( std::stoi(tok.text) );
    }

    if( tok.type == TokenType::SYM && tok.text == "nil" )
    {
        return std::make_shared<ExprNil>();
    }

    if( tok.type == TokenType::SYM )
    {
        return std::make_shared<ExprSym>( tok.text );
    }

    if( tok.type == TokenType::KEYW )
    {
        return std::make_shared<ExprKey>( tok.text );
    }

    if( tok.type == TokenType::BOOL )
    {
        return std::make_shared<ExprBool>( tok.text == "#t" ? true : false );
    }

    if( tok.type == TokenType::STR )
    {
        return std::make_shared<ExprStr>( tok.text );
    }

    return std::make_shared<ExprErr>(-1, "BUG Found => Edge case found in the parser.");
}


// Parse Lisp-like (scheme-like) S-Expression by reading a string source code 
auto parseSexp(std::string const& code) -> std::shared_ptr<IExpr> 
{
    std::stringstream ss; 
    ss << code; 
    Tokenizer tokenizer(ss);
    auto tokens = tokenizer.readTokens();
    auto result = readTokens(tokens);
    return result;
}

// Parse Lisp-like (scheme-like) S-Expression by reading an input stream 
auto parseSexp(std::istream& is) -> std::shared_ptr<IExpr> 
{
    Tokenizer tokenizer(is);
    auto tokens = tokenizer.readTokens();
    auto result = readTokens(tokens);
    return result;
}


class PrintVisitor: public IVisitor
{
public:

    void visit(ExprNil&  expr)  override { std::cout << "nil"; } 
    void visit(ExprStr&  expr)  override { std::cout << "\"" << expr.value << "\""; }
    void visit(ExprNum&  expr)  override { std::cout << expr.value; }
    void visit(ExprBool& expr)  override { std::cout << (expr.value ? "#t" : "#f"); }
    void visit(ExprSym&  expr)  override { std::cout << expr.value; }
    void visit(ExprKey&  expr) override { std::cout << expr.value; }
    void visit(ExprErr&  expr)  override { std::cout << "<< [ERROR] " << expr.info; }
    void visit(ExprFun&  expr)  override { std::cout << expr.strValue(); }

    void visit(ExprLst& expr) override
    {
        std::cout << "( ";
        for(auto node : expr.lst){ std::cout << " "; node->accept(*this); }
        std::cout << " )";
    }

};

class WriterVisitor: public IVisitor
{
    std::ostream& out;
public:
    WriterVisitor(std::ostream& os_): out(os_){}

    void visit(ExprNil&  expr)  override { out << "nil"; } 
    void visit(ExprStr&  expr)  override { out << "\"" << expr.value << "\""; }
    void visit(ExprNum&  expr)  override { out << expr.value; }
    void visit(ExprBool& expr)  override { out << (expr.value ? "#t" : "#f"); }
    void visit(ExprSym&  expr)  override { out << expr.value; }
    void visit(ExprKey&  expr)  override { out << expr.value; }
    void visit(ExprErr&  expr)  override { out << "<< [ERROR] " << expr.info; }
    void visit(ExprFun&  expr)  override { out << expr.strValue(); }

    void visit(ExprLst& expr) override
    {
        // out << "\n ( ";
        for(auto const& node : expr.lst)
        { 
            out << " "; node->accept(*this);
            //if( node->isList() ){ out << '\n'; }
         }
        out << " )";
    }

};


// Print S-Expression 
void printSexp(IExpr& expr)
{
    PrintVisitor visitor;
    expr.accept(visitor);
    std::cout << std::endl;
}


/// Lisp interpreter's primitive functions 
namespace primitives {

    // All Lisp functions passed to the interpreter must have this type signature 
    // Lisp function primitive 'list' => Example: (list 10 20 (+ 1 2 5) "Hello" #f #t nil)
    std::shared_ptr<IExpr> list(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        return std::make_shared<ExprLst>(args);
    }


    // Return the number of elements of alist 
    std::shared_ptr<IExpr> length(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: length() requires 1 argument of type list."); } 
        if( !args[0]->isList() )
        { throw std::runtime_error("Error: length() expects 1 argument of type list."); }

        auto node = static_cast<ExprLst const&>( *args[0] );
        auto lst = node.lst;
        return std::make_shared<ExprNum>(lst.size());
    }

    //  car => Returns first element of the list or nil 
    std::shared_ptr<IExpr> car(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: car() requires 1 argument of type list."); } 
        if( !args[0]->isList() )
        { throw std::runtime_error("Error: car() expects 1 argument of type list."); }

        auto node = static_cast<ExprLst const&>( *args[0] );
        auto lst = node.lst;
        if( lst.size() == 0 ){ return std::make_shared<ExprNil>(); }
        return lst[0];
    }

    std::shared_ptr<IExpr> cdr(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: cdr() requires 1 argument of type list."); } 
        if( !args[0]->isList() )
        { throw std::runtime_error("Error: cdr() expects 1 argument of type list."); }

        auto node = static_cast<ExprLst const&>( *args[0] );
        auto lst = node.lst;
        if( lst.size() == 0 ){ return std::make_shared<ExprNil>(); }
        // Remove first list argument 
        lst.erase(lst.begin());
        return std::make_shared<ExprLst>(lst);
    }

    // cons => List constructor 
    std::shared_ptr<IExpr> cons(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 2 )
        { throw std::runtime_error("Error: cons() requires 2 arguments."); } 
        if( !args[1]->isList() && !args[1]->isNil() )
        { throw std::runtime_error("Error: pairs construction not allowed. Second argument can only be a list or nil."); }

        if( args[1]->isList() )
        {
            auto lst  = std::static_pointer_cast<ExprLst>( args[1] )->lst;
            lst.insert(lst.begin(), args[0]);
            return std::make_shared<ExprLst>(lst);
        }
        assert( args[1]->isNil() );
        auto lst =  std::vector<std::shared_ptr<IExpr>>{ args[0] };
        return std::make_shared<ExprLst>(lst);
    }

    // Get the nth element of a list
    std::shared_ptr<IExpr> nth(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 2 )
        { throw std::runtime_error("Error: cons() requires 2 arguments."); } 
        if( !args[0]->isNum() ) 
        { throw std::runtime_error("Error: Expected number "); }
        if( !args[1]->isList() && !args[1]->isNil() )
        { throw std::runtime_error("Error: Expected list or nil."); }

        if( args[1]->isNil() )
        { return std::make_shared<ExprNil>(); }

        auto n = (int) args[0]->numValue();    
        auto lst = std::static_pointer_cast<ExprLst>(args[1])->lst;

        if( n < lst.size() && n >= 0 ){ return lst[n]; }
        return std::make_shared<ExprNil>();
    }

    // (= 10 20) => #f ; (= 10 10) => #t
    std::shared_ptr<IExpr> equal_number(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 2 )
        { throw std::runtime_error("Error: = requires 2 arguments."); } 
        if( !args[0]->isNum() && !args[1]->isNum() ) 
        { throw std::runtime_error("Error: Expected number "); }
        auto a = args[0]->numValue();    
        auto b = args[1]->numValue();    
        return std::make_shared<ExprBool>(a == b);
    }

    std::shared_ptr<IExpr> less_than(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 2 )
        { throw std::runtime_error("Error: = requires 2 arguments."); } 
        if( !args[0]->isNum() && !args[1]->isNum() ) 
        { throw std::runtime_error("Error: Expected number "); }
        auto a = args[0]->numValue();    
        auto b = args[1]->numValue();    
        return std::make_shared<ExprBool>(a < b);
    }


    // Parse a string returning a S-Expression 
    std::shared_ptr<IExpr> read(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: read() requires 1 argument of type string."); } 
        if( args[0]->type() != ExprType::STR )
        { throw std::runtime_error("Error: read() expects 1 argument of type string."); }
        std::string code  = args[0]->strValue();
        auto result = parseSexp(code);
        return result;
    }

    // Primitive predicate function list? => Return true if the argument is of type list 
    std::shared_ptr<IExpr> is_list(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: list?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->isList() );
    }

    // Primitive predicate function symbol? => Return true if the argument is of type symbol
    std::shared_ptr<IExpr> is_symbol(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: symbol?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->type() == ExprType::SYM );
    }

    std::shared_ptr<IExpr> is_keyword(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: keyword?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->type() == ExprType::KEY );
    }

    // Primitive predicate function number? => Return true if the argument is of type number
    std::shared_ptr<IExpr> is_number(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: number?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->isNum() );
    }

    // Primitive predicate function boolean? => Return true if the argument is of type number
    std::shared_ptr<IExpr> is_boolean(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: boolean?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->type() == ExprType::BOOL );
    }

    // Primitive predicate function nil? => Return true if the argument is of type nil
    std::shared_ptr<IExpr> is_nil(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: nil?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->isNil() );
    }

    // Primitive predicate function string? => Return true if the argument is of type string
    std::shared_ptr<IExpr> is_string(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 )
        { throw std::runtime_error("Error: string?() requires 1 argument."); } 
        return std::make_shared<ExprBool>( args[0]->type() == ExprType::STR );
    }


    // Display an S-Expression 
    std::shared_ptr<IExpr> disp(std::vector<std::shared_ptr<IExpr>> const& args)
    {
        if( args.size() != 1 ){
           throw std::runtime_error("Error: function disp() requires 1 argument.");
        } 
        PrintVisitor visitor;
        args[0]->accept(visitor);
        std::cout << "\n";
        return std::make_shared<ExprNil>();
    }

    // Lisp function (+) => Example: (+ 1 2 3 4 5) = 15
    std::shared_ptr<IExpr> add(std::vector<std::shared_ptr<IExpr>> const& args)
    {
       if( args.size() == 0 ){
           throw std::runtime_error("Error: this function requires at least 1 argument.");
       } 
       double acc = 0.0;
       for(auto const& a: args){
           if( a->type() != ExprType::NUM){
               throw std::runtime_error("Invalid argument. Expected a number");
           }
           acc = acc + a->numValue();
       }
       return std::make_shared<ExprNum>(acc);
    }

    // Lisp function (*) => Example: (* 1 2 3 4 5) = 120
    std::shared_ptr<IExpr> mul(std::vector<std::shared_ptr<IExpr>> const& args)
    {
       if( args.size() == 0 ){
           throw std::runtime_error("Error: this function requires at least 1 argument.");
       } 
       double acc = 1.0;
       for(auto const& a: args){
           if( a->type() != ExprType::NUM){
               throw std::runtime_error("Invalid argument. Expected a number");
           }
           acc = acc * a->numValue();
       }
       return std::make_shared<ExprNum>(acc);
    }

    // List function (-) => Example: (- 100 20 30 ) = 100 - 20 - 30 = 50 
    std::shared_ptr<IExpr> sub(std::vector<std::shared_ptr<IExpr>> const& args)
    {

        // std::fprintf(stderr, " [TRACE] Called Lispfun sub() \n "); 
        if (args.size() == 0)
        {
            throw std::runtime_error("Error: this function requires at least 1 argument.");
        }
        if (args.size() == 1)
        {
            if (args[0]->type() != ExprType::NUM)
            {
                throw std::runtime_error("Error: invalid argument type. Expected number");
            }
            assert(args[0]->type() == ExprType::NUM);
            return std::make_shared<ExprNum>(-args[0]->numValue());
        }

        if (args[0]->type() != ExprType::NUM)
        {
            throw std::runtime_error("Error: invalid argument type. Expected number");
        }
        double acc = args[0]->numValue();

        // std::fprintf(stderr, " [TRACE] acc = %f \n", acc);

        auto args_ = args;
        // Remove first element
        args_.erase(args_.begin());

        for (auto const &a : args_)
        {
            if (a->type() != ExprType::NUM)
            {
                throw std::runtime_error("Invalid argument. Expected a number");
            }
            double x = a->numValue();
            // std::fprintf(stderr, " [TRACE] x = %f \n", x);
            acc = acc - x; 
        }
        return std::make_shared<ExprNum>(acc);
    }

    std::shared_ptr<IExpr> div(std::vector<std::shared_ptr<IExpr>> const& args)
    {

        // std::fprintf(stderr, " [TRACE] Called Lispfun sub() \n "); 
        if (args.size() == 0)
        {
            throw std::runtime_error("Error: this function requires at least 1 argument.");
        }
        if (args.size() == 1)
        {
            if (args[0]->type() != ExprType::NUM)
            {
                throw std::runtime_error("Error: invalid argument type. Expected number");
            }
            assert(args[0]->type() == ExprType::NUM);
            return std::make_shared<ExprNum>(1.0 / args[0]->numValue());
        }

        if (args[0]->type() != ExprType::NUM)
        {
            throw std::runtime_error("Error: invalid argument type. Expected number");
        }
        double acc = args[0]->numValue();

        // std::fprintf(stderr, " [TRACE] acc = %f \n", acc);

        auto args_ = args;
        // Remove first element
        args_.erase(args_.begin());

        for (auto const &a : args_)
        {
            if (a->type() != ExprType::NUM)
            {
                throw std::runtime_error("Invalid argument. Expected a number");
            }
            double x = a->numValue();
            // std::fprintf(stderr, " [TRACE] x = %f \n", x);
            acc = acc / x; 
        }
        return std::make_shared<ExprNum>(acc);
    }


}

class Eval
{
    // Reference to itself in oder to provide code completion
    Eval& self = *this;

public:
    using Env = std::map<std::string, std::shared_ptr<IExpr>>; 

    // Lisp environment 
    Env _env;

    Eval()
    {
        self.addFunction("disp",    &primitives::disp);
        // Primitive list functions 
        self.addFunction("list",    &primitives::list);
        self.addFunction("length",  &primitives::length);
        self.addFunction("car",     &primitives::car);
        self.addFunction("cdr",     &primitives::cdr);
        self.addFunction("cons",    &primitives::cons);
        self.addFunction("nth",     &primitives::nth);
        // Primitive predicate functions  
        self.addFunction("number?",  &primitives::is_number);
        self.addFunction("boolean?", &primitives::is_boolean);
        self.addFunction("symbol?",  &primitives::is_symbol);
        self.addFunction("nil?",     &primitives::is_nil);
        self.addFunction("keyword?", &primitives::is_keyword);
        self.addFunction("list?",    &primitives::is_list);
        // Primtive math functions 
        self.addFunction("=",       &primitives::equal_number);
        self.addFunction("<",       &primitives::less_than);
        self.addFunction("+",       &primitives::add);
        self.addFunction("*",       &primitives::mul); 
        self.addFunction("-",       &primitives::sub);
        self.addFunction("/",       &primitives::div);
        self.addMath1ArgFun("sin", static_cast<double (*) (double)>(&std::sin));
        self.addMath1ArgFun("cos", static_cast<double (*) (double)>(&std::cos));
        self.addMath1ArgFun("tan", static_cast<double (*) (double)>(&std::tan));
        self.addMath1ArgFun("sqrt", static_cast<double (*) (double)>(&std::sqrt));
        self.addMath1ArgFun("inv", [](double x){ return 1.0 / x; });
        self.addVariable("PI", 3.1415);

        // Parse string into a SExp - S-Expression 
        self.addFunction("read", &primitives::read);

        // Evaluate a List (AST - Abstract Syntax Tree) or SEXP returning a SEXP (S-Expression)
        self.addFunction("eval", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 1 )
            { throw std::runtime_error("Error: eval(sexp) requires 1 argument of type list."); } 
            if( !args[0]->isList() )
            { throw std::runtime_error("Error: eval(sexpr) expects 1 argument of type list."); }
            auto expr = static_cast<ExprLst const&>( *args[0] );
            return expr.eval(this->_env); 
        });

        // load a file 
        self.addFunction("load-file", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 1  && !args[0]->isStr() )
            { throw std::runtime_error("Error: load-file() requires 1 argument of type string."); } 
            auto file = args[0]->strValue(); 
            auto expr = this->evalFile(file); 
            return expr;
        });

        // Read a single S-Expression from file without evaluating it 
        self.addFunction("read-file", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 1  && !args[0]->isStr() )
            { throw std::runtime_error("Error: eval(sexp) requires 1 argument of type string."); } 
            auto file = args[0]->strValue(); 
            auto ifs  = std::ifstream(file);
            auto sexp  = parseSexp(ifs);
            return sexp;
        });

        // Write a single S-Expression to a file 
        self.addFunction("write-file", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 2  && !args[0]->isStr() )
            { throw std::runtime_error("Error: eval(sexp) requires 1 argument of type string."); } 
            auto file = args[0]->strValue(); 
            auto ofs  = std::ofstream(file);
            WriterVisitor visitor(ofs); 
            args[1]->accept(visitor);
            return std::make_shared<ExprNil>();
        });

        // Read a multiple S-Expression from file without evaluating it 
        self.addFunction("read-file-multiple", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 1  && !args[0]->isStr() )
            { throw std::runtime_error("Error: eval(sexp) requires 1 argument of type string."); } 
            auto file = args[0]->strValue(); 
            std::ifstream is(file);
            if( !is.good() ){ throw std::runtime_error("Error: stream has errors."); }
            std::stringstream ss;
            ss << is.rdbuf();
            auto code = "( \n" +  ss.str() + "\n )";
            auto sexp = parseSexp(code);
            return sexp;
        });


        self.addFunction("apply", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 2 )
            { throw std::runtime_error("Error: apply() requires 2 arguments."); } 
            if( !args[0]->isFun() )
            { throw std::runtime_error("Error: expected function as first argument."); }
            if( !args[1]->isList() )
            { throw std::runtime_error("Error: expected list as second argument."); }
            auto func = std::static_pointer_cast<ExprFun>(args[0]);
            auto params = std::static_pointer_cast<ExprLst>(args[1]); 
            return func->call(params->lst, this->_env);
        });
  
        self.addFunction("map", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 2 )
            { throw std::runtime_error("Error: apply() requires 2 arguments."); } 
            if( !args[0]->isFun() )
            { throw std::runtime_error("Error: expected function as first argument."); }
            if( !args[1]->isList() )
            { throw std::runtime_error("Error: expected list as second argument."); }
            auto func = std::static_pointer_cast<ExprFun>(args[0]);
            auto params = std::static_pointer_cast<ExprLst>(args[1]); 

            auto result = std::vector<std::shared_ptr<IExpr>>{};
            auto args_ = std::vector<std::shared_ptr<IExpr>>{ std::make_shared<ExprNil>() };
            result.reserve( params->lst.size() );
            for(auto const& p: params->lst){
                args_[0] = p; 
                result.push_back( func->call( args_, this->_env ) );
            }
            return std::make_shared<ExprLst>(result);

        });

        self.addFunction("for-each", [=](std::vector<std::shared_ptr<IExpr>> const& args)
        {
            if( args.size() != 2 )
            { throw std::runtime_error("Error: apply() requires 2 arguments."); } 
            if( !args[0]->isFun() )
            { throw std::runtime_error("Error: expected function as first argument."); }
            if( !args[1]->isList() )
            { throw std::runtime_error("Error: expected list as second argument."); }
            auto func = std::static_pointer_cast<ExprFun>(args[0]);
            auto params = std::static_pointer_cast<ExprLst>(args[1]); 
            for(auto const& p: params->lst){ 
                auto args_ = std::vector<std::shared_ptr<IExpr>>{ p };
                func->call( args_, this->_env ); 
            }
            return std::make_shared<ExprNil>();

        });

    }

    void addVariable(std::string const& name, double value)
    {
        auto expr = std::make_shared<ExprNum>(value);
        _env[name] = expr;
    }

    void addVariable(std::string const& name, std::shared_ptr<IExpr> expr) 
    {
        _env[name] = expr;
    }

    void addFunction(std::string const& name, LispFunc func)
    {
        auto fn = std::make_shared<ExprFunNative>(func);
        fn->name = name;
        _env[name] = fn;
    }

    template<typename Func>
    void addMath1ArgFun(std::string const& name, Func funcMath) 
    {
       auto func = [=](std::vector<std::shared_ptr<IExpr>> const& args) {
           if( args.size() != 1){
               throw std::runtime_error(" [ERROR] This function requires exactly one argument.");
           }
           auto x = args[0];
           if( x->type() != ExprType::NUM ){
               throw std::runtime_error(" [ERROR] Invalid arguument type. Number required. ");
           }
           double res = funcMath(x->numValue());
           return std::make_shared<ExprNum>(res);
       };
       auto val = std::make_shared<ExprFunNative>(func);
       val->name = name;
       _env[name] = val;
    }

    std::shared_ptr<IExpr> eval(IExpr& expr)
    {
        return expr.eval( this->_env );
    }

    // Interactive read-print eval loop0 
    void repl()
    {
        std::string line; 
        std::string arg, command; 

        for(;;)
        {
            std::cout << " $ lisp>> ";
            if( !std::getline(std::cin, line) ){ break; }
            if( line == "" ){ continue; }
            std::stringstream ss(line);
            ss >> command >> arg;
            try
            {
                if( command == ":file")
                {
                    auto res = this->evalFile(arg);
                    continue;
                }

                if( command == ":block")
                {
                    std::fprintf(stderr, " [INFO] Type a multi-line s-expression and type (;;) as the last line when you are done. \n");
                    std::string code;

                    while( line != ";;" ){ 
                        std::getline(std::cin, line);
                        code = code + "\n" + line;
                     }
                    auto res = this->evalCode(code);
                    self.addVariable("ans", res);
                    printSexp(*res);
                    continue;

                }
                auto res = this->evalCode(line);
                self.addVariable("ans", res);
                printSexp(*res);
            }
            catch(const std::exception& e)
            {
                std::cerr << e.what() << '\n';
            }

        }
    }

    /// Eval lisp-like code given as string 
    std::shared_ptr<IExpr>  
    evalCode(std::string const& code) 
    {
        auto expr = parseSexp(code);
        auto result = expr->eval(_env); 
        return result;
    }

    std::shared_ptr<IExpr>  
    evalFile(std::string const& file) 
    {
        std::ifstream is(file);
        if( !is.good() ){ throw std::runtime_error("Error: stream has errors."); }
        std::stringstream ss;
        ss << is.rdbuf();
        auto code = "(begin \n" +  ss.str() + "\n )";
        auto expr = parseSexp(code);
        auto result = expr->eval(_env); 
        return result;
    }
};

int main(){

    std::cout << " [TRACE] Testing " << std::endl;
    
    const char* text = R"( 
         ; comment1
         ;   comment 2  
         ; comment 3 
     (  print->list 
         ; comment 4
          " Hello world" A8 B100
          ; Next comment 
          #t #f 
             (+  20 30 -200(* 20 -20 x y z 8000)) ) 
    )";

    std::stringstream ss;
   
    #if 0 
    std::cout << " =========== Tokenizer  ======================== " << std::endl;
    ss << text; 
    ss << "100";
    
    Tokenizer tokenizer(ss);
    Token tok;
    
    while( !tok.isEOF() ){
        tok = tokenizer.nextToken();
        std::cout << " => " << tok.type << " ; " << tok.text 
                  << " ; line = " << tok.lin << " ; col = " << tok.col 
                  << "\n";
    }
    #endif 

    auto expr = parseSexp(text); 

    std::cout <<  std::boolalpha << " [TRACE] expr->isList() = " << expr->isList() << "\n";

    printSexp(*expr);

    std::cout << " ====== Evaluate Code  ======================== " << std::endl;

    const char* code1 = R"( 
        (list 10 #t #f "hello world" 
            ; Operation 1
            (+ 10 25 6) 
            ; Operation 2
            (* 4 2 6) )
     )";

    Eval eval; 

    auto res = eval.evalCode(code1);
    std::cout << " [TRACE] Result = ";
    printSexp(*res);

    std::cout << "============ Start LISP REPL ======================" << std::endl;
    eval.repl(); 


    return 0;
  }