Function Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
L
 lily_arg_boolean
 lily_arg_byte
 lily_arg_bytestring
 lily_arg_container
 lily_arg_coroutine
 lily_arg_count
 lily_arg_double
 lily_arg_file
 lily_arg_function
 lily_arg_generic
 lily_arg_hash
 lily_arg_integer
 lily_arg_isa
 lily_arg_string
 lily_arg_string_raw
 lily_arg_value
 lily_as_boolean
 lily_as_byte
 lily_as_bytestring
 lily_as_container
 lily_as_coroutine
 lily_as_double
 lily_as_file
 lily_as_function
 lily_as_generic
 lily_as_hash
 lily_as_integer
 lily_as_string
 lily_as_string_raw
 lily_bytestring_length
 lily_bytestring_raw
 lily_call
 lily_call_prepare
 lily_call_result
 lily_cid_at
 lily_con_get
 lily_con_set
 lily_con_set_from_stack
 lily_con_size
 lily_config_get, lily_config
 lily_config_init, lily_config
 lily_default_import_func
 lily_DivisionByZeroError
 lily_error_callback_pop
 lily_error_callback_push
 lily_error_message
 lily_error_message_no_trace
 lily_file_for_read
 lily_file_for_write
 lily_find_function
 lily_free_msgbuf
 lily_free_state
 lily_function_is_foreign
 lily_function_is_native
 lily_hash_get
 lily_hash_set
 lily_hash_set_from_stack
 lily_hash_take
 lily_import_current_root_dir
 lily_import_file
 lily_import_library
 lily_import_library_data
 lily_import_string
 lily_import_use_local_dir
 lily_import_use_package_dir
 lily_IndexError
 lily_IOError
 lily_is_valid_utf8
 lily_KeyError
 lily_list_insert
 lily_list_push
 lily_list_reserve
 lily_list_take
 lily_load_file
 lily_load_string
 lily_mb_add
 lily_mb_add_char
 lily_mb_add_fmt
 lily_mb_add_fmt_va
 lily_mb_add_slice
 lily_mb_add_value
 lily_mb_flush
 lily_mb_html_escape
 lily_mb_pos
 lily_mb_raw
 lily_mb_sprintf
 lily_msgbuf_get
 lily_new_msgbuf
 lily_new_state
 lily_parse_content
 lily_parse_expr
 lily_push_boolean
 lily_push_byte
 lily_push_bytestring
 lily_push_double
 lily_push_empty_variant
 lily_push_file
 lily_push_foreign
 lily_push_hash
 lily_push_instance
 lily_push_integer
 lily_push_list
 lily_push_string
 lily_push_string_sized
 lily_push_super
 lily_push_tuple
 lily_push_unit
 lily_push_value
 lily_push_variant
 lily_register_module
 lily_render_content
 lily_return_boolean
 lily_return_byte
 lily_return_double
 lily_return_integer
 lily_return_none
 lily_return_super
 lily_return_top
 lily_return_unit
 lily_return_value
 lily_RuntimeError
 lily_stack_drop_top
 lily_stack_get_top
 lily_string_length
 lily_string_raw
 lily_value_tag
 lily_ValueError
