lib/eggdrop/xmlread.c File Reference

#include <eggdrop/eggdrop.h>
#include <errno.h>

Go to the source code of this file.

Functions
int	xml_parse_children (xml_node_t *parent, char **bufptr)
static int	skip_space (char **bufptr)
static void	copy_text (char **ptr, int *ptrlen, int *ptrmax, char *str, int len)
char *	xml_entity_lookup (const char *name)
int	xml_decode_text (char *text, int len, char **outtext, int *outlen)
static void	append_text (xml_node_t *node, char *text, int len, int decode)
static char *	read_name (char **bufptr)
static char *	read_value (char **bufptr)
static void	read_attributes (xml_node_t *node, char **bufptr)
int	xml_parse_node (xml_node_t *parent, char **bufptr)
xml_node_t *	xml_parse_file (const char *fname)
Variables
static const char *	name_terminators = "= \t\n\r?/>"
static xml_entity_t	entities []
static int	nentities = 5

---

Function Documentation

static void append_text	(	xml_node_t *	node,
		char *	text,
		int	len,
		int	decode
	)			[static]

Definition at line 84 of file xmlread.c.

References xml_node::len, xml_node::text, and xml_decode_text().

Referenced by xml_parse_children(), and xml_parse_node().

{
  char *finaltext;
  int finallen;

  if (decode) xml_decode_text(text, len, &finaltext, &finallen);
  else {
    finaltext = text;
    finallen = len;
  }

  node->text = realloc(node->text, node->len + finallen + 1);
  memcpy(node->text + node->len, finaltext, finallen);
  node->len += finallen;
  node->text[node->len] = 0;

  if (finaltext != text) free(finaltext);
}

static void copy_text	(	char **	ptr,
		int *	ptrlen,
		int *	ptrmax,
		char *	str,
		int	len
	)			[static]

Definition at line 27 of file xmlread.c.

Referenced by xml_decode_text().

{
  if (*ptrlen + len + 1 > *ptrmax) {
    *ptrmax = *ptrlen + len + 64;
    *ptr = realloc(*ptr, *ptrmax);
  }
  memcpy(*ptr + *ptrlen, str, len);
  *ptrlen += len;
}

static void read_attributes	(	xml_node_t *	node,
		char **	bufptr
	)			[static]

Definition at line 142 of file xmlread.c.

References read_name(), read_value(), skip_space(), xml_attr_new(), and xml_node_append_attr().

Referenced by xml_parse_node().

{
  xml_attr_t *attr;
  char *name, *value;

  while (1) {
    skip_space(bufptr);
    name = read_name(bufptr);
    if (!name || **bufptr != '=') {
      if (name) free(name);
      return;
    }
    (*bufptr)++;
    value = read_value(bufptr);
    attr = xml_attr_new(name, value);
    xml_node_append_attr(node, attr);
  }
}

static char* read_name

(

char **

bufptr

)

[static]

Definition at line 103 of file xmlread.c.

References name_terminators, and NULL.

Referenced by read_attributes(), and xml_parse_node().

{
  int n;
  char *name;

  n = strcspn(*bufptr, name_terminators);
  if (!n) return NULL;
  name = malloc(n+1);
  memcpy(name, *bufptr, n);
  name[n] = 0;
  *bufptr += n;
  return(name);
}

static char* read_value

(

char **

bufptr

)

[static]

Definition at line 117 of file xmlread.c.

References name_terminators.

Referenced by read_attributes().

{
  const char *term;
  char *value;
  int n;

  if (**bufptr == '\'') term = "'";
  else if (**bufptr == '"') term = "\"";
  else {
    term = name_terminators;
    (*bufptr)--;
  }

  /* Skip past first quote. */
  (*bufptr)++;
  n = strcspn(*bufptr, term);
  value = malloc(n+1);
  memcpy(value, *bufptr, n);
  value[n] = 0;

  if (term != name_terminators) n++;
  *bufptr += n;
  return(value);
}

