END_TEST START_TEST(test_integer) { #define OVERSIZE ":19223372036854775807\r\n" #define INVALID1 ":123lOl456\r\n" #define INVALID2 ":\r\n" struct element el_c, el_p; int ret; struct int_pair { char *serialized; uint64_t num; } pairs[3] = { {":-1\r\n", -1}, {":9223372036854775807\r\n", 9223372036854775807}, {":128\r\n", 128} }; test_reset(); for (int i = 0; i < 3; i++) { size_t len = strlen(pairs[i].serialized); buf_reset(buf); el_c.type = ELEM_INT; el_c.num = pairs[i].num; ret = compose_element(&buf, &el_c); ck_assert(ret == len); ck_assert_int_eq(cc_bcmp(buf->rpos, pairs[i].serialized, len), 0); el_p.type = ELEM_UNKNOWN; ret = parse_element(&el_p, buf); ck_assert_int_eq(ret, PARSE_OK); ck_assert(buf->rpos == buf->wpos); ck_assert(el_p.type == ELEM_INT); ck_assert(el_p.num == pairs[i].num); } buf_reset(buf); buf_write(buf, OVERSIZE, sizeof(OVERSIZE) - 1); ret = parse_element(&el_p, buf); ck_assert_int_eq(ret, PARSE_EOVERSIZE); buf_reset(buf); buf_write(buf, INVALID1, sizeof(INVALID1) - 1); ret = parse_element(&el_p, buf); ck_assert_int_eq(ret, PARSE_EINVALID); buf_reset(buf); buf_write(buf, INVALID2, sizeof(INVALID2) - 1); ret = parse_element(&el_p, buf); ck_assert_int_eq(ret, PARSE_EINVALID); #undef INVALID2 #undef INVALID1 #undef OVERSIZE }
void parse_element(char *tok) { int len; char *p; if(tok == NULL) return; if((p = strstr(tok, "<br>")) != NULL) { char prev[LINE_LEN]; // deal with string ahead of <br> if(tok != p) { memcpy(prev, tok, p - tok); prev[p - tok] = '\0'; parse_element(prev); } // deal with <br> printf("\n"); pos = 0; // deal with string ahead of <br> parse_element(p + 4); return; } if((p = strstr(tok, "<hr>")) != NULL) { char prev[LINE_LEN]; // deal with string ahead of <hr> if(tok != p) { memcpy(prev, tok, p - tok); prev[p - tok] = '\0'; parse_element(prev); } // deal with <hr> display_hr(); // deal with string ahead of <hr> parse_element(p + 4); return; } // Now we only need to deal with words len = strlen(tok); if((pos+len) >= LINE_LEN) { printf("\n"); pos = 0; } if(pos != 0) { printf(" "); pos++; } printf("%s", tok); pos += strlen(tok); }
LVAVSPresetContainer *lvavs_preset_container_from_xml_node(LVAVSPresetContainer *cont, xmlNodePtr node) { xmlNodePtr child; LVAVSPresetElement *element; int i; for(child = node->children; child; child = child->next) { if (xmlIsBlankNode (child) || child->type != XML_ELEMENT_NODE) continue; if(xmlStrcmp(child->name, (xmlChar *)"container_child") == 0) { LVAVSPresetContainer *cont2 = lvavs_preset_container_new(); VisParamContainer *pcont = visual_param_container_new(); LVAVS_PRESET_ELEMENT(cont2)->pcont = pcont; visual_param_container_add_many(pcont, container_params); visual_list_add(cont->members, cont2); lvavs_preset_container_from_xml_node(cont2, child); } for(i = 0; id_to_name_map[i] != NULL; i++) if (xmlStrcmp (child->name, (const xmlChar *) id_to_name_map[i]) == 0) break; if(id_to_name_map[i] == NULL) continue; element = lvavs_preset_element_new(LVAVS_PRESET_ELEMENT_TYPE_PLUGIN, (char*)child->name); if(parse_element(child, element)) visual_list_add(cont->members, element); } return cont; }
END_TEST START_TEST(test_error) { #define ERR "something is wrong" #define SERIALIZED "-" ERR "\r\n" struct element el_c, el_p; int ret; int len = sizeof(SERIALIZED) - 1; char *pos; test_reset(); /* compose */ el_c.type = ELEM_ERR; el_c.bstr = str2bstr(ERR); ret = compose_element(&buf, &el_c); ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0); /* parse */ pos = buf->rpos + 1; ret = parse_element(&el_p, buf); ck_assert_int_eq(ret, PARSE_OK); ck_assert(buf->rpos == buf->wpos); ck_assert(el_p.type == ELEM_ERR); ck_assert(el_p.bstr.len == sizeof(ERR) - 1); ck_assert(el_p.bstr.data == pos); #undef SERIALIZED #undef ERR }
tree xml_html_parser::parse_doctype () { s += 9; tree dt= tuple ("doctype"); skip_space (); dt << parse_name (); skip_space (); if (test (s, "SYSTEM")) dt << parse_system (); else if (test (s, "PUBLIC")) dt << parse_public (); skip_space (); if (test (s, "[")) { s += 1; while (s) { skip_space (); if (test (s, "]")) { s += 1; break; } else if (test (s, "<!ELEMENT")) dt << parse_element (); else if (test (s, "<!ATTLIST")) dt << parse_cdata (); else if (test (s, "<!ENTITY")) parse_entity_decl (); else if (test (s, "<!NOTATION")) a << parse_notation (); else if (test (s, "<?")) dt << parse_pi (); else if (test (s, "<!--")) dt << parse_comment (); else if (s[0] == '&' || s[0] == '%') (void) parse_entity (); else s += 1; } } skip_space (); if (test (s, ">")) s += 1; return dt; }
bool window_part::parse_element(const char*& p) { char ch = *p; switch (ch) { case '.': { partition pt = {leaf, 0}; m_index.add(pt); p ++; return true; } case 'h': case 'v': { partition pt0 = {(ch == 'h' ? short(horizontal) : short(vertical))}; unsigned n = m_index.size(); m_index.add(pt0); p ++; unsigned count = 0; while (parse_element(p)) { count ++; } m_index[n].childs_number = count; return true; } case '(': { p ++; if (!parse_element(p)) break; if (*p == ')') { p ++; return true; } } default: /* */ ; } return false; }
END_TEST START_TEST(test_bulk_string) { #define BULK "foo bar\r\n" #define SERIALIZED "$9\r\n" BULK "\r\n" #define EMPTY "$0\r\n\r\n" struct element el_c, el_p; int ret; int len = sizeof(SERIALIZED) - 1; test_reset(); /* compose */ el_c.type = ELEM_BULK; el_c.bstr = str2bstr(BULK); ret = compose_element(&buf, &el_c); ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0); /* parse */ ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK); ck_assert(buf->rpos == buf->wpos); ck_assert(el_p.type == ELEM_BULK); ck_assert(el_p.bstr.len == sizeof(BULK) - 1); ck_assert(el_p.bstr.data + el_p.bstr.len == buf->rpos - CRLF_LEN); ck_assert(buf->rpos == buf->wpos); /* empty string */ buf_reset(buf); len = sizeof(EMPTY) - 1; el_c.bstr = null_bstring; ret = compose_element(&buf, &el_c); ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret); ck_assert_int_eq(cc_bcmp(buf->rpos, EMPTY, ret), 0); ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK); ck_assert(el_p.bstr.len == 0); #undef EMPTY #undef SERIALIZED #undef BULK }
static int parse_node(xmlNodePtr node, simple_binary_t **otabxml) { int status = 0; /* Call for the parser function of the node type. */ switch (node->type) { case XML_ELEMENT_NODE: status = parse_element(node, otabxml); break; case XML_TEXT_NODE: case XML_COMMENT_NODE: case XML_PI_NODE: /* Text nodes, comments and PIs are ignored. */ break; /* * XML has also many other node types, these are not needed with * OTA. Therefore they are assumed to be an error. */ default: error(0, "OTA compiler: Unknown XML node in the OTA source."); return -1; break; } /* * If node is an element with content, it will need an end tag after it's * children. The status for it is returned by parse_element. */ switch (status) { case 0: if (node->children != NULL) if (parse_node(node->children, otabxml) == -1) return -1; break; case 1: if (node->children != NULL) if (parse_node(node->children, otabxml) == -1) return -1; parse_end(otabxml); break; case -1: /* Something went wrong in the parsing. */ return -1; default: warning(0,"OTA compiler: undefined return value in a parse function."); return -1; break; } if (node->next != NULL) if (parse_node(node->next, otabxml) == -1) return -1; return 0; }
LVAVSPreset *lvavs_preset_new_from_preset (char *filename) { LVAVSPreset *preset = NULL; LVAVSPresetElement *element; LVAVSPresetContainer *cont; xmlDocPtr doc; xmlNodePtr cur; int i; doc = xmlParseFile(filename); if(doc == NULL) { return NULL; } cur = xmlDocGetRootElement (doc); if(!cur) { xmlFreeDoc(doc); fprintf(stderr, "No root element\n"); return NULL; } if(xmlStrcmp(cur->name, (const xmlChar *) "pipeline_preset") != 0) { xmlFreeDoc(doc); fprintf(stderr, "Bad opening node in preset file %s. Looking for 'pipeline_preset' but got '%s'.", filename, cur->name); return NULL; } preset = lvavs_preset_new (); preset->main = lvavs_preset_container_new(); VisParamContainer *pcont = visual_param_container_new(); visual_param_container_add_many(pcont, container_params); LVAVS_PRESET_ELEMENT(preset->main)->pcont = pcont; for (cur = cur->children; cur; cur = cur->next) { if(xmlStrcmp(cur->name, (const xmlChar *)"container_main") == 0) { xmlNodePtr child; LVAVSPresetContainer *cont = lvavs_preset_container_new(); LVAVS_PRESET_ELEMENT(cont)->pcont = pcont; visual_list_add(preset->main->members, cont); cont = lvavs_preset_container_from_xml_node(cont, cur); } if(xmlStrcmp(cur->name, (const xmlChar *)"params") == 0) { parse_element(cur, LVAVS_PRESET_ELEMENT(preset->main)); } } xmlFreeDoc (doc); return preset; }
std::vector<XMLElement_Ptr> XMLParser::parse_elements() { std::vector<XMLElement_Ptr> elements; XMLElement_Ptr element; while(element = parse_element()) { elements.push_back(element); } return elements; }
unsigned char *skip_table(unsigned char *html, unsigned char *eof) { int level = 1; unsigned char *name; int namelen; r: while (html < eof && (*html != '<' || parse_element(html, eof, &name, &namelen, NULL, &html))) html++; if (html >= eof) return eof; if (namelen == 5 && !casecmp(name, "TABLE", 5)) level++; if (namelen == 6 && !casecmp(name, "/TABLE", 6)) if (!--level) return html; goto r; }
bool window_part::parse(const char* str) { const char* p = str; m_index.clear(); parse_element(p); bool success = (*p == 0); if (!success) parse_reset(); split(); return success; }
void dicom_load(const char *path, dicom_t *dicom, char *out_buffer, int buffer_size) { FILE *in = fopen(path, "rb"); int state = 0; const char *uid_name; element_t element = { .buffer = out_buffer, .buffer_size = buffer_size, }; if (!parse_preamble(in)) { state |= STATE_IMPLICIT_VR; } while (true) { if (!parse_element(in, state, &element)) break; #define S(attr, tag_, v_) \ if (element.tag.v == tag_.v) \ dicom->attr = element.value.v_; S(instance_number, TAG_INSTANCE_NUMBER, is); S(slice_location, TAG_SLICE_LOCATION, ds); S(samples_per_pixel, TAG_SAMPLES_PER_PIXEL, us); S(rows, TAG_ROWS, us); S(columns, TAG_COLUMNS, us); S(bits_allocated, TAG_BITS_ALLOCATED, us); S(bits_stored, TAG_BITS_STORED, us); S(high_bit, TAG_HIGH_BIT, us); #undef S if (element.tag.v == TAG_PIXEL_DATA.v) dicom->data_size = element.length; if (element.tag.v == TAG_TRANSFER_SYNTAX_UID.v) { uid_name = get_uid_name(element.value.ui); if (uid_name && strstr(uid_name, "Implicit")) { state |= STATE_IMPLICIT_VR; } if (!streq(element.value.ui, "1.2.840.10008.1.2.1")) { LOG_E("format not supported: %s", uid_name); CHECK(false); } } } fclose(in); }
/** * \brief Load IPFIX elements * * \warning When function fails to load all elements, content of ipfix_group * will not be defined and should be destroyed using elements_destroy(). * \param[in] file_descriptor Opened file with XML specification of IPFIX elems. * \param[out] ipfix_groups Structure with elements description * \return 0 on success. Otherwise returns non-zero value. */ int elements_load(int file_descriptor, struct elem_groups *ipfix_groups) { // Create an iterator over IPFIX elements in XML document struct elem_xml_iter *iter = elem_iter_init(file_descriptor); if (!iter) { // Failed to init iterator return 1; } unsigned int count = 0; bool failed = false; xmlNodePtr node; // Iterate over all elements and fill structures while((node = elem_iter_next(iter)) != NULL) { ipfix_element_t *new_item = parse_element(node); if (!new_item) { // Failed to create new element description failed = true; break; } if (elem_add_element(ipfix_groups, new_item) != 0) { failed = true; break; } ++count; } elem_iter_destroy(iter); if (failed) { return 1; } elem_sort(ipfix_groups); if (elem_make_name_indexes(ipfix_groups)) { return 1; } if (elem_duplication_check(ipfix_groups)) { // Duplication found return 1; } // All elements successfully loaded MSG_INFO(msg_module, "Description of %u IPFIX elements loaded.", count); return 0; }
View* XmlParser::parse(const string& xml) { TiXmlDocument doc(xml); if (!doc.LoadFile()) { return NULL; } TiXmlElement *re = doc.RootElement(); if (!re) { return NULL; } return parse_element(re); }
END_TEST START_TEST(test_unfin_token) { char *token[13] = { "+hello ", "-err", "-err\r", ":5", ":5\r", "$5", "$5\r", "$5\r\n", "$5\r\nabc", "$5\r\nabcde\r", "*5", "*5\r", }; char *pos; size_t len; for (int i = 0; i < 10; i++) { struct element el; len = strlen(token[i]); buf_reset(buf); buf_write(buf, token[i], len); pos = buf->rpos; ck_assert_int_eq(parse_element(&el, buf), PARSE_EUNFIN); ck_assert(buf->rpos == pos); } for (int i = 10; i < 12; i++) { int64_t nelem; len = strlen(token[i]); buf_reset(buf); buf_write(buf, token[i], len); pos = buf->rpos; ck_assert_int_eq(token_array_nelem(&nelem, buf), PARSE_EUNFIN); ck_assert(buf->rpos == pos); } }
int main(int argc, char **argv) { char *line = NULL; char *tok; size_t len = 0; ssize_t read; int rtval; while((read = getline(&line, &len, stdin)) != -1) { if(0 == strcmp(line, "\n")) continue; tok = strtok(line, DELIMITERS); while(tok != NULL) { parse_element(tok); tok = strtok(NULL, DELIMITERS); } } printf("\n"); free(line); return 0; }
END_TEST START_TEST(test_nil_bulk) { #define NIL_BULK "$-1\r\n" size_t len = sizeof(NIL_BULK) - 1; struct element el_c, el_p; test_reset(); el_c.type = ELEM_NIL; ck_assert_int_eq(compose_element(&buf, &el_c), len); ck_assert_int_eq(buf_rsize(buf), len); ck_assert_int_eq(cc_bcmp(buf->rpos, NIL_BULK, len), 0); el_p.type = ELEM_UNKNOWN; ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK); ck_assert_int_eq(el_p.type, ELEM_NIL); #undef NIL_BULK }
View* XmlParser::parse_element(TiXmlElement *e, View *parent /* = NULL */) { if (!e) { return NULL; } View *view = ResourceCreator::instance().get_view(e->Value()); if (!view) { return NULL; } if (parent) { view->set_parent(parent); parent->push_child(view); } TiXmlAttribute *a = e->FirstAttribute(); PropMap props; while(a) { props.insert(make_pair(a->Name(), a->Value())); a = a->Next(); } view->parse(props); TiXmlNode *node = e->FirstChild(); if (!node) { return view; } TiXmlElement *sub = node->ToElement(); while (sub) { View* sv = parse_element(sub, view); sub = sub->NextSiblingElement(); } return view; }
void window_part::parse_reset() { const char* p = "."; parse_element(p); }
static bool parse_element(FILE *in, int state, element_t *out) { tag_t tag; element_t item; int length; char vr[3] = " "; char tmp_buff[128]; bool extra_len = false; int i; if (remain_size(in) == 0) return false; tag.group = READ(uint16_t, in); tag.element = READ(uint16_t, in); // The meta data is always in explicit form. if (tag.group == 0x0002) state &= ~STATE_IMPLICIT_VR; if (state & STATE_IMPLICIT_VR) { length = READ(uint32_t, in); // XXX: Handle this with a static table. if (tag.v == TAG_INSTANCE_NUMBER.v) sprintf(vr, "IS"); if (tag.v == TAG_SLICE_LOCATION.v) sprintf(vr, "DS"); if (tag.v == TAG_SAMPLES_PER_PIXEL.v) sprintf(vr, "US"); if (tag.v == TAG_ROWS.v) sprintf(vr, "US"); if (tag.v == TAG_COLUMNS.v) sprintf(vr, "US"); if (tag.v == TAG_BITS_ALLOCATED.v) sprintf(vr, "US"); if (tag.v == TAG_BITS_STORED.v) sprintf(vr, "US"); if (tag.v == TAG_HIGH_BIT.v) sprintf(vr, "US"); if (tag.v == TAG_PIXEL_DATA.v) sprintf(vr, "OB"); } else { fread(vr, 2, 1, in); for (i = 0; i < ARRAY_SIZE(EXTRA_LEN_VRS); i++) { if (strncmp(vr, EXTRA_LEN_VRS[i], 2) == 0) { extra_len = true; break; } } if (extra_len) { READ(uint16_t, in); // Reserved 2 bytes length = READ(uint32_t, in); } else { length = READ(uint16_t, in); } } LOG_V("(%.4x, %.4x) %s, length:%d", tag.group, tag.element, vr, length); // Read a sequence of undefined length. if (length == 0xffffffff && (streq(vr, "SQ") || streq(vr, "OW"))) { while (true) { parse_element(in, STATE_SEQUENCE_ITEM | STATE_IMPLICIT_VR, &item); if (item.tag.v == TAG_SEQ_DEL.v) { break; } if (item.tag.v != TAG_ITEM.v) LOG_E("Expected item tag"); } } if (state & STATE_SEQUENCE_ITEM && length == 0xffffffff) { while (true) { parse_element(in, 0, &item); if (item.tag.v == TAG_ITEM_DEL.v) { break; } } } if (out) { out->tag = tag; out->length = length; memcpy(out->vr, vr, 2); } // For the moment we just skip the data. if (length != 0xffffffff) { CHECK(length >= 0); if (length > remain_size(in)) { CHECK(false); } if (out && length == 2 && strncmp(vr, "US", 2) == 0) { out->value.us = READ(uint16_t, in); } else if (out && strncmp(vr, "IS", 2) == 0) { CHECK(length < sizeof(tmp_buff) - 1); fread(tmp_buff, length, 1, in); tmp_buff[length] = '\0'; sscanf(tmp_buff, "%d", &out->value.is); } else if (out && strncmp(vr, "DS", 2) == 0) { CHECK(length < sizeof(tmp_buff) - 1); fread(tmp_buff, length, 1, in); tmp_buff[length] = '\0'; sscanf(tmp_buff, "%f", &out->value.ds); } else if (out && strncmp(vr, "UI", 2) == 0) { CHECK(length < sizeof(out->value.ui) - 1); fread(out->value.ui, length, 1, in); out->value.ui[length] = '\0'; } else if (out && tag.v == TAG_PIXEL_DATA.v && out->buffer) { CHECK(out->buffer_size >= length); fread(out->buffer, length, 1, in); } else { // Skip the data. fseek(in, length, SEEK_CUR); } } if (tag.group == 0) return false; return true; }
static void parse(rapidxml::xml_node<>* node, configuration const& config, documentation& doc, bool member = false) { if (node != NULL) { bool recurse = false; bool is_member = member; std::string nodename = node->name(); if (nodename == "doxygen") { recurse = true; } else if (nodename == "sectiondef") { std::string kind = get_attribute(node, "kind"); if (kind == "func" || kind == "define" || kind == "enum" ) { recurse = true; } else if (boost::starts_with(kind, "public")) { recurse = true; is_member = true; } } else if (nodename == "compounddef") { std::string kind = get_attribute(node, "kind"); if (kind == "group") { recurse = true; } else if (kind == "struct") { recurse = true; doc.cos.is_class = false; parse_element(node->first_node(), config, "", doc.cos); } else if (kind == "class") { recurse = true; doc.cos.is_class = true; parse_element(node->first_node(), config, "", doc.cos); } } else if (nodename == "memberdef") { std::string kind = get_attribute(node, "kind"); if (kind == "function") { function f; parse_element(node->first_node(), config, "", f); parse_function(node->first_node(), config, "", f); if (member) { f.type = boost::equals(f.name, doc.cos.name) ? function_constructor : function_member; doc.cos.functions.push_back(f); } else { f.type = function_free; doc.functions.push_back(f); } } else if (kind == "define") { function f; f.type = function_define; parse_element(node->first_node(), config, "", f); parse_function(node->first_node(), config, "", f); doc.functions.push_back(f); } else if (kind == "enum") { enumeration e; parse_element(node->first_node(), config, "", e); parse_enumeration(node->first_node(), config, "", e); doc.enumerations.push_back(e); } else if (kind == "typedef") { if (boost::equals(get_attribute(node, "prot"), "public")) { std::string name = parse_named_node(node->first_node(), "name"); doc.cos.typedefs.push_back(base_element(name)); } } else if (kind == "variable") { if (boost::equals(get_attribute(node, "static"), "yes") && boost::equals(get_attribute(node, "mutable"), "no") && boost::equals(get_attribute(node, "prot"), "public")) { std::string name = parse_named_node(node->first_node(), "name"); doc.cos.variables.push_back(base_element(name)); } } } else if (nodename == "compoundname") { std::string name = node->value(); if (name.find("::") != std::string::npos) { doc.cos.fullname = name; // For a class, it should have "boost::something::" before // set its name without namespace doc.cos.name = keep_after(name, "::"); } } else if (nodename == "basecompoundref") { base_class bc; bc.name = node->value(); bc.derivation = get_attribute(node, "prot"); bc.virtuality = get_attribute(node, "virt"); doc.cos.base_classes.push_back(bc); } else { //std::cout << nodename << " ignored." << std::endl; } if (recurse) { // First recurse into childnodes, then handle next siblings parse(node->first_node(), config, doc, is_member); } parse(node->next_sibling(), config, doc, is_member); } }
static void parse_element(rapidxml::xml_node<>* node, configuration const& config, std::string const& parent, Element& el) { if (node != NULL) { std::string name = node->name(); std::string full = parent + "." + name; if (full == ".briefdescription.para") { parse_para(node, el.brief_description, el.skip); } else if (full == ".detaileddescription.para") { std::string para; parse_para(node, para, el.skip); if (!para.empty() && !el.detailed_description.empty()) { el.detailed_description += "\n\n"; } el.detailed_description += para; } else if (full == ".location") { std::string loc = get_attribute(node, "file"); // Location of (header)file. It is a FULL path, so find the start // and strip the rest std::size_t pos = loc.rfind(config.start_include); if (pos != std::string::npos) { loc = loc.substr(pos); } el.location = loc; el.line = atol(get_attribute(node, "line").c_str()); } else if (full == ".detaileddescription.para.qbk") { el.qbk_markup.push_back(markup(node->value())); } else if (full == ".detaileddescription.para.qbk.after.synopsis") { el.qbk_markup.push_back(markup(markup_after, markup_synopsis, node->value())); } else if (full == ".detaileddescription.para.qbk.before.synopsis") { el.qbk_markup.push_back(markup(markup_before, markup_synopsis, node->value())); } else if (full == ".detaileddescription.para.qbk.distinguish") { el.additional_description = node->value(); boost::trim(el.additional_description); } else if (full == ".templateparamlist") { parse_parameter_list(node->first_node(), el.template_parameters); } else if (full == ".detaileddescription.para.parameterlist") { std::string kind = get_attribute(node, "kind"); if (kind == "param") { parse_parameter_list(node->first_node(), el.parameters); } else if (kind == "templateparam") { parse_parameter_list(node->first_node(), el.template_parameters); } } parse_element(node->first_node(), config, full, el); parse_element(node->next_sibling(), config, parent, el); } }
struct table *parse_table(unsigned char *html, unsigned char *eof, unsigned char **end, struct rgb *bgcolor, int sh, struct s_e **bad_html, int *bhp) { int qqq; struct table *t; struct table_cell *cell; unsigned char *t_name, *t_attr, *en; int t_namelen; int x = 0, y = -1; int p = 0; unsigned char *lbhp = NULL; int l_al = AL_LEFT; int l_val = VAL_MIDDLE; int csp, rsp; int group = 0; int i, j, k; struct rgb l_col; int c_al = AL_TR, c_val = VAL_TR, c_width = W_AUTO, c_span = 0; memcpy(&l_col, bgcolor, sizeof(struct rgb)); *end = html; if (bad_html) { *bad_html = DUMMY; *bhp = 0; } if (!(t = new_table())) return NULL; se: en = html; see: html = en; if (bad_html && !p && !lbhp) { if (!(*bhp & (ALLOC_GR-1))) { if ((unsigned)*bhp > MAXINT / sizeof(struct s_e) - ALLOC_GR) overalloc(); *bad_html = mem_realloc(*bad_html, (*bhp + ALLOC_GR) * sizeof(struct s_e)); } lbhp = (*bad_html)[(*bhp)++].s = html; } while (html < eof && *html != '<') html++; if (html >= eof) { if (p) CELL(t, x, y)->end = html; if (lbhp) (*bad_html)[*bhp-1].e = html; goto scan_done; } if (html + 2 <= eof && (html[1] == '!' || html[1] == '?')) { html = skip_comment(html, eof); goto se; } if (parse_element(html, eof, &t_name, &t_namelen, &t_attr, &en)) { html++; goto se; } if (t_namelen == 5 && !casecmp(t_name, "TABLE", 5)) { en = skip_table(en, eof); goto see; } if (t_namelen == 6 && !casecmp(t_name, "/TABLE", 6)) { if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (p) CELL(t, x, y)->end = html; if (lbhp) (*bad_html)[*bhp-1].e = html; goto scan_done; } if (t_namelen == 8 && !casecmp(t_name, "COLGROUP", 8)) { if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; c_al = AL_TR; c_val = VAL_TR; c_width = W_AUTO; get_align(t_attr, &c_al); get_valign(t_attr, &c_val); get_c_width(t_attr, &c_width, sh); if ((c_span = get_num(t_attr, "span")) == -1) c_span = 1; goto see; } if (t_namelen == 9 && !casecmp(t_name, "/COLGROUP", 9)) { if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; c_span = 0; c_al = AL_TR; c_val = VAL_TR; c_width = W_AUTO; goto see; } if (t_namelen == 3 && !casecmp(t_name, "COL", 3)) { int sp, wi, al, val; if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; if ((sp = get_num(t_attr, "span")) == -1) sp = 1; wi = c_width; al = c_al; val = c_val; get_align(t_attr, &al); get_valign(t_attr, &val); get_c_width(t_attr, &wi, sh); new_columns(t, sp, wi, al, val, !!c_span); c_span = 0; goto see; } if (t_namelen == 3 && (!casecmp(t_name, "/TR", 3) || !casecmp(t_name, "/TD", 3) || !casecmp(t_name, "/TH", 3))) { if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (p) CELL(t, x, y)->end = html, p = 0; if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; } if (t_namelen == 2 && !casecmp(t_name, "TR", 2)) { if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (p) CELL(t, x, y)->end = html, p = 0; if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; if (group) group--; l_al = AL_LEFT; l_val = VAL_MIDDLE; memcpy(&l_col, bgcolor, sizeof(struct rgb)); get_align(t_attr, &l_al); get_valign(t_attr, &l_val); get_bgcolor(t_attr, &l_col); y++, x = 0; goto see; } if (t_namelen == 5 && ((!casecmp(t_name, "THEAD", 5)) || (!casecmp(t_name, "TBODY", 5)) || (!casecmp(t_name, "TFOOT", 5)))) { if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; group = 2; } if (t_namelen != 2 || (casecmp(t_name, "TD", 2) && casecmp(t_name, "TH", 2))) goto see; if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1); if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL; if (p) CELL(t, x, y)->end = html, p = 0; if (y == -1) y = 0, x = 0; nc: cell = new_cell(t, x, y); if (cell->used) { if (cell->colspan == -1) goto see; x++; goto nc; } cell->mx = x; cell->my = y; cell->used = 1; cell->start = en; p = 1; cell->align = l_al; cell->valign = l_val; if ((cell->b = upcase(t_name[1]) == 'H')) cell->align = AL_CENTER; if (group == 1) cell->group = 1; if (x < t->c) { if (t->cols[x].align != AL_TR) cell->align = t->cols[x].align; if (t->cols[x].valign != VAL_TR) cell->valign = t->cols[x].valign; } memcpy(&cell->bgcolor, &l_col, sizeof(struct rgb)); get_align(t_attr, &cell->align); get_valign(t_attr, &cell->valign); get_bgcolor(t_attr, &cell->bgcolor); if ((csp = get_num(t_attr, "colspan")) == -1) csp = 1; if (!csp) csp = -1; if ((rsp = get_num(t_attr, "rowspan")) == -1) rsp = 1; if (!rsp) rsp = -1; if (csp >= 0 && rsp >= 0 && csp * rsp > 100000) { if (csp > 10) csp = -1; if (rsp > 10) rsp = -1; } cell->colspan = csp; cell->rowspan = rsp; if (csp == 1) { int w = W_AUTO; get_c_width(t_attr, &w, sh); if (w != W_AUTO) set_td_width(t, x, w, 0); } qqq = t->x; for (i = 1; csp != -1 ? i < csp : x + i < qqq; i++) { struct table_cell *sc = new_cell(t, x + i, y); if (sc->used) { csp = i; for (k = 0; k < i; k++) CELL(t, x + k, y)->colspan = csp; break; } sc->used = sc->spanned = 1; sc->rowspan = rsp; sc->colspan = csp; sc->mx = x; sc->my = y; } qqq = t->y; for (j = 1; rsp != -1 ? j < rsp : y + j < qqq; j++) { for (k = 0; k < i; k++) { struct table_cell *sc = new_cell(t, x + k, y + j); if (sc->used) { int l, m; if (sc->mx == x && sc->my == y) continue; /*internal("boo");*/ for (l = 0; l < k; l++) memset(CELL(t, x + l, y + j), 0, sizeof(struct table_cell)); rsp = j; for (l = 0; l < i; l++) for (m = 0; m < j; m++) CELL(t, x + l, y + m)->rowspan = j; goto brk; } sc->used = sc->spanned = 1; sc->rowspan = rsp; sc->colspan = csp; sc->mx = x; sc->my = y; } } brk: goto see; scan_done: *end = html; for (x = 0; x < t->x; x++) for (y = 0; y < t->y; y++) { struct table_cell *c = CELL(t, x, y); if (!c->spanned) { if (c->colspan == -1) c->colspan = t->x - x; if (c->rowspan == -1) c->rowspan = t->y - y; } } if ((unsigned)t->y > MAXINT / sizeof(int)) overalloc(); t->r_heights = mem_alloc(t->y * sizeof(int)); memset(t->r_heights, 0, t->y * sizeof(int)); for (x = 0; x < t->c; x++) if (t->cols[x].width != W_AUTO) set_td_width(t, x, t->cols[x].width, 1); set_td_width(t, t->x, W_AUTO, 0); return t; }
void html_textarea(struct html_context *html_context, unsigned char *attr, unsigned char *html, unsigned char *eof, unsigned char **end) { struct form_control *fc; unsigned char *p, *t_name, *wrap_attr; int t_namelen; int cols, rows; int i; html_focusable(html_context, attr); while (html < eof && (*html == '\n' || *html == '\r')) html++; p = html; while (p < eof && *p != '<') { pp: p++; } if (p >= eof) { *end = eof; return; } if (parse_element(p, eof, &t_name, &t_namelen, NULL, end)) goto pp; if (c_strlcasecmp(t_name, t_namelen, (const unsigned char *)"/TEXTAREA", 9)) goto pp; fc = init_form_control(FC_TEXTAREA, attr, html_context); if (!fc) return; fc->id = get_attr_val(attr, (unsigned char *)"id", html_context->doc_cp); fc->name = get_attr_val(attr, (unsigned char *)"name", html_context->doc_cp); fc->default_value = convert_string(NULL, html, p - html, html_context->doc_cp, CSM_DEFAULT, NULL, NULL, NULL); for (p = fc->default_value; p && p[0]; p++) { /* FIXME: We don't cope well with entities here. Bugzilla uses * inside of textarea and we fail miserably upon that * one. --pasky */ if (p[0] == '\r') { if (p[1] == '\n' || (p > fc->default_value && p[-1] == '\n')) { memmove(p, p + 1, strlen((const char *)p)); p--; } else { p[0] = '\n'; } } } cols = get_num(attr, (unsigned char *)"cols", html_context->doc_cp); if (cols <= 0) cols = html_context->options->default_form_input_size; cols++; /* Add 1 column, other browsers may have different behavior here (mozilla adds 2) --Zas */ if (cols > html_context->options->box.width) cols = html_context->options->box.width; fc->cols = cols; rows = get_num(attr, (unsigned char *)"rows", html_context->doc_cp); if (rows <= 0) rows = 1; if (rows > html_context->options->box.height) rows = html_context->options->box.height; fc->rows = rows; html_context->options->needs_height = 1; wrap_attr = get_attr_val(attr, (unsigned char *)"wrap", html_context->doc_cp); if (wrap_attr) { if (!c_strcasecmp((const char *)wrap_attr, "hard") || !c_strcasecmp((const char *)wrap_attr, "physical")) { fc->wrap = FORM_WRAP_HARD; } else if (!c_strcasecmp((const char *)wrap_attr, "soft") || !c_strcasecmp((const char *)wrap_attr, "virtual")) { fc->wrap = FORM_WRAP_SOFT; } else if (!c_strcasecmp((const char *)wrap_attr, "none") || !c_strcasecmp((const char *)wrap_attr, "off")) { fc->wrap = FORM_WRAP_NONE; } mem_free(wrap_attr); } else if (has_attr(attr, (unsigned char *)"nowrap", html_context->doc_cp)) { fc->wrap = FORM_WRAP_NONE; } else { fc->wrap = FORM_WRAP_SOFT; } fc->maxlength = get_num(attr, (unsigned char *)"maxlength", html_context->doc_cp); if (fc->maxlength == -1) fc->maxlength = INT_MAX; if (rows > 1) ln_break(html_context, 1); else put_chrs(html_context, (unsigned char *)" ", 1); html_stack_dup(html_context, ELEMENT_KILLABLE); format.form = fc; format.style.attr |= AT_BOLD; for (i = 0; i < rows; i++) { int j; for (j = 0; j < cols; j++) put_chrs(html_context, (unsigned char *)"_", 1); if (i < rows - 1) ln_break(html_context, 1); } pop_html_element(html_context); if (rows > 1) ln_break(html_context, 1); else put_chrs(html_context, (unsigned char *)" ", 1); html_context->special_f(html_context, SP_CONTROL, fc); }
END_TEST /* * request */ START_TEST(test_quit) { #define QUIT "quit" #define SERIALIZED "*1\r\n$4\r\n" QUIT "\r\n" #define INVALID "*2\r\n$4\r\n" QUIT "\r\n$3\r\nnow\r\n" int ret; struct element *el; test_reset(); req->type = REQ_QUIT; el = array_push(req->token); el->type = ELEM_BULK; el->bstr = (struct bstring){sizeof(QUIT) - 1, QUIT}; ret = compose_req(&buf, req); ck_assert_int_eq(ret, sizeof(SERIALIZED) - 1); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0); el->type = ELEM_UNKNOWN; /* this effectively resets *el */ request_reset(req); ck_assert_int_eq(parse_req(req, buf), PARSE_OK); ck_assert_int_eq(req->type, REQ_QUIT); ck_assert_int_eq(req->token->nelem, 1); el = array_first(req->token); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(cc_bcmp(el->bstr.data, QUIT, sizeof(QUIT) - 1), 0); /* invalid number of arguments */ test_reset(); buf_write(buf, INVALID, sizeof(INVALID) - 1); ck_assert_int_eq(parse_req(req, buf), PARSE_EINVALID); #undef INVALID #undef SERIALIZED #undef QUIT } END_TEST START_TEST(test_ping) { #define PING "ping" #define VAL "hello" #define S_PING "*1\r\n$4\r\n" PING "\r\n" #define S_ECHO "*2\r\n$4\r\n" PING "\r\n$5\r\nhello\r\n" int ret; struct element *el; test_reset(); /* simple ping */ buf_write(buf, S_PING, sizeof(S_PING) - 1); ck_assert_int_eq(parse_req(req, buf), PARSE_OK); ck_assert_int_eq(req->type, REQ_PING); /* ping as echo */ test_reset(); req->type = REQ_PING; el = array_push(req->token); el->type = ELEM_BULK; el->bstr = (struct bstring){sizeof(PING) - 1, PING}; el = array_push(req->token); el->type = ELEM_BULK; el->bstr = (struct bstring){sizeof(VAL) - 1, VAL}; ret = compose_req(&buf, req); ck_assert_int_eq(ret, sizeof(S_ECHO) - 1); ck_assert_int_eq(cc_bcmp(buf->rpos, S_ECHO, ret), 0); el->type = ELEM_UNKNOWN; /* resets *el */ request_reset(req); ck_assert_int_eq(parse_req(req, buf), PARSE_OK); ck_assert_int_eq(req->type, REQ_PING); ck_assert_int_eq(req->token->nelem, 2); el = array_first(req->token); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(cc_bcmp(el->bstr.data, PING, sizeof(PING) - 1), 0); el = array_get(req->token, 1); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(cc_bcmp(el->bstr.data, VAL, sizeof(VAL) - 1), 0); #undef S_ECHO #undef ECHO #undef S_PING #undef QUIT } END_TEST START_TEST(test_unfin_req) { char *token[4] = { "*2\r\n", "*2\r\n$3\r\n", "*2\r\n$3\r\nfoo\r\n", "*2\r\n$3\r\nfoo\r\n$3\r\n", }; for (int i = 0; i < 4; i++) { char *pos; size_t len; len = strlen(token[i]); buf_reset(buf); buf_write(buf, token[i], len); pos = buf->rpos; ck_assert_int_eq(parse_req(req, buf), PARSE_EUNFIN); ck_assert(buf->rpos == pos); } } END_TEST /* * response */ START_TEST(test_ok) { #define OK "OK" #define SERIALIZED "+" OK "\r\n" int ret; struct element *el; test_reset(); rsp->type = ELEM_STR; el = array_push(rsp->token); el->type = ELEM_STR; el->bstr = (struct bstring){sizeof(OK) - 1, OK}; ret = compose_rsp(&buf, rsp); ck_assert_int_eq(ret, sizeof(SERIALIZED) - 1); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0); el->type = ELEM_UNKNOWN; /* resets *el */ response_reset(rsp); ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_OK); ck_assert_int_eq(rsp->type, ELEM_STR); ck_assert_int_eq(rsp->token->nelem, 1); el = array_first(rsp->token); ck_assert_int_eq(el->type, ELEM_STR); ck_assert_int_eq(cc_bcmp(el->bstr.data, OK, sizeof(OK) - 1), 0); #undef SERIALIZED #undef OK } END_TEST START_TEST(test_array_reply) { #define SERIALIZED "*5\r\n:-10\r\n$-1\r\n-ERR invalid arg\r\n+foo\r\n$5\r\nHELLO\r\n" size_t len = sizeof(SERIALIZED) - 1; struct element *el; test_reset(); buf_write(buf, SERIALIZED, len); ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_OK); ck_assert_int_eq(rsp->type, ELEM_ARRAY); ck_assert_int_eq(rsp->token->nelem, 5); el = array_first(rsp->token); ck_assert_int_eq(el->type, ELEM_INT); el = array_get(rsp->token, 1); ck_assert_int_eq(el->type, ELEM_NIL); el = array_get(rsp->token, 2); ck_assert_int_eq(el->type, ELEM_ERR); el = array_get(rsp->token, 3); ck_assert_int_eq(el->type, ELEM_STR); el = array_get(rsp->token, 4); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(el->bstr.len, 5); ck_assert_int_eq(cc_bcmp(el->bstr.data, "HELLO", 5), 0); ck_assert_int_eq(buf_rsize(buf), 0); ck_assert_int_eq(compose_rsp(&buf, rsp), len); ck_assert_int_eq(buf_rsize(buf), len); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, len), 0); #undef SERIALIZED } END_TEST /* * edge cases */ START_TEST(test_empty_buf) { struct element el; test_reset(); ck_assert(!token_is_array(buf)); ck_assert_int_eq(parse_element(&el, buf), PARSE_EUNFIN); ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_EUNFIN); ck_assert_int_eq(parse_req(req, buf), PARSE_EUNFIN); } END_TEST /* * request/response pool */ START_TEST(test_req_pool_basic) { #define POOL_SIZE 10 int i; struct request *reqs[POOL_SIZE]; request_options_st options = { .request_ntoken = {.type = OPTION_TYPE_UINT, .val.vuint = REQ_NTOKEN}, .request_poolsize = {.type = OPTION_TYPE_UINT, .val.vuint = POOL_SIZE}}; request_setup(&options, NULL); for (i = 0; i < POOL_SIZE; i++) { reqs[i] = request_borrow(); ck_assert_msg(reqs[i] != NULL, "expected to borrow a request"); } ck_assert_msg(request_borrow() == NULL, "expected request pool to be depleted"); for (i = 0; i < POOL_SIZE; i++) { request_return(&reqs[i]); ck_assert_msg(reqs[i] == NULL, "expected request to be nulled after return"); } request_teardown(); #undef POOL_SIZE } END_TEST START_TEST(test_rsp_pool_basic) { #define POOL_SIZE 10 int i; struct response *rsps[POOL_SIZE]; response_options_st options = { .response_ntoken = {.type = OPTION_TYPE_UINT, .val.vuint = RSP_NTOKEN}, .response_poolsize = {.type = OPTION_TYPE_UINT, .val.vuint = POOL_SIZE}}; response_setup(&options, NULL); for (i = 0; i < POOL_SIZE; i++) { rsps[i] = response_borrow(); ck_assert_msg(rsps[i] != NULL, "expected to borrow a response"); } ck_assert_msg(response_borrow() == NULL, "expected response pool to be depleted"); for (i = 0; i < POOL_SIZE; i++) { response_return(&rsps[i]); ck_assert_msg(rsps[i] == NULL, "expected response to be nulled after return"); } response_teardown(); #undef POOL_SIZE } END_TEST /* * test suite */ static Suite * redis_suite(void) { Suite *s = suite_create(SUITE_NAME); /* token */ TCase *tc_token = tcase_create("token"); suite_add_tcase(s, tc_token); tcase_add_test(tc_token, test_simple_string); tcase_add_test(tc_token, test_error); tcase_add_test(tc_token, test_integer); tcase_add_test(tc_token, test_bulk_string); tcase_add_test(tc_token, test_array); tcase_add_test(tc_token, test_nil_bulk); tcase_add_test(tc_token, test_unfin_token); /* basic requests */ TCase *tc_request = tcase_create("request"); suite_add_tcase(s, tc_request); tcase_add_test(tc_request, test_quit); tcase_add_test(tc_request, test_ping); tcase_add_test(tc_request, test_unfin_req); /* basic responses */ TCase *tc_response = tcase_create("response"); suite_add_tcase(s, tc_response); tcase_add_test(tc_response, test_ok); tcase_add_test(tc_response, test_array_reply); /* edge cases */ TCase *tc_edge = tcase_create("edge cases"); suite_add_tcase(s, tc_edge); tcase_add_test(tc_edge, test_empty_buf); /* req/rsp objects, pooling */ TCase *tc_pool = tcase_create("request/response pool"); suite_add_tcase(s, tc_pool); tcase_add_test(tc_pool, test_req_pool_basic); tcase_add_test(tc_pool, test_rsp_pool_basic); return s; } /* TODO(yao): move main to a different file, keep most test files main-less */ int main(void) { int nfail; /* setup */ test_setup(); Suite *suite = redis_suite(); SRunner *srunner = srunner_create(suite); srunner_set_log(srunner, DEBUG_LOG); srunner_run_all(srunner, CK_ENV); /* set CK_VEBOSITY in ENV to customize */ nfail = srunner_ntests_failed(srunner); srunner_free(srunner); /* teardown */ test_teardown(); return (nfail == 0) ? EXIT_SUCCESS : EXIT_FAILURE; }
int eeprom(int argc, char *argv[]) { int i, len, ret; unsigned char buf[58], *p; struct eth_device dev = { .iobase = CONFIG_SMC91111_BASE }; app_startup(argv); if (get_version() != XF_VERSION) { printf("Wrong XF_VERSION.\n"); printf("Application expects ABI version %d\n", XF_VERSION); printf("Actual U-Boot ABI version %d\n", (int)get_version()); return 1; } return crcek(); if ((SMC_inw (&dev, BANK_SELECT) & 0xFF00) != 0x3300) { printf("SMSC91111 not found.\n"); return 2; } /* Called without parameters - print MAC address */ if (argc < 2) { verify_macaddr(&dev, NULL); return 0; } /* Print help message */ if (argv[1][1] == 'h') { printf("VoiceBlue EEPROM writer\n"); printf("Built: %s at %s\n", U_BOOT_DATE, U_BOOT_TIME); printf("Usage:\n\t<mac_address> [<element_1>] [<...>]\n"); return 0; } /* Try to parse information elements */ len = sizeof(buf); p = buf; for (i = 2; i < argc; i++) { ret = parse_element(argv[i], p, len); switch (ret) { case -1: printf("Element %d: malformed\n", i - 1); return 3; case -2: printf("Element %d: odd character count\n", i - 1); return 3; case -3: printf("Out of EEPROM memory\n"); return 3; default: p += ret; len -= ret; } } /* First argument (MAC) is mandatory */ set_mac(&dev, argv[1]); if (verify_macaddr(&dev, argv[1])) { printf("*** MAC address does not match! ***\n"); return 4; } while (len--) *p++ = 0; write_data(&dev, (u16 *)buf, sizeof(buf) >> 1); return 0; }
/* * Prepares a template file. */ static apr_status_t parse_template (parser_rec *p) { apr_status_t status; apr_finfo_t finfo; apr_file_t *file; apr_size_t size; /* read file */ if ((status = apr_stat(&finfo, p->filename, APR_FINFO_SIZE, p->pool)) != APR_SUCCESS) { p->err = apr_psprintf(p->pool, "file '%s' does not exist", p->filename); return status; } if ((status = apr_file_open(&file, p->filename, APR_READ, 0, p->pool)) != APR_SUCCESS) { p->err = apr_psprintf(p->pool, "file '%s' cannot be opened", p->filename); return status; } apr_pool_cleanup_register(p->pool, file, file_close, apr_pool_cleanup_null); p->buf = apr_palloc(p->pool, finfo.size + 1); size = finfo.size; if ((status = apr_file_read(file, p->buf, &size)) != APR_SUCCESS) { p->err = apr_psprintf(p->pool, "file '%s' cannot be read", p->filename); return status; } if ((status = apr_file_close(file)) != APR_SUCCESS) { p->err = apr_psprintf(p->pool, "file '%s' cannot be closed", p->filename); return status; } apr_pool_cleanup_kill(p->pool, file, file_close); p->buf[size] = '\0'; /* no parse? */ if ((p->flags & TEMPLATE_FPARSE) == 0) { p->pos = p->buf + size; p->begin = p->buf; parse_raw(p); return APR_SUCCESS; } /* process elements and substitution, treat all else as raw */ p->pos = p->buf; p->begin = p->pos; while (*p->pos != '\0') { switch (*p->pos) { case '<': if ((p->pos[1] == 'l' && p->pos[2] == ':') || (p->pos[1] == '/' && p->pos[2] == 'l' && p->pos[3] == ':')) { parse_raw(p); if ((status = parse_element(p)) != APR_SUCCESS) { return status; } p->begin = p->pos; } else { p->pos++; } break; case '$': switch (p->pos[1]) { case '{': case '[': parse_raw(p); if ((status = parse_sub(p)) != APR_SUCCESS) { return status; } p->begin = p->pos; break; case '$': p->pos++; parse_raw(p); p->pos++; p->begin = p->pos; break; default: p->pos++; } break; default: p->pos++; } } parse_raw(p); return APR_SUCCESS; }
static void do_html_select(unsigned char *attr, unsigned char *html, unsigned char *eof, unsigned char **end, struct html_context *html_context) { struct conv_table *ct = (struct conv_table *)html_context->special_f(html_context, SP_TABLE, NULL); struct form_control *fc; struct string lbl = NULL_STRING, orig_lbl = NULL_STRING; unsigned char **values = NULL; unsigned char **labels; unsigned char *name, *t_attr, *en; int namelen; int nnmi = 0; int order = 0; int preselect = -1; int group = 0; int i, max_width; int closing_tag; html_focusable(html_context, attr); init_menu(&lnk_menu); se: en = html; see: html = en; while (html < eof && *html != '<') html++; if (html >= eof) { abort: *end = html; if (lbl.source) done_string(&lbl); if (orig_lbl.source) done_string(&orig_lbl); if (values) { int j; for (j = 0; j < order; j++) mem_free_if(values[j]); mem_free(values); } destroy_menu(&lnk_menu); *end = en; return; } if (lbl.source) { unsigned char *q, *s = en; int l = html - en; while (l && isspace(s[0])) s++, l--; while (l && isspace(s[l-1])) l--; q = convert_string(ct, s, l, html_context->options->cp, CSM_DEFAULT, NULL, NULL, NULL); if (q) add_to_string(&lbl, q), mem_free(q); add_bytes_to_string(&orig_lbl, s, l); } if (html + 2 <= eof && (html[1] == '!' || html[1] == '?')) { html = skip_comment(html, eof); goto se; } if (parse_element(html, eof, &name, &namelen, &t_attr, &en)) { html++; goto se; } if (!namelen) goto see; if (name[0] == '/') { namelen--; if (!namelen) goto see; name++; closing_tag = 1; } else { closing_tag = 0; } if (closing_tag && !c_strlcasecmp(name, namelen, (const unsigned char *)"SELECT", 6)) { add_select_item(&lnk_menu, &lbl, &orig_lbl, values, order, nnmi); goto end_parse; } if (!c_strlcasecmp(name, namelen, (const unsigned char *)"OPTION", 6)) { add_select_item(&lnk_menu, &lbl, &orig_lbl, values, order, nnmi); if (!closing_tag) { unsigned char *value, *label; if (has_attr(t_attr, (unsigned char *)"disabled", html_context->doc_cp)) goto see; if (preselect == -1 && has_attr(t_attr, (unsigned char *)"selected", html_context->doc_cp)) preselect = order; value = get_attr_val(t_attr, (unsigned char *)"value", html_context->doc_cp); if (!mem_align_alloc(&values, order, order + 1, 0xFF)) goto abort; values[order++] = value; label = get_attr_val(t_attr, (unsigned char *)"label", html_context->doc_cp); if (label) new_menu_item(&lnk_menu, label, order - 1, 0); if (!value || !label) { init_string(&lbl); init_string(&orig_lbl); nnmi = !!label; } } goto see; } if (!c_strlcasecmp(name, namelen, (const unsigned char *)"OPTGROUP", 8)) { add_select_item(&lnk_menu, &lbl, &orig_lbl, values, order, nnmi); if (group) new_menu_item(&lnk_menu, NULL, -1, 0), group = 0; if (!closing_tag) { unsigned char *label; label = get_attr_val(t_attr, (unsigned char *)"label", html_context->doc_cp); if (!label) { label = stracpy((const unsigned char *)""); if (!label) goto see; } new_menu_item(&lnk_menu, label, -1, 0); group = 1; } } goto see; end_parse: *end = en; if (!order) goto abort; labels = (unsigned char **)mem_calloc(order, sizeof(unsigned char *)); if (!labels) goto abort; fc = init_form_control(FC_SELECT, attr, html_context); if (!fc) { mem_free(labels); goto abort; } fc->id = get_attr_val(attr, (unsigned char *)"id", html_context->doc_cp); fc->name = get_attr_val(attr, (unsigned char *)"name", html_context->doc_cp); fc->default_state = preselect < 0 ? 0 : preselect; fc->default_value = order ? stracpy(values[fc->default_state]) : stracpy((const unsigned char *)""); fc->nvalues = order; fc->values = values; fc->menu = detach_menu(&lnk_menu); fc->labels = labels; menu_labels(fc->menu, (unsigned char *)"", labels); put_chrs(html_context, (unsigned char *)"[", 1); html_stack_dup(html_context, ELEMENT_KILLABLE); format.form = fc; format.style.attr |= AT_BOLD; max_width = 0; for (i = 0; i < order; i++) { if (!labels[i]) continue; #ifdef CONFIG_UTF8 if (html_context->options->utf8) int_lower_bound(&max_width, utf8_ptr2cells(labels[i], NULL)); else #endif /* CONFIG_UTF8 */ int_lower_bound(&max_width, strlen((const char *)labels[i])); } for (i = 0; i < max_width; i++) put_chrs(html_context, (unsigned char *)"_", 1); pop_html_element(html_context); put_chrs(html_context, (unsigned char *)"]", 1); html_context->special_f(html_context, SP_CONTROL, fc); }
void html_option(struct html_context *html_context, unsigned char *a, unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5) { struct form_control *fc; unsigned char *val; if (!format.select) return; val = get_attr_val(a, (unsigned char *)"value", html_context->doc_cp); if (!val) { struct string str; unsigned char *p, *r; unsigned char *name; int namelen; for (p = a - 1; *p != '<'; p--); if (!init_string(&str)) goto end_parse; if (parse_element(p, html_context->eoff, NULL, NULL, NULL, &p)) { INTERNAL("parse element failed"); val = str.source; goto end_parse; } se: while (p < html_context->eoff && isspace(*p)) p++; while (p < html_context->eoff && !isspace(*p) && *p != '<') { sp: add_char_to_string(&str, *p ? *p : ' '), p++; } r = p; val = str.source; /* Has to be before the possible 'goto end_parse' */ while (r < html_context->eoff && isspace(*r)) r++; if (r >= html_context->eoff) goto end_parse; if (r - 2 <= html_context->eoff && (r[1] == '!' || r[1] == '?')) { p = skip_comment(r, html_context->eoff); goto se; } if (parse_element(r, html_context->eoff, &name, &namelen, NULL, &p)) goto sp; if (namelen < 6) goto se; if (name[0] == '/') name++, namelen--; if (c_strlcasecmp(name, namelen, (const unsigned char *)"OPTION", 6) && c_strlcasecmp(name, namelen, (const unsigned char *)"SELECT", 6) && c_strlcasecmp(name, namelen, (const unsigned char *)"OPTGROUP", 8)) goto se; } end_parse: fc = init_form_control(FC_CHECKBOX, a, html_context); if (!fc) { mem_free_if(val); return; } fc->id = get_attr_val(a, (unsigned char *)"id", html_context->doc_cp); fc->name = null_or_stracpy(format.select); fc->default_value = val; fc->default_state = has_attr(a, (unsigned char *)"selected", html_context->doc_cp); fc->mode = has_attr(a, (unsigned char *)"disabled", html_context->doc_cp) ? FORM_MODE_DISABLED : format.select_disabled; put_chrs(html_context, (unsigned char *)" ", 1); html_stack_dup(html_context, ELEMENT_KILLABLE); format.form = fc; format.style.attr |= AT_BOLD; put_chrs(html_context, (unsigned char *)"[ ]", 3); pop_html_element(html_context); put_chrs(html_context, (unsigned char *)" ", 1); html_context->special_f(html_context, SP_CONTROL, fc); }