nany.h

/*
** Nany - https://nany.io
** This Source Code Form is subject to the terms of the Mozilla Public
** License, v. 2.0. If a copy of the MPL was not distributed with this
** file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef __LIBNANYC_NANY_C_H__
#define __LIBNANYC_NANY_C_H__
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#if defined(_WIN32) || defined(__CYGWIN__)
#  ifdef __GNUC__
#    define LIBNANYC_VISIBILITY_EXPORT   __attribute__ ((dllexport))
#    define LIBNANYC_VISIBILITY_IMPORT   __attribute__ ((dllimport))
#  else
#    define LIBNANYC_VISIBILITY_EXPORT   __declspec(dllexport) /* note: actually gcc seems to also supports this syntax */
#    define LIBNANYC_VISIBILITY_IMPORT   __declspec(dllimport) /* note: actually gcc seems to also supports this syntax */
#  endif
#else
#  define LIBNANYC_VISIBILITY_EXPORT     __attribute__((visibility("default")))
#  define LIBNANYC_VISIBILITY_IMPORT     __attribute__((visibility("default")))
#endif

#if defined(_DLL) && !defined(LIBNANYC_DLL_EXPORT)
#  define LIBNANYC_DLL_EXPORT
#endif

#if defined(LIBNANYC_DLL_EXPORT)
#   define NY_EXPORT LIBNANYC_VISIBILITY_EXPORT
#else
#   define NY_EXPORT LIBNANYC_VISIBILITY_IMPORT
#endif