int lily_arg_boolean (lily_state *s,
int index)
Fetch a Boolean from the stack.
uint8_t lily_arg_byte (lily_state *s,
int index)
Fetch a Byte from the stack.
lily_bytestring_val *lily_arg_bytestring(lily_state *s,
int index)
Fetch a ByteString from the stack.
lily_container_val * lily_arg_container (lily_state *s,
int index)
Fetch a user-defined class, (non-empty) variant, List, or Tuple.
lily_coroutine_val * lily_arg_coroutine (lily_state *s,
int index)
Fetch a Coroutine from the stack.
int lily_arg_count(lily_state *s)
How many arguments the function being called was given.
double lily_arg_double (lily_state *s,
int index)
Fetch a Double from the stack.
lily_file_val * lily_arg_file (lily_state *s,
int index)
Fetch a File from the stack.
lily_function_val * lily_arg_function (lily_state *s,
int index)
Fetch a Function from the stack.
lily_generic_val * lily_arg_generic (lily_state *s,
int index)
Fetch a pointer-based (foreign) value from the stack.
lily_hash_val * lily_arg_hash (lily_state *s,
int index)
Fetch a Hash from the stack.
int64_t lily_arg_integer (lily_state *s,
int index)
Fetch a Integer from the stack.
int lily_arg_isa(lily_state *s,
int index,
uint16_t class_id)
Check if an argument has an exact class id.
lily_string_val * lily_arg_string (lily_state *s,
int index)
Fetch a String from the stack.
char * lily_arg_string_raw(lily_state *s,
int index)
Fetch the underlying buffer of a String from the stack.
lily_value * lily_arg_value (lily_state *s,
int index)
Fetch a complete value with flags and class information.
int lily_as_boolean (lily_value *value)
Extract a Boolean.
uint8_t lily_as_byte (lily_value *value)
Extract a Byte.
lily_bytestring_val *lily_as_bytestring(lily_value *value)
Extract a ByteString.
lily_container_val * lily_as_container (lily_value *value)
Extract a container (user-defined class, non-empty variant, List, or Tuple).
lily_coroutine_val * lily_as_coroutine (lily_value *value)
Extract a Coroutine.
double lily_as_double (lily_value *value)
Extract a Double.
lily_file_val * lily_as_file (lily_value *value)
Extract a File.
lily_function_val * lily_as_function (lily_value *value)
Extract a Function.
lily_generic_val * lily_as_generic (lily_value *value)
Extract a generic pointer (to be cast to some other type)..
lily_hash_val * lily_as_hash (lily_value *value)
Extract a Hash.
int64_t lily_as_integer (lily_value *value)
Extract a Integer.
lily_string_val * lily_as_string (lily_value *value)
Extract a String.
char * lily_as_string_raw(lily_value *value)
Extract the raw buffer behind a String.
int lily_bytestring_length(lily_bytestring_val *byte_val)
Get the size (in bytes) of a ByteString.
char *lily_bytestring_raw(lily_bytestring_val *byte_val)
Get the raw buffer behind a ByteString.
void lily_call(lily_state *s,
int count)
(Stack: -count) Perform a prepared call using values from the stack.
void lily_call_prepare(lily_state *s,
lily_function_val *func)
(Stack: +1) Reserve a result register and prepare ‘func’.
lily_value *lily_call_result(lily_state *s)
Return the register that ‘lily_call_prepare’ reserved.
uint16_t lily_cid_at(lily_state *s,
int index)
Function for autogenerated ID_* macros to get a class id.
lily_value *lily_con_get(lily_container_val *con,
int index)
Fetch an element from a container.
void lily_con_set(lily_container_val *con,
int index,
lily_value *value)
Set an element into a container.
void lily_con_set_from_stack(lily_state *s,
lily_container_val *con,
int index)
(Stack: -1) Set an element into a container from the stack.
uint32_t lily_con_size(lily_container_val *con)
Return the number of occupied values in a container.
lily_config *lily_config_get(lily_state *s)
Fetch an interpreter’s config struct.
void lily_config_init(lily_config *config)
Initialize a config to default values.
void lily_default_import_func(lily_state *s,
const char *target)
This is the default import hook.
void lily_DivisionByZeroError(lily_state *s,
const char *format,
 ...)
