PhasorStdLib.hpp

Go to the documentation of this file.

// Copyright 2026 Daniel McGuire
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
// README
//
// Usage:
// ```cpp
// #include "PhasorStdLib.hpp"
// // later
// Phasor::StdLib::registerFunctions(vm);
// ```
 
#pragma once
 
#include <cmath>
#include <cstdlib>
#include <cstring>
 
#include <functional>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <stdexcept>
 
#include "PhasorVM.hpp"
#include "../Value.hpp"

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(std::string &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);
 
#pragma region stdmeta
#ifndef SANDBOXED
    static int64_t meta_operation(const std::vector<Value> &args, VM *vm);
    static Value   meta_stack_run(const std::vector<Value> &args, VM *vm);
#endif
    static std::string 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 double math_sqrt(const std::vector<Value> &args, VM *vm);  
    static double math_pow(const std::vector<Value> &args, VM *vm);   
    static Value  math_abs(const std::vector<Value> &args, VM *vm);   
    static double math_floor(const std::vector<Value> &args, VM *vm); 
    static double math_ceil(const std::vector<Value> &args, VM *vm);  
    static double 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 double math_log(const std::vector<Value> &args, VM *vm);   
    static double math_exp(const std::vector<Value> &args, VM *vm);   
    static double math_sin(const std::vector<Value> &args, VM *vm);   
    static double math_cos(const std::vector<Value> &args, VM *vm);   
    static double math_tan(const std::vector<Value> &args, VM *vm);   
#pragma endregion
 
#pragma region stdfile
#ifndef SANDBOXED
    static std::string 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 std::string 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 int64_t     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 std::string file_join_path(const std::vector<Value> &args, VM *vm);
    static std::string file_stem(const std::vector<Value> &args, VM *vm);         
    static std::string file_filename(const std::vector<Value> &args, VM *vm);     
    static std::string file_extension(const std::vector<Value> &args, VM *vm);    
    static bool        file_is_directory(const std::vector<Value> &args, VM *vm); 
    static std::string file_parent(const std::vector<Value> &args, VM *vm);       
    static int64_t     file_get_size(const std::vector<Value> &args, VM *vm);
#pragma endregion
 
#pragma region stdsys
    static int64_t     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 int64_t     sys_fork(const std::vector<Value> &args, VM *vm);            
    static int64_t     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 int64_t     sys_pid(const std::vector<Value> &args, VM *vm);             
    static std::string 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 int64_t sys_argc(const std::vector<Value> &args, VM *vm); 
    static double  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 int64_t     to_int(const std::vector<Value> &args, VM *vm);    
    static double      to_float(const std::vector<Value> &args, VM *vm);  
    static std::string to_string(const std::vector<Value> &args, VM *vm); 
    static bool        to_bool(const std::vector<Value> &args, VM *vm);   
#pragma endregion
 
#pragma region stdrand
 
    static Value   rand_seed(const std::vector<Value> &args, VM *vm);       
    static int64_t rand_next_range(const std::vector<Value> &args, VM *vm); 
    static double  rand_next_float(const std::vector<Value> &args,
                                   VM *vm); 
 
#pragma endregion
 
#pragma region stdstr
    static int64_t     str_find(const std::vector<Value> &args, VM *vm);        
    static int64_t     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 std::string str_concat(const std::vector<Value> &args, VM *vm);      
    static std::string str_upper(const std::vector<Value> &args, VM *vm);       
    static std::string 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 int64_t     sb_new(const std::vector<Value> &args, VM *vm);       
    static Value       sb_append(const std::vector<Value> &args, VM *vm);    
    static std::string sb_to_string(const std::vector<Value> &args, VM *vm); 
    static Value       sb_clear(const std::vector<Value> &args, VM *vm);     
    static std::string sb_free(const std::vector<Value> &args, VM *vm);      
#pragma endregion
 
#pragma region stdio
    static std::string 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 std::string io_prints(const std::vector<Value> &args, VM *vm); 
    static std::string io_printf(const std::vector<Value> &args, VM *vm); 
    static std::string io_puts(const std::vector<Value> &args, VM *vm);   
    static std::string io_putf(const std::vector<Value> &args, VM *vm);   
#ifndef SANDBOXED
    static Value io_gets(const std::vector<Value> &args, VM *vm); 
#endif
    static std::string io_putf_error(const std::vector<Value> &args,
                                     VM *vm); 
    static std::string io_puts_error(const std::vector<Value> &args,
                                     VM                       *vm); 
#pragma endregion
};
 
} // namespace Phasor