StdLib.hpp

Go to the documentation of this file.

#pragma once
#include <functional>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <stdlib.h>
#include <string.h>
#include <phsint.hpp>
 
#include "../VM/VM.hpp"
#ifndef CMAKE_PCH
#include <Value.hpp>
#endif

namespace Phasor
{

using NativeFunction = std::function<Value(const std::vector<Value> &args, VM *vm)>;

class StdLib
{
  public:
    inline static void registerFunctions(VM &vm)
    {
#ifdef TRACING
        vm.log(std::format("StdLib::{}(&VM@{:#x})\n", __func__, reinterpret_cast<std::uintptr_t>(&vm)));
        vm.flush();
#endif
        vm.registerNativeFunction("using", std_import);
#ifndef SANDBOXED
        vm.registerNativeFunction("assert", std_assert);
#endif
    }
 
    static char **argv; 
    static int    argc; 
 
    static void checkArgCount(const std::vector<Value> &args, size_t minimumArguments, const std::string &name,
                              bool allowMoreArguments = false);
 
  private:
    static bool std_import(const std::vector<Value> &args, VM *vm);
#ifndef SANDBOXED
    static Value std_assert(const std::vector<Value> &args, VM *vm);
#endif
 
    enum class dupenv_ret {
        Success = 0,
        InvalidInput = 1,
        NotFound = 2
    };
 
    static dupenv_ret dupenv(PhsString &out, const char *name);
 
    static void registerMetaFunctions(VM *vm);
    static void registerMemoryFunctions(VM *vm);
    static void registerMathFunctions(VM *vm);
    static void registerRandomFunctions(VM *vm);
    static void registerStringFunctions(VM *vm);
    static void registerTypeConvFunctions(VM *vm);
#ifndef SANDBOXED
    static void registerFileFunctions(VM *vm);
#endif
    static void registerSysFunctions(VM *vm);
    static void registerIOFunctions(VM *vm);
    static void registerArrayFunctions(VM *vm);
 
#pragma region stdmeta
#ifndef SANDBOXED
    static i64 meta_operation(const std::vector<Value> &args, VM *vm);
    static Value   meta_stack_run(const std::vector<Value> &args, VM *vm);
#endif
    static PhsString meta_get_version(const std::vector<Value> &args, VM *vm);
 
#pragma endregion stdmeta
 
#pragma region stdmemory
    static Value var_free(const std::vector<Value> &args, VM *vm); 
#pragma endregion
 
#pragma region stdmath
    static f64 math_sqrt(const std::vector<Value> &args, VM *vm);  
    static f64 math_pow(const std::vector<Value> &args, VM *vm);   
    static Value  math_abs(const std::vector<Value> &args, VM *vm);   
    static f64 math_floor(const std::vector<Value> &args, VM *vm); 
    static f64 math_ceil(const std::vector<Value> &args, VM *vm);  
    static f64 math_round(const std::vector<Value> &args, VM *vm); 
    static Value  math_min(const std::vector<Value> &args, VM *vm);   
    static Value  math_max(const std::vector<Value> &args, VM *vm);   
    static f64 math_log(const std::vector<Value> &args, VM *vm);   
    static f64 math_exp(const std::vector<Value> &args, VM *vm);   
    static f64 math_sin(const std::vector<Value> &args, VM *vm);   
    static f64 math_cos(const std::vector<Value> &args, VM *vm);   
    static f64 math_tan(const std::vector<Value> &args, VM *vm);   
#pragma endregion
 
#pragma region stdfile
#ifndef SANDBOXED
    static PhsString file_absolute(const std::vector<Value> &args, VM *vm);   
    static Value       file_read(const std::vector<Value> &args, VM *vm);       
    static bool        file_write(const std::vector<Value> &args, VM *vm);      
    static bool        file_exists(const std::vector<Value> &args, VM *vm);     
    static PhsString file_read_line(const std::vector<Value> &args, VM *vm);  
    static bool        file_write_line(const std::vector<Value> &args, VM *vm); 
    static bool        file_append(const std::vector<Value> &args, VM *vm);     
    static bool        file_delete(const std::vector<Value> &args, VM *vm);     
    static bool        file_rename(const std::vector<Value> &args, VM *vm);     
    static Value       file_current_directory(const std::vector<Value> &args, VM *vm); 
    static bool        file_copy(const std::vector<Value> &args, VM *vm);              
    static bool        file_move(const std::vector<Value> &args, VM *vm);              
    static bool        file_property_edit(const std::vector<Value> &args, VM *vm);
    static i64     file_property_get(const std::vector<Value> &args, VM *vm);
    static bool        file_create(const std::vector<Value> &args, VM *vm);
    static Value       file_read_directory(const std::vector<Value> &args, VM *vm);
    static bool        file_create_directory(const std::vector<Value> &args, VM *vm);
    static bool        file_remove_directory(const std::vector<Value> &args, VM *vm);
    static PhsString file_join_path(const std::vector<Value> &args, VM *vm);
    static PhsString file_stem(const std::vector<Value> &args, VM *vm);         
    static PhsString file_filename(const std::vector<Value> &args, VM *vm);     
    static PhsString file_extension(const std::vector<Value> &args, VM *vm);    
    static bool        file_is_directory(const std::vector<Value> &args, VM *vm); 
    static PhsString file_parent(const std::vector<Value> &args, VM *vm);       
    static i64     file_get_size(const std::vector<Value> &args, VM *vm);
#pragma endregion
 
#pragma region stdsys
    static i64     sys_get_free_memory(const std::vector<Value> &args, VM *vm); 
    static Value       sys_wait_for_input(const std::vector<Value> &args, VM *vm);  
    static Value       sys_shell(const std::vector<Value> &args, VM *vm);           
    static i64     sys_fork(const std::vector<Value> &args, VM *vm);            
    static i64     sys_fork_detached(const std::vector<Value> &args, VM *vm);   
    static Value       sys_crash(const std::vector<Value> &args, VM *vm);           
    static Value       sys_reset(const std::vector<Value> &args, VM *vm);           
    static i64     sys_pid(const std::vector<Value> &args, VM *vm);             
    static PhsString sys_os(const std::vector<Value> &args, VM *vm);              
    static Value sys_isatty(const std::vector<Value> &args, VM *vm); 
#endif
    static Value sys_env(const std::vector<Value> &args, VM *vm); 
    static Value   sys_argv(const std::vector<Value> &args, VM *vm); 
    static i64 sys_argc(const std::vector<Value> &args, VM *vm); 
    static Value sys_args(const std::vector<Value> &args, VM *vm); 
    static f64  sys_time(const std::vector<Value> &args, VM *vm);           
    static Value   sys_time_formatted(const std::vector<Value> &args, VM *vm); 
    static Value   sys_sleep(const std::vector<Value> &args, VM *vm);          
    static Value   sys_shutdown(const std::vector<Value> &args, VM *vm);       
#pragma endregion
 
#pragma region stdtype
    static i64     to_int(const std::vector<Value> &args, VM *vm);    
    static f64      to_float(const std::vector<Value> &args, VM *vm);  
    static PhsString to_string(const std::vector<Value> &args, VM *vm); 
    static bool        to_bool(const std::vector<Value> &args, VM *vm);   
#pragma endregion
 
#pragma region stdarray
    static i64 array_length(const std::vector<Value> &args, VM *vm); 
    static Value array_push(const std::vector<Value> &args, VM *vm);   
    static Value array_pop(const std::vector<Value> &args, VM *vm);    
    static Value array_insert(const std::vector<Value> &args, VM *vm); 
    static Value array_resize(const std::vector<Value> &args, VM *vm); 
 
#pragma region stdrand
 
