char *tmp_start; // start of work area
char *tmp_end; // end of work area
short standalone; // non-zero if <?xml standalone="yes"?>
- char err[V3_XML_ERRL]; // error string
};
static char * empty_attrib_list[] = { NULL }; // empty, null terminated array of strings
new_buf = V3_Malloc(new_size);
if (new_buf == NULL) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in tmp_realloc in xml\n");
return NULL;
}
}
// set an error string and return root
-static void v3_xml_err(struct v3_xml_root * root, char * xml_str, const char * err, ...) {
- va_list ap;
+static void v3_xml_err(struct v3_xml_root * root, char * xml_str, const char * err, const char *arg) {
int line = 1;
char * tmp;
- char fmt[V3_XML_ERRL];
for (tmp = root->tmp_start; tmp < xml_str; tmp++) {
if (*tmp == '\n') {
}
}
- snprintf(fmt, V3_XML_ERRL, "[error near line %d]: %s", line, err);
-
- va_start(ap, err);
- vsnprintf(root->err, V3_XML_ERRL, fmt, ap);
- va_end(ap);
-
- PrintError("XML Error: %s\n", root->err);
-
+ PrintError(VM_NONE, VCORE_NONE, "XML Error: [error near line %d]: %s (%s)", line, err ,arg ? arg : "");
+
// free memory
v3_xml_free(&(root->xml));
return NULL; // found default
}
-// same as v3_xml_get but takes an already initialized va_list
-static struct v3_xml * v3_xml_vget(struct v3_xml * xml, va_list ap) {
- char * name = va_arg(ap, char *);
- int idx = -1;
-
- if ((name != NULL) && (*name != 0)) {
- idx = va_arg(ap, int);
- xml = v3_xml_child(xml, name);
- }
- return (idx < 0) ? xml : v3_xml_vget(v3_xml_idx(xml, idx), ap);
-}
-// Traverses the xml tree to retrieve a specific subtag. Takes a variable
-// length list of tag names and indexes. The argument list must be terminated
-// by either an index of -1 or an empty string tag name. Example:
-// title = v3_xml_get(library, "shelf", 0, "book", 2, "title", -1);
-// This retrieves the title of the 3rd book on the 1st shelf of library.
-// Returns NULL if not found.
-struct v3_xml * v3_xml_get(struct v3_xml * xml, ...) {
- va_list ap;
- struct v3_xml * r;
-
- va_start(ap, xml);
- r = v3_xml_vget(xml, ap);
- va_end(ap);
- return r;
-}
// sets a flag for the given tag and returns the tag
char * tmp = NULL;
tmp = V3_Malloc((l = strlen(xml->txt)) + len);
+
+ if (!tmp) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml char content\n");
+ return ;
+ }
+
strcpy(tmp, xml->txt);
xml->txt = tmp;
}
if ( (root->cur == NULL) ||
(root->cur->name == NULL) ||
(strcasecmp(name, root->cur->name))) {
- v3_xml_err(root, s, "unexpected closing tag </%s>", name);
+ v3_xml_err(root, s, "unexpected closing tag", name);
return -1;
}
static struct v3_xml * v3_xml_new(const char * name) {
struct v3_xml_root * root = (struct v3_xml_root *)V3_Malloc(sizeof(struct v3_xml_root));
+
+ if (!root) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml_new\n");
+ return NULL;
+ }
+
memset(root, 0, sizeof(struct v3_xml_root));
root->xml.name = (char *)name;
root->cur = &root->xml;
root->xml.txt = "";
- memset(root->err, 0, V3_XML_ERRL);
return &root->xml;
}
child = (struct v3_xml *)V3_Malloc(sizeof(struct v3_xml));
+
+ if (!child) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml_add_child\n");
+ return NULL;
+ }
+
memset(child, 0, sizeof(struct v3_xml));
child->name = (char *)name;
char ** attr;
int attr_idx;
+ if (buf==NULL) {
+ return NULL;
+ }
+
+ if (root==NULL) {
+ return NULL;
+ }
+
root->str_ptr = buf;
if (len == 0) {
- v3_xml_err(root, NULL, "Empty XML String\n");
+ v3_xml_err(root, NULL, "Empty XML String", 0);
return NULL;
}
}
if (*buf == '\0') {
- v3_xml_err(root, buf, "root tag missing");
+ v3_xml_err(root, buf, "root tag missing", 0);
return NULL;
}
// new tag
if (root->cur == NULL) {
- v3_xml_err(root, tag_ptr, "markup outside of root element");
+ v3_xml_err(root, tag_ptr, "markup outside of root element", 0);
return NULL;
}
((attr_cnt * (2 * sizeof(char *))) +
(2 * sizeof(char *))));
+ if (!attr) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot reallocate in xml parse string\n");
+ return NULL;
+ }
+
attr[last_idx] = tmp_realloc(attr[last_idx - 2],
attr_cnt,
(attr_cnt + 1));
+
+ if (!attr[last_idx]) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot reallocate in xml parse string\n");
+ return NULL;
+ }
+
} else {
attr = V3_Malloc(4 * sizeof(char *));
+ if (!attr) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml parse string\n");
+ return NULL;
+ }
attr[last_idx] = V3_Malloc(2);
+ if (!attr[last_idx]) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot alloocate in xml parse string\n");
+ return NULL;
+ }
}
attr[attr_idx] = buf; // set attribute name
// null terminate attribute val
*(buf++) = '\0';
} else {
+ char err_buf[2] = {quote_char,0};
+
v3_xml_free_attr(attr);
- v3_xml_err(root, tag_ptr, "missing %c", quote_char);
+ v3_xml_err(root, tag_ptr, "missing quote char", err_buf);
return NULL;
}
if (attr_idx > 0) {
v3_xml_free_attr(attr);
}
- v3_xml_err(root, tag_ptr, "missing >");
+ v3_xml_err(root, tag_ptr, "missing >", 0);
return NULL;
}
v3_xml_open_tag(root, tag_ptr, attr);
if (attr_idx > 0) {
v3_xml_free_attr(attr);
}
- v3_xml_err(root, tag_ptr, "missing >");
+ v3_xml_err(root, tag_ptr, "missing >", 0);
return NULL;
}
} else if (*buf == '/') {
quote_char = *buf;
if ((*buf == '\0') && (last_char != '>')) {
- v3_xml_err(root, tag_ptr, "missing >");
+ v3_xml_err(root, tag_ptr, "missing >", 0);
return NULL;
}
if ( ((buf = strstr(buf + 3, "--")) == 0) ||
((*(buf += 2) != '>') && (*buf)) ||
((!*buf) && (last_char != '>'))) {
- v3_xml_err(root, tag_ptr, "unclosed <!--");
+ v3_xml_err(root, tag_ptr, "unclosed <!--", 0);
return NULL;
}
} else if (! strncmp(buf, "![CDATA[", 8)) {
if ((buf = strstr(buf, "]]>"))) {
v3_xml_char_content(root, tag_ptr + 8, (buf += 2) - tag_ptr - 10, 'c');
} else {
- v3_xml_err(root, tag_ptr, "unclosed <![CDATA[");
+ v3_xml_err(root, tag_ptr, "unclosed <![CDATA[", 0);
return NULL;
}
} else {
- v3_xml_err(root, tag_ptr, "unexpected <");
+ v3_xml_err(root, tag_ptr, "unexpected <",0);
return NULL;
}
- if (! buf || ! *buf) {
+ // at this point, buf cannot be NULL
+ if (!*buf) {
break;
}
if (root->cur == NULL) {
return &root->xml;
} else if (root->cur->name == NULL) {
- v3_xml_err(root, tag_ptr, "root tag missing");
+ v3_xml_err(root, tag_ptr, "root tag missing",0);
return NULL;
} else {
- v3_xml_err(root, tag_ptr, "unclosed tag <%s>", root->cur->name);
+ v3_xml_err(root, tag_ptr, "unclosed tag", root->cur->name);
return NULL;
}
}
str_len = strlen(buf);
xml_buf = (char *)V3_Malloc(str_len + 1);
+
+ if (!xml_buf) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml parse\n");
+ return NULL;
+ }
+
strcpy(xml_buf, buf);
return parse_str(xml_buf, str_len);
// first attribute
xml->attr = V3_Malloc(4 * sizeof(char *));
+ if (!xml->attr) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml set attr\n");
+ return NULL;
+ }
+
// empty list of malloced names/vals
xml->attr[1] = strdup("");
+
+ if (!xml->attr[1]) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot strdup in xml set attr\n");
+ return NULL;
+ }
+
} else {
xml->attr = tmp_realloc(xml->attr, l * sizeof(char *), (l + 4) * sizeof(char *));
+
+ if (!xml->attr) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot reallocate in xml set attr\n");
+ return NULL;
+ }
}
// set attribute name
strlen(xml->attr[l + 1]),
(c = strlen(xml->attr[l + 1])) + 2);
+
+ if (!xml->attr[l + 3]) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot reallocate in xml set attr\n");
+ return NULL;
+ }
+
// set name/value as not malloced
strcpy(xml->attr[l + 3] + c, " ");
*len += sprintf(*s + *len, "</%s>", xml->name); // close tag
- while (txt[off] && off < xml->off) off++; // make sure off is within bounds
+ while (off < xml->off && txt[off]) off++; // make sure off is within bounds
return (xml->ordered) ? toxml_r(xml->ordered, s, len, max, off)
: ampencode(txt + off, -1, s, len, max, 0);
}
struct v3_xml * o = (xml) ? xml->ordered : NULL;
struct v3_xml_root * root = (struct v3_xml_root *)xml;
size_t len = 0, max = V3_XML_BUFSIZE;
- char *s = strcpy(V3_Malloc(max), "");
+ char *s = V3_Malloc(max);
+
+ if (!s) {
+ PrintError(VM_NONE, VCORE_NONE, "Cannot allocate in xml tostrr\n");
+ return NULL;
+ }
+
+ strcpy(s, "");
if (! xml || ! xml->name) return tmp_realloc(s, max, len + 1);
while (root->xml.parent) root = (struct v3_xml_root *)root->xml.parent; // root tag
