parser_manager.h

Go to the documentation of this file.

 
#ifndef PARSER_MANAGER_H
#define PARSER_MANAGER_H
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Forward declarations */
typedef struct ParserSnapshot ParserSnapshot;
typedef struct ParseContext ParseContext;
 
/* ================================================================== */
/* ================================================================== */
 
typedef uint32_t LimePluginHandle;
 
#define LIME_PLUGIN_HANDLE_INVALID ((LimePluginHandle)0)
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef enum LimePluginCaps {
    LIME_CAP_SNAPSHOT        = (1u << 0), 
    LIME_CAP_EXTENSIBLE      = (1u << 1), 
    LIME_CAP_JIT             = (1u << 2), 
    LIME_CAP_INCREMENTAL     = (1u << 3), 
    LIME_CAP_SERIALIZABLE    = (1u << 4), 
} LimePluginCaps;
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef struct LimePluginVersion {
    uint16_t major; 
    uint16_t minor; 
    uint16_t patch; 
} LimePluginVersion;
 
#define LIME_PLUGIN_ABI_VERSION_MAJOR 1
 
#define LIME_PLUGIN_ABI_VERSION_MINOR 0
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef struct LimeParserPlugin {
    /* -------------------------------------------------------------- */
    /*  Identity                                                       */
    /* -------------------------------------------------------------- */
 
    const char *(*get_name)(void);
 
    LimePluginVersion (*get_version)(void);
 
    uint16_t (*get_abi_major)(void);
 
    uint16_t (*get_abi_minor)(void);
 
    uint32_t (*get_capabilities)(void);
 
    /* -------------------------------------------------------------- */
    /*  Lifecycle                                                       */
    /* -------------------------------------------------------------- */
 
    bool (*init)(void *user_data);
 
    void (*destroy)(void);
 
    /* -------------------------------------------------------------- */
    /*  Snapshot production                                             */
    /* -------------------------------------------------------------- */
 
    ParserSnapshot *(*create_snapshot)(const char *grammar_file,
                                       char **error);
 
    bool (*validate_snapshot)(const ParserSnapshot *snap, char **error);
 
    /* -------------------------------------------------------------- */
    /*  Serialization (optional, requires LIME_CAP_SERIALIZABLE)       */
    /* -------------------------------------------------------------- */
 
    bool (*serialize_snapshot)(const ParserSnapshot *snap,
                               uint8_t **buf_out,
                               size_t *len_out);
 
    ParserSnapshot *(*deserialize_snapshot)(const uint8_t *buf,
                                            size_t len,
                                            char **error);
 
    /* -------------------------------------------------------------- */
    /*  Reserved for future expansion                                  */
    /* -------------------------------------------------------------- */
 
    void *_reserved[8]; 
} LimeParserPlugin;
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef const LimeParserPlugin *(*LimePluginEntryFn)(void);
 
#define LIME_PLUGIN_ENTRY_SYMBOL "lime_plugin_entry"
 
#ifdef _WIN32
  #define LIME_PLUGIN_EXPORT __declspec(dllexport)
#else
  #define LIME_PLUGIN_EXPORT __attribute__((visibility("default")))
#endif
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef struct ParserManagerConfig {
    uint32_t max_plugins;
 
    bool validate_on_load;
 
    bool auto_jit;
 
    const char **plugin_search_paths;
 
} ParserManagerConfig;
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef enum ParserManagerStatus {
    PM_OK = 0,                    
    PM_ERR_INVALID_ARG,           
    PM_ERR_ALLOC,                 
    PM_ERR_PLUGIN_NOT_FOUND,      
    PM_ERR_DUPLICATE_NAME,        
    PM_ERR_ABI_MISMATCH,          
    PM_ERR_INIT_FAILED,           
    PM_ERR_DLOPEN_FAILED,         
    PM_ERR_NO_ENTRY_POINT,        
    PM_ERR_SNAPSHOT_FAILED,       
    PM_ERR_VALIDATION_FAILED,     
    PM_ERR_PLUGIN_IN_USE,         
    PM_ERR_NO_ACTIVE_PLUGIN,      
    PM_ERR_CAPABILITY_MISSING,    
} ParserManagerStatus;
 
const char *parser_manager_status_string(ParserManagerStatus status);
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef struct ParserManager ParserManager;
 
 
/* ================================================================== */
/* ================================================================== */
 
ParserManager *parser_manager_create(const ParserManagerConfig *config);
 
void parser_manager_destroy(ParserManager *mgr);
 
 
/* ================================================================== */
/* ================================================================== */
 
ParserManagerStatus parser_manager_load(ParserManager *mgr,
                                        const char *path,
                                        void *user_data,
                                        LimePluginHandle *handle_out);
 
ParserManagerStatus parser_manager_register(ParserManager *mgr,
                                            const LimeParserPlugin *plugin,
                                            void *user_data,
                                            LimePluginHandle *handle_out);
 
ParserManagerStatus parser_manager_unload(ParserManager *mgr,
                                          LimePluginHandle handle);
 
 
/* ================================================================== */
/* ================================================================== */
 
ParserManagerStatus parser_manager_set_active(ParserManager *mgr,
                                              LimePluginHandle handle,
                                              const char *grammar_file);
 
LimePluginHandle parser_manager_get_active(const ParserManager *mgr);
 
ParserManagerStatus parser_manager_set_snapshot(ParserManager *mgr,
                                                ParserSnapshot *snap);
 
ParserSnapshot *parser_manager_get_snapshot(ParserManager *mgr);
 
 
/* ================================================================== */
/* ================================================================== */
 
typedef struct LimePluginInfo {
    LimePluginHandle handle;    
    const char *name;           
    LimePluginVersion version;  
    uint32_t capabilities;      
    bool is_active;             
    bool is_dynamic;            
} LimePluginInfo;
 
ParserManagerStatus parser_manager_get_plugin_info(const ParserManager *mgr,
                                                   LimePluginHandle handle,
                                                   LimePluginInfo *info);
 
ParserManagerStatus parser_manager_list_plugins(const ParserManager *mgr,
                                                LimePluginInfo *infos,
                                                uint32_t max_count,
                                                uint32_t *actual_count);
 
LimePluginHandle parser_manager_find_by_name(const ParserManager *mgr,
                                             const char *name);
 
uint32_t parser_manager_plugin_count(const ParserManager *mgr);
 
 
/* ================================================================== */
/* ================================================================== */
 
ParserManagerStatus parser_manager_hot_swap(ParserManager *mgr,
                                            LimePluginHandle new_handle,
                                            const char *grammar_file);
 
 
/* ================================================================== */
/* ================================================================== */
 
int lime_plugin_version_compare(LimePluginVersion a, LimePluginVersion b);
 
bool lime_plugin_version_satisfies(LimePluginVersion actual,
                                   LimePluginVersion required);
 
char *lime_plugin_version_string(LimePluginVersion v, char *buf, size_t buflen);
 
 
/* ================================================================== */
/* ================================================================== */
 
ParserManagerStatus lime_plugin_validate(const LimeParserPlugin *plugin);
 
bool lime_plugin_has_capability(const LimeParserPlugin *plugin,
                                LimePluginCaps cap);
 
bool lime_plugin_has_all_capabilities(const LimeParserPlugin *plugin,
                                      uint32_t required_caps);
 
const char *lime_plugin_capability_name(LimePluginCaps cap);
 
char *lime_plugin_capabilities_string(uint32_t caps, char *buf, size_t buflen);
 
void lime_plugin_dump(const LimeParserPlugin *plugin, FILE *out);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* PARSER_MANAGER_H */