Vous ne pouvez pas sélectionner plus de 25 sujets
Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
355 lignes
10 KiB
355 lignes
10 KiB
#pragma once
|
|
#include "stddef.h"
|
|
|
|
|
|
/**
|
|
* Represents the natively defined type of integers
|
|
*/
|
|
#define INK_INTEGER 0
|
|
|
|
/**
|
|
* Represents the natively defined type of natively defined functions
|
|
*/
|
|
#define INK_NATIVE_FUNCTION 1
|
|
|
|
/**
|
|
* Represents the natively defined type of functions defined from within ink
|
|
*/
|
|
#define INK_FUNCTION 2
|
|
|
|
/**
|
|
* Represents the special coroutine state that means that it was disposed of and is ready for reuse
|
|
*/
|
|
#define INK_ROUTINE_CAN_REUSE 32
|
|
|
|
/**
|
|
* Represents the special coroutine state that means that it was terminated without errors
|
|
*/
|
|
#define INK_ROUTINE_SUCCESS 1
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* Represents arbitrary values within ink
|
|
*/
|
|
struct elem {
|
|
int type;
|
|
int value;
|
|
};
|
|
|
|
/**
|
|
* Represents a stack-frame within the execution context
|
|
*/
|
|
struct stack_frame {
|
|
struct elem executing;
|
|
int index;
|
|
};
|
|
|
|
/**
|
|
* Represents a function within ink, defined in ink, using the homoiconic representation of ink
|
|
*/
|
|
struct fn {
|
|
char *name;
|
|
struct elem *things;
|
|
int size;
|
|
};
|
|
|
|
struct context;
|
|
|
|
/**
|
|
* Represents natively defined words within ink
|
|
*/
|
|
struct native_fn {
|
|
char *name;
|
|
void (*value)(struct context *);
|
|
};
|
|
|
|
/**
|
|
* Represents the narrow execution context of a single thread of execution within ink.
|
|
*/
|
|
struct ink_routine {
|
|
int panic;
|
|
|
|
struct elem *stack;
|
|
int capacity;
|
|
int top;
|
|
|
|
struct stack_frame *function_stack;
|
|
int function_stack_capacity;
|
|
int function_stack_top;
|
|
|
|
/**
|
|
* This user data can be set to any value convenient for the user to track a state local to the routine that is executing
|
|
*/
|
|
void *routine_userdata;
|
|
};
|
|
|
|
/**
|
|
* Contains a list of element on which garbage collection is to not be performed
|
|
*/
|
|
struct ink_collection_list {
|
|
struct elem* elements;
|
|
int count;
|
|
};
|
|
|
|
/**
|
|
* Contains the data and metadata of an embedded element including the pointer to the element
|
|
*/
|
|
struct element_slab {
|
|
void* data;
|
|
int is_protected;
|
|
int uses;
|
|
int in_use;
|
|
};
|
|
|
|
/**
|
|
* Contains all the data for every element of any type and its garbage collection information.
|
|
*/
|
|
struct ink_type {
|
|
const char* name; /**< The name of the type */
|
|
int element_size; /**< The size of individual elements of the type, 0 for int adjacent, negative for unmanaged size */
|
|
struct element_slab* elements; /**< The elements that are still live */
|
|
int elements_top; /**< The top of the elements list */
|
|
int elements_capacity; /**< The allocated capacity of the elements list */
|
|
void (*collect)(struct context*,void*); /**< The "destructor" of the object */
|
|
struct ink_collection_list (*gc)(struct context*,void*); /**< A function that returns an in-interpreter allocated list of elem references within the object */
|
|
};
|
|
|
|
/**
|
|
* Represents a complete execution context for the ink interpreter
|
|
*/
|
|
struct context {
|
|
int panic;
|
|
|
|
void *(*inner_malloc)(size_t);
|
|
void *(*inner_realloc)(void *, size_t);
|
|
void (*inner_free)(void *);
|
|
|
|
void *(*malloc)(size_t);
|
|
void *(*realloc)(void *, size_t);
|
|
void (*free)(void *);
|
|
int (*putchar)(int);
|
|
|
|
struct ink_routine *routines;
|
|
int routines_capacity;
|
|
int routines_top;
|
|
|
|
struct ink_type *types;
|
|
int types_capacity;
|
|
int types_top;
|
|
|
|
/**
|
|
* Contains the id of the routine that is currently being manipulated
|
|
*/
|
|
int routine_current;
|
|
|
|
struct native_fn *native_words;
|
|
int native_words_capacity;
|
|
int native_words_top;
|
|
|
|
struct fn *words;
|
|
int words_capacity;
|
|
int words_top;
|
|
|
|
char **lex_reserved_words;
|
|
int lex_reserved_words_capacity;
|
|
int lex_reserved_words_top;
|
|
|
|
unsigned int steps;
|
|
unsigned int collections;
|
|
|
|
/**
|
|
* Can be set to any data that is convenient to the user to track and use within natively defined functions
|
|
*/
|
|
void *persistent_userdata;
|
|
};
|
|
|
|
/**
|
|
* Creates a routine to execute within the context
|
|
* @param ctx The context in which to create the routine
|
|
* @warning Does not set the `routine_current` of the context to the newly created routine
|
|
* @return either a negative error value or the id of the created routine
|
|
*/
|
|
int ink_make_routine(struct context *ctx);
|
|
|
|
/**
|
|
* Cleans the targeted routine id data from the context
|
|
* @param ctx The context to operate in
|
|
* @param routine The id of the routine to destroy
|
|
* @return 0 if nothing could or needed to be performed, 1 otherwise
|
|
*/
|
|
int ink_kill_routine(struct context *ctx, int routine);
|
|
|
|
/**
|
|
* Declares and defines a native function within the context
|
|
* @param ctx The context tpo operate in
|
|
* @param name The name to give to the newly declared word
|
|
* @param value A pointer to a valid word-function
|
|
* @return a negative value in case of error, 0 otherwise
|
|
*/
|
|
int ink_add_native(struct context *ctx, const char *name, void(*value)(struct context *));
|
|
|
|
/**
|
|
* Pushes a value on the current routine's value stack
|
|
* @param ctx The context to manipulate
|
|
* @param value The value to push
|
|
* @return 0 on success, a negative value on failure
|
|
*/
|
|
int ink_push(struct context *ctx, struct elem value);
|
|
|
|
/**
|
|
* Pushes a function on the execution stack of the current routine of the context
|
|
* @param ctx The context to operate in
|
|
* @param value the function that will be pushed. in the state one wants it to run from
|
|
* @return 0 on success, a negative value on failure
|
|
*/
|
|
int ink_push_fn(struct context *ctx, struct stack_frame value);
|
|
|
|
/**
|
|
* Create a context to execute routines
|
|
* @param malloc the memory allocation function, with a signature similar to the standard malloc
|
|
* @param realloc the memory allocation function, with a signature similar to the standard realloc
|
|
* @param free the memory allocation function, with a signature similar to the standard free
|
|
* @param putchar a function to print to the output character by character
|
|
* @return a pointer to a context allocated within the malloc function itself.
|
|
*/
|
|
struct context* ink_make_context(void *(*malloc)(size_t), void *(*realloc)(void *, size_t), void(*free)(void *), int(*putchar)(int));
|
|
|
|
#ifndef NOSTDLIB
|
|
/**
|
|
* Creates a context that includes the standard library of ink, as well as uses the C standard library to operate
|
|
* @return a pointer to a context allocated with malloc and with predefined functions added
|
|
*/
|
|
struct context* ink_make_default_context(void);
|
|
#endif
|
|
|
|
/**
|
|
* Steps the current routine by one execution step
|
|
* @param pContext The context of the routine to advance
|
|
* @return A negative value in case of error, 0 if execution is finished, a positive value if more steps are required to execute
|
|
*/
|
|
int ink_step(struct context *pContext);
|
|
|
|
/**
|
|
* Examine the context to see if any routines can execute
|
|
* @param pContext the context
|
|
* @return 0 if no coroutines are available, 1 otherwise
|
|
*/
|
|
int ink_can_run(struct context *pContext);
|
|
|
|
/**
|
|
* Step every routine that can be executed.
|
|
* @param pContext The context, the `routine_current` value may be modified.
|
|
* @return 0
|
|
*/
|
|
int ink_step_everyone(struct context *pContext);
|
|
|
|
/**
|
|
* Compiles the code and starts a main routine to execute it
|
|
* @param pContext The context to execute the code in
|
|
* @param buffer The buffer that contains the source as a NULL terminated string
|
|
* @return the routine that was created when compiling the code or -1 in case an error occured
|
|
*/
|
|
int ink_compile(struct context *pContext, const char *buffer);
|
|
|
|
/**
|
|
* Includes the standard library in the specified context
|
|
* @param ctx The context
|
|
* @return 0
|
|
*/
|
|
int ink_std_library(struct context *ctx);
|
|
|
|
/**
|
|
* Removes the top element of the function stack of the current routine of the specified context
|
|
* @param ctx the context
|
|
*/
|
|
void ink_pop_fn(struct context *ctx);
|
|
|
|
/**
|
|
* Removes the top element of the stack of the current routine of the specified context
|
|
* @param ctx the context
|
|
*/
|
|
void ink_pop(struct context *ctx);
|
|
|
|
/**
|
|
* Declares a new type that can be stored within the interpreter
|
|
* @param ctx The context in which to add the file
|
|
* @param type_name The name of the type we want to add
|
|
* @param size The size in bytes of the type to add, size of 0 mean no size, in which case the type is adjacent to C int, negative size means that the memory is not managed by the interpreter.
|
|
* @param collect A "destructor" function for the data
|
|
* @param gc A function that returns a list (allocated with the `inner_malloc`) of all the elements this element holds references to
|
|
* @return if positive, a new type id, if negative an error value
|
|
* @internal user defined type ids minimal value is 15, we keep the first 16 types as reserved, just like negative type ids
|
|
*/
|
|
int ink_new_type(
|
|
struct context* ctx,
|
|
const char* type_name,
|
|
int size,
|
|
void (*collect)(struct context*,void*),
|
|
struct ink_collection_list (*gc)(struct context*,void*)
|
|
);
|
|
|
|
/**
|
|
*
|
|
* @param ctx The context of the interpreter
|
|
* @param ref The in-interpreter reference
|
|
* @return A pointer to the created value or NULL if it can't be found or has a size of 0
|
|
*/
|
|
void* ink_get_value(struct context* ctx, struct elem ref);
|
|
|
|
/**
|
|
* Builds a native type from the provided memory by copying it using memcpy
|
|
* @param ctx The context in which we operate
|
|
* @param type_id The type_id to use
|
|
* @param ptr The pointer from which to copy
|
|
* @return The in-interpreter reference of the newly created element
|
|
*/
|
|
struct elem ink_make_native(struct context* ctx, int type_id, void* ptr);
|
|
|
|
/**
|
|
* Builds a transparent type from the provided pointer
|
|
* @param ctx The context in which we operate
|
|
* @param type_id The type_id to use
|
|
* @param ptr The pointer
|
|
* @return The in-interpreter reference of the newly created element
|
|
*/
|
|
struct elem ink_make_transparent(struct context* ctx, int type_id, void* ptr);
|
|
|
|
/**
|
|
* Launch the mark and sweep garbage collection
|
|
* @param ctx The context to clean
|
|
*/
|
|
void ink_gc(struct context* ctx);
|
|
|
|
/**
|
|
* Obtains the type id from the declared name of the type
|
|
* @param ctx The context where we want to detect the type
|
|
* @param name The name of the type
|
|
* @return the type id if it exists, -1 otherwise
|
|
*/
|
|
int get_type_by_name(struct context* ctx, const char* name);
|
|
|
|
/**
|
|
* The internal representation of arrays in ink
|
|
*/
|
|
struct ink_array {
|
|
int top;
|
|
int capacity;
|
|
struct elem* elements;
|
|
};
|
|
|
|
/**
|
|
* Pushes a value in an array. in case of failure, panics the routine
|
|
*
|
|
* @param ctx the working context
|
|
* @param currentRoutine the routine that will panic
|
|
* @param ary the array to be incremented
|
|
* @param value the value to push
|
|
*/
|
|
void array_push(struct context* ctx, struct ink_routine* currentRoutine, struct ink_array* ary, struct elem value);
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|