212 lines
7.0 KiB
C
212 lines
7.0 KiB
C
#ifndef LIBABACUS_TABLE_H
|
|
#define LIBABACUS_TABLE_H
|
|
|
|
#include "basetype.h"
|
|
#include "custom.h"
|
|
#include "refcount.h"
|
|
#include "result.h"
|
|
#include "trie.h"
|
|
|
|
/**
|
|
* A struct that represents a structure
|
|
* similar to a symbol table. This structure
|
|
* is used to keep track of definitions such
|
|
* as types, functions, and variables in an
|
|
* environment with scopes.
|
|
*/
|
|
struct libab_table_s {
|
|
/**
|
|
* The "parent" scope of this table.
|
|
*/
|
|
libab_ref parent;
|
|
/**
|
|
* The hash table used to store the data.
|
|
*/
|
|
libab_trie trie;
|
|
};
|
|
|
|
/**
|
|
* Enum that represents the type of a table
|
|
* entry.
|
|
*/
|
|
enum libab_table_entry_variant_e {
|
|
ENTRY_VALUE,
|
|
ENTRY_BASETYPE,
|
|
ENTRY_OP,
|
|
ENTRY_TYPE_PARAM
|
|
};
|
|
|
|
/**
|
|
* An entry in the table.
|
|
*/
|
|
struct libab_table_entry_s {
|
|
/**
|
|
* The type of this entry.
|
|
*/
|
|
enum libab_table_entry_variant_e variant;
|
|
/**
|
|
* Union that holds the various types of
|
|
* data that this entry could hold.
|
|
*/
|
|
union {
|
|
libab_operator op;
|
|
libab_basetype* basetype;
|
|
libab_ref value;
|
|
libab_ref type_param;
|
|
} data_u;
|
|
};
|
|
|
|
typedef struct libab_table_s libab_table;
|
|
typedef enum libab_table_entry_variant_e libab_table_entry_variant;
|
|
typedef struct libab_table_entry_s libab_table_entry;
|
|
|
|
/**
|
|
* Initializes the given table.
|
|
* @param table the table to initialize.
|
|
*/
|
|
void libab_table_init(libab_table* table);
|
|
/**
|
|
* Searches for the given string in the table, comparing
|
|
* values to a given reference as an extra filtering step.
|
|
* @param table the table to search.
|
|
* @param string the string to search for.
|
|
* @param data the data to compare against potential values.
|
|
* @param compare the comparison function to use.
|
|
* @return the table entry, or NULL if an entry was not found.
|
|
*/
|
|
libab_table_entry* libab_table_search_filter(libab_table* table,
|
|
const char* string, void* data,
|
|
compare_func compare);
|
|
/**
|
|
* Searches for the given string in the table.
|
|
* @param table the table to search.
|
|
* @param string the string to search for.
|
|
* @return the table entry, or NULL if an entry was not found.
|
|
*/
|
|
libab_table_entry* libab_table_search(libab_table* table, const char* string);
|
|
/**
|
|
* Searches for the given string in the table, returning a value only
|
|
* if it is an operator.
|
|
* @param table the table to search.
|
|
* @param string the string to search for.
|
|
* @param type the type of operator to search for (infix, prefix, postfix)
|
|
* @return the found operator, or NULL if it was not found.
|
|
*/
|
|
libab_operator* libab_table_search_operator(libab_table* table,
|
|
const char* string, int type);
|
|
/**
|
|
* Searches for a given string in the table,
|
|
* returning the entry that holds it only if it is an operator.
|
|
* @param table the table to search.
|
|
* @param string the string to search for.
|
|
* @param type the type of operator to search for (infix, prefix, postfix)
|
|
* @return the entry, or NULL if it was not found.
|
|
*/
|
|
libab_table_entry* libab_table_search_entry_operator(libab_table* table,
|
|
const char* string,
|
|
int type);
|
|
/**
|
|
* Searches for the given basetype in the table, returning a value
|
|
* only if it's a basetype.
|
|
* @param table the table to search.
|
|
* @param string the string to search for.
|
|
* @return the found basetype, or NULL if it was not found.
|
|
*/
|
|
libab_basetype* libab_table_search_basetype(libab_table* table,
|
|
const char* string);
|
|
/**
|
|
* Searches for the given basetype in the table, returning a table
|
|
* entry only if it holds a basetype.
|
|
* @param table to table to search.
|
|
* @param string the string to search for.
|
|
* @return the entry holding the basetype, or NULL if it was not found.
|
|
*/
|
|
libab_table_entry* libab_table_search_entry_basetype(libab_table* table,
|
|
const char* string);
|
|
/**
|
|
* Searches for the given value in the table.
|
|
* @param table the table to search.
|
|
* @param string the table entry key.
|
|
* @param ref the reference to store the result into.
|
|
*/
|
|
void libab_table_search_value(libab_table* table, const char* string,
|
|
libab_ref* ref);
|
|
/**
|
|
* Searches for a value with the given name in the table,
|
|
* and returns an entry that holds it.
|
|
* @param table the table to search.
|
|
* @param string the tabe entry key.
|
|
* @return the table entry holding the value, or NULL if it was not found.
|
|
*/
|
|
libab_table_entry* libab_table_search_entry_value(libab_table* table,
|
|
const char* string);
|
|
/**
|
|
* Searches for the given type parameter in the table.
|
|
* @param table the table to search in.
|
|
* @param string the key to search for.
|
|
* @param ref the reference to store the type into.
|
|
*/
|
|
void libab_table_search_type_param(libab_table* table, const char* string,
|
|
libab_ref* ref);
|
|
/**
|
|
* Searches for the given type parameter in the table.
|
|
* @param table the table to search in.
|
|
* @param string the key to search for.
|
|
* @return the table entry holding the type parameter, or NULL.
|
|
*/
|
|
libab_table_entry* libab_table_search_entry_type_param(libab_table* table,
|
|
const char* string);
|
|
/**
|
|
* Stores the given entry in the table under the given key.
|
|
* @param table the table to store the entry into.
|
|
* @param string the string to use as the key.
|
|
* @param entry the new entry to put into the table.
|
|
* @return the result of the insertion, which could be LIBAB_MALLOC.
|
|
*/
|
|
libab_result libab_table_put(libab_table* table, const char* string,
|
|
libab_table_entry* entry);
|
|
/**
|
|
* Sets the parent of the given table.
|
|
* @param table the table whose parent to set.
|
|
* @param parent a valid reference to a parent table.
|
|
*/
|
|
void libab_table_set_parent(libab_table* table, libab_ref* parent);
|
|
/**
|
|
* Clears the table.
|
|
* @param table the table to clear.
|
|
*/
|
|
void libab_table_clear(libab_table* table);
|
|
/**
|
|
* Frees the resources allocated by the
|
|
* given table.
|
|
* @param table the table to free.
|
|
*/
|
|
void libab_table_free(libab_table* table);
|
|
/**
|
|
* Comparison function used to search the table for a prefix operator.
|
|
*/
|
|
int libab_table_compare_op_prefix(const void* left, const void* right);
|
|
/**
|
|
* Comparison function used to search the table for a infix operator.
|
|
*/
|
|
int libab_table_compare_op_infix(const void* left, const void* right);
|
|
/**
|
|
* Comparison function used to search the table for a postfix operator.
|
|
*/
|
|
int libab_table_compare_op_postfix(const void* left, const void* right);
|
|
/**
|
|
* Comparison function used to search the table for a value.
|
|
*/
|
|
int libab_table_compare_value(const void* left, const void* right);
|
|
/**
|
|
* Comparison function used to search the table for a basetype.
|
|
*/
|
|
int libab_table_compare_basetype(const void* left, const void* right);
|
|
/**
|
|
* Frees the given table entry.
|
|
* @param entry the entry to free.
|
|
*/
|
|
void libab_table_entry_free(libab_table_entry* entry);
|
|
|
|
#endif
|