StdLib.hpp

Go to the documentation of this file.

#pragma once
#include "../VM/VM.hpp"
#include <Value.hpp>
#include <functional>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <stdlib.h>
#include <string.h>
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::{}(): using 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 char **envp; 
    
    static void checkArgCount(const std::vector<Value> &args, size_t minimumArguments, const std::string &name,
                              bool allowMoreArguments = false);
  private:
    static Value std_import(const std::vector<Value> &args, VM *vm);
#ifndef SANDBOXED
    static Value std_assert(const std::vector<Value> &args, VM *vm);
#endif
 
#ifndef __EMSCRIPTEN__
#ifndef SANDBOXED
    static int dupenv(std::string &out, const char *name, char *const argp[]);
#endif
 
    static void registerMathFunctions(VM *vm);
    static void registerStringFunctions(VM *vm);
    static void registerTypeConvFunctions(VM *vm);
    static void registerFileFunctions(VM *vm);
    static void registerSysFunctions(VM *vm);
    static void registerIOFunctions(VM *vm);
 
    // Math functions
    static Value math_sqrt(const std::vector<Value> &args, VM *vm);  
    static Value math_pow(const std::vector<Value> &args, VM *vm);   
    static Value math_abs(const std::vector<Value> &args, VM *vm);   
    static Value math_floor(const std::vector<Value> &args, VM *vm); 
    static Value math_ceil(const std::vector<Value> &args, VM *vm);  
    static Value 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 Value math_log(const std::vector<Value> &args, VM *vm);   
    static Value math_exp(const std::vector<Value> &args, VM *vm);   
    static Value math_sin(const std::vector<Value> &args, VM *vm);   
    static Value math_cos(const std::vector<Value> &args, VM *vm);   
    static Value math_tan(const std::vector<Value> &args, VM *vm);   
 
#ifndef SANDBOXED
    // File IO
    static Value file_absolute(const std::vector<Value> &args, VM *vm);     
    static Value file_read(const std::vector<Value> &args, VM *vm);              
    static Value file_write(const std::vector<Value> &args, VM *vm);             
    static Value file_exists(const std::vector<Value> &args, VM *vm);            
    static Value file_read_line(const std::vector<Value> &args, VM *vm);         
    static Value file_write_line(const std::vector<Value> &args, VM *vm);        
    static Value file_append(const std::vector<Value> &args, VM *vm);            
    static Value file_delete(const std::vector<Value> &args, VM *vm);            
    static Value file_rename(const std::vector<Value> &args, VM *vm);            
    static Value file_current_directory(const std::vector<Value> &args, VM *vm); 
    static Value file_copy(const std::vector<Value> &args, VM *vm);              
    static Value file_move(const std::vector<Value> &args, VM *vm);              
    static Value file_property_edit(const std::vector<Value> &args, VM *vm);
    static Value file_property_get(const std::vector<Value> &args, VM *vm);
    static Value file_create(const std::vector<Value> &args, VM *vm);
    static Value file_read_directory(const std::vector<Value> &args, VM *vm);
    static Value file_statistics(const std::vector<Value> &args, VM *vm);
    static Value file_create_directory(const std::vector<Value> &args, VM *vm);
    static Value file_remove_directory(const std::vector<Value> &args, VM *vm);
 
    // System (meaning VM/CRT more than actual system)
    static Value sys_env(const std::vector<Value> &args, VM *vm);            
    static Value sys_argv(const std::vector<Value> &args, VM *vm);           
    static Value system_get_free_memory(const std::vector<Value> &args, VM *vm); 
    static Value sys_argc(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 Value sys_fork(const std::vector<Value> &args, VM *vm);           
    static Value 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 Value sys_pid(const std::vector<Value> &args, VM *vm);      
    static Value sys_os(const std::vector<Value> &args, VM *vm);             
#endif
    static Value 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); 
 
    // Type conversion functions
    static Value to_int(const std::vector<Value> &args, VM *vm);    
    static Value to_float(const std::vector<Value> &args, VM *vm);  
    static Value to_string(const std::vector<Value> &args, VM *vm); 
    static Value to_bool(const std::vector<Value> &args, VM *vm);   
 
    // String functions
    static Value str_find(const std::vector<Value> &args, VM *vm);        
    static Value 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 Value str_concat(const std::vector<Value> &args, VM *vm);      
    static Value str_upper(const std::vector<Value> &args, VM *vm);       
    static Value 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 Value sb_new(const std::vector<Value> &args, VM *vm);       
    static Value sb_append(const std::vector<Value> &args, VM *vm);    
    static Value sb_to_string(const std::vector<Value> &args, VM *vm); 
    static Value sb_clear(const std::vector<Value> &args, VM *vm);     
    static Value sb_free(const std::vector<Value> &args, VM *vm);      
 
    // IO
    static Value 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 Value io_prints(const std::vector<Value> &args, VM *vm);   
    static Value io_printf(const std::vector<Value> &args, VM *vm);   
    static Value io_puts(const std::vector<Value> &args, VM *vm);     
    static Value io_putf(const std::vector<Value> &args, VM *vm);     
#ifndef SANDBOXED
    static Value io_gets(const std::vector<Value> &args, VM *vm);     
#endif
    static Value io_putf_error(const std::vector<Value> &args,
                               VM                       *vm); 
    static Value io_puts_error(const std::vector<Value> &args, VM *vm); 
#endif
};
 
} // namespace Phasor