conflict.h

Go to the documentation of this file.

 
#ifndef CONFLICT_H
#define CONFLICT_H
 
#include <stdint.h>
#include <stdbool.h>
 
/* Forward declarations to avoid circular includes */
struct GrammarModification;
struct ExtensionRegistry;
struct ParserSnapshot;
typedef uint32_t ExtensionID;
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
typedef enum ConflictType {
    CONFLICT_TOKEN_COLLISION,     
    CONFLICT_DUPLICATE_RULE,      
    CONFLICT_PRECEDENCE_CLASH,    
    CONFLICT_SHIFT_REDUCE,        
    CONFLICT_REDUCE_REDUCE,       
} ConflictType;
 
typedef struct Conflict {
    ConflictType type;            
    uint32_t mod_index_a;         
    uint32_t mod_index_b;         
    ExtensionID ext_id_a;         
    ExtensionID ext_id_b;         
    char *description;            
    bool resolved;                
} Conflict;
 
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
typedef struct ConflictSet {
    Conflict *conflicts;          
    uint32_t count;               
    uint32_t capacity;            
} ConflictSet;
 
ConflictSet *conflict_set_create(void);
 
void conflict_set_destroy(ConflictSet *cs);
 
bool conflict_set_add(
    ConflictSet *cs,
    ConflictType type,
    uint32_t mod_index_a,
    uint32_t mod_index_b,
    ExtensionID ext_id_a,
    ExtensionID ext_id_b,
    const char *description
);
 
uint32_t conflict_set_unresolved_count(const ConflictSet *cs);
 
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
bool detect_conflicts(
    const struct GrammarModification *mods,
    uint32_t nmods,
    ConflictSet *cs
);
 
uint32_t resolve_conflicts(
    ConflictSet *cs,
    const struct GrammarModification *mods,
    uint32_t nmods,
    struct ExtensionRegistry *registry
);
 
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
typedef enum ConflictLevel {
    CONFLICT_LEVEL_TOKEN    = 0,   
    CONFLICT_LEVEL_RULE     = 1,   
    CONFLICT_LEVEL_SEMANTIC = 2,   
} ConflictLevel;
 
typedef struct LimeContext {
    ExtensionID ext_id;            
    uint16_t token;                
    int state;                     
    int priority;                  
    const char *grammar_name;      
} LimeContext;
 
typedef struct ConflictPoint {
    uint16_t token;                
    int state;                     
    ConflictLevel level;           
    LimeContext *contexts;         
    int ncontexts;                 
    int capacity;                  
    char *description;             
} ConflictPoint;
 
typedef struct MultiGrammarConflictResult {
    ConflictPoint *points;         
    uint32_t npoints;              
    uint32_t capacity;             
    uint32_t token_conflicts;      
    uint32_t rule_conflicts;       
    uint32_t semantic_conflicts;   
} MultiGrammarConflictResult;
 
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
void conflict_point_init(ConflictPoint *cp, uint16_t token, int state,
                         ConflictLevel level);
 
void conflict_point_destroy(ConflictPoint *cp);
 
bool conflict_point_add_context(ConflictPoint *cp, const LimeContext *ctx);
 
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
MultiGrammarConflictResult *multi_conflict_result_create(void);
 
void multi_conflict_result_destroy(MultiGrammarConflictResult *result);
 
 
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------ */
 
uint32_t detect_token_conflicts(
    struct ExtensionRegistry *reg,
    MultiGrammarConflictResult *result
);
 
uint32_t detect_rule_conflicts(
    struct ExtensionRegistry *reg,
    uint16_t token,
    int state,
    MultiGrammarConflictResult *result
);
 
uint32_t detect_semantic_conflicts(
    struct ExtensionRegistry *reg,
    uint16_t token,
    int state,
    MultiGrammarConflictResult *result
);
 
ConflictPoint detect_conflict(
    struct ExtensionRegistry *reg,
    uint16_t token,
    int state
);
 
bool detect_all_multi_grammar_conflicts(
    struct ExtensionRegistry *reg,
    MultiGrammarConflictResult *result
);
 
 
#endif /* CONFLICT_H */