int lpostfix_expression(struct token *token) { if (token->type == ID_KW){ struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw != NULL){ //is a keyword log_error(LPOSTFIX_EXPRESSION); return -1; } else{ struct hashentry *entry = hash_retrieve(symboltable, token->lexeme); if (entry == NULL){ //not defined log_error(POSTFIX_EXPRESSION); printf("%s has not been defined!\n", token->lexeme); } else{ tree_mknode(LPOSTFIX_EXPRESSION); tree_add_attr(entry->data, 1); input_consume(); free_token(token); stack_pop(); stack_push(PRIMARY_EXPRESSION_MODS); return 0; } } } else{ log_error(LPOSTFIX_EXPRESSION); return -1; } return -1; }
int postfix_expression(struct token *token) { if ((token->type >= ID_KW) && (token->type <= S_C)){ if(token->type == ID_KW){ struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw != NULL){ //is a keyword log_error(POSTFIX_EXPRESSION); return -1; } } //if identifier if (token->type == ID_KW){ //already checked if kw struct hashentry *entry = hash_retrieve(symboltable, token->lexeme); if (entry == NULL){ //not defined log_error(POSTFIX_EXPRESSION); printf("%s has not been defined!\n", token->lexeme); return -1; } else{ tree_mknode(POSTFIX_EXPRESSION); tree_add_attr(entry->data, 1); input_consume(); free_token(token); stack_pop(); stack_push(PRIMARY_EXPRESSION_MODS); return 0; } } else{ //should be some sort of constant struct identifier *c = malloc(sizeof(struct identifier)); type_const(c->type); c->lexeme = token->lexeme; tree_mknode(POSTFIX_EXPRESSION); tree_add_attr(c, 1); input_consume(); free(token); stack_pop(); return 0; } } else{ log_error(POSTFIX_EXPRESSION); return -1; } }
int assignment_operator(struct token *token) { printf("Hello from assignment operator!\n");//DEBUG if(token->op_type == ASSIGN){ printf("found the assignment!\n");//DEBUG tree_mknode(ASSIGNMENT_OPERATOR); stack_pop(); struct hashentry *he = hash_retrieve(kwtable, token->lexeme); if (he == NULL){ log_error(ASSIGNMENT_OPERATOR); printf("disconnect between scanner's %s and parser!\n", token->lexeme); return -1; } tree_add_attr(he->data, 1); input_consume(); free_token(token); return 0; } return -1; }
int statement(struct token *token) { printf("Hello from statement\n");//DEBUG struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw != NULL){ //is a keyword if (strncmp("goto", token->lexeme, 4) == 0){ tree_mknode(STATEMENT); stack_pop(); stack_push(JUMP_STATEMENT); } if (strncmp("begin", token->lexeme, 5) == 0){ tree_mknode(STATEMENT); stack_pop(); stack_push(LABELED_STATEMENT); } } else if (token->op_type == CLOSESCOPE){ stack_pop(); //not a statement } else{ tree_mknode(STATEMENT); stack_pop(); stack_push(EXPRESSION_STATEMENT); } return 0; }
int reference_operator(struct token *token) { if ((token->op_type == STAR) || (token->op_type == AND) || (token->op_type == MULTIPLY) || (token->op_type == BWAND)){ tree_mknode(REFERENCE_OPERATOR); struct hashentry *he = hash_retrieve(kwtable, token->lexeme); if (he == NULL){ log_error(ASSIGNMENT_OPERATOR); printf("disconnect between scanner's %s and parser!\n", token->lexeme); return -1; } tree_add_attr(he->data, 0); input_consume(); stack_pop(); free_token(token); return 0; } else { log_error(REFERENCE_OPERATOR); return -1; } }
int type_specifier(struct token *token) { printf("Hello from type_specifier\n");//DEBUG struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw == NULL){ //not a keyword printf("%s, not a keyword\n", token->lexeme);//DEBUG log_error(TYPE_SPECIFIER); return -1; } else{ //check if right kind of keyword if( ifkw->data->id == KW_TYPESPECIFIER){ tree_mknode(TYPE_SPECIFIER); stack_pop(); tree_add_attr(ifkw->data, 1);//TODO input_consume(); free(token); return 0; } else{ log_error(TYPE_SPECIFIER); return -1; } } return 0; }
int declaration(struct token *token) { printf("Hello from declaration\n");//DEBUG struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw == NULL){ //not a keyword printf("%s, not a keyword\n", token->lexeme);//DEBUG log_error(DECLARATION); return -1; } else{ //check if right kind of keyword if( (ifkw->data->id == KW_TYPEQUALIFIER) || (ifkw->data->id == KW_TYPESPECIFIER)){ tree_mknode(DECLARATION); stack_pop(); stack_push(TOKEN_ENDSTATEMENT);// ';' stack_push(TYPEDEF_NAME); stack_push(DECLARATION_SPECIFIERS); } else{ log_error(DECLARATION); return -1; } } return 0; }
int declaration_specifiers(struct token *token) { printf("Hello from declaration speficiers\n");//DEBUG struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw == NULL){ //not a keyword printf("%s, not a keyword\n", token->lexeme);//DEBUG log_error(DECLARATION); return -1; } else{ //check if right kind of keyword if( ifkw->data->id == KW_TYPEQUALIFIER){ tree_mknode(DECLARATION_SPECIFIERS); stack_pop(); stack_push(POINTER_QUALIFIER); stack_push(TYPE_SPECIFIER); stack_push(TYPE_QUALIFIER); } else if( ifkw->data->id == KW_TYPESPECIFIER){ tree_mknode(DECLARATION_SPECIFIERS); stack_pop(); stack_push(POINTER_QUALIFIER); stack_push(TYPE_SPECIFIER); } else{ log_error(DECLARATION_SPECIFIERS); return -1; } } return 0; }
static METACACHE_RECORD* _cache_lookup(METACACHE_FS_PRIV* fspriv, const char* filename) { METACACHE_RECORD* rec; // FIXME: do a lookup if ((hash_retrieve(&(fspriv->cache), (char*)filename, (void**)&rec)) && (rec!=NULL)) { if ((rec->mtime+CACHE_TIMEOUT) > _curtime()) { DEBUGMSG("cached: %s", filename); return rec; } DEBUGMSG("purging old cache record for %s", filename); mvfs_stat_free(rec->stat); rec->stat = NULL; return rec; } // ... lookup failed - no record yet rec = calloc(1,sizeof(METACACHE_RECORD)); rec->filename = strdup(filename); // now insert hash_insert(&(fspriv->cache),rec->filename,rec); return rec; }
int lvalue(struct token *token) { // & operator not allowed on lhs printf("Hello from lvalue\n");//DEBUG if ((token->op_type == STAR) || (token->op_type == MULTIPLY)){ //must be interpreted as star token->op_type = STAR; tree_mknode(LVALUE); stack_pop(); struct hashentry *he = hash_retrieve(kwtable, token->lexeme); if (he == NULL){ log_error(LVALUE); printf("disconnect between scanner's %s and parser!\n", token->lexeme); return -1; } tree_add_attr(he->data, 0); input_consume(); stack_push(LPOSTFIX_EXPRESSION); free_token(token); return 0; } else if (token->type == ID_KW){ //check if keyword struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw == NULL){ // identifier tree_mknode(LVALUE); stack_pop(); stack_push(LPOSTFIX_EXPRESSION); return 0; } else{ log_error(LVALUE); return -1; } } else{ log_error(LVALUE); return -1; } }
//TODO int labeled_statement(struct token *token) { printf("hello from labeled statement\n");//DEBUG //need to make node //consume the "begin" kw (check for it first) //consume and add the next identifier token (check) //check and consume the final ':' input_consume(); // "begin" free_token(token); struct token *t = input_consume(); // the identifier struct hashentry *label = hash_retrieve(kwtable, t->lexeme); struct token *colon = input_consume(); //should be ':' if(label == NULL && colon->op_type == TERNC){ //good, not a keyword tree_mknode(LABELED_STATEMENT); struct hashentry *predefined; struct identifier *labelsym = malloc(sizeof(struct identifier)); labelsym->lexeme = t->lexeme; predefined = hash_insert(symboltable, labelsym); if(predefined == NULL || predefined == (void *)1){ log_error(LABELED_STATEMENT); printf("Symbol: %s has previously been defined\n", t->lexeme); return -1; } type_id(labelsym->type); labelsym->op_type = 0; struct hashentry *beginkw = hash_retrieve(kwtable, "begin"); tree_add_attr(beginkw->data, 0); tree_add_attr(labelsym, 1); free(t); free(colon); stack_pop(); return 0; } else{ log_error(LABELED_STATEMENT); return -1; } }
int typedef_name(struct token *token) { printf("Hello from typedef_name\n");//DEBUG if (token->type != ID_KW){ printf("Not an identifier!\n");//DEBUG log_error(TYPEDEF_NAME); return -1; } struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw != NULL){ //not a keyword printf("%s, not an identifier\n", token->lexeme);//DEBUG log_error(TYPEDEF_NAME); return -1; } else{ //add to symboltable //create a new identifier for symbol table struct identifier *newid = malloc(sizeof(struct identifier *)); type_id(newid->type); newid->op_type = 0; newid->kw_name = 0; newid->lexeme = token->lexeme; //ensure not already in the symbol table struct hashentry *entry = hash_insert(symboltable, newid); if (entry == NULL){ log_error(TYPEDEF_NAME); printf("Error inserting into symbol table!\n"); return -1; } else if (entry == (void *)1){ log_error(TYPEDEF_NAME); printf("%s is already defined!\n", newid->lexeme); return -1; } //make the tree node, and add the attribute tree_mknode(TYPEDEF_NAME); stack_pop(); tree_add_attr(newid, 3);//TODO input_consume(); //consume the identifier struct token *t = input_peek(); if (t->op_type == OPENBRACKET){ input_consume(); stack_push(DEFINE_ARRAY); } free(token); } printf("leaving typedef_name\n");//DEBUG; return 0; }
static void *get_record(t_symtab *symtab, const char *s) { t_symrec *symrec; if (symtab->lookup_table) { symrec = hash_retrieve(symtab->lookup_table, s); } else { symtab->symrec = NULL; llist_iterate(symtab->list, symtab_find, (char*)s); symrec = symtab->symrec; } return symrec; }
void test_kwtable(){ int i; for(i = 0; i < NUMKEYWORDS; i++){ struct hashentry *temp = hash_retrieve(kwtable, keywords[i]); if( temp == NULL ){ printf("ERROR, not all keywords entered into table!\n"); } else{ printf("%s keyword found in table.\n", temp->data->lexeme); } } }
/** * Link Detached Handler */ static int router_link_detach_handler(void* context, dx_link_t *link, int closed) { dx_router_t *router = (dx_router_t*) context; pn_link_t *pn_link = dx_link_pn(link); const char *r_tgt = pn_terminus_get_address(pn_link_remote_target(pn_link)); dx_link_item_t *item; sys_mutex_lock(router->lock); if (pn_link_is_sender(pn_link)) { item = DEQ_HEAD(router->out_links); dx_field_iterator_t *iter = dx_field_iterator_string(r_tgt, ITER_VIEW_NO_HOST); dx_router_link_t *rlink; if (iter) { int result = hash_retrieve(router->out_hash, iter, (void*) &rlink); if (result == 0) { dx_field_iterator_reset(iter, ITER_VIEW_NO_HOST); hash_remove(router->out_hash, iter); free_dx_router_link_t(rlink); dx_log(module, LOG_TRACE, "Removed local address: %s", r_tgt); } dx_field_iterator_free(iter); } } else item = DEQ_HEAD(router->in_links); while (item) { if (item->link == link) { if (pn_link_is_sender(pn_link)) DEQ_REMOVE(router->out_links, item); else DEQ_REMOVE(router->in_links, item); free_dx_link_item_t(item); break; } item = item->next; } sys_mutex_unlock(router->lock); return 0; }
int pointer_qualifier(struct token *token) { printf("Hello from pointer qualifier\n"); if (token->op_type == STAR || token->op_type == MULTIPLY){ struct hashentry *he = hash_retrieve(kwtable, token->lexeme); if (he == NULL){ log_error(POINTER_QUALIFIER); printf("disconnect between scanner's %s and parser!\n", token->lexeme); return -1; } tree_add_attr(he->data, 2); input_consume(); free_token(token); } else{ stack_pop(); } return 0; }
int cast_expression(struct token *token) { printf("hello from cast_expression\n");//DEBUG //need to get 'type' ')' 'lrvalue' struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw == NULL){ //not a keyword, error log_error(CAST_EXPRESSION); return -1; } else { //TODO implement actual check tree_mknode(CAST_EXPRESSION); tree_add_attr(ifkw->data, 0); input_consume(); stack_pop(); free_token(token); stack_push(LRVALUE); stack_push(TOKEN_CLOSEPAREN); return 0; } }
int declaration_list(struct token *token) { printf("Hello from declaration list\n");//DEBUG struct hashentry *ifkw = hash_retrieve(kwtable, token->lexeme); if (ifkw == NULL){ //not a keyword printf("%s, not a keyword\n", token->lexeme);//DEBUG stack_pop(); } else{ //check if right kind of keyword if( (ifkw->data->id == KW_TYPEQUALIFIER) || (ifkw->data->id == KW_TYPESPECIFIER)){ stack_push(DECLARATION); printf("%s, IS a keyword\n", token->lexeme);//DEBUG } else{ stack_pop(); } } return 0; }
int main(int argc, char **argv) { hash *h=hash_retrieve(argv[1]); hash_dump(h); return 0; }
int primary_expression_mods(struct token *token) { printf("Hello from primary_expression_mods\n"); if (token->op_type == OPENPAREN){ tree_mknode(-1); //TODO implement '(' input_consume(); free_token(token); stack_pop(); stack_push(TOKEN_CLOSEPAREN); //')' stack_push(PRIMARY_EXPRESSION_LIST); return -1; } else if (token->op_type == OPENBRACKET){ tree_mknode(PRIMARY_EXPRESSION_MODS); input_consume(); //get the [ free_token(token); stack_pop(); struct token *t = input_consume(); //the inner part of the [x] struct identifier *nid = malloc(sizeof(struct identifier)); nid->lexeme = t->lexeme; if (t->type == ID_KW){ struct hashentry *he = hash_retrieve(kwtable, nid->lexeme); if (he != NULL){ //is a keyword (an error) log_error(PRIMARY_EXPRESSION_MODS); return -1; } else{ he = hash_retrieve(symboltable, nid->lexeme); if (he == NULL){ //symbol not defined log_error(PRIMARY_EXPRESSION_MODS); printf("%s has not been initialized\n", nid->lexeme); return -1; } else{ tree_add_attr(he->data, 4); free_token(t); input_consume(); //the last ] return 0; } } } else if (t->type >= C_NUM && t->type <= C_F){ struct identifier *id = malloc(sizeof(struct identifier)); id->lexeme = t->lexeme; type_const(id->type); tree_add_attr(id, 4); //add it as attribute free(t); input_consume(); // the last ] return 0; } else{ log_error(PRIMARY_EXPRESSION_MODS); printf("%s has not been initialized\n", nid->lexeme); return -1; } } else if (token->op_type == VALUEAT){ input_consume(); // throw away '.' struct token *tmp = input_consume(); //get the identifier struct hashentry *ifkw = hash_retrieve(kwtable, tmp->lexeme); if (ifkw != NULL){ //error is a keyword log_error(PRIMARY_EXPRESSION_MODS); return -1; } else{ tree_mknode(-1); //TODO implement '.' free_token(token); stack_pop(); stack_push(PRIMARY_EXPRESSION); return -1; } } else{ //not a mod of a primary expression stack_pop(); return 0; } }
/** * Inbound Delivery Handler */ static void router_rx_handler(void* context, dx_link_t *link, pn_delivery_t *delivery) { dx_router_t *router = (dx_router_t*) context; pn_link_t *pn_link = pn_delivery_link(delivery); dx_message_t *msg; int valid_message = 0; // // Receive the message into a local representation. If the returned message // pointer is NULL, we have not yet received a complete message. // sys_mutex_lock(router->lock); msg = dx_message_receive(delivery); sys_mutex_unlock(router->lock); if (!msg) return; // // Validate the message through the Properties section // valid_message = dx_message_check(msg, DX_DEPTH_PROPERTIES); pn_link_advance(pn_link); pn_link_flow(pn_link, 1); if (valid_message) { dx_field_iterator_t *iter = dx_message_field_iterator(msg, DX_FIELD_TO); dx_router_link_t *rlink; if (iter) { dx_field_iterator_reset(iter, ITER_VIEW_NO_HOST); sys_mutex_lock(router->lock); int result = hash_retrieve(router->out_hash, iter, (void*) &rlink); dx_field_iterator_free(iter); if (result == 0) { // // To field is valid and contains a known destination. Enqueue on // the output fifo for the next-hop-to-destination. // pn_link_t* pn_outlink = dx_link_pn(rlink->link); DEQ_INSERT_TAIL(rlink->out_fifo, msg); pn_link_offered(pn_outlink, DEQ_SIZE(rlink->out_fifo)); dx_link_activate(rlink->link); } else { // // To field contains an unknown address. Release the message. // pn_delivery_update(delivery, PN_RELEASED); pn_delivery_settle(delivery); } sys_mutex_unlock(router->lock); } } else { // // Message is invalid. Reject the message. // pn_delivery_update(delivery, PN_REJECTED); pn_delivery_settle(delivery); pn_delivery_set_context(delivery, 0); dx_free_message(msg); } }
int jump_statement(struct token *token) { printf("Hello from jump_statement\n");//DEBUG // goto label conditional if( strncmp("goto", token->lexeme, 4) == 0){ tree_mknode(JUMP_STATEMENT); input_consume(); //consume the goto free_token(token); struct token *label = input_consume(); struct token *conditional = input_consume(); if (label->type == ID_KW){ struct hashentry *ifkw = hash_retrieve(kwtable, label->lexeme); if (ifkw == NULL){//not a keyword, an identifier struct hashentry *predefined; struct hashentry *predefined2; //get symboltable entry for label predefined = hash_retrieve(symboltable, label->lexeme); if(predefined == NULL){ predefined = malloc(sizeof(struct hashentry)); predefined->data = malloc(sizeof(struct identifier)); predefined->data->lexeme = label->lexeme; type_id(predefined->data->type); //log_error(LABELED_STATEMENT); //printf("Symbol: %s has not been defined!\n", label->lexeme); //return -1; } //get symboltable entry for conditional predefined2 = hash_retrieve(symboltable, conditional->lexeme); if(predefined2 == NULL){ log_error(LABELED_STATEMENT); printf("Symbol: %s has not been defined!\n", conditional->lexeme); return -1; } struct hashentry *gokw = hash_retrieve(kwtable, "goto"); tree_add_attr(gokw->data, 0); tree_add_attr(predefined->data, 1); tree_add_attr(predefined2->data, 2); printf("Consumed: goto %s %s\n", label->lexeme, conditional->lexeme);//DEBUG stack_pop(); stack_push(TOKEN_ENDSTATEMENT); free(label); free(conditional); return 0; } else{ log_error(JUMP_STATEMENT); free_token(label); free_token(conditional); return -1; } } else{ printf("Incorrect goto label: %s\n", label->lexeme);//DEBUG free_token(label); free_token(conditional); log_error(JUMP_STATEMENT); return -1; } } else{ log_error(JUMP_STATEMENT); return -1; } }