static bool read_prefixID(SerdReader* reader) { bool ret = true; // `@' is already eaten in read_directive eat_string(reader, "prefix", 6); TRY_RET(read_ws_plus(reader)); Ref name = push_node(reader, SERD_LITERAL, "", 0); if (read_PN_PREFIX(reader, name) > SERD_FAILURE) { return pop_node(reader, name); } if (eat_byte_check(reader, ':') != ':') { return pop_node(reader, name); } read_ws_star(reader); const Ref uri = read_IRIREF(reader); if (!uri) { pop_node(reader, name); return false; } if (reader->prefix_sink) { ret = !reader->prefix_sink(reader->handle, deref(reader, name), deref(reader, uri)); } pop_node(reader, uri); pop_node(reader, name); return ret; }
static bool read_verb(SerdReader* reader, Ref* dest) { if (peek_byte(reader) == '<') { return (*dest = read_IRIREF(reader)); } else { /* Either a qname, or "a". Read the prefix first, and if it is in fact "a", produce that instead. */ *dest = push_node(reader, SERD_CURIE, "", 0); SerdNode* node = deref(reader, *dest); const SerdStatus st = read_PN_PREFIX(reader, *dest); bool ate_dot = false; if (!st && node->n_bytes == 1 && node->buf[0] == 'a' && is_token_end(peek_byte(reader))) { pop_node(reader, *dest); return (*dest = push_node(reader, SERD_URI, NS_RDF "type", 47)); } else if (st > SERD_FAILURE || !read_PrefixedName(reader, *dest, false, &ate_dot) || ate_dot) { return (*dest = pop_node(reader, *dest)); } else { return true; } } return false; }
static bool read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot) { uint8_t c; while (true) { TRY_THROW(read_verb(reader, &ctx.predicate)); read_ws_star(reader); TRY_THROW(read_objectList(reader, ctx, ate_dot)); ctx.predicate = pop_node(reader, ctx.predicate); if (*ate_dot) { return true; } do { read_ws_star(reader); switch (c = peek_byte(reader)) { case 0: return false; case '.': case ']': return true; case ';': eat_byte_safe(reader, c); } } while (c == ';'); } pop_node(reader, ctx.predicate); return true; except: pop_node(reader, ctx.predicate); return false; }
static bool read_literal(SerdReader* reader, Ref* dest, Ref* datatype, Ref* lang, SerdNodeFlags* flags, bool* ate_dot) { Ref str = read_String(reader, flags); if (!str) { return false; } switch (peek_byte(reader)) { case '@': eat_byte_safe(reader, '@'); TRY_THROW(*lang = read_LANGTAG(reader)); break; case '^': eat_byte_safe(reader, '^'); eat_byte_check(reader, '^'); TRY_THROW(read_iri(reader, datatype, ate_dot)); break; } *dest = str; return true; except: pop_node(reader, *datatype); pop_node(reader, *lang); pop_node(reader, str); return false; }
// STRING_LITERAL_QUOTE and STRING_LITERAL_SINGLE_QUOTE // Initial quote is already eaten by caller static Ref read_STRING_LITERAL(SerdReader* reader, SerdNodeFlags* flags, uint8_t q) { Ref ref = push_node(reader, SERD_LITERAL, "", 0); while (true) { const uint8_t c = peek_byte(reader); uint32_t code; switch (c) { case '\n': case '\r': r_err(reader, SERD_ERR_BAD_SYNTAX, "line end in short string\n"); return pop_node(reader, ref); case '\\': eat_byte_safe(reader, c); if (!read_ECHAR(reader, ref, flags) && !read_UCHAR(reader, ref, &code)) { r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid escape `\\%c'\n", peek_byte(reader)); return pop_node(reader, ref); } break; default: if (c == q) { eat_byte_check(reader, q); return ref; } else { read_character(reader, ref, flags, eat_byte_safe(reader, c)); } } } eat_byte_check(reader, q); return ref; }
static bool end_collection(SerdReader* reader, ReadContext ctx, Ref n1, Ref n2, bool ret) { pop_node(reader, n2); pop_node(reader, n1); *ctx.flags &= ~SERD_LIST_CONT; return ret && (eat_byte_safe(reader, ')') == ')'); }
void test_rewind_node_resets_a_previous_sequence_of_pops() { Node *a = NEW_STMTLST(NEW_NUM(1), NULL); Node *b = NEW_STMTLST(NEW_NUM(2), a); Node *c = NEW_STMTLST(NEW_NUM(3), b); Node *d = NEW_STMTLST(NEW_NUM(4), c); Node *found1 = pop_node(d); TEST(found1->val == 1); Node *found2 = pop_node(d); TEST(found2->val == 2); Node *found3 = pop_node(d); TEST(found3->val == 3); Node *found4 = pop_node(d); TEST(found4->val == 4); // Now rewind, and start over. rewind_node(d); Node *found5 = pop_node(d); TEST(found5->val == 1); Node *found6 = pop_node(d); TEST(found6->val == 2); Node *found7 = pop_node(d); TEST(found7->val == 3); Node *found8 = pop_node(d); TEST(found8->val == 4); }
static Ref read_IRIREF(SerdReader* reader) { TRY_RET(eat_byte_check(reader, '<')); Ref ref = push_node(reader, SERD_URI, "", 0); uint32_t code; while (true) { const uint8_t c = peek_byte(reader); switch (c) { case '"': case '<': case '^': case '`': case '{': case '|': case '}': r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid IRI character `%c'\n", c); return pop_node(reader, ref); case '>': eat_byte_safe(reader, c); return ref; case '\\': eat_byte_safe(reader, c); if (!read_UCHAR(reader, ref, &code)) { r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid IRI escape\n"); return pop_node(reader, ref); } switch (code) { case 0: case ' ': case '<': case '>': r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid escaped IRI character %X %c\n", code, code); return pop_node(reader, ref); } break; default: if (c <= 0x20) { if (isprint(c)) { r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid IRI character `%c' (escape %%%02X)\n", c, c); } else { r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid IRI character (escape %%%02X)\n", c, c); } if (reader->strict) { return pop_node(reader, ref); } push_byte(reader, ref, eat_byte_safe(reader, c)); } else { push_byte(reader, ref, eat_byte_safe(reader, c)); } } } }
static Ref read_BLANK_NODE_LABEL(SerdReader* reader, bool* ate_dot) { eat_byte_safe(reader, '_'); eat_byte_check(reader, ':'); Ref ref = push_node(reader, SERD_BLANK, reader->bprefix ? (char*)reader->bprefix : "", reader->bprefix_len); uint8_t c = peek_byte(reader); // First: (PN_CHARS | '_' | [0-9]) if (is_digit(c) || c == '_') { push_byte(reader, ref, eat_byte_safe(reader, c)); } else if (!read_PN_CHARS(reader, ref)) { r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid name start character\n"); return pop_node(reader, ref); } while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.')* if (c == '.') { push_byte(reader, ref, eat_byte_safe(reader, c)); } else if (!read_PN_CHARS(reader, ref)) { break; } } SerdNode* n = deref(reader, ref); if (n->buf[n->n_bytes - 1] == '.' && !read_PN_CHARS(reader, ref)) { // Ate trailing dot, pop it from stack/node and inform caller --n->n_bytes; serd_stack_pop(&reader->stack, 1); *ate_dot = true; } if (reader->syntax == SERD_TURTLE) { if (is_digit(n->buf[reader->bprefix_len + 1])) { if ((n->buf[reader->bprefix_len]) == 'b') { ((char*)n->buf)[reader->bprefix_len] = 'B'; // Prevent clash reader->seen_genid = true; } else if (reader->seen_genid && n->buf[reader->bprefix_len] == 'B') { r_err(reader, SERD_ERR_ID_CLASH, "found both `b' and `B' blank IDs, prefix required\n"); return pop_node(reader, ref); } } } return ref; }
int main(){ NODE *ptr = NULL; int ch; while(1){ printf("choose stack function <1>push <2>pop <3>show all nodes :"); scanf("%d",&ch); switch(ch){ case 1: ptr = push_node(ptr); //printf("ptr->data:%d ptr->next:%p\n",ptr->data,ptr->nextpoint); break; case 2: ptr = pop_node(ptr); break; case 3: show_node(ptr); break; default: printf("wrong input,try again\n"); } } system("pause"); return(0); }
static bool read_triples(SerdReader* reader, ReadContext ctx, bool* ate_dot) { bool nested = false; const Ref subject = read_subject(reader, ctx, &nested); bool ret = false; if (subject) { ctx.subject = subject; if (nested) { read_ws_star(reader); ret = true; if (peek_byte(reader) != '.') { ret = read_predicateObjectList(reader, ctx, ate_dot); } } else { TRY_RET(read_ws_plus(reader)); ret = read_predicateObjectList(reader, ctx, ate_dot); } pop_node(reader, subject); } else { ret = false; } ctx.subject = ctx.predicate = 0; return ret; }
SERD_API void serd_reader_free(SerdReader* reader) { pop_node(reader, reader->rdf_nil); pop_node(reader, reader->rdf_rest); pop_node(reader, reader->rdf_first); serd_node_free(&reader->default_graph); #ifdef SERD_STACK_CHECK free(reader->allocs); #endif free(reader->stack.buf); free(reader->bprefix); if (reader->free_handle) { reader->free_handle(reader->handle); } free(reader); }
void test_empty_returns_true_on_an_emptied_list() { Node *a = NEW_STMTLST(NEW_NUM(1), NULL); Node *b = NEW_STMTLST(NEW_NUM(2), a); Node *c = NEW_STMTLST(NEW_NUM(3), b); Node *d = NEW_STMTLST(NEW_NUM(4), c); TEST(empty_node(d) == false); Node *found1 = pop_node(d); Node *found2 = pop_node(d); Node *found3 = pop_node(d); TEST(empty_node(d) == false); Node *found4 = pop_node(d); TEST(found4->val == 4); TEST(empty_node(d) == true); }
void test_pop_node_returns_the_last_node_in_a_linked_list() { Node *a = NEW_STMTLST(NEW_NUM(1), NULL); Node *b = NEW_STMTLST(NEW_NUM(2), a); Node *c = NEW_STMTLST(NEW_NUM(3), b); Node *d = NEW_STMTLST(NEW_NUM(4), c); Node *found1 = pop_node(d); TEST(found1->val == 1); Node *found2 = pop_node(d); TEST(found2->val == 2); Node *found3 = pop_node(d); TEST(found3->val == 3); Node *found4 = pop_node(d); TEST(found4->val == 4); }
static bool read_base(SerdReader* reader) { // `@' is already eaten in read_directive eat_string(reader, "base", 4); TRY_RET(read_ws_plus(reader)); Ref uri; TRY_RET(uri = read_IRIREF(reader)); if (reader->base_sink) { reader->base_sink(reader->handle, deref(reader, uri)); } pop_node(reader, uri); return true; }
static bool read_iri(SerdReader* reader, Ref* dest, bool* ate_dot) { switch (peek_byte(reader)) { case '<': *dest = read_IRIREF(reader); break; default: *dest = push_node(reader, SERD_CURIE, "", 0); if (!read_PrefixedName(reader, *dest, true, ate_dot)) { *dest = pop_node(reader, *dest); } } return *dest != 0; }
static Ref read_subject(SerdReader* reader, ReadContext ctx, bool* nested) { Ref subject = 0; bool ate_dot = false; switch (peek_byte(reader)) { case '[': case '(': *nested = true; // nobreak case '_': read_blank(reader, ctx, true, &subject, &ate_dot); break; default: read_iri(reader, &subject, &ate_dot); } return ate_dot ? pop_node(reader, subject) : subject; }
static Ref read_subject(SerdReader* reader, ReadContext ctx, bool* nested) { Ref subject = 0; bool ate_dot = false; switch (peek_byte(reader)) { case '[': *nested = true; read_anon(reader, ctx, true, &subject); break; case '(': *nested = true; read_collection(reader, ctx, &subject); break; case '_': *nested = false; subject = read_BLANK_NODE_LABEL(reader, &ate_dot); break; default: read_iri(reader, &subject, &ate_dot); } return ate_dot ? pop_node(reader, subject) : subject; }
// STRING_LITERAL_LONG_QUOTE and STRING_LITERAL_LONG_SINGLE_QUOTE // Initial triple quotes are already eaten by caller static Ref read_STRING_LITERAL_LONG(SerdReader* reader, SerdNodeFlags* flags, uint8_t q) { Ref ref = push_node(reader, SERD_LITERAL, "", 0); while (true) { const uint8_t c = peek_byte(reader); uint32_t code; switch (c) { case '\\': eat_byte_safe(reader, c); if (!read_ECHAR(reader, ref, flags) && !read_UCHAR(reader, ref, &code)) { r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid escape `\\%c'\n", peek_byte(reader)); return pop_node(reader, ref); } break; default: if (c == q) { eat_byte_safe(reader, q); const uint8_t q2 = eat_byte_safe(reader, peek_byte(reader)); const uint8_t q3 = peek_byte(reader); if (q2 == q && q3 == q) { // End of string eat_byte_safe(reader, q3); return ref; } else { *flags |= SERD_HAS_QUOTE; push_byte(reader, ref, c); read_character(reader, ref, flags, q2); } } else { read_character(reader, ref, flags, eat_byte_safe(reader, c)); } } } return ref; }
/** * Tree expansion. */ struct mib_node * snmp_expand_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret) { u8_t node_type, ext_level, climb_tree; ext_level = 0; /* reset node stack */ node_stack_cnt = 0; while (node != NULL) { climb_tree = 0; node_type = node->node_type; if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA)) { struct mib_array_node *an; u16_t i; /* array node (internal ROM or RAM, fixed length) */ an = (struct mib_array_node *)node; if (ident_len > 0) { i = 0; while ((i < an->maxlength) && (an->objid[i] < *ident)) { i++; } if (i < an->maxlength) { LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident)); /* add identifier to oidret */ oidret->id[oidret->len] = an->objid[i]; (oidret->len)++; if (an->nptr[i] == NULL) { LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n")); /* leaf node (e.g. in a fixed size table) */ if (an->objid[i] > *ident) { return (struct mib_node*)an; } else if ((i + 1) < an->maxlength) { /* an->objid[i] == *ident */ (oidret->len)--; oidret->id[oidret->len] = an->objid[i + 1]; (oidret->len)++; return (struct mib_node*)an; } else { /* (i + 1) == an->maxlength */ (oidret->len)--; climb_tree = 1; } } else { u8_t j; struct nse cur_node; LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n")); /* non-leaf, store right child ptr and id */ LWIP_ASSERT("i < 0xff", i < 0xff); j = (u8_t)i + 1; while ((j < an->maxlength) && (empty_table(an->nptr[j]))) { j++; } if (j < an->maxlength) { cur_node.r_ptr = an->nptr[j]; cur_node.r_id = an->objid[j]; cur_node.r_nl = 0; } else { cur_node.r_ptr = NULL; } push_node(&cur_node); if (an->objid[i] == *ident) { ident_len--; ident++; } else { /* an->objid[i] < *ident */ ident_len = 0; } /* follow next child pointer */ node = an->nptr[i]; } } else { /* i == an->maxlength */ climb_tree = 1; } } else { u8_t j; /* ident_len == 0, complete with leftmost '.thing' */ j = 0; while ((j < an->maxlength) && empty_table(an->nptr[j])) { j++; } if (j < an->maxlength) { LWIP_DEBUGF(SNMP_MIB_DEBUG,("left an->objid[j]==%"S32_F"\n",an->objid[j])); oidret->id[oidret->len] = an->objid[j]; (oidret->len)++; if (an->nptr[j] == NULL) { /* leaf node */ return (struct mib_node*)an; } else { /* no leaf, continue */ node = an->nptr[j]; } } else { /* j == an->maxlength */ climb_tree = 1; } } } else if(node_type == MIB_NODE_LR) { struct mib_list_rootnode *lrn; struct mib_list_node *ln; /* list root node (internal 'RAM', variable length) */ lrn = (struct mib_list_rootnode *)node; if (ident_len > 0) { ln = lrn->head; /* iterate over list, head to tail */ while ((ln != NULL) && (ln->objid < *ident)) { ln = ln->next; } if (ln != NULL) { LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident)); oidret->id[oidret->len] = ln->objid; (oidret->len)++; if (ln->nptr == NULL) { /* leaf node */ if (ln->objid > *ident) { return (struct mib_node*)lrn; } else if (ln->next != NULL) { /* ln->objid == *ident */ (oidret->len)--; oidret->id[oidret->len] = ln->next->objid; (oidret->len)++; return (struct mib_node*)lrn; } else { /* ln->next == NULL */ (oidret->len)--; climb_tree = 1; } } else { struct mib_list_node *jn; struct nse cur_node; /* non-leaf, store right child ptr and id */ jn = ln->next; while ((jn != NULL) && empty_table(jn->nptr)) { jn = jn->next; } if (jn != NULL) { cur_node.r_ptr = jn->nptr; cur_node.r_id = jn->objid; cur_node.r_nl = 0; } else { cur_node.r_ptr = NULL; } push_node(&cur_node); if (ln->objid == *ident) { ident_len--; ident++; } else { /* ln->objid < *ident */ ident_len = 0; } /* follow next child pointer */ node = ln->nptr; } } else { /* ln == NULL */ climb_tree = 1; } } else { struct mib_list_node *jn; /* ident_len == 0, complete with leftmost '.thing' */ jn = lrn->head; while ((jn != NULL) && empty_table(jn->nptr)) { jn = jn->next; } if (jn != NULL) { LWIP_DEBUGF(SNMP_MIB_DEBUG,("left jn->objid==%"S32_F"\n",jn->objid)); oidret->id[oidret->len] = jn->objid; (oidret->len)++; if (jn->nptr == NULL) { /* leaf node */ LWIP_DEBUGF(SNMP_MIB_DEBUG,("jn->nptr == NULL\n")); return (struct mib_node*)lrn; } else { /* no leaf, continue */ node = jn->nptr; } } else { /* jn == NULL */ climb_tree = 1; } } } else if(node_type == MIB_NODE_EX) { struct mib_external_node *en; s32_t ex_id; /* external node (addressing and access via functions) */ en = (struct mib_external_node *)node; if (ident_len > 0) { u16_t i, len; i = 0; len = en->level_length(en->addr_inf,ext_level); while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) < 0)) { i++; } if (i < len) { /* add identifier to oidret */ en->get_objid(en->addr_inf,ext_level,i,&ex_id); LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,ex_id,*ident)); oidret->id[oidret->len] = ex_id; (oidret->len)++; if ((ext_level + 1) == en->tree_levels) { LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n")); /* leaf node */ if (ex_id > *ident) { return (struct mib_node*)en; } else if ((i + 1) < len) { /* ex_id == *ident */ en->get_objid(en->addr_inf,ext_level,i + 1,&ex_id); (oidret->len)--; oidret->id[oidret->len] = ex_id; (oidret->len)++; return (struct mib_node*)en; } else { /* (i + 1) == len */ (oidret->len)--; climb_tree = 1; } } else { u8_t j; struct nse cur_node; LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n")); /* non-leaf, store right child ptr and id */ LWIP_ASSERT("i < 0xff", i < 0xff); j = (u8_t)i + 1; if (j < len) { /* right node is the current external node */ cur_node.r_ptr = node; en->get_objid(en->addr_inf,ext_level,j,&cur_node.r_id); cur_node.r_nl = ext_level + 1; } else { cur_node.r_ptr = NULL; } push_node(&cur_node); if (en->ident_cmp(en->addr_inf,ext_level,i,*ident) == 0) { ident_len--; ident++; } else { /* external id < *ident */ ident_len = 0; } /* proceed to child */ ext_level++; } } else { /* i == len (en->level_len()) */ climb_tree = 1; } } else { /* ident_len == 0, complete with leftmost '.thing' */ en->get_objid(en->addr_inf,ext_level,0,&ex_id); LWIP_DEBUGF(SNMP_MIB_DEBUG,("left en->objid==%"S32_F"\n",ex_id)); oidret->id[oidret->len] = ex_id; (oidret->len)++; if ((ext_level + 1) == en->tree_levels) { /* leaf node */ LWIP_DEBUGF(SNMP_MIB_DEBUG,("(ext_level + 1) == en->tree_levels\n")); return (struct mib_node*)en; } else { /* no leaf, proceed to child */ ext_level++; } } } else if(node_type == MIB_NODE_SC) { mib_scalar_node *sn; /* scalar node */ sn = (mib_scalar_node *)node; if (ident_len > 0) { /* at .0 */ climb_tree = 1; } else { /* ident_len == 0, complete object identifier */ oidret->id[oidret->len] = 0; (oidret->len)++; /* leaf node */ LWIP_DEBUGF(SNMP_MIB_DEBUG,("completed scalar leaf\n")); return (struct mib_node*)sn; } } else { /* unknown/unhandled node_type */ LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node_type %"U16_F" unkown\n",(u16_t)node_type)); return NULL; } if (climb_tree) { struct nse child; /* find right child ptr */ child.r_ptr = NULL; child.r_id = 0; child.r_nl = 0; while ((node_stack_cnt > 0) && (child.r_ptr == NULL)) { pop_node(&child); /* trim returned oid */ (oidret->len)--; } if (child.r_ptr != NULL) { /* incoming ident is useless beyond this point */ ident_len = 0; oidret->id[oidret->len] = child.r_id; oidret->len++; node = child.r_ptr; ext_level = child.r_nl; } else { /* tree ends here ... */ LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed, tree ends here\n")); return NULL; } } } /* done, found nothing */ LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node==%p\n",(void*)node)); return NULL; }
/* Take the node from the front of the source, and move it to the front of the dest. It is an error to call this with the source list empty. */ void move_node(struct node** dest, struct node** source) { struct node* source_head = pop_node(source); push_node(dest, source_head); }
// Recurses, calling statement_sink for every statement encountered. // Leaves stack in original calling state (i.e. pops everything it pushes). static bool read_object(SerdReader* reader, ReadContext ctx, bool* ate_dot) { static const char* const XSD_BOOLEAN = NS_XSD "boolean"; static const size_t XSD_BOOLEAN_LEN = 40; #ifndef NDEBUG const size_t orig_stack_size = reader->stack.size; #endif bool ret = false; bool emit = (ctx.subject != 0); SerdNode* node = NULL; Ref o = 0; Ref datatype = 0; Ref lang = 0; uint32_t flags = 0; const uint8_t c = peek_byte(reader); switch (c) { case '\0': case ')': return false; case '[': emit = false; TRY_THROW(ret = read_anon(reader, ctx, false, &o)); break; case '(': emit = false; TRY_THROW(ret = read_collection(reader, ctx, &o)); break; case '_': TRY_THROW(ret = (o = read_BLANK_NODE_LABEL(reader, ate_dot))); break; case '<': case ':': TRY_THROW(ret = read_iri(reader, &o, ate_dot)); break; case '+': case '-': case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': TRY_THROW(ret = read_number(reader, &o, &datatype, ate_dot)); break; case '\"': case '\'': TRY_THROW(ret = read_literal(reader, &o, &datatype, &lang, &flags, ate_dot)); break; default: /* Either a boolean literal, or a qname. Read the prefix first, and if it is in fact a "true" or "false" literal, produce that instead. */ node = deref(reader, o = push_node(reader, SERD_CURIE, "", 0)); while (read_PN_CHARS_BASE(reader, o)) {} if ((node->n_bytes == 4 && !memcmp(node->buf, "true", 4)) || (node->n_bytes == 5 && !memcmp(node->buf, "false", 5))) { node->type = SERD_LITERAL; datatype = push_node( reader, SERD_URI, XSD_BOOLEAN, XSD_BOOLEAN_LEN); ret = true; } else if (read_PN_PREFIX_tail(reader, o) > SERD_FAILURE) { ret = false; } else { ret = read_PrefixedName(reader, o, false, ate_dot); } } if (ret && emit) { deref(reader, o)->flags = flags; ret = emit_statement(reader, ctx, o, datatype, lang); } except: pop_node(reader, lang); pop_node(reader, datatype); pop_node(reader, o); #ifndef NDEBUG assert(reader->stack.size == orig_stack_size); #endif return ret; }
int main(void) { /* Declare YOUR variables here ! */ Stack mystack; Queue myqueue; int menu_choice; srand((unsigned int)time(NULL)); if ((myqueue = QUEUEinit(my_destroy)) == NULL) /* Create new queue... */ { printf("\nFatal error - bailing out...!"); QUEUEdestroy(myqueue); exit(-1); } if ((mystack = STACKinit(my_destroy)) == NULL) /* Create new stack... */ { printf("\nFatal error - bailing out...!"); STACKdestroy(mystack); exit(-1); } /* Create and initialize queue and stack... */ enqueue_push_nodes(myqueue, mystack, NR_OF_ITEMS); do { menu_choice = menu(MAIN_MENU_ROW, 0, 6); switch (menu_choice) { case 1: enqueue_node(myqueue); break; case 2: dequeue_node(myqueue); break; case 3: push_node(mystack); break; case 4: pop_node(mystack); break; case 5: dequeue_push_node(myqueue, mystack); break; case 6: print_queue_stack(myqueue, mystack); break; default: final_status(myqueue, mystack); break; } } while (menu_choice); prompt_and_pause("\n\nLet's tidy up (destroy queue/stack)..- Bye!"); STACKdestroy(mystack); QUEUEdestroy(myqueue); return 0; }
static bool read_number(SerdReader* reader, Ref* dest, Ref* datatype, bool* ate_dot) { #define XSD_DECIMAL NS_XSD "decimal" #define XSD_DOUBLE NS_XSD "double" #define XSD_INTEGER NS_XSD "integer" Ref ref = push_node(reader, SERD_LITERAL, "", 0); uint8_t c = peek_byte(reader); bool has_decimal = false; if (c == '-' || c == '+') { push_byte(reader, ref, eat_byte_safe(reader, c)); } if ((c = peek_byte(reader)) == '.') { has_decimal = true; // decimal case 2 (e.g. '.0' or `-.0' or `+.0') push_byte(reader, ref, eat_byte_safe(reader, c)); TRY_THROW(read_0_9(reader, ref, true)); } else { // all other cases ::= ( '-' | '+' ) [0-9]+ ( . )? ( [0-9]+ )? ... TRY_THROW(is_digit(c)); read_0_9(reader, ref, true); if ((c = peek_byte(reader)) == '.') { has_decimal = true; // Annoyingly, dot can be end of statement, so tentatively eat eat_byte_safe(reader, c); c = peek_byte(reader); if (!is_digit(c) && c != 'e' && c != 'E') { *dest = ref; *ate_dot = true; // Force caller to deal with stupid grammar return true; // Next byte is not a number character, done } push_byte(reader, ref, '.'); read_0_9(reader, ref, false); } } c = peek_byte(reader); if (c == 'e' || c == 'E') { // double push_byte(reader, ref, eat_byte_safe(reader, c)); switch ((c = peek_byte(reader))) { case '+': case '-': push_byte(reader, ref, eat_byte_safe(reader, c)); default: break; } TRY_THROW(read_0_9(reader, ref, true)); *datatype = push_node(reader, SERD_URI, XSD_DOUBLE, sizeof(XSD_DOUBLE) - 1); } else if (has_decimal) { *datatype = push_node(reader, SERD_URI, XSD_DECIMAL, sizeof(XSD_DECIMAL) - 1); } else { *datatype = push_node(reader, SERD_URI, XSD_INTEGER, sizeof(XSD_INTEGER) - 1); } *dest = ref; return true; except: pop_node(reader, *datatype); pop_node(reader, ref); return false; }