    static Value   rand_seed(const std::vector<Value> &args, VM *vm);       
    static i64 rand_next_range(const std::vector<Value> &args, VM *vm); 
    static f64  rand_next_float(const std::vector<Value> &args,
                                   VM *vm); 
 
#pragma endregion
 
#pragma region stdstr
    static i64     str_find(const std::vector<Value> &args, VM *vm);        
    static i64     str_len(const std::vector<Value> &args, VM *vm);         
    static Value       str_char_at(const std::vector<Value> &args, VM *vm);     
    static Value       str_substr(const std::vector<Value> &args, VM *vm);      
    static PhsString str_concat(const std::vector<Value> &args, VM *vm);      
    static PhsString str_upper(const std::vector<Value> &args, VM *vm);       
    static PhsString str_lower(const std::vector<Value> &args, VM *vm);       
    static Value       str_starts_with(const std::vector<Value> &args, VM *vm); 
    static Value       str_ends_with(const std::vector<Value> &args, VM *vm);   
    // StringBuilder functions
    static i64     sb_new(const std::vector<Value> &args, VM *vm);       
    static Value       sb_append(const std::vector<Value> &args, VM *vm);    
    static PhsString sb_to_string(const std::vector<Value> &args, VM *vm); 
    static Value       sb_clear(const std::vector<Value> &args, VM *vm);     
    static PhsString sb_free(const std::vector<Value> &args, VM *vm);      
#pragma endregion
 
#pragma region stdio
    static PhsString io_c_format(const std::vector<Value> &args, VM *vm); 
#ifndef SANDBOXED
    static Value io_clear(const std::vector<Value> &args, VM *vm); 
#endif
    static PhsString io_prints(const std::vector<Value> &args, VM *vm); 
    static PhsString io_printf(const std::vector<Value> &args, VM *vm); 
    static PhsString io_puts(const std::vector<Value> &args, VM *vm);   
    static PhsString io_putf(const std::vector<Value> &args, VM *vm);   
#ifndef SANDBOXED
    static Value io_gets(const std::vector<Value> &args, VM *vm); 
#endif
    static PhsString io_putf_error(const std::vector<Value> &args,
                                     VM *vm); 
    static PhsString io_puts_error(const std::vector<Value> &args,
                                     VM                       *vm); 
#pragma endregion
};
 
} // namespace Phasor