Raise DivisionByZeroError with the given message and args.
void lily_error_callback_pop(lily_state *s)
Remove an error callback (typically at foreign function exit).
void lily_error_callback_push(lily_state *s,
lily_error_callback_func callback_fn)
Push an error callback for the current foreign function.
const char *lily_error_message(lily_state *s)
Fetch the message and traceback of the last failed parse/render.
const char *lily_error_message_no_trace(lily_state *s)
Fetch only the message of the last failed parse/render.
FILE *lily_file_for_read(lily_state *s,
lily_file_val *file)
Return the underlying FILE * of a File (if in read mode), or raise IOError.
FILE *lily_file_for_write(lily_state *s,
lily_file_val *file)
Return the underlying FILE * of a File (if in write mode), or raise IOError.
lily_function_val *lily_find_function(lily_state *s,
const char *name)
Search for a function called ‘name’.
void lily_free_msgbuf(lily_msgbuf *msgbuf)
Free a msgbuf struct and the underlying buffer.
void lily_free_state(lily_state *s)
Destroy an interpreter and any values it holds.
int lily_function_is_foreign(lily_function_val *func)
Return 1 if the Function has a foreign implementation, 0 otherwise.
int lily_function_is_native(lily_function_val *func)
Return 1 if the Function has a native implementation, 0 otherwise.
lily_value *lily_hash_get(lily_state *s,
lily_hash_val *hash,
lily_value *key)
Look for a given key within a Hash.
void lily_hash_set(lily_state *s,
lily_hash_val *hash,
lily_value *key,
lily_value *record)
Set ‘key’ to ‘value’ within a given hash.
void lily_hash_set_from_stack(lily_state *s,
lily_hash_val *hash)
(Stack: -2) lily_hash_set, but key and value come from the stack.
int lily_hash_take(lily_state *s,
lily_hash_val *hash,
lily_value *key)
(Stack: +1?)
const char *lily_import_current_root_dir(lily_state *s)
Return the directory of the package that the source import belongs to.
int lily_import_file(lily_state *s,
const char *target)
Import a file for the interpreter.
int lily_import_library(lily_state *s,
const char *target)
Load a library from a given path.
int lily_import_library_data(lily_state *s,
const char *target,
const char **info_table,
lily_call_entry_func *call_table)
Load a preloaded library.
int lily_import_string(lily_state *s,
const char *target,
const char *content)
Load a string (context path, then content) as a library.
void lily_import_use_local_dir(lily_state *s,
const char *dir)
Use a local directory for upcoming imports.
Use a package directory for upcoming imports.
void lily_IndexError(lily_state *s,
const char *format,
 ...)
Raise IndexError with the given message and args.
void lily_IOError(lily_state *s,
const char *format,
 ...)
Raise IOError with the given message and args.
int lily_is_valid_utf8(const char *source)
Check if ‘source’ is valid utf-8.
void lily_KeyError(lily_state *s,
const char *format,
 ...)
Raise KeyError with the given message and args.
void lily_list_insert(lily_container_val *con,
int index,
lily_value *value)
Insert a value, pushing others to the right.
void lily_list_push(lily_container_val *con,
lily_value *value)
Push a value onto the end of a List.
void lily_list_reserve(lily_container_val *con,
int size)
Reserve N elements in a List.
void lily_list_take(lily_state *s,
lily_container_val *con,
int index)
(Stack: +1) Take an element out of a List, pushing it onto the stack.
int lily_load_file(lily_state *s,
const char *path)
Prepare a file for the interpreter.
int lily_load_string(lily_state *s,
const char *context,
const char *str)
Prepare a string for the interpreter.
void lily_mb_add(lily_msgbuf *msgbuf,
const char *source)
Add ‘source’ to the msgbuf.
void lily_mb_add_char(lily_msgbuf *msgbuf,
char ch)
Add a single character ‘ch’ to the msgbuf.
void lily_mb_add_fmt(lily_msgbuf *msgbuf,
const char *format,
 ...)
Add to the msgbuf based on a format string.
void lily_mb_add_fmt_va(lily_msgbuf *msgbuf,
const char *format,
 va_list)
lily_mb_add_fmt, but using a va_list.
void lily_mb_add_slice(lily_msgbuf *msgbuf,
const char *source,
int start,
int end)
Add ‘source’ to the msgbuf, from ‘start’ to ‘end’.
void lily_mb_add_value(lily_msgbuf *msgbuf,
lily_state *s,
lily_value *value)
Interpolate a value into the msgbuf.
lily_msgbuf *lily_mb_flush(lily_msgbuf *msgbuf)
Drop all contents in the msgbuf.
const char *lily_mb_html_escape(lily_msgbuf *msgbuf,
const char *input)
Add html-escaped version of ‘input’ to the msgbuf.
int lily_mb_pos(lily_msgbuf *msgbuf)
Return the length of the msgbuf.
const char *lily_mb_raw(lily_msgbuf *msgbuf)
Return the underlying buffer of a msgbuf.
const char *lily_mb_sprintf(lily_msgbuf *msgbuf,
const char *format,
 ...)
