HParseResult* h_parse__m(HAllocator* mm__, const HParser* parser, const uint8_t* input, size_t length) { // Set up a parse state... HArena * arena = h_new_arena(mm__, 0); HParseState *parse_state = a_new_(arena, HParseState, 1); parse_state->cache = h_hashtable_new(arena, cache_key_equal, // key_equal_func cache_key_hash); // hash_func parse_state->input_stream.input = input; parse_state->input_stream.index = 0; parse_state->input_stream.bit_offset = 8; // bit big endian parse_state->input_stream.overrun = 0; parse_state->input_stream.endianness = BIT_BIG_ENDIAN | BYTE_BIG_ENDIAN; parse_state->input_stream.length = length; parse_state->lr_stack = h_slist_new(arena); parse_state->recursion_heads = h_hashtable_new(arena, cache_key_equal, cache_key_hash); parse_state->arena = arena; HParseResult *res = h_do_parse(parser, parse_state); h_slist_free(parse_state->lr_stack); h_hashtable_free(parse_state->recursion_heads); // tear down the parse state h_hashtable_free(parse_state->cache); if (!res) h_delete_arena(parse_state->arena); return res; }
void h_symbol_put(HParseState *state, const char* key, void *value) { if (!state->symbol_table) { state->symbol_table = h_slist_new(state->arena); h_slist_push(state->symbol_table, h_hashtable_new(state->arena, h_eq_ptr, h_hash_ptr)); } HHashTable *head = h_slist_top(state->symbol_table); assert(!h_hashtable_present(head, key)); h_hashtable_put(head, key, value); }
HSlist* h_slist_copy(HSlist *slist) { HSlist *ret = h_slist_new(slist->arena); HSlistNode *head = slist->head; HSlistNode *tail; if (head != NULL) { h_slist_push(ret, head->elem); tail = ret->head; head = head->next; while (head != NULL) { // append head item to tail in a new node HSlistNode *node = h_arena_malloc(slist->arena, sizeof(HSlistNode)); node->elem = head->elem; node->next = NULL; tail = tail->next = node; head = head->next; } } return ret; }
HParseResult *h_packrat_parse(HAllocator* mm__, const HParser* parser, HInputStream *input_stream) { HArena * arena = h_new_arena(mm__, 0); HParseState *parse_state = a_new_(arena, HParseState, 1); parse_state->cache = h_hashtable_new(arena, cache_key_equal, // key_equal_func cache_key_hash); // hash_func parse_state->input_stream = *input_stream; parse_state->lr_stack = h_slist_new(arena); parse_state->recursion_heads = h_hashtable_new(arena, pos_equal, pos_hash); parse_state->arena = arena; HParseResult *res = h_do_parse(parser, parse_state); h_slist_free(parse_state->lr_stack); h_hashtable_free(parse_state->recursion_heads); // tear down the parse state h_hashtable_free(parse_state->cache); if (!res) h_delete_arena(parse_state->arena); return res; }
void setupLR(const HParser *p, HParseState *state, HLeftRec *rec_detect) { if (!rec_detect->head) { HRecursionHead *some = a_new(HRecursionHead, 1); some->head_parser = p; some->involved_set = h_slist_new(state->arena); some->eval_set = NULL; rec_detect->head = some; } HSlistNode *it; for(it=state->lr_stack->head; it; it=it->next) { HLeftRec *lr = it->elem; if(lr->rule == p) break; lr->head = rec_detect->head; h_slist_push(lr->head->involved_set, (void*)lr->rule); } }
HLRTable *h_lrtable_new(HAllocator *mm__, size_t nrows) { HArena *arena = h_new_arena(mm__, 0); // default blocksize assert(arena != NULL); HLRTable *ret = h_new(HLRTable, 1); ret->nrows = nrows; ret->ntmap = h_arena_malloc(arena, nrows * sizeof(HHashTable *)); ret->tmap = h_arena_malloc(arena, nrows * sizeof(HStringMap *)); ret->forall = h_arena_malloc(arena, nrows * sizeof(HLRAction *)); ret->inadeq = h_slist_new(arena); ret->arena = arena; ret->mm__ = mm__; for(size_t i=0; i<nrows; i++) { ret->ntmap[i] = h_hashtable_new(arena, h_eq_symbol, h_hash_symbol); ret->tmap[i] = h_stringmap_new(arena); ret->forall[i] = NULL; } return ret; }
int h_lalr_compile(HAllocator* mm__, HParser* parser, const void* params) { // generate (augmented) CFG from parser // construct LR(0) DFA // build LR(0) table // if necessary, resolve conflicts "by conversion to SLR" if (!parser->vtable->isValidCF(parser->env)) { return -1; } HCFGrammar *g = h_cfgrammar_(mm__, h_desugar_augmented(mm__, parser)); if(g == NULL) // backend not suitable (language not context-free) return -1; HLRDFA *dfa = h_lr0_dfa(g); if (dfa == NULL) { // this should normally not happen h_cfgrammar_free(g); return -1; } HLRTable *table = h_lr0_table(g, dfa); if (table == NULL) { // this should normally not happen h_cfgrammar_free(g); return -1; } if(has_conflicts(table)) { HArena *arena = table->arena; HLREnhGrammar *eg = enhance_grammar(g, dfa, table); if(eg == NULL) { // this should normally not happen h_cfgrammar_free(g); h_lrtable_free(table); return -1; } // go through the inadequate states; replace inadeq with a new list HSlist *inadeq = table->inadeq; table->inadeq = h_slist_new(arena); for(HSlistNode *x=inadeq->head; x; x=x->next) { size_t state = (uintptr_t)x->elem; bool inadeq = false; // clear old forall entry, it's being replaced by more fine-grained ones table->forall[state] = NULL; // go through each reducible item of state H_FOREACH_KEY(dfa->states[state], HLRItem *item) if(item->mark < item->len) continue; // action to place in the table cells indicated by lookahead HLRAction *action = h_reduce_action(arena, item); // find all LR(0)-enhanced productions matching item HHashSet *lhss = h_hashtable_get(eg->corr, item->lhs); assert(lhss != NULL); H_FOREACH_KEY(lhss, HCFChoice *lhs) assert(lhs->type == HCF_CHOICE); // XXX could be CHARSET? for(HCFSequence **p=lhs->seq; *p; p++) { HCFChoice **rhs = (*p)->items; if(!match_production(eg, rhs, item->rhs, state)) { continue; } // the left-hand symbol's follow set is this production's // contribution to the lookahead const HStringMap *fs = h_follow(1, eg->grammar, lhs); assert(fs != NULL); assert(fs->epsilon_branch == NULL); assert(!h_stringmap_empty(fs)); // for each lookahead symbol, put action into table cell if(terminals_put(table->tmap[state], fs, action) < 0) inadeq = true; } H_END_FOREACH // enhanced production H_END_FOREACH // reducible item if(inadeq) { h_slist_push(table->inadeq, (void *)(uintptr_t)state); } } } h_cfgrammar_free(g); parser->backend_data = table; return has_conflicts(table)? -1 : 0; }
#ifndef NDEBUG action->production.rhs = item->rhs; #endif return action; } // adds 'new' to the branches of 'action' // returns a 'action' if it is already of type HLR_CONFLICT // allocates a new HLRAction otherwise HLRAction *h_lr_conflict(HArena *arena, HLRAction *action, HLRAction *new) { if(action->type != HLR_CONFLICT) { HLRAction *old = action; action = h_arena_malloc(arena, sizeof(HLRAction)); action->type = HLR_CONFLICT; action->branches = h_slist_new(arena); h_slist_push(action->branches, old); h_slist_push(action->branches, new); } else { // check if 'new' is already among branches HSlistNode *x; for(x=action->branches->head; x; x=x->next) { if(x->elem == new) break; } // add 'new' if it is not already in list if(x == NULL) h_slist_push(action->branches, new); } return action;