glr.h

#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 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;
 
/* Create a GLR parser. initial_state is the LALR start state (typically 0).
** arena_size controls the initial arena block size (0 for default). */
GLRParser *glr_parser_create(uint32_t initial_state, size_t arena_size);
 
/* Destroy a GLR parser and free all resources. */
void glr_parser_destroy(GLRParser *parser);
 
/*
** Feed a token to the GLR parser.
**
** For each active stack head, the action table is consulted. If a
** shift/reduce conflict exists (both actions are valid), the head is
** forked: one copy shifts, the other reduces. After processing all
** heads, heads that arrived at the same state are merged.
**
** The action table arrays are the same ones generated by Lime into
** the parser source file.
**
** Parameters:
**   parser          - The GLR parser context
**   token           - The terminal symbol code
**   yy_action       - The generated action table
**   action_count    - Number of entries in yy_action
**   yy_lookahead    - The generated lookahead verification table
**   lookahead_count - Number of entries in yy_lookahead
**   yy_shift_ofst   - Per-state shift offset into yy_action
**   yy_reduce_ofst  - Per-state reduce offset into yy_action (for goto)
**   yy_default      - Per-state default action
**   nstate          - Total number of parser states
**   yy_rule_lhs     - LHS nonterminal for each rule (yyRuleInfoLhs)
**   yy_rule_nrhs    - Negative RHS length for each rule (yyRuleInfoNRhs)
**   nrule           - Number of rules
**   min_shiftreduce - YY_MIN_SHIFTREDUCE constant
**   max_shiftreduce - YY_MAX_SHIFTREDUCE constant
**   min_reduce      - YY_MIN_REDUCE constant
**   max_reduce      - YY_MAX_REDUCE constant
**   error_action    - YY_ERROR_ACTION constant
**   accept_action   - YY_ACCEPT_ACTION constant
**   no_action       - YY_NO_ACTION constant
**
** Returns 0 on success, -1 on unresolvable ambiguity, -2 on all-heads-dead.
*/
int glr_parser_feed(GLRParser *parser, uint16_t token,
                    const uint16_t *yy_action, uint32_t action_count,
                    const uint16_t *yy_lookahead, uint32_t lookahead_count,
                    const int16_t *yy_shift_ofst,
                    const int16_t *yy_reduce_ofst,
                    const uint16_t *yy_default,
                    uint32_t nstate,
                    const uint16_t *yy_rule_lhs,
                    const int8_t *yy_rule_nrhs,
                    uint32_t nrule,
                    uint16_t min_shiftreduce,
                    uint16_t max_shiftreduce,
                    uint16_t min_reduce,
                    uint16_t max_reduce,
                    uint16_t error_action,
                    uint16_t accept_action,
                    uint16_t no_action);
 
/* Set the disambiguation callback. */
void glr_parser_set_disambiguate(GLRParser *parser,
                                  GLRDisambiguateFn fn, void *user_data);
 
/* Return number of active parse heads (1 for unambiguous, >1 for ambiguous). */
uint32_t glr_parser_head_count(const GLRParser *parser);
 
/* Check if the parse completed successfully (single head in accept state). */
bool glr_parser_accepted(const GLRParser *parser, uint16_t accept_action);
 
/* GSSNode management */
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);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LIME_GLR_H */