Equivalent to flush, add_fmt, returning the underlying buffer.
lily_msgbuf *lily_msgbuf_get(lily_state *)
Return the common msgbuf of the interpreter.
lily_msgbuf *lily_new_msgbuf(uint32_t size)
Create a new msgbuf with a starting size of ‘size’.
lily_state *lily_new_state(lily_config *config)
Create a new interpreter.
int lily_parse_content(lily_state *s)
Parse content prepared for the interpreter.
int lily_parse_expr(lily_state *s,
const char **output)
Parse an expression prepared for the interpreter.
void lily_push_boolean (lily_state *s,
int value)
(Stack: +1) Push a Boolean value onto the stack.
void lily_push_byte (lily_state *s,
uint8_t value)
(Stack: +1) Push a Byte value onto the stack.
void lily_push_bytestring (lily_state *s,
const char *source,
int size)
(Stack: +1) Push a ByteString value onto the stack.
void lily_push_double (lily_state *s,
double value)
(Stack: +1) Push a Double value onto the stack.
void lily_push_empty_variant(lily_state *s,
uint16_t class_id)
(Stack: +1) Push an empty variant (such as None) onto the stack.
void lily_push_file (lily_state *s,
FILE *f,
const char *mode)
(Stack: +1) Push a file onto the stack (interpreter takes it over).
lily_foreign_val * lily_push_foreign (lily_state *s,
uint16_t class_id,
lily_destroy_func destroy_fn,
size_t size)
(Stack: +1) Push a foreign class value onto the stack.
lily_hash_val * lily_push_hash (lily_state *s,
int size)
(Stack: +1) Push a new Hash with ‘size’ slots reserved onto the stack.
lily_container_val *lily_push_instance (lily_state *s,
uint16_t class_id,
uint32_t size)
(Stack: +1) Push a user-defined class instance with ‘size’ values onto the stack.
void lily_push_integer (lily_state *s,
int64_t value)
(Stack: +1) Push a new Integer onto the stack.
lily_container_val *lily_push_list (lily_state *s,
uint32_t size)
(Stack: +1) Push a List with ‘size’ values onto the stack.
void lily_push_string (lily_state *s,
const char *source)
(Stack: +1) Push a String wrapping over ‘source’ onto the stack.
void lily_push_string_sized (lily_state *s,
const char *source,
int size)
(Stack: +1) Push a String of ‘size’ bytes from ‘source’ onto the stack.
lily_container_val *lily_push_super (lily_state *s,
uint16_t class_id,
uint32_t size)
(Stack: +1) Push a superclass onto the stack.
lily_container_val *lily_push_tuple (lily_state *s,
uint32_t size)
(Stack: +1) Push a Tuple with ‘size’ values onto the stack.
void lily_push_unit (lily_state *s)
(Stack: +1) Push the unit value (of class Unit) onto the stack.
void lily_push_value (lily_state *s,
lily_value *value)
(Stack: +1) Push a full value onto the stack.
lily_container_val *lily_push_variant (lily_state *s,
uint16_t class_id,
uint32_t size)
(Stack: +1) Push a variant of ‘class_id’ and ‘size’ values onto the stack.
Make a module called ‘name’ available to the interpreter.
int lily_render_content(lily_state *s)
Parse content prepared for the interpreter.
void lily_return_boolean(lily_state *s,
int value)
Set a Boolean return value.
void lily_return_byte (lily_state *s,
uint8_t value)
Set a Byte return value.
void lily_return_double (lily_state *s,
double value)
Set a Double return value.
void lily_return_integer(lily_state *s,
int64_t value)
Set an Integer return value.
void lily_return_none (lily_state *s)
Set a None return value.
void lily_return_super (lily_state *s)
Use this if lily_push_super was used.
void lily_return_top (lily_state *s)
Set the return value as the value currently at the top of the stack.
void lily_return_unit (lily_state *s)
Set a Unit return value.
void lily_return_value (lily_state *s,
lily_value *value)
Set the value given as the return value.
void lily_RuntimeError(lily_state *s,
const char *format,
 ...)
Raise RuntimeError with the given message and args.
void lily_stack_drop_top(lily_state *s)
Pop the top of the stack, deref-ing it if necessary.
lily_value *lily_stack_get_top(lily_state *s)
Return the value at the top of the stack.
int lily_string_length(lily_string_val *string_val)
Returns the size (in bytes) of a String buffer.
char *lily_string_raw(lily_string_val *string_val)
Returns the raw buffer behind a String.
void lily_value_tag(lily_state *s,
lily_value *value)
Place a gc tag onto ‘value’.
void lily_ValueError(lily_state *s,
const char *format,
 ...)
Raise ValueError with the given message and args.
Close