static int skip_space

(

char **

bufptr

)

[static]

Definition at line 17 of file xmlread.c.

References start.

Referenced by read_attributes(), xml_decode_text(), and xml_parse_node().

{
  char *start, *ptr;

  start = ptr = *bufptr;
  while (isspace(*ptr)) ptr++;
  *bufptr = ptr;
  return(ptr - start);
}

int xml_decode_text	(	char *	text,
		int	len,
		char **	outtext,
		int *	outlen
	)

Definition at line 57 of file xmlread.c.

References copy_text(), skip_space(), and xml_entity_lookup().

Referenced by append_text().

{
  char *amp, *colon, *entity;
  int outmax, amplen;

  *outlen = 0;
  outmax = len+1;
  *outtext = malloc(outmax);

  len -= skip_space(&text);

  while ((amp = memchr(text, '&', len))) {
    amplen = amp - text;
    colon = memchr(amp, ';', len - amplen);
    if (!colon) break;
    copy_text(outtext, outlen, &outmax, text, amplen);
    len -= (colon+1 - text);
    text = colon+1;
    *colon = 0;
    entity = xml_entity_lookup(amp+1);
    if (entity) copy_text(outtext, outlen, &outmax, entity, strlen(entity));
  }
  while (len > 0 && isspace(text[len-1])) len--;
  copy_text(outtext, outlen, &outmax, text, len);
  return(0);
}

char* xml_entity_lookup

(

const char *

name

)

Definition at line 37 of file xmlread.c.

References nentities, and NULL.

Referenced by xml_decode_text().

{
  int i, num;
  static char numcode[2] = {0, 0};

  /* See if it's a hex code. */
  if (*name == '#') {
    name++;
    if (*name == 'x') num = strtol(name+1, NULL, 16);
    else num = strtol(name, NULL, 10);
    numcode[0] = num;
    return(numcode);
  }

  for (i = 0; i < nentities; i++) {
    if (!strcasecmp(entities[i].name, name)) return(entities[i].value);
  }
  return(NULL);
}

int xml_parse_children	(	xml_node_t *	parent,
		char **	bufptr
	)

Definition at line 280 of file xmlread.c.

References append_text(), and xml_parse_node().

Referenced by xml_parse_file(), and xml_parse_node().

{
  char *ptr, *buf = *bufptr;
  int ret;

  do {
    ptr = strchr(buf, '<');
    if (!ptr) {
      append_text(parent, buf, strlen(buf), 1);
      return(0);
    }

    /* Append the intervening text to the parent. */
    append_text(parent, buf, ptr - buf, 1);
    buf = ptr;

    ret = xml_parse_node(parent, &buf);
    *bufptr = buf;
  } while (ret == 1);
  return(ret);
}

xml_node_t* xml_parse_file

(

const char *

fname

)

Definition at line 302 of file xmlread.c.

References NULL, xml_node::type, XML_DOCUMENT, xml_node_new(), xml_parse_children(), xml_root_element(), and xml_set_error().

Referenced by channel_load(), config_load(), help_lookup_entry(), help_parse_file(), and user_load().

{
  FILE *fp;
  xml_node_t *root;
  char *buf, *ptr;
  int len;

  fp = fopen(fname, "r");
  if (!fp) {
    xml_set_error(strerror(errno));
    return(NULL);
  }
  fseek(fp, 0l, SEEK_END);
  len = ftell(fp);
  fseek(fp, 0l, SEEK_SET);
  buf = malloc(len+1);
  if (!buf) {
    fclose(fp);
    xml_set_error("out of memory");
    return(NULL);
  }
  len = fread(buf, 1, len, fp);
  buf[len] = '\0';
  fclose(fp);
  root = xml_node_new();
  root->type = XML_DOCUMENT;
  ptr = buf;
  xml_parse_children(root, &ptr);
  free(buf);
  return xml_root_element(root);
}

int xml_parse_node	(	xml_node_t *	parent,
		char **	bufptr
	)

