genx4r 0.04

data/ext/genx4r/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config("genx4r");
+
+create_makefile("genx4r");

data/ext/genx4r/genx.c

@@ -0,0 +1,1940 @@
+/*
+ * Copyright (c) 2004 by Tim Bray and Sun Microsystems.  For copying
+ *  permission, see http://www.tbray.org/ongoing/genx/COPYING
+ */
+
+#define GENX_VERSION "beta5"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "genx.h"
+
+#define Boolean int
+#define True 1
+#define False 0
+#define STRLEN_XMLNS_COLON 6
+
+
+/*******************************
+ * writer state
+ */
+typedef enum
+{
+  SEQUENCE_NO_DOC,
+  SEQUENCE_PRE_DOC,
+  SEQUENCE_POST_DOC,
+  SEQUENCE_START_TAG,
+  SEQUENCE_ATTRIBUTES,
+  SEQUENCE_CONTENT
+} writerSequence;
+
+/*******************************
+ * generic pointer list
+ */
+typedef struct
+{
+  genxWriter writer;
+  int        count;
+  int        space;
+  void * *   pointers;
+} plist;
+
+/*******************************
+ * text collector, for attribute values
+ */
+typedef struct
+{
+  utf8 buf;
+  int  used;
+  int  space;
+} collector;
+
+/*******************************
+ * Structs with opaquely-exposed handles
+ */
+
+/*
+ * This one's tricky, to handle stacking namespaces
+ *  'declaration' is the current attribute which would be used to
+ *    declare the currently-effective prefix
+ *  'defDeclaration' is a appropriate declaration when this is being
+ *    used with the default prefix as passed to genxDeclareNamespace
+ *  baroque is true if this namespace has been used with more than one
+ *   prefix, or is the default namespace but has been unset
+ */
+struct genxNamespace_rec
+{
+  genxWriter 	writer;
+  utf8       	name;
+  int           declCount;
+  Boolean       baroque;
+  genxAttribute declaration;
+  genxAttribute defaultDecl;
+};
+
+struct genxElement_rec
+{
+  genxWriter 	writer;
+  utf8       	type;
+  genxNamespace ns;
+};
+
+typedef enum
+{
+  ATTR_NSDECL,
+  ATTR_NAKED,
+  ATTR_PREFIXED 
+} attrType;
+
+struct genxAttribute_rec
+{
+  genxWriter 	writer;
+  utf8       	name;
+  genxNamespace ns;
+  collector     value;
+  int           provided;   /* provided for current element? */
+  attrType      atype;
+};
+
+/*******************************
+ * genx's sandbox
+ */
+struct genxWriter_rec
+{
+  FILE *       	  	   file;
+  genxSender *    	   sender;
+  genxStatus   	  	   status;
+  writerSequence  	   sequence;
+  char            	   xmlChars[0x10000];
+  void *          	   userData;
+  int             	   nextPrefix;
+  utf8                     empty;
+  Boolean                  defaultNsDeclared;
+  genxAttribute            xmlnsEquals;
+  genxElement              nowStarting;
+  plist           	   namespaces;
+  plist           	   elements;
+  plist           	   attributes;
+  plist                    prefixes;
+  plist           	   stack;   
+  struct genxAttribute_rec arec;
+  char *                   etext[100];
+  void *       		(* alloc)(void * userData, int bytes);
+  void         		(* dealloc)(void * userData, void * data);
+};
+
+/*******************************
+ * Forward declarations
+ */
+static genxAttribute declareAttribute(genxWriter w, genxNamespace ns,
+				      constUtf8 name, constUtf8 valuestr,
+				      genxStatus * statusP);
+static genxStatus addNamespace(genxNamespace ns, utf8 prefix);
+static genxStatus unsetDefaultNamespace(genxWriter w);
+static genxStatus addAttribute(genxAttribute a, constUtf8 valuestr);
+void genxSetCharProps(char * p);
+
+/*******************************
+ * End of declarations
+ */
+
+/*******************************
+ * private memory utilities
+ */
+static void * allocate(genxWriter w, int bytes)
+{
+  if (w->alloc)
+    return (void *) (*w->alloc)(w->userData, bytes);
+  else
+    return (void *) malloc(bytes);
+}
+
+static void deallocate(genxWriter w, void * data)
+{
+  if (w->dealloc)
+    (*w->dealloc)(w->userData, data);
+  else if (w->alloc == NULL)
+    free(data);
+}
+
+static utf8 copy(genxWriter w, constUtf8 from)
+{
+  utf8 temp;
+
+  if ((temp = (utf8) allocate(w, strlen((const char *) from) + 1)) == NULL)
+    return NULL;
+  strcpy((char *) temp, (const char *) from);
+  return temp;
+}
+
+static genxStatus initCollector(genxWriter w, collector * c)
+{
+  c->space = 100;
+  if ((c->buf = (utf8) allocate(w, c->space)) == NULL)
+    return GENX_ALLOC_FAILED;
+  c->used = 0;
+  return GENX_SUCCESS;
+}
+
+static genxStatus growCollector(genxWriter w, collector * c, int size)
+{
+  utf8 newSpace; 
+
+  c->space = size * 2;
+  if ((newSpace = (utf8) allocate(w, c->space)) == NULL)
+    return GENX_ALLOC_FAILED;
+
+  strncpy((char *) newSpace, (const char *) c->buf, c->used);
+  newSpace[c->used] = 0;
+  deallocate(w, c->buf);
+  c->buf = newSpace;
+  return GENX_SUCCESS;
+}
+
+static void startCollect(collector * c)
+{
+  c->used = 0;
+}
+static void endCollect(collector * c)
+{
+  c->buf[c->used] = 0;
+}
+
+static genxStatus collectString(genxWriter w, collector * c, constUtf8 string)
+{
+  int sl = strlen((const char *) string);
+
+  if (sl >= c->space)
+    if ((w->status = growCollector(w, c, sl)) != GENX_SUCCESS)
+      return GENX_ALLOC_FAILED;
+
+  strcpy((char *) c->buf, (const char *) string);
+  return GENX_SUCCESS;
+}
+
+#define collectPiece(w,c,d,size) {if (((c)->used+(size))>=(c)->space){if (((w)->status=growCollector(w,c,(c)->used+(size)))!=GENX_SUCCESS) return (w)->status;}strncpy((char *)(c)->buf+(c)->used,d,size);(c)->used+=size;}
+
+/*******************************
+ * private list utilities
+ */
+static genxStatus initPlist(genxWriter w, plist * pl)
+{
+  pl->writer = w;
+  pl->count = 0;
+  pl->space = 10;
+  pl->pointers = (void * *) allocate(w, pl->space * sizeof(void *));
+  if (pl->pointers == NULL)
+    return GENX_ALLOC_FAILED;
+  
+  return GENX_SUCCESS;
+}
+
+/*
+ * make room in a plist
+ */
+static Boolean checkExpand(plist * pl)
+{
+  void * * newlist;
+  int i;
+
+  if (pl->count < pl->space)
+    return True;
+
+  pl->space *= 2;
+  newlist = (void * *) allocate(pl->writer, pl->space * sizeof(void *));
+  if (newlist == NULL)
+    return False;
+  for (i = 0; i < pl->count; i++)
+    newlist[i] = pl->pointers[i];
+  deallocate(pl->writer, pl->pointers); 
+  pl->pointers = newlist;
+
+  return True;
+}
+
+/*
+ * stick something on the end of a plist
+ */
+static genxStatus listAppend(plist * pl, void * pointer)
+{
+  if (!checkExpand(pl))
+    return GENX_ALLOC_FAILED;
+
+  pl->pointers[pl->count++] = pointer;
+  return GENX_SUCCESS;
+}
+
+/*
+ * insert in place, shuffling up
+ */
+static genxStatus listInsert(plist * pl, void * pointer, int at)
+{
+  int i;
+
+  if (!checkExpand(pl))
+    return GENX_ALLOC_FAILED;
+
+  for (i = pl->count; i > at; i--)
+    pl->pointers[i] = pl->pointers[i - 1];
+  pl->count++;
+
+  pl->pointers[at] = pointer;
+  return GENX_SUCCESS;
+}
+
+/*******************************
+ * list lookups
+ */
+
+static genxNamespace findNamespace(plist * pl, constUtf8 uri)
+{
+  int i;
+  genxNamespace * nn = (genxNamespace *) pl->pointers;
+
+  for (i = 0; i < pl->count; i++)
+    if (strcmp((char *) uri, (const char *) nn[i]->name) == 0)
+      return nn[i];
+
+  return NULL;
+}
+
+static genxElement findElement(plist * pl, constUtf8 xmlns, constUtf8 type)
+{
+  int i;
+  genxElement * ee = (genxElement *) pl->pointers;
+
+  for (i = 0; i < pl->count; i++)
+  {
+    if (xmlns == NULL)
+    {
+      if (ee[i]->ns == NULL && strcmp((const char *) type,
+				      (const char *) ee[i]->type) == 0)
+	return ee[i];
+    }
+    else
+    {
+      if (ee[i]->ns != NULL &&
+	  strcmp((const char *) xmlns, (const char *) ee[i]->ns->name) == 0 &&
+	  strcmp((const char *) type, (const char *) ee[i]->type) == 0)
+	return ee[i];
+    }
+  }
+
+  return NULL;
+}
+
+/*
+ * store & intern a prefix, after giving it the
+ *  "xmlns:" prefix.  Don't allow storing the same one twice unless 'force'
+ *  is set.
+ */
+static utf8 storePrefix(genxWriter w, constUtf8 prefix, Boolean force)
+{
+  int high, low;
+  utf8 * pp = (utf8 *) w->prefixes.pointers;
+  unsigned char buf[1024];
+
+  if (prefix[0] == 0)
+    prefix = (utf8) "xmlns";
+  else
+  {
+    sprintf((char *) buf, "xmlns:%s", prefix);
+    prefix = buf;
+  }
+
+  high = w->prefixes.count; low = -1;
+  while (high - low > 1)
+  {
+    int probe = (high + low) / 2;
+    if (strcmp((const char *) prefix, (const char *) pp[probe]) < 0)
+      high = probe;
+    else
+      low = probe;
+  }
+
+  /* already there? */
+  if (low != -1 && strcmp((const char *) prefix, (const char *) pp[low]) == 0)
+  {
+    if (force)
+      return pp[low];
+
+    w->status = GENX_DUPLICATE_PREFIX;
+    return NULL;
+  }
+
+  /* copy & insert */
+  if ((prefix = copy(w, prefix)) == NULL)
+  {
+    w->status = GENX_ALLOC_FAILED;
+    return NULL;
+  }
+  
+  w->status = listInsert(&w->prefixes, (void *) prefix, high);
+  if (w->status != GENX_SUCCESS)
+    return NULL;
+
+  return (utf8) prefix;
+}
+
+/*******************************
+ * UTF8 bit-banging
+ */
+
+/*
+ * Retrieve the character pointed at, and advance the pointer; return -1 on
+ *  error
+ */
+int genxNextUnicodeChar(constUtf8 * sp)
+{
+  utf8 s = (utf8) *sp;
+  int c;
+
+  if (*s == 0)
+    return -1;
+
+  if (*s < 0x80)
+    c = *s++;
+
+  /* all this encoding sanity-checking taken from section 3.10 of Unicode 4 */
+  else if (*s < 0xc2)
+    goto malformed;
+
+  /* 2-byte encodings, first byte c2 .. df */
+  else if (*s < 0xe0) 
+  {
+    c = (*s++ & 0x1f) << 6;
+
+    /*
+     * for this common idiom, if ((c & 0xc0) != 0x80) is slightly faster
+     *  on MacOS (PPC)
+     */
+    if (*s < 0x80 || *s > 0xbf)
+      goto malformed;
+
+    c |= *s++ & 0x3f;
+  }
+
+  /* 3-byte encodings, first byte e0 .. ef */
+  else if (*s < 0xf0)
+  {
+    int b0 = *s;
+    c = (*s++ & 0x0f) << 12;
+
+    if ((b0 == 0xe0 && (*s < 0xa0 || *s > 0xbf)) ||
+	(b0 <  0xed && (*s < 0x80 || *s > 0xbf)) ||
+	(b0 == 0xed && (*s < 0x80 || *s > 0x9f)) ||
+	(b0  > 0xed && (*s < 0x80 || *s > 0xbf)))
+      goto malformed;
+
+    c |= (*s++ & 0x3f) << 6;
+
+    if (*s < 0x80 || *s > 0xbf)
+      goto malformed;
+
+    c |= *s++ & 0x3f;
+  }
+
+  /* 4-byte encodings, first byte f0 .. f4 */
+  else if (*s < 0xf5)
+  {
+    int b0 = *s;
+    c = (*s++ & 0x07) << 18;
+
+    if ((b0 == 0xf0 && (*s < 0x90 || *s > 0xbf)) ||
+	(b0 <  0xf4 && (*s < 0x80 || *s > 0xbf)) ||
+	(b0 >= 0xf4 && (*s < 0x80 || *s > 0x8f)))
+      goto malformed;
+
+    c |= (*s++ & 0x3f) << 12;
+
+    if (*s < 0x80 || *s > 0xbf)
+      goto malformed;
+
+    c |= (*s++ & 0x3f) << 6;
+
+    if (*s < 0x80 || *s > 0xbf)
+      goto malformed;
+
+    c |= *s++ & 0x3f;
+  }
+  else
+    goto malformed;
+
+  *sp = s;
+  return c;
+
+  /*
+   * this is needed by scrubText, which wants to get the pointer moved
+   *  past the problem area.
+   */
+malformed:
+  if (*s)
+    ++s;
+  *sp = s;
+  return -1;
+}
+
+static Boolean isXMLChar(genxWriter w, int c)
+{
+  if (c < 0)
+    return False;
+  else if (c < 0x10000)
+    return (int) w->xmlChars[c];
+  else
+    return (c <= 0x10ffff);
+}
+
+static Boolean isLetter(genxWriter w, int c)
+{
+  if (c < 0 || c > 0xffff)
+    return False;
+  else
+    return w->xmlChars[c] & GENX_LETTER;
+}
+
+static Boolean isNameChar(genxWriter w, int c)
+{
+  if (c < 0 || c > 0xffff)
+    return False;
+  else
+    return w->xmlChars[c] & GENX_NAMECHAR;
+}
+
+/*******************************
+ * Constructors, setters/getters
+ */
+
+/*
+ * Construct a new genxWriter
+ */
+genxWriter genxNew(void * (* alloc)(void * userData, int bytes),
+		   void (* dealloc)(void * userData, void * data),
+		   void * userData)
+{
+  genxWriter w;
+  genxNamespace xml;
+
+  if (alloc)
+    w = (genxWriter) (*alloc)(userData, sizeof(struct genxWriter_rec));
+  else
+    w = (genxWriter) malloc(sizeof(struct genxWriter_rec));
+
+  if (w == NULL)
+    return NULL;
+
+  w->status = GENX_SUCCESS;
+  w->alloc = alloc;
+  w->dealloc = dealloc;
+  w->userData = userData;
+  w->sequence = SEQUENCE_NO_DOC;
+
+  if (initPlist(w, &w->namespaces) != GENX_SUCCESS ||
+      initPlist(w, &w->elements) != GENX_SUCCESS ||
+      initPlist(w, &w->attributes) != GENX_SUCCESS ||
+      initPlist(w, &w->prefixes) != GENX_SUCCESS ||
+      initPlist(w, &w->stack) != GENX_SUCCESS)
+    return NULL;
+
+  if ((w->status = initCollector(w, &w->arec.value)) != GENX_SUCCESS)
+    return NULL;
+
+  if ((w->empty = copy(w, (utf8) "")) == NULL)
+  {
+    w->status = GENX_ALLOC_FAILED;
+    return NULL;
+  }
+
+  w->xmlnsEquals = declareAttribute(w, NULL, (utf8) "xmlns", NULL, &w->status);
+  if (w->xmlnsEquals == NULL || w->status != GENX_SUCCESS)
+    return NULL;
+  w->defaultNsDeclared = False;
+
+  w->nextPrefix = 1;
+
+  genxSetCharProps(w->xmlChars);
+
+  w->etext[GENX_SUCCESS] = "Success";
+  w->etext[GENX_BAD_UTF8] = "Bad UTF8";
+  w->etext[GENX_NON_XML_CHARACTER] = "Non XML Character";
+  w->etext[GENX_BAD_NAME] = "Bad NAME";
+  w->etext[GENX_ALLOC_FAILED] = "Memory allocation failed";
+  w->etext[GENX_BAD_NAMESPACE_NAME] = "Bad namespace name";
+  w->etext[GENX_INTERNAL_ERROR] = "Internal error";
+  w->etext[GENX_DUPLICATE_PREFIX] = "Duplicate prefix";
+  w->etext[GENX_SEQUENCE_ERROR] = "Call out of sequence";
+  w->etext[GENX_NO_START_TAG] = "No Start-tag for EndElement call";
+  w->etext[GENX_IO_ERROR] = "I/O error";
+  w->etext[GENX_MISSING_VALUE] = "Missing attribute value";
+  w->etext[GENX_MALFORMED_COMMENT] = "Malformed comment body";
+  w->etext[GENX_MALFORMED_PI] = "?> in PI";
+  w->etext[GENX_XML_PI_TARGET] = "Target of PI matches [xX][mM][lL]";
+  w->etext[GENX_DUPLICATE_ATTRIBUTE] =
+    "Same attribute specified more than once";
+  w->etext[GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE] =
+    "Attribute cannot be in default namespace";
+  w->etext[GENX_DUPLICATE_NAMESPACE] =
+    "Declared namespace twice with different prefixes on one element.";
+  w->etext[GENX_BAD_DEFAULT_DECLARATION] =
+    "Declared a default namespace on an element which is in no namespace";
+
+  /* the xml: namespace is pre-wired */
+  xml = genxDeclareNamespace(w, (utf8) "http://www.w3.org/XML/1998/namespace",
+			     (utf8) "xml", &w->status);
+  if (xml == NULL)
+    return NULL;
+  xml->declCount = 1;
+  xml->declaration = xml->defaultDecl;
+
+  return w;
+}
+
+/*
+ * get/set userData
+ */
+void genxSetUserData(genxWriter w, void * userData)
+{
+  w->userData = userData;
+}
+void * genxGetUserData(genxWriter w)
+{
+  return w->userData;
+}
+
+/*
+ * get/set allocator
+ */
+void genxSetAlloc(genxWriter w, void * (* alloc)(void * userData, int bytes))
+{
+  w->alloc = alloc;
+}
+void genxSetDealloc(genxWriter w,
+		    void (* dealloc)(void * userData, void * data))
+{
+  w->dealloc = dealloc;
+}
+void * (* genxGetAlloc(genxWriter w))(void * userData, int bytes)
+{
+  return w->alloc;
+}
+void (* genxGetDealloc(genxWriter w))(void * userData, void * data)
+{
+  return w->dealloc;
+}
+
+/*
+ * Clean up
+ */
+void genxDispose(genxWriter w)
+{
+  int i;
+  genxNamespace * nn = (genxNamespace *) w->namespaces.pointers;
+  genxElement * ee = (genxElement *) w->elements.pointers;
+  genxAttribute * aa = (genxAttribute *) w->attributes.pointers;
+  utf8 * pp = (utf8 *) w->prefixes.pointers;
+
+  for (i = 0; i < w->namespaces.count; i++)
+  {
+    deallocate(w, nn[i]->name);
+    deallocate(w, nn[i]);
+  }
+
+  for (i = 0; i < w->elements.count; i++)
+  {
+    deallocate(w, ee[i]->type);
+    deallocate(w, ee[i]);
+  }
+
+  for (i = 0; i < w->attributes.count; i++)
+  {
+    deallocate(w, aa[i]->name);
+    deallocate(w, aa[i]->value.buf);
+    deallocate(w, aa[i]);
+  }
+
+  for(i = 0; i < w->prefixes.count; i++)
+    deallocate(w, pp[i]);
+
+  deallocate(w, w->namespaces.pointers);
+  deallocate(w, w->elements.pointers);
+  deallocate(w, w->attributes.pointers);
+  deallocate(w, w->prefixes.pointers);
+  deallocate(w, w->stack.pointers);
+
+  deallocate(w, w->arec.value.buf);
+
+  deallocate(w, w->empty);
+
+  /* how Oscar dealt with Igli */
+  deallocate(w, w);
+}
+
+/*******************************
+ * External utility routines
+ */
+
+/*
+ * scan a buffer and report problems with UTF-8 encoding or non-XML characters
+ */
+genxStatus genxCheckText(genxWriter w, constUtf8 s)
+{
+  while (*s)
+  {
+    int c = genxNextUnicodeChar(&s);
+    if (c == -1)
+      return GENX_BAD_UTF8;
+
+    if (!isXMLChar(w, c))
+      return GENX_NON_XML_CHARACTER;
+  }
+  return GENX_SUCCESS;
+}
+
+/*
+ * Purify some text
+ */
+int genxScrubText(genxWriter w, constUtf8 in, utf8 out)
+{
+  int problems = 0;
+  constUtf8 last = in;
+
+  while (*in)
+  {
+    int c = genxNextUnicodeChar(&in);
+    if (c == -1)
+    {
+      problems++;
+      last = in;
+      continue;
+    }
+
+    if (!isXMLChar(w, c))
+    {
+      problems++;
+      last = in;
+      continue;
+    }
+
+    while (last < in)
+      *out++ = *last++;
+  }
+  *out = 0;
+  return problems;
+}
+
+/*
+ * check one character
+ */
+int genxCharClass(genxWriter w, int c)
+{
+  int ret = 0;
+
+  if (isXMLChar(w, c))
+    ret |= GENX_XML_CHAR;
+  if (isNameChar(w, c))
+    ret |= GENX_NAMECHAR;
+  if (isLetter(w, c))
+    ret |= GENX_LETTER;
+  return ret;
+}
+
+static genxStatus checkNCName(genxWriter w, constUtf8 name)
+{
+  int c;
+
+  if (name == NULL || *name == 0)
+    return GENX_BAD_NAME;
+
+  c = genxNextUnicodeChar(&name);
+  if (!isLetter(w, c) && c != ':' && c != '_')
+    return GENX_BAD_NAME;
+
+  while (*name)
+  {
+    c = genxNextUnicodeChar(&name);
+    if (c == -1)
+      return GENX_BAD_UTF8;
+    if (!isNameChar(w, c))
+      return GENX_BAD_NAME;
+  }
+  return GENX_SUCCESS;
+}
+
+char * genxGetErrorMessage(genxWriter w, genxStatus status)
+{
+  return w->etext[status];
+}
+char * genxLastErrorMessage(genxWriter w)
+{
+  return w->etext[w->status];
+}
+
+/*******************************
+ * Declarations: namespace/element/attribute
+ */
+
+/*
+ * DeclareNamespace - by far the most complex routine in Genx
+ */
+genxNamespace genxDeclareNamespace(genxWriter w, constUtf8 uri,
+				   constUtf8 defaultPref,
+				   genxStatus * statusP)
+{
+  genxNamespace ns;
+  genxAttribute defaultDecl;
+  unsigned char newPrefix[100];
+
+  if (uri == NULL || uri[0] == 0)
+  {
+    w->status = GENX_BAD_NAMESPACE_NAME;
+    goto busted;
+  }
+
+  if ((w->status = genxCheckText(w, uri)) != GENX_SUCCESS)
+    goto busted;
+
+  /* if a prefix is provided, it has to be an NCname */
+  if (defaultPref != NULL && defaultPref[0] != 0 &&
+      (w->status = checkNCName(w, defaultPref)) != GENX_SUCCESS)
+    goto busted;
+
+  /* previously declared? */
+  if ((ns = findNamespace(&w->namespaces, uri)))
+  {
+    /* just a lookup, really */
+    if ((defaultPref == NULL) ||
+	(defaultPref[0] == 0 && ns->defaultDecl == w->xmlnsEquals) ||
+	(strcmp((const char *) ns->defaultDecl->name + STRLEN_XMLNS_COLON,
+		(const char *) defaultPref) == 0))
+    {
+      w->status = *statusP = GENX_SUCCESS;
+      return ns;
+    }
+  }
+
+  /* wasn't already declared */
+  else
+  {
+
+    /* make a default prefix if none provided */
+    if (defaultPref == NULL)
+    {
+      sprintf((char *) newPrefix, "g%d", w->nextPrefix++);
+      defaultPref = newPrefix;
+    }
+
+    ns = (genxNamespace) allocate(w, sizeof(struct genxNamespace_rec));
+    if (ns == NULL)
+    {
+      w->status = GENX_ALLOC_FAILED;
+      goto busted;
+    }
+    ns->writer = w;
+    ns->baroque = False;
+
+    if ((ns->name = copy(w, uri)) == NULL)
+    {
+      w->status = GENX_ALLOC_FAILED;
+      goto busted;
+    }
+
+    if ((w->status = listAppend(&w->namespaces, ns)) != GENX_SUCCESS)
+      goto busted;
+    ns->defaultDecl = ns->declaration = NULL;
+    ns->declCount = 0;
+  }
+
+  if (defaultPref[0] == 0)
+  {
+    if (w->defaultNsDeclared)
+    {
+      w->status = GENX_DUPLICATE_PREFIX;
+      goto busted;
+    }
+    defaultDecl = w->xmlnsEquals;
+    w->defaultNsDeclared = True;
+  }
+  else
+  {
+    /* this catches dupes too */
+    if ((defaultPref = storePrefix(w, defaultPref, False)) == NULL)
+      goto busted;
+
+    defaultDecl = declareAttribute(w, NULL, defaultPref, ns->name, statusP);
+    if (defaultDecl == NULL || *statusP != GENX_SUCCESS)
+    {
+      w->status = *statusP;
+      return NULL;
+    }
+  }
+
+  if (ns->defaultDecl != NULL && defaultDecl != ns->defaultDecl)
+    ns->baroque = True;
+  ns->defaultDecl = defaultDecl;
+  
+  *statusP = GENX_SUCCESS;
+  return ns;
+
+busted:
+  *statusP = w->status;
+  return NULL;
+}
+
+/*
+ * get namespace prefix
+ */
+utf8 genxGetNamespacePrefix(genxNamespace ns)
+{
+  if (ns->declaration == NULL)
+    return NULL;
+
+  if (ns->declaration == ns->writer->xmlnsEquals)
+    return ns->writer->empty;
+
+  return ns->declaration->name + STRLEN_XMLNS_COLON;
+}
+
+/*
+ * DeclareElement - see genx.h for details
+ */
+genxElement genxDeclareElement(genxWriter w,
+			       genxNamespace ns, constUtf8 type, 
+			       genxStatus * statusP)
+{
+  genxElement old;
+  genxElement el;
+
+  if ((w->status = checkNCName(w, type)) != GENX_SUCCESS)
+  {
+    *statusP = w->status;
+    return NULL;
+  }
+
+  /* already declared? */
+  old = findElement(&w->elements, (ns == NULL) ? NULL : ns->name, type);
+  if (old)
+    return old;
+
+  if ((el = (genxElement) allocate(w, sizeof(struct genxElement_rec))) == NULL)
+  {
+    w->status = *statusP = GENX_ALLOC_FAILED;
+    return NULL;
+  }
+
+  el->writer = w;
+  el->ns = ns;
+  if ((el->type = copy(w, type)) == NULL)
+  {
+    w->status = *statusP = GENX_ALLOC_FAILED;
+    return NULL;
+  }
+
+  if ((w->status = listAppend(&w->elements, el)) != GENX_SUCCESS)
+  {
+    *statusP = w->status;
+    return NULL;
+  }
+  
+  *statusP = GENX_SUCCESS;
+  return el;
+}
+
+/*
+ * C14n ordering for attributes: 
+ * - first, namespace declarations by the prefix being declared
+ * - second, unprefixed attributes by attr name
+ * - third, prefixed attrs by ns uri then local part
+ */
+static int orderAttributes(genxAttribute a1, genxAttribute a2)
+{
+  if (a1->atype == a2->atype)
+  {
+    if (a1->atype == ATTR_PREFIXED && a1->ns != a2->ns)
+      return strcmp((const char *) a1->ns->name, (const char *) a2->ns->name);
+    else
+      return strcmp((const char *) a1->name, (const char *) a2->name);
+  }
+
+  else if (a1->atype == ATTR_NSDECL)
+    return -1;
+
+  else if (a1->atype == ATTR_NAKED)
+  {
+    if (a2->atype == ATTR_NSDECL)
+      return 1;
+    else
+      return -1;
+  }
+
+  else
+    return 1;
+}
+
+/*
+ * internal declare-attribute.  This one allows colonized values for
+ *  names, so that you can declare xmlns:-type attributes
+ */
+static genxAttribute declareAttribute(genxWriter w, genxNamespace ns,
+				      constUtf8 name, constUtf8 valuestr,
+				      genxStatus * statusP)
+{
+  int high, low;
+  genxAttribute * aa = (genxAttribute *) w->attributes.pointers;
+  genxAttribute a;
+
+  w->arec.ns = ns;
+  w->arec.name = (utf8) name;
+
+  if (ns)
+    w->arec.atype = ATTR_PREFIXED;
+  else if (strncmp((const char *) name, "xmlns", STRLEN_XMLNS_COLON - 1) == 0)
+    w->arec.atype = ATTR_NSDECL;
+  else
+    w->arec.atype = ATTR_NAKED;
+
+  if (ns && (ns->defaultDecl == w->xmlnsEquals))
+  {
+    w->status = GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE;
+    goto busted;
+  }
+
+  /* attribute list has to be kept sorted per c14n rules */
+  high = w->attributes.count; low = -1;
+  while (high - low > 1)
+  {
+    int probe = (high + low) / 2;
+    if (orderAttributes(&w->arec, aa[probe]) < 0)
+      high = probe;
+    else
+      low = probe;
+  }
+
+  /* if it was already there */
+  if (low != -1 && orderAttributes(&w->arec, aa[low]) == 0)
+    return aa[low];
+
+  /* not there, build it */
+  a = (genxAttribute) allocate(w, sizeof(struct genxAttribute_rec));
+  if (a == NULL)
+  {
+    w->status = GENX_ALLOC_FAILED;
+    goto busted;
+  }
+
+  a->writer = w;
+  a->ns = ns;
+  a->provided = False;
+  a->atype = w->arec.atype;
+
+  if ((a->name = copy(w, name)) == NULL)
+  {
+    w->status = GENX_ALLOC_FAILED;
+    goto busted;
+  }
+
+  if ((w->status = initCollector(w, &a->value)) != GENX_SUCCESS)
+    goto busted;
+
+  if (valuestr)
+    if ((w->status = collectString(w, &a->value, valuestr)) != GENX_SUCCESS)
+      goto busted;
+  
+  w->status = listInsert(&w->attributes, a, high);
+  if (w->status != GENX_SUCCESS)
+    goto busted;
+  
+  *statusP = GENX_SUCCESS;
+  return a;
+
+busted:
+  *statusP = w->status;
+  return NULL;
+}
+
+/*
+ * genxDeclareAttribute - see genx.h for details
+ */
+genxAttribute genxDeclareAttribute(genxWriter w,
+				   genxNamespace ns, constUtf8 name,
+				   genxStatus * statusP)
+{
+  if ((w->status = checkNCName(w, name)) != GENX_SUCCESS)
+  {
+    *statusP = w->status;
+    return NULL;
+  }
+
+  return declareAttribute(w, ns, name, NULL, statusP);
+}
+
+/*******************************
+ * I/O
+ */
+static genxStatus sendx(genxWriter w, constUtf8 s)
+{
+  if (w->sender)
+    return (*w->sender->send)(w->userData, s);
+  else
+  {
+    if (fputs((const char *) s, w->file) == -1)
+      return GENX_IO_ERROR;
+    else
+      return GENX_SUCCESS;
+  }
+}
+
+static genxStatus sendxBounded(genxWriter w, constUtf8 start, constUtf8 end)
+{
+  if (w->sender)
+    return (*w->sender->sendBounded)(w->userData, start, end);
+  else
+    if (fwrite(start, 1, end - start, w->file) != (unsigned) (end - start))
+      return GENX_IO_ERROR;
+    else
+      return GENX_SUCCESS;
+}
+
+#define SendCheck(w,s) if ((w->status=sendx(w,(utf8)s))!=GENX_SUCCESS) return w->status;
+
+/*******************************
+ * XML writing routines.  The semantics of the externally-facing ones are
+ *  written up in genx.h.  Commentary here is implementation notes and
+ *  for internal routines.
+ */
+
+/*
+ * Start a document
+ */
+genxStatus genxStartDocFile(genxWriter w, FILE * file)
+{
+  if (w->sequence != SEQUENCE_NO_DOC)
+    return w->status = GENX_SEQUENCE_ERROR;
+  
+  w->sequence = SEQUENCE_PRE_DOC;
+  w->file = file;
+  w->sender = NULL;
+  return GENX_SUCCESS;
+}
+
+genxStatus genxStartDocSender(genxWriter w, genxSender * sender)
+{
+  if (w->sequence != SEQUENCE_NO_DOC)
+    return w->status = GENX_SEQUENCE_ERROR;
+  
+  w->sequence = SEQUENCE_PRE_DOC;
+  w->file = NULL;
+  w->sender = sender;
+  return GENX_SUCCESS;
+}
+
+/*
+ * Write out the attributes we've been gathering up for an element.  We save
+ *  them until we've gathered them all so they can be writen in canonical
+ *  order.
+ * Also, we end the start-tag.
+ * The trick here is that we keep the attribute list properly sorted as
+ *  we build it, then as each attribute is added, we fill in its value and
+ *  mark the fact that it's been added, in the "provided" field.
+ */
+static genxStatus writeStartTag(genxWriter w)
+{
+  int i;
+  genxAttribute * aa = (genxAttribute *) w->attributes.pointers;
+  genxElement e = w->nowStarting;
+
+  /*
+   * make sure the right namespace decls are in effect;
+   *  if they are these might create an error, so ignore it
+   */
+  if (e->ns)
+    addNamespace(e->ns, NULL);
+  else
+    unsetDefaultNamespace(w);
+  w->status = GENX_SUCCESS;
+
+  SendCheck(w, "<");
+  if (e->ns && (e->ns->declaration != w->xmlnsEquals))
+  {
+    SendCheck(w, e->ns->declaration->name + STRLEN_XMLNS_COLON);
+    SendCheck(w, ":");
+  }
+  SendCheck(w, e->type);
+
+  for (i = 0; i < w->attributes.count; i++)
+  {
+    if (aa[i]->provided)
+    {
+      if (aa[i]->ns && aa[i]->ns->baroque &&
+	  aa[i]->ns->declaration == w->xmlnsEquals)
+	return w->status = GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE;
+
+      SendCheck(w, " ");
+
+      if (aa[i]->ns)
+      {
+	SendCheck(w, aa[i]->ns->declaration->name + STRLEN_XMLNS_COLON)
+	SendCheck(w, ":");
+      }
+      SendCheck(w, aa[i]->name);
+      SendCheck(w, "=\"");
+      SendCheck(w, aa[i]->value.buf);
+      SendCheck(w, "\"");
+    }
+  }
+  SendCheck(w, ">");
+  return GENX_SUCCESS;
+}
+
+/*
+ * internal clear-er; no sequence checking
+ */
+static genxStatus unsetDefaultNamespace(genxWriter w)
+{
+  int i;
+  Boolean found = False;
+
+  /* don't put it in if not needed */
+  i = w->stack.count - 1;
+  while (found == False && i > 0)
+  {
+    while (w->stack.pointers[i] != NULL)
+    {
+      genxAttribute decl = (genxAttribute) w->stack.pointers[i--];
+      genxNamespace ns = (genxNamespace) w->stack.pointers[i--];
+
+      /* if already unset */
+      if (ns == NULL)
+	return w->status = GENX_SUCCESS;
+
+      /*
+       * the default namespace was declared.  This namespace now
+       *  becomes baroque
+       */
+      if (decl == w->xmlnsEquals)
+      {
+	ns->baroque = True;
+	found = True;
+	break;
+      }
+    }
+    i -= 2;
+  }
+
+  if (!found)
+    return GENX_SUCCESS;
+
+  /*
+   * push a signal on the stack
+   */
+  if ((w->status = listAppend(&w->stack, NULL)) != GENX_SUCCESS)
+    return w->status;
+  w->status = listAppend(&w->stack, w->xmlnsEquals);
+  if (w->status != GENX_SUCCESS)
+    return w->status;
+
+  /* add the xmlns= attribute, it must be the first one */
+  return addAttribute(w->xmlnsEquals, w->empty);
+}
+
+/*
+ * clear the default namespace declaration
+ */
+genxStatus genxUnsetDefaultNamespace(genxWriter w)
+{
+
+  /* can only do this while in start-tag mode */
+  if (w->sequence != SEQUENCE_START_TAG)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  return unsetDefaultNamespace(w);
+}
+
+genxStatus genxStartElement(genxElement e)
+{
+  genxWriter w = e->writer;
+  int i;
+
+  switch (w->sequence)
+  {
+  case SEQUENCE_NO_DOC:
+  case SEQUENCE_POST_DOC:
+    return w->status = GENX_SEQUENCE_ERROR;
+  case SEQUENCE_START_TAG:
+  case SEQUENCE_ATTRIBUTES:
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    break;
+  case SEQUENCE_PRE_DOC:
+  case SEQUENCE_CONTENT:
+    break;
+  }
+
+  w->sequence = SEQUENCE_START_TAG;
+
+  /* clear provided attributes */
+  for (i = 0; i < w->attributes.count; i++)
+    ((genxAttribute) w->attributes.pointers[i])->provided = 0;
+
+  /*
+   * push the stack.  We push a NULL after a pointer to this element
+   *  because the stack will also contain pointers to the namespace
+   *  attributes that got declared here, so we can keep track of what's
+   *  in effect.  I.e. a single stack entry consists logically of a pointer
+   *  to an element object, a NULL, then zero or more pairs of pointers to
+   *  namespace objects/declarations
+   */
+  if ((w->status = listAppend(&w->stack, e)) != GENX_SUCCESS)
+    return w->status;
+  if ((w->status = listAppend(&w->stack, NULL)) != GENX_SUCCESS)
+    return w->status;
+
+  w->nowStarting = e;
+
+  return GENX_SUCCESS;
+}
+
+/*
+ * internal namespace adder; no sequence checking
+ */
+static genxStatus addNamespace(genxNamespace ns, utf8 prefix)
+{
+  genxWriter w = ns->writer;
+  genxAttribute decl;
+  int i;
+  genxElement e;
+
+  /*
+   * first, we'll find the declaring attribute
+   */
+  if (prefix == NULL)
+    decl = ns->defaultDecl;
+  else
+  {
+    if (prefix[0] == 0)
+      decl = w->xmlnsEquals;
+    else
+    {
+      if ((prefix = storePrefix(w, prefix, True)) == NULL)
+	return w->status;
+      decl = declareAttribute(w, NULL, prefix, ns->name, &w->status);
+      if (decl == NULL || w->status != GENX_SUCCESS)
+	return w->status;
+    }
+  }
+
+  if (decl != ns->defaultDecl)
+    ns->baroque = True;
+
+  /*
+   * avoid doing anything if this namespace is already declared.  If
+   *  they've shown good taste we can do this cheaply
+   */
+  if (!ns->baroque)
+  {
+    if (ns->declCount > 0)
+      return w->status = GENX_SUCCESS;
+  }
+  else
+  {
+
+    /*
+     * First, we'll run all the way up the stack to see if there is
+     *  another declaration for this namespace/prefix in scope, in which
+     *  case it's a no-op; or, if there's another declaration for this
+     *  prefix on another namespace, in which case we have to over-ride
+     */
+    i = w->stack.count - 1;
+    while (i > 0)
+    {
+      while (w->stack.pointers[i] != NULL)
+      {
+	genxAttribute otherDecl = (genxAttribute) w->stack.pointers[i--];
+	genxNamespace otherNs = (genxNamespace) w->stack.pointers[i--];
+
+	if (ns == otherNs)
+	{
+	  if (decl == otherDecl)
+	    return w->status = GENX_SUCCESS;
+	  else
+	  {
+	    i = 0;
+	    break;
+	  }
+	}
+	else
+	{
+	  /* different namespace, same prefix? */
+	  if (decl == otherDecl)
+	  {
+	    i = 0;
+	    break;
+	  }
+	}
+      }
+      i -= 2;
+    }
+  }
+
+  /*
+   * If this namespace is already declared on
+   *  this element (with different prefix/decl) which is an error.
+   */
+  i = w->stack.count - 1;
+  while (w->stack.pointers[i] != NULL)
+  {
+    genxNamespace otherNs;
+    i--; /* don't need declaration */
+    otherNs = (genxNamespace) w->stack.pointers[i--];
+
+    if (ns == otherNs)
+      return w->status = GENX_DUPLICATE_NAMESPACE;
+  }
+
+  /* move pointer from NULL to element */
+  --i;
+
+  /*
+   * It's also an error if this is a default-namespace declaration and the
+   *  element is in no namespace.
+   */
+  e = (genxElement) w->stack.pointers[i];    
+  if (e->ns == NULL && decl == w->xmlnsEquals)
+    return w->status = GENX_BAD_DEFAULT_DECLARATION;
+
+  if ((w->status = listAppend(&w->stack, ns)) != GENX_SUCCESS)
+    return w->status;
+  if ((w->status = listAppend(&w->stack, decl)) != GENX_SUCCESS)
+    return w->status;
+
+  ns->declaration = decl;
+  ns->declCount++;
+  return addAttribute(decl, ns->name);
+}
+
+/*
+ * Add a namespace declaration
+ */
+genxStatus genxAddNamespace(genxNamespace ns, utf8 prefix)
+{
+  if (ns->writer->sequence != SEQUENCE_START_TAG)
+    return ns->writer->status = GENX_SEQUENCE_ERROR;
+
+  return addNamespace(ns, prefix);
+}
+
+/*
+ * Private attribute-adding code
+ * most of the work here is normalizing the value, which is the same
+ *  as regular normalization except for " is replaced by "&quot;"
+ */
+static genxStatus addAttribute(genxAttribute a, constUtf8 valuestr)
+{
+  utf8 lastv = (utf8) valuestr;
+  genxWriter w = a->writer;
+
+  /* if valuestr not provided, this is an xmlns with a pre-cooked value */
+  if (valuestr)
+  {
+    startCollect(&a->value);
+    while (*valuestr)
+    {
+      int c = genxNextUnicodeChar(&valuestr);
+      
+      if (c == -1)
+	return w->status = GENX_BAD_UTF8;
+      
+      if (!isXMLChar(w, c))
+	return w->status = GENX_NON_XML_CHARACTER;
+      
+      switch(c)
+      {
+      case 9:
+	collectPiece(w, &a->value, "&#x9;", 5);
+	break;
+      case 0xa:
+	collectPiece(w, &a->value, "&#xA;", 5); 
+	break;
+      case 0xd:
+	collectPiece(w, &a->value, "&#xD;", 5); 
+	break;
+      case '"':
+	collectPiece(w, &a->value, "&quot;", 6);
+	break;
+      case '<':
+	collectPiece(w, &a->value, "&lt;", 4);
+	break;
+      case '&':
+	collectPiece(w, &a->value, "&amp;", 5);
+	break;
+	/*
+      case '>':
+	collectPiece(w, &a->value, "&gt;", 4);
+	break;
+	*/
+      default:
+	collectPiece(w, &a->value, (const char *) lastv, valuestr - lastv);
+	break;
+      }
+      lastv = (utf8) valuestr;
+    }
+    endCollect(&a->value);
+  }
+
+  /* now add the namespace attribute; might fail if it's bee hand-declared */
+  if (a->ns)
+    addNamespace(a->ns, NULL);
+
+  if (valuestr && a->provided)
+    return w->status = GENX_DUPLICATE_ATTRIBUTE;
+  a->provided = 1;
+
+  return GENX_SUCCESS;
+}
+
+/*
+ * public attribute adder.
+ * The only difference is that it doesn't allow a NULL value
+ */
+genxStatus genxAddAttribute(genxAttribute a, constUtf8 valuestr)
+{
+  if (a->writer->sequence != SEQUENCE_START_TAG &&
+      a->writer->sequence != SEQUENCE_ATTRIBUTES)
+    return a->writer->status = GENX_SEQUENCE_ERROR;
+  a->writer->sequence = SEQUENCE_ATTRIBUTES;
+
+  if (valuestr == NULL)
+    return a->writer->status = GENX_MISSING_VALUE;
+
+  return addAttribute(a, valuestr);
+}
+
+genxStatus genxEndElement(genxWriter w)
+{
+  genxElement e;
+  int i;
+
+  switch (w->sequence)
+  {
+  case SEQUENCE_NO_DOC:
+  case SEQUENCE_PRE_DOC:
+  case SEQUENCE_POST_DOC:
+    return w->status = GENX_SEQUENCE_ERROR;
+  case SEQUENCE_START_TAG:
+  case SEQUENCE_ATTRIBUTES:
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    break;
+  case SEQUENCE_CONTENT:
+    break;
+  }
+
+  /*
+   * first peek into the stack to find the right namespace declaration
+   *  (if any) so we can properly prefix the end-tag.  Have to do this
+   *  before unwinding the stack because that might reset some xmlns
+   *  prefixes to the context in the parent element
+   */
+  for (i = w->stack.count - 1; w->stack.pointers[i] != NULL; i -= 2)
+    ;
+  e = (genxElement) w->stack.pointers[--i];
+
+  SendCheck(w, "</");
+  if (e->ns && e->ns->declaration != w->xmlnsEquals)
+  {
+    SendCheck(w, e->ns->declaration->name + STRLEN_XMLNS_COLON);
+    SendCheck(w, ":");
+  }
+  SendCheck(w, e->type);
+  SendCheck(w, ">");
+
+  /*
+   * pop zero or more namespace declarations, then a null, then the
+   *  start-element declaration off the stack
+   */
+  w->stack.count--;
+  while (w->stack.pointers[w->stack.count] != NULL)
+  {
+    genxNamespace ns = (genxNamespace) w->stack.pointers[--w->stack.count];
+    w->stack.count--; /* don't need decl */
+
+    /* if not a fake unset-default namespace */
+    if (ns)
+    {
+      /*
+       * if they've stupidly jammed in their own namespace-prefix
+       *  declarations, we have to go looking to see if there's another
+       *  one in effect
+       */
+      if (ns->baroque)
+      {
+	i = w->stack.count;
+	while (i > 0)
+	{
+	  while (w->stack.pointers[i] != NULL)
+	  {
+	    genxAttribute otherDecl = (genxAttribute) w->stack.pointers[i--];
+	    genxNamespace otherNs = (genxNamespace) w->stack.pointers[i--];
+	    
+	    if (otherNs == ns)
+	    {
+	      ns->declaration = otherDecl;
+	      i = 0;
+	      break;
+	    }
+	  }
+	  
+	  /* skip NULL & element */
+	  i -= 2;
+	}
+      }
+      ns->declCount--;
+      if (ns->declCount == 0)
+	ns->baroque = False;
+    }
+  }
+
+  /* pop the NULL */
+  --w->stack.count;
+  if (w->stack.count < 0)
+    return w->status = GENX_NO_START_TAG;
+
+  if (w->stack.count == 0)
+    w->sequence = SEQUENCE_POST_DOC;
+  else
+    w->sequence = SEQUENCE_CONTENT;
+
+  return GENX_SUCCESS;
+}
+
+/*
+ * Internal character-adder.  It tries to keep the number of sendx()
+ *  calls down by looking at each character but only doing the output
+ *  when it has to escape something; ordinary text gets saved up in
+ *  chunks the start of which is indicated by *breaker.
+ * c is the character, next points to the UTF8 representing the next
+ *  lastsP indirectly points to the UTF8 representing the
+ *  character, breakerP* indirectly points to the last place genx
+ *  changed the UTF8, e.g. by escaping a '<'
+ */
+static genxStatus addChar(genxWriter w, int c, constUtf8 next,
+			  constUtf8 * lastsP, constUtf8 * breakerP)
+{
+  if (c == -1)
+    return GENX_BAD_UTF8;
+
+  if (!isXMLChar(w, c))
+    return GENX_NON_XML_CHARACTER;
+
+  switch(c)
+  {
+  case 0xd:
+    if ((w->status = sendxBounded(w, *breakerP, *lastsP)) != GENX_SUCCESS)
+      return w->status;
+    *breakerP = next;
+    sendx(w, (utf8) "&#xD;");
+    break;
+  case '<':
+    if ((w->status = sendxBounded(w, *breakerP, *lastsP)) != GENX_SUCCESS)
+      return w->status;
+    *breakerP = next;
+    sendx(w, (utf8) "&lt;");
+    break;
+  case '&':
+    if ((w->status = sendxBounded(w, *breakerP, *lastsP)) != GENX_SUCCESS)
+      return w->status;
+    *breakerP = next;
+    sendx(w, (utf8) "&amp;");
+    break;
+  case '>':
+    if ((w->status = sendxBounded(w, *breakerP, *lastsP)) != GENX_SUCCESS)
+      return w->status;
+    *breakerP = next;
+    sendx(w, (utf8) "&gt;");
+    break;
+  default:
+    break;
+  }
+  *lastsP = next;
+  return GENX_SUCCESS;
+}
+
+genxStatus genxAddText(genxWriter w, constUtf8 start)
+{
+  constUtf8 lasts = start;
+  constUtf8 breaker = start;
+
+  if (w->sequence == SEQUENCE_START_TAG ||
+      w->sequence == SEQUENCE_ATTRIBUTES)
+  {
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    w->sequence = SEQUENCE_CONTENT;
+  }
+
+  if (w->sequence != SEQUENCE_CONTENT)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  while (*start)
+  {
+    int c = genxNextUnicodeChar(&start);
+
+    w->status = addChar(w, c, start, &lasts, &breaker);
+    if (w->status != GENX_SUCCESS)
+      return w->status;
+  }
+  return sendxBounded(w, breaker, (utf8) start);
+}
+
+genxStatus genxAddBoundedText(genxWriter w, constUtf8 start, constUtf8 end)
+{
+  constUtf8 lasts = start;
+  constUtf8 breaker = start;
+
+  if (w->sequence == SEQUENCE_START_TAG ||
+      w->sequence == SEQUENCE_ATTRIBUTES)
+  {
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    w->sequence = SEQUENCE_CONTENT;
+  }
+
+  if (w->sequence != SEQUENCE_CONTENT)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  while (start < end)
+  {
+    int c = genxNextUnicodeChar(&start);
+
+    w->status = addChar(w, c, (utf8) start, &lasts, &breaker);
+    if (w->status != GENX_SUCCESS)
+      return w->status;
+  }
+  return sendxBounded(w, breaker, (utf8) start);
+}
+
+genxStatus genxAddCountedText(genxWriter w, constUtf8 start, int byteCount)
+{
+  utf8 end = (utf8) (start + byteCount);
+
+  return genxAddBoundedText(w, start, end);
+}
+
+genxStatus genxAddCharacter(genxWriter w, int c)
+{
+  unsigned char cUTF8[10];
+  utf8 lasts, breaker, next;
+
+  if (w->sequence == SEQUENCE_START_TAG ||
+      w->sequence == SEQUENCE_ATTRIBUTES)
+  {
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    w->sequence = SEQUENCE_CONTENT;
+  }
+
+  if (w->sequence != SEQUENCE_CONTENT)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  if (!isXMLChar(w, c))
+    return w->status = GENX_NON_XML_CHARACTER;
+
+  /* make UTF8 representation of character */
+  lasts = breaker = next = cUTF8;
+
+  if (c < 0x80)
+    *next++ = c;
+  else if (c < 0x800)
+  {
+    *next++ = 0xc0 | (c >> 6);
+    *next++ = 0x80 | (c & 0x3f);
+  }
+  else if (c < 0x10000)
+  {
+    *next++ = 0xe0 | (c >> 12);
+    *next++ = 0x80 | ((c & 0xfc0) >> 6);
+    *next++ = 0x80 | (c & 0x3f);
+  }
+  else
+  {
+    *next++ = 0xf0 | (c >> 18);
+    *next++ = 0x80 | ((c & 0x3f000) >> 12);
+    *next++ = 0x80 | ((c & 0xfc0) >> 6);
+    *next++ = 0x80 | (c & 0x3f);
+  }
+  *next = 0;
+
+  w->status =
+    addChar(w, c, next, (constUtf8 *) &lasts, (constUtf8 *) &breaker);
+  if (w->status != GENX_SUCCESS)
+    return w->status;
+
+  return sendxBounded(w, breaker, next);
+}  
+
+genxStatus genxEndDocument(genxWriter w)
+{
+  if (w->sequence != SEQUENCE_POST_DOC)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  if (w->file)
+    fflush(w->file);
+  else
+    if ((w->status = (*w->sender->flush)(w->userData)) != GENX_SUCCESS)
+      return w->status;
+
+  w->sequence = SEQUENCE_NO_DOC;
+  return GENX_SUCCESS;
+}
+
+genxStatus genxComment(genxWriter w, constUtf8 text)
+{
+  int i;
+
+  if (w->sequence == SEQUENCE_NO_DOC)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  if ((w->status = genxCheckText(w, text)) != GENX_SUCCESS)
+    return w->status;
+
+  /* no leading '-', no trailing '-', no '--' */
+  if (text[0] == '-')
+    return w->status = GENX_MALFORMED_COMMENT;
+  for (i = 0; text[i]; i++)
+    if (text[i] == '-' && (text[i + 1] == '-' || text[i + 1] == 0))
+      return w->status = GENX_MALFORMED_COMMENT;
+
+  if (w->sequence == SEQUENCE_START_TAG ||
+      w->sequence == SEQUENCE_ATTRIBUTES)
+  {
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    w->sequence = SEQUENCE_CONTENT;
+  }
+
+  else if (w->sequence == SEQUENCE_POST_DOC)
+    if ((w->status = sendx(w, (utf8) "\n")) != GENX_SUCCESS)
+      return w->status;
+
+  if ((w->status = sendx(w, (utf8) "<!--")) != GENX_SUCCESS)
+    return w->status;
+  if ((w->status = sendx(w, (utf8) text)) != GENX_SUCCESS)
+    return w->status;
+  if ((w->status = sendx(w, (utf8) "-->")) != GENX_SUCCESS)
+    return w->status;
+
+  if (w->sequence == SEQUENCE_PRE_DOC)
+    if ((w->status = sendx(w, (utf8) "\n")) != GENX_SUCCESS)
+      return w->status;
+
+  return GENX_SUCCESS;
+}
+
+genxStatus genxPI(genxWriter w, constUtf8 target, constUtf8 text)
+{
+  int i;
+
+  if (w->sequence == SEQUENCE_NO_DOC)
+    return w->status = GENX_SEQUENCE_ERROR;
+
+  if ((w->status = genxCheckText(w, target)) != GENX_SUCCESS)
+    return w->status;
+  if ((w->status = checkNCName(w, target)) != GENX_SUCCESS)
+    return w->status;
+  if ((strlen((const char *) target) >= 3) &&
+      (target[0] == 'x' || target[0] == 'X') &&
+      (target[1] == 'm' || target[1] == 'M') &&
+      (target[2] == 'l' || target[2] == 'L') &&
+      (target[3] == 0))
+    return w->status = GENX_XML_PI_TARGET;
+
+  if ((w->status = genxCheckText(w, text)) != GENX_SUCCESS)
+    return w->status;
+
+  /* no ?> within */
+  for (i = 1; text[i]; i++)
+    if (text[i] == '>' && text[i - 1] == '?')
+      return w->status = GENX_MALFORMED_PI;
+
+  if (w->sequence == SEQUENCE_START_TAG ||
+      w->sequence == SEQUENCE_ATTRIBUTES)
+  {
+    if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
+      return w->status;
+    w->sequence = SEQUENCE_CONTENT;
+  }
+
+  else if (w->sequence == SEQUENCE_POST_DOC)
+    if ((w->status = sendx(w, (utf8) "\n")) != GENX_SUCCESS)
+      return w->status;
+
+  if ((w->status = sendx(w, (utf8) "<?")) != GENX_SUCCESS)
+    return w->status;
+  if ((w->status = sendx(w, target)) != GENX_SUCCESS)
+    return w->status;
+  if (text[0])
+  {
+    if ((w->status = sendx(w, (utf8) " ")) != GENX_SUCCESS)
+      return w->status;
+    if ((w->status = sendx(w, text)) != GENX_SUCCESS)
+      return w->status;
+  }
+  if ((w->status = sendx(w, (utf8) "?>")) != GENX_SUCCESS)
+    return w->status;
+
+  if (w->sequence == SEQUENCE_PRE_DOC)
+    if ((w->status = sendx(w, (utf8) "\n")) != GENX_SUCCESS)
+      return w->status;
+
+  return GENX_SUCCESS;
+}
+
+/*******************************
+ * Literal versions of the writing routines
+ */
+genxStatus genxStartElementLiteral(genxWriter w,
+				   constUtf8 xmlns, constUtf8 type)
+{
+  genxNamespace ns = NULL;
+  genxElement e;
+
+  if (xmlns)
+  {
+    ns = genxDeclareNamespace(w, xmlns, NULL, &w->status);
+    if (ns == NULL || w->status != GENX_SUCCESS)
+      return w->status;
+  }
+  e = genxDeclareElement(w, ns, type, &w->status);
+  if (e == NULL || w->status != GENX_SUCCESS)
+    return w->status;
+
+  return genxStartElement(e);
+}
+
+genxStatus genxAddAttributeLiteral(genxWriter w, constUtf8 xmlns,
+				   constUtf8 name, constUtf8 value)
+{
+  genxNamespace ns = NULL;
+  genxAttribute a;
+
+  if (xmlns)
+  {
+    ns = genxDeclareNamespace(w, xmlns, NULL, &w->status);
+    if (ns == NULL && w->status != GENX_SUCCESS)
+      return w->status;
+  }
+  
+  a = genxDeclareAttribute(w, ns, name, &w->status);
+  if (a == NULL || w->status != GENX_SUCCESS)
+    return w->status;
+
+  return genxAddAttribute(a, value);
+}
+
+/*
+ * return version
+ */
+char * genxGetVersion()
+{
+  return GENX_VERSION;
+}
+