glr.h

Go to the documentation of this file.

 
#ifndef LIME_GLR_H
#define LIME_GLR_H
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Forward declarations */
typedef struct LimeArena LimeArena;
typedef struct ParserSnapshot ParserSnapshot;
 
typedef struct GSSNode {
    uint32_t state; 
    union {
        int ival;
        void *pval;
        double dval;
    } value;
    struct GSSNode **predecessors; 
    uint32_t npred;                
    uint32_t pred_capacity;        
    uint32_t refcount;             
#ifdef YYLOCATIONTYPE
    struct {
        uint32_t first_line, first_column, last_line, last_column;
    } location;
#endif
} GSSNode;
 
typedef int (*GLRDisambiguateFn)(uint32_t rule1_index, uint32_t rule2_index, void *user_data);
 
typedef struct GLRParser {
    GSSNode **active_heads;         
    uint32_t nheads;                
    uint32_t max_heads;             
    LimeArena *arena;               
    GLRDisambiguateFn disambiguate; 
    void *disambiguate_data;        
    uint32_t total_forks;           
    uint32_t total_merges;          
    bool has_ambiguity;             
} GLRParser;
 
GLRParser *glr_parser_create(uint32_t initial_state, size_t arena_size);
 
void glr_parser_destroy(GLRParser *parser);
 
int glr_parser_feed(GLRParser *parser, const ParserSnapshot *snap, uint16_t token);
 
void glr_parser_set_disambiguate(GLRParser *parser, GLRDisambiguateFn fn, void *user_data);
 
uint32_t glr_parser_head_count(const GLRParser *parser);
 
bool glr_parser_accepted(const GLRParser *parser, uint16_t accept_action);
 
/* GSSNode management (exposed for testing and embedding integrations). */
GSSNode *gss_node_create(LimeArena *arena, uint32_t state);
void gss_node_add_predecessor(GSSNode *node, GSSNode *pred);
GSSNode *gss_node_acquire(GSSNode *node);
void gss_node_release(GSSNode *node);
 
/* ----------------------------------------------------------------------
 * Public GLR API (parse_glr.c).
 *
 * These are the user-facing entry points that lift the GLR engine
 * above into the same conceptual world as the LALR push parser.
 * The LALR fast path (parse_token()) is intentionally untouched;
 * users who never call lime_parse_glr() pay zero cost for GLR.
 *
 * Lifecycle:
 *   ParseContext *ctx = parse_begin(snap);
 *   if (lime_parse_glr(ctx, my_disambig, my_data) != 0) ...
 *   while (have_more_tokens) {
 *       int rc = lime_parse_glr_feed(ctx, token);
 *       if (rc < 0) break;
 *   }
 *   bool ok = lime_parse_glr_accepted(ctx);
 *   lime_parse_glr_end(ctx);
 *   parse_end(ctx);
 * ---------------------------------------------------------------------- */
 
/* Forward declaration so the prototypes below don't pull in parser.h. */
struct ParseContext;
 
int lime_parse_glr(struct ParseContext *ctx,
                   GLRDisambiguateFn disambig,
                   void *user_data);
 
int lime_parse_glr_feed(struct ParseContext *ctx, uint16_t token);
 
bool lime_parse_glr_accepted(struct ParseContext *ctx);
 
uint32_t lime_parse_glr_head_count(struct ParseContext *ctx);
 
void lime_parse_glr_end(struct ParseContext *ctx);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LIME_GLR_H */