Definition at line 162 of file xmlread.c.

References append_text(), xml_node::name, read_attributes(), read_name(), skip_space(), xml_node::type, XML_COMMENT, XML_ELEMENT, xml_node_append(), xml_node_free(), xml_node_new(), xml_parse_children(), XML_PROCESSING_INSTRUCTION, and xml_set_error().

Referenced by xml_parse_children().

{
  xml_node_t *node;
  char *ptr, *buf = *bufptr;

  if (*buf++ != '<') return(-1);
  skip_space(&buf);

  /* Is it a closing tag? (returns 0) */
  if (*buf == '/') {
    char *name;

    if (!parent->name) return(-1);

    buf++;
    name = read_name(&buf);
    if (strcasecmp(name, parent->name)) {
      free(name);
      xml_set_error("closing tag doesn't match opening tag");
      return(-1);
    }
    free(name);

    ptr = strchr(buf, '>');
    if (!ptr) return(-1);
    *bufptr = ptr+1;
    return(0);
  }

  /* Figure out what type of node this is. */
  if (!strncmp(buf, "!--", 3)) {
    /* A comment. */
    buf += 3;
    ptr = strstr(buf, "-->");
    if (!ptr) {
      xml_set_error("comment has no end");
      return(-1);
    }

    node = xml_node_new();
    node->type = XML_COMMENT;
    append_text(node, buf, ptr-buf, 1);
    xml_node_append(parent, node);
    *bufptr = ptr+3;
    return(1);
  }
  else if (!strncasecmp(buf, "![CDATA[", 8)) {
    /* CDATA section. */
    buf += 7;
    ptr = strstr(buf, "]]>");
    if (!ptr) {
      xml_set_error("CDATA has no end");
      return(-1);
    }

    append_text(parent, buf, ptr-buf, 0);
    *bufptr = ptr+3;
    return(1);
  }
  else if (!strncasecmp(buf, "!DOCTYPE", 8)) {
    /* XXX Incorrect doctype parsing, fix later. */
    buf += 8;
    ptr = strchr(buf, '>');
    if (!ptr) return(-1);
    *bufptr = ptr+1;
    return(1);
  }
  else if (*buf == '?') {
    /* Processing instruction. */
    buf++;
    skip_space(&buf);
    node = xml_node_new();
    node->type = XML_PROCESSING_INSTRUCTION;
  }
  else {
    /* Otherwise, try it as a normal node. */
    node = xml_node_new();
    node->type = XML_ELEMENT;
  }

  node->name = read_name(&buf);
  read_attributes(node, &buf);
  if (node->type == XML_PROCESSING_INSTRUCTION) {
    if (strncmp(buf, "?>", 2)) {
      xml_node_free(node);
      xml_set_error("invalid processing instruction");
      return(-1);
    }
    xml_node_append(parent, node);
    *bufptr = buf+2;
    return(1);
  }

  /* Is it an empty tag? */
  if (!strncmp(buf, "/>", 2)) {
    xml_node_append(parent, node);
    *bufptr = buf+2;
    return(1);
  }
  else if (*buf != '>') {
    xml_set_error("invalid tag");
    return(-1);
  }

  /* Move past the '>'. */
  buf++;
  if (xml_parse_children(node, &buf) != -1) {
    *bufptr = buf;
    xml_node_append(parent, node);
    return(1);
  }

  /* Error reading children. */
  xml_node_free(node);
  return(-1);
}

---

Variable Documentation

xml_entity_t entities[] [static]

Initial value:

 {
  {"lt", "<"},
  {"gt", ">"},
  {"amp", "&"},
  {"apos", "'"},
  {"quot", "\""}
}

Definition at line 8 of file xmlread.c.

const char* name_terminators = "= \t\n\r?/>" [static]

Definition at line 4 of file xmlread.c.

Referenced by read_name(), and read_value().

int nentities = 5 [static]

Definition at line 15 of file xmlread.c.

Referenced by xml_entity_lookup().