#ifdef __cplusplus
extern "C" {
#endif


NY_EXPORT void nylib_print_info_for_bugreport();

NY_EXPORT char* nylib_get_info_for_bugreport(uint32_t* length);

NY_EXPORT const char* nylib_website_url();

NY_EXPORT uint32_t nylib_get_version(uint32_t* major, uint32_t* minor, uint32_t* patch);

NY_EXPORT const char* nylib_version();
NY_EXPORT const char* nylib_version_metadata();
NY_EXPORT const char* nylib_version_prerelease();

NY_EXPORT int nylib_check_compatible_version(uint32_t major, uint32_t minor);
#ifndef LIBNANYC_NYBOOL_T
#define LIBNANYC_NYBOOL_T

typedef enum nybool_t {nyfalse = 0, nytrue} nybool_t;
#endif


#ifndef LIBNANYC_NYANYSTR_T
#define LIBNANYC_NYANYSTR_T
typedef struct {
    uint32_t size;
    const char* c_str;
}
nyanystr_t;

static inline nyanystr_t nyanystr(const char* const text) {
    nyanystr_t s = {((text) ? (uint32_t) strlen(text) : 0), text};
    return s;
}

static inline nyanystr_t nyanystr_ex(const char* const text, uint32_t len) {
    nyanystr_t s = {len, text};
    return s;
}

static inline void nyanystr_duplicate(nyanystr_t* const out, const nyanystr_t* const src) {
    uint32_t len = src->size;
    const char* srcstr = src->c_str;
    char* str = (char*) malloc(sizeof(char) * (len + 1));
    memcpy(str, srcstr, len);
    str[len] = '\0';
    out->c_str = str;
    out->size = len;
}
#endif


typedef enum { /* nytype_t */
    nyt_void = 0,
    nyt_any,
    nyt_ptr,
    nyt_bool,
    nyt_u8,
    nyt_u16,
    nyt_u32,
    nyt_u64,
    nyt_i8,
    nyt_i16,
    nyt_i32,
    nyt_i64,
    nyt_f32,
    nyt_f64
}
nytype_t;

enum {
    nyt_count = nyt_f64 + 1,
};


typedef enum { /* nyvisibility_t */
    nyv_undefined,
    nyv_default,
    nyv_private,
    nyv_protected,
    nyv_internal,
    nyv_public,
    nyv_published
}
nyvisibility_t;

enum {
    nyv_count = nyv_published + 1,
};


typedef struct nythread_t nythread_t;
typedef struct nyproject_t nyproject_t;
typedef struct nytarget_t nytarget_t;
typedef struct nysource_t nysource_t;
typedef struct nybuild_t nybuild_t;
typedef struct nyprogram_t nyprogram_t;
typedef struct nythread_t nytctx_t;
struct nyallocator_t;

typedef struct nyallocator_cf_t {
    void* userdata;
    nybool_t (*create_mt)(struct nyallocator_t*, const struct nyallocator_cf_t*);
    nybool_t (*create_st)(struct nyallocator_t*, const struct nyallocator_cf_t*);
    void (*on_not_enough_memory)(struct nyallocator_t*, nybool_t limit_reached);
}
nyallocator_cf_t;

typedef struct nyallocator_t {
    void* userdata;
    void* (*allocate)(struct nyallocator_t*, size_t);
    void* (*reallocate)(struct nyallocator_t*, void* ptr, size_t oldsize, size_t newsize);
    void (*deallocate)(struct nyallocator_t*, void* ptr, size_t);
    volatile size_t reserved_mem0;
    size_t limit_mem_size;
    void (*on_not_enough_memory)(struct nyallocator_t*, nybool_t limit_reached);
    void (*on_internal_abort)(struct nyallocator_t*);
    void (*release)(struct nyallocator_t*);
}
nyallocator_t;


NY_EXPORT void nyallocator_cf_init(nyallocator_cf_t*);

NY_EXPORT void nany_memalloc_set_default(nyallocator_t*);
NY_EXPORT void nany_memalloc_set_with_limit(nyallocator_t*, size_t limit);
void nany_memalloc_copy(nyallocator_t* out, const nyallocator_t* const src);
typedef enum nyconsole_output_t {
    nycout = 1,
    nycerr = 2,
}
nyconsole_output_t;


typedef enum nycolor_t {
    nyc_none = 0,
    nyc_black,
    nyc_red,
    nyc_green,
    nyc_yellow,
    nyc_blue,
    nyc_purple,
    nyc_gray,
    nyc_white,
    nyc_lightblue
}
nycolor_t;

enum {
    nyc_count = nyc_lightblue + 1
};


typedef struct nyconsole_t {
    void (*write_stdout)(void*, const char* text, size_t length);
    void (*write_stderr)(void*, const char* text, size_t length);
    void (*flush)(void*, nyconsole_output_t);
    void (*set_color)(void*, nyconsole_output_t, nycolor_t);
    nybool_t (*has_color)(void*, nyconsole_output_t);

    void* internal;
    void (*release)(const struct nyconsole_t*);
}
nyconsole_t;

NY_EXPORT void nyconsole_cf_set_stdcout(nyconsole_t*);

void nyconsole_cf_copy(nyconsole_t* out, const nyconsole_t* const src);
typedef struct nyproject_cf_t {
    nyallocator_t allocator;
    void (*on_target_added)(nyproject_t*, nytarget_t*, const char* name, uint32_t len);
    void (*on_target_removed)(nyproject_t*, nytarget_t*, const char* name, uint32_t len);
    nybool_t with_nsl_unittests;
}
nyproject_cf_t;


NY_EXPORT nyproject_t* nyproject_create(const nyproject_cf_t* cf);

NY_EXPORT void nyproject_ref(nyproject_t* project);

NY_EXPORT void nyproject_unref(nyproject_t* project);

NY_EXPORT void nyproject_cf_init(nyproject_cf_t*);


NY_EXPORT nybool_t nyproject_add_source_from_file(nyproject_t*, const char* filename);
NY_EXPORT nybool_t nyproject_add_source_from_file_n(nyproject_t*, const char* filename, size_t);

NY_EXPORT nybool_t nyproject_add_source(nyproject_t*, const char* text);
NY_EXPORT nybool_t nyproject_add_source_n(nyproject_t*, const char* text, size_t);


NY_EXPORT void nyproject_lock(const nyproject_t*);
NY_EXPORT void nyproject_unlock(const nyproject_t*);
NY_EXPORT nybool_t nyproject_trylock(const nyproject_t*);
typedef struct nybuild_cf_t {
    nyallocator_t allocator;
    nyconsole_t console;

    nybool_t warnings_into_errors;
    nyanystr_t entrypoint;
    /* (can be used to only retrieve the list of atoms or unittests) */
    nybool_t ignore_atoms;

    void* userdata;

    void (*on_unittest)(void* userdata, const char* mod, uint32_t mlen, const char* name, uint32_t nlen);

    nybool_t (*on_query)(const nyproject_t*);
    void (*on_begin)(const nyproject_t*, nybuild_t*);

    nybool_t (*on_progress)(const nyproject_t*, nybuild_t*, const char* id, const char* element,
                            uint32_t percent);
    nybool_t (*on_binding_discovery)(nybuild_t*, const char* name, uint32_t size);

    void (*on_end)(const nyproject_t*, nybuild_t*, nybool_t success);
    void (*on_error_file_eacces)(const nyproject_t*, nybuild_t*, const char* filename, uint32_t length);
}
nybuild_cf_t;



NY_EXPORT nybuild_t* nybuild_prepare(nyproject_t*, const nybuild_cf_t*);

NY_EXPORT nybool_t nybuild(nybuild_t*);

NY_EXPORT void nybuild_print_report_to_console(nybuild_t* build, nybool_t print_header);

NY_EXPORT void nybuild_ref(nybuild_t* build);
NY_EXPORT void nybuild_unref(nybuild_t* build);

NY_EXPORT void nybuild_cf_init(nybuild_cf_t* cf, const nyproject_t* project);
typedef struct nyfile_t nyfile_t;


typedef enum nyio_type_t {
    nyiot_failed = 0,
    nyiot_file,
    nyiot_folder,
}
nyio_type_t;


typedef enum nyio_err_t {
    nyioe_ok = 0,
    nyioe_failed,
    nyioe_unsupported,
    nyioe_memory,
    nyioe_access,
    nyioe_exists,
}
nyio_err_t;


typedef enum nyio_automout_flag_t {
    nyioaf_all   = (uint32_t) - 1,
    nyioaf_none  = 0,
    nyioaf_root  = (1 << 0),
    nyioaf_tmp   = (1 << 1),
    nyioaf_home  = (1 << 2),
    nyioaf_users = (1 << 3),
}
nyio_automout_flag_t;




typedef nybool_t (*nyio_opened_files_it_t)(const char* vpath, uint32_t len, const char* localpath,
    uint32_t lplen);


typedef struct nyio_adapter_t nyio_adapter_t;

typedef struct nyio_iterator_t nyio_iterator_t;


struct nyio_adapter_t {
    void* internal;
    void* invalid_fd;

    nyio_type_t (*stat)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_type_t (*statex)(nyio_adapter_t*, const char* path, uint32_t len, uint64_t* size, int64_t* modified);


    uint64_t (*file_read)(void*, void* buffer, uint64_t bufsize);
    uint64_t (*file_write)(void*, const void* buffer, uint64_t bufsize);
    void* (*file_open)(nyio_adapter_t*, const char* path, uint32_t len,
                       nybool_t readm, nybool_t writem, nybool_t appendm, nybool_t truncm);
    void (*file_close)(void*);
    nybool_t (*file_eof)(void*);

    nyio_err_t (*file_seek)(void*, uint64_t offset);
    nyio_err_t (*file_seek_from_end)(void*, int64_t offset);
    nyio_err_t (*file_seek_cur)(void*, int64_t offset);
    uint64_t (*file_tell)(void*);

    void (*file_flush)(void*);

    uint64_t (*file_size)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_err_t (*file_erase)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_err_t (*file_exists)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_err_t (*file_resize)(nyio_adapter_t*, const char* path, uint32_t len, uint64_t newsize);

    nyio_err_t (*file_get_contents)(nyio_adapter_t*, char** content, uint64_t* size, uint64_t* capacity,
                                    const char* path, uint32_t len);
    nyio_err_t (*file_set_contents)(nyio_adapter_t*, const char* path, uint32_t len, const char* content,
                                    uint32_t ctlen);
    nyio_err_t (*file_append_contents)(nyio_adapter_t*, const char* path, uint32_t len, const char* content,
                                       uint32_t ctlen);


    nyio_err_t (*folder_create)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_err_t (*folder_erase)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_err_t (*folder_clear)(nyio_adapter_t*, const char* path, uint32_t len);
    uint64_t (*folder_size)(nyio_adapter_t*, const char* path, uint32_t len);
    nyio_err_t (*folder_exists)(nyio_adapter_t*, const char* path, uint32_t len);

    nyio_iterator_t* (*folder_iterate)(nyio_adapter_t*, const char* path, uint32_t len,
                                       nybool_t recursive, nybool_t files, nybool_t folders);
    nyio_iterator_t* (*folder_next)(nyio_iterator_t*);
    const char* (*folder_iterator_fullpath)(nyio_adapter_t*, nyio_iterator_t*);
    const char* (*folder_iterator_name)(nyio_iterator_t*);
    uint64_t (*folder_iterator_size)(nyio_iterator_t*);
    nyio_type_t (*folder_iterator_type)(nyio_iterator_t*);
    void (*folder_iterator_close)(nyio_iterator_t*);

    void (*clone)(nyio_adapter_t* parent, nyio_adapter_t* dst);
    void (*release)(nyio_adapter_t*);
};


typedef struct nyio_cf_t {
    nyio_err_t (*on_mount_query)(nyprogram_t*, nytctx_t*, const char* url, const char* path, uint32_t len);
    nyio_err_t (*on_adapter_create)(nyprogram_t*, nytctx_t*, nyio_adapter_t**, const char* url,
        nyio_adapter_t* parent);

    uint32_t automount_flags;
}
nyio_cf_t;

NY_EXPORT void nyio_adapter_create_from_local_folder(nyio_adapter_t*, nyallocator_t*,
    const char* localfolder, size_t len);
typedef struct nybacktrace_entry_t {
    const char* atom;
    const char* filename;
    uint32_t atom_size;
    uint32_t filename_size;
    uint32_t line;
    uint32_t column;
}
nybacktrace_entry_t;


typedef struct nyprogram_cf_t {
    nyallocator_t allocator;
    nyconsole_t console;

    nybool_t (*on_execute)(nyprogram_t*);

    nybool_t (*on_thread_create)(nyprogram_t*, nytctx_t*, nythread_t* parent, const char* name, uint32_t size);
    void (*on_thread_destroy)(nyprogram_t*, nythread_t*);

    /* wip - void (*on_error)(const nyprogram_t*, const nybacktrace_entry_t** backtrace, uint32_t bt_len); */
    void (*on_terminate)(const nyprogram_t*, nybool_t error, int exitcode);

    nyio_cf_t io;

    nyanystr_t entrypoint;
}
nyprogram_cf_t;


typedef struct nyvm_t {
    nyallocator_t* allocator;
    nyprogram_t* program;
    nytctx_t* tctx;
    nyconsole_t* console;
}
nyvm_t;


NY_EXPORT nyprogram_t* nyprogram_prepare(nybuild_t* build, const nyprogram_cf_t* cf);

NY_EXPORT int nyprogram_main(nyprogram_t* program, uint32_t argc, const char** argv);


NY_EXPORT void nyprogram_ref(nyprogram_t* program);
NY_EXPORT void nyprogram_unref(nyprogram_t* program);

NY_EXPORT void nyprogram_cf_init(nyprogram_cf_t* cf, const nybuild_cf_t*);
nybool_t nyprint_ast_from_file(const char* filename, int fd, nybool_t unixcolors);

NY_EXPORT nybool_t nyprint_ast_from_file_n(const char* filename, size_t length, int fd, nybool_t unixcolors);

NY_EXPORT nybool_t nyprint_ast_from_memory(const char* content, int fd, nybool_t unixcolors);
NY_EXPORT  nybool_t nyprint_ast_from_memory_n(const char* content, size_t length, int fd,
    nybool_t unixcolors);

NY_EXPORT nybool_t nytry_parse_file(const char* const filename);
NY_EXPORT nybool_t nytry_parse_file_n(const char* filename, size_t length);




NY_EXPORT nyvisibility_t  nycstring_to_visibility(const char* const text);
NY_EXPORT nyvisibility_t  nycstring_to_visibility_n(const char* const text, size_t length);

NY_EXPORT const char* nyvisibility_to_cstring(nyvisibility_t);


NY_EXPORT nytype_t nycstring_to_type(const char* const text);

NY_EXPORT nytype_t nycstring_to_type_n(const char* const text, size_t length);

NY_EXPORT const char* nytype_to_cstring(nytype_t);

NY_EXPORT uint32_t nytype_sizeof(nytype_t);
typedef struct nyrun_cf_t {
    nyallocator_t allocator;
    nyconsole_t console;
    nyproject_cf_t project;
    nybuild_cf_t build;
    nyprogram_cf_t program;
    nybool_t verbose;
}
nyrun_cf_t;

NY_EXPORT void nyrun_cf_init(nyrun_cf_t*);

NY_EXPORT void nyrun_cf_release(nyrun_cf_t*);
NY_EXPORT int nyrun(const nyrun_cf_t* cf, const char* source, uint32_t argc, const char** argv);

NY_EXPORT int nyrun_n(const nyrun_cf_t* cf, const char* source, size_t length, uint32_t argc,
    const char** argv);


NY_EXPORT int nyrun_file(const nyrun_cf_t* cf, const char* file, uint32_t argc, const char** argv);

NY_EXPORT int nyrun_file_n(const nyrun_cf_t* cf, const char* file, size_t length, uint32_t argc,
    const char** argv);

NY_EXPORT int nyrun_filelist(const nyrun_cf_t* cf, const char** files, uint32_t file_count, uint32_t argc,
    const char** argv);
#ifdef __cplusplus
}
#endif

#endif /* __LIBNANYC_NANY_C_H__ */