Remove files that are no longer used.

This closes SF patch #488187.

3 files changed, 0 insertions, 1021 deletions

diff --git a/xmlwf/wfcheck.c b/xmlwf/wfcheck.c
deleted file mode 100755
index c18abd2..0000000
--- a/xmlwf/wfcheck.c
+++ /dev/null
@@ -1,953 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-
-#include "wfcheck.h"
-#include "hashtable.h"
-
-#include "xmltok.h"
-#include "xmlrole.h"
-
-typedef struct {
-  const char *name;
-  const char *textPtr;
-  size_t textLen;
-  const char *docTextPtr;
-  const char *systemId;
-  const char *publicId;
-  const char *notation;
-  char open;
-  char wfInContent;
-  char wfInAttribute;
-  char magic;
-} ENTITY;
-
-#define INIT_BLOCK_SIZE 1024
-
-typedef struct block {
-  struct block *next;
-  char s[1];
-} BLOCK;
-
-typedef struct {
-  BLOCK *blocks;
-  const char *end;
-  char *ptr;
-  char *start;
-} STRING_POOL;
-
-typedef struct {
-  HASH_TABLE generalEntities;
-  HASH_TABLE paramEntities;
-  STRING_POOL pool;
-  int containsRef;
-  int standalone;
-  char *groupConnector;
-  size_t groupSize;
-} DTD;
-
-typedef struct {
-  DTD dtd;
-  size_t stackSize;
-  const char **startName;
-  int attsSize;
-  ATTRIBUTE *atts;
-} CONTEXT;
-
-static void poolInit(STRING_POOL *);
-static void poolDestroy(STRING_POOL *);
-static const char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
-			      const char *ptr, const char *end);
-static const char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
-			    const char *ptr, const char *end);
-static int poolGrow(STRING_POOL *);
-static int dtdInit(DTD *);
-static void dtdDestroy(DTD *);
-static int contextInit(CONTEXT *);
-static void contextDestroy(CONTEXT *);
-
-#define poolStart(pool) ((pool)->start)
-#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
-#define poolFinish(pool) ((pool)->start = (pool)->ptr)
-
-static enum WfCheckResult
-checkProlog(DTD *, const char *s, const char *end, const char **, const ENCODING **enc);
-static enum WfCheckResult
-checkContent(size_t level, CONTEXT *context, const ENCODING *enc,
-  	     const char *s, const char *end, const char **badPtr);
-static enum WfCheckResult
-checkGeneralTextEntity(CONTEXT *context,
-		       const char *s, const char *end,
-		       const char **nextPtr,
-		       const ENCODING **enc);
-static enum WfCheckResult
-checkAttributeValue(DTD *, const ENCODING *, const char *, const char *, const char **);
-static enum WfCheckResult
-checkAttributeUniqueness(CONTEXT *context, const ENCODING *enc, int nAtts,
-			 const char **badPtr);
-static enum WfCheckResult
-checkParsedEntities(CONTEXT *context, const char **badPtr);
-
-static
-enum WfCheckResult storeEntity(DTD *dtd,
-			       const ENCODING *enc,
-			       int isParam,
-			       const char *entityNamePtr,
-			       const char *entityNameEnd,
-			       const char *entityTextPtr,
-			       const char *entityTextEnd,
-			       const char **badPtr);
-
-
-enum WfCheckResult
-wfCheck(enum EntityType entityType, const char *s, size_t n,
-	const char **badPtr, unsigned long *badLine, unsigned long *badCol)
-{
-  CONTEXT context;
-  const ENCODING *enc;
-  const char *start = s;
-  const char *end = s + n;
-  const char *next = 0;
-  enum WfCheckResult result;
-
-  if (!contextInit(&context)) {
-    contextDestroy(&context);
-    return noMemory;
-  }
-  if (entityType == documentEntity) {
-    result = checkProlog(&context.dtd, s, end, &next, &enc);
-    s = next;
-    if (!result) {
-      result = checkParsedEntities(&context, &next);
-      s = next;
-      if (!result) {
-	result = checkContent(0, &context, enc, s, end, &next);
-	s = next;
-      }
-    }
-  }
-  else {
-    result = checkGeneralTextEntity(&context, s, end, &next, &enc);
-    s = next;
-  }
-  if (result && s) {
-    POSITION pos;
-    memset(&pos, 0, sizeof(POSITION));
-    XmlUpdatePosition(enc, start, s, &pos);
-    *badPtr = s;
-    *badLine = pos.lineNumber;
-    *badCol = pos.columnNumber;
-  }
-  contextDestroy(&context);
-  return result;
-}
-
-static
-int contextInit(CONTEXT *p)
-{
-  p->stackSize = 1024;
-  p->startName = malloc(p->stackSize * sizeof(char *));
-  p->attsSize = 1024;
-  p->atts = malloc(p->attsSize * sizeof(ATTRIBUTE));
-  return dtdInit(&(p->dtd)) && p->atts && p->startName;
-}
-
-static
-void contextDestroy(CONTEXT *p)
-{
-  dtdDestroy(&(p->dtd));
-  free((void *)p->startName);
-  free((void *)p->atts);
-}
-
-static enum WfCheckResult
-checkContent(size_t level, CONTEXT *context, const ENCODING *enc,
-	     const char *s, const char *end, const char **badPtr)
-{
-  size_t startLevel = level;
-  const char *next;
-  int tok = XmlContentTok(enc, s, end, &next);
-  for (;;) {
-    switch (tok) {
-    case XML_TOK_TRAILING_CR:
-    case XML_TOK_NONE:
-      if (startLevel > 0) {
-	if (level != startLevel) {
-	  *badPtr = s;
-	  return asyncEntity;
-        }
-	return wellFormed;
-      }
-      *badPtr = s;
-      return noElements;
-    case XML_TOK_INVALID:
-      *badPtr = next;
-      return invalidToken;
-    case XML_TOK_PARTIAL:
-      *badPtr = s;
-      return unclosedToken;
-    case XML_TOK_PARTIAL_CHAR:
-      *badPtr = s;
-      return partialChar;
-    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
-      break;
-    case XML_TOK_ENTITY_REF:
-      {
-	const char *name = poolStoreString(&context->dtd.pool, enc,
-					   s + enc->minBytesPerChar,
-					   next - enc->minBytesPerChar);
-	ENTITY *entity = (ENTITY *)lookup(&context->dtd.generalEntities, name, 0);
-	poolDiscard(&context->dtd.pool);
-	if (!entity) {
-	  if (!context->dtd.containsRef || context->dtd.standalone) {
-	    *badPtr = s;
-	    return undefinedEntity;
-	  }
-	  break;
-	}
-	if (entity->wfInContent)
-	  break;
-	if (entity->open) {
-	  *badPtr = s;
-	  return recursiveEntityRef;
-	}
-	if (entity->notation) {
-	  *badPtr = s;
-	  return binaryEntityRef;
-	}
-	if (entity) {
-	  if (entity->textPtr) {
-	    enum WfCheckResult result;
-	    const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
-	    entity->open = 1;
-	    result = checkContent(level, context, internalEnc,
-				  entity->textPtr, entity->textPtr + entity->textLen,
-				  badPtr);
-	    entity->open = 0;
-	    if (result && *badPtr) {
-	      *badPtr = s;
-	      return result;
-	    }
-	    entity->wfInContent = 1;
-	  }
-	}
-	break;
-      }
-    case XML_TOK_START_TAG_NO_ATTS:
-      if (level == context->stackSize) {
-	context->startName
-	  = realloc((void *)context->startName, (context->stackSize *= 2) * sizeof(char *));
-	if (!context->startName)
-	  return noMemory;
-      }
-      context->startName[level++] = s + enc->minBytesPerChar;
-      break;
-    case XML_TOK_START_TAG_WITH_ATTS:
-      if (level == context->stackSize) {
-	context->startName = realloc((void *)context->startName, (context->stackSize *= 2) * sizeof(char *));
-	if (!context->startName)
-	  return noMemory;
-      }
-      context->startName[level++] = s + enc->minBytesPerChar;
-      /* fall through */
-    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
-      {
-	int i;
-	int n = XmlGetAttributes(enc, s, context->attsSize, context->atts);
-	if (n > context->attsSize) {
-	  context->attsSize = 2*n;
-	  context->atts = realloc((void *)context->atts, context->attsSize * sizeof(ATTRIBUTE));
-	  if (!context->atts)
-	    return noMemory;
-	  XmlGetAttributes(enc, s, n, context->atts);
-	}
-	for (i = 0; i < n; i++) {
-	  if (!context->atts[i].normalized) {
-	    enum WfCheckResult result
-	      = checkAttributeValue(&context->dtd, enc,
-			  	    context->atts[i].valuePtr,
-				    context->atts[i].valueEnd,
-				    badPtr);
-	    if (result)
-	      return result;
-	  }
-	}
-	if (i > 1) {
-	  enum WfCheckResult result = checkAttributeUniqueness(context, enc, n, badPtr);
-	  if (result)
-	    return result;
-	}
-      }
-      break;
-    case XML_TOK_END_TAG:
-      if (level == startLevel) {
-        *badPtr = s;
-        return asyncEntity;
-      }
-      --level;
-      if (!XmlSameName(enc, context->startName[level], s + enc->minBytesPerChar * 2)) {
-	*badPtr = s;
-	return tagMismatch;
-      }
-      break;
-    case XML_TOK_CHAR_REF:
-      if (XmlCharRefNumber(enc, s) < 0) {
-	*badPtr = s;
-	return badCharRef;
-      }
-      break;
-    case XML_TOK_XML_DECL:
-      *badPtr = s;
-      return misplacedXmlPi;
-    }
-    s = next;
-    if (level == 0) {
-      do {
-	tok = XmlPrologTok(enc, s, end, &next);
-	switch (tok) {
-	case XML_TOK_TRAILING_CR:
-	case XML_TOK_NONE:
-	  return wellFormed;
-	case XML_TOK_PROLOG_S:
-	case XML_TOK_COMMENT:
-	case XML_TOK_PI:
-	  s = next;
-	  break;
-	default:
-	  if (tok > 0) {
-	    *badPtr = s;
-	    return junkAfterDocElement;
-	  }
-	  break;
-	}
-      } while (tok > 0);
-    }
-    else
-      tok = XmlContentTok(enc, s, end, &next);
-  }
-  /* not reached */
-}
-
-static
-int attcmp(const void *p1, const void *p2)
-{
-  const ATTRIBUTE *a1 = p1;
-  const ATTRIBUTE *a2 = p2;
-  size_t n1 = a1->valuePtr - a1->name;
-  size_t n2 = a2->valuePtr - a2->name;
-
-  if (n1 == n2) {
-    int n = memcmp(a1->name, a2->name, n1);
-    if (n)
-      return n;
-    /* Sort identical attribute names by position, so that we always
-       report the first duplicate attribute. */
-    if (a1->name < a2->name)
-      return -1;
-    else if (a1->name > a2->name)
-      return 1;
-    else
-      return 0;
-  }
-  else if (n1 < n2)
-    return -1;
-  else
-    return 1;
-}
-
-/* Note that this trashes the attribute values. */
-
-static enum WfCheckResult
-checkAttributeUniqueness(CONTEXT *context, const ENCODING *enc, int nAtts,
-			 const char **badPtr)
-{
-#define QSORT_MIN_ATTS 10
-  if (nAtts < QSORT_MIN_ATTS) {
-    int i;
-    for (i = 1; i < nAtts; i++) {
-      int j;
-      for (j = 0; j < i; j++) {
-	if (XmlSameName(enc, context->atts[i].name, context->atts[j].name)) {
-	  *badPtr = context->atts[i].name;
-  	  return duplicateAttribute;
-	}
-      }
-    }
-  }
-  else {
-    int i;
-    const char *dup = 0;
-    /* Store the end of the name in valuePtr */
-    for (i = 0; i < nAtts; i++) {
-      ATTRIBUTE *a = context->atts + i;
-      a->valuePtr = a->name + XmlNameLength(enc, a->name);
-    }
-    qsort(context->atts, nAtts, sizeof(ATTRIBUTE), attcmp);
-    for (i = 1; i < nAtts; i++) {
-      ATTRIBUTE *a = context->atts + i;
-      if (XmlSameName(enc, a->name, a[-1].name)) {
-	if (!dup || a->name < dup)
-	  dup = a->name;
-      }
-    }
-    if (dup) {
-      *badPtr = dup;
-      return duplicateAttribute;
-    }
-  }
-  return wellFormed;
-}
-
-static enum WfCheckResult
-checkProlog(DTD *dtd, const char *s, const char *end,
-	    const char **nextPtr, const ENCODING **enc)
-{
-  const char *entityNamePtr, *entityNameEnd;
-  int entityIsParam;
-  PROLOG_STATE state;
-  ENTITY *entity;
-  INIT_ENCODING initEnc;
-  XmlInitEncoding(&initEnc, enc);
-  XmlPrologStateInit(&state);
-  for (;;) {
-    const char *next;
-    int tok = XmlPrologTok(*enc, s, end, &next);
-    switch (XmlTokenRole(&state, tok, s, next, *enc)) {
-    case XML_ROLE_XML_DECL:
-      {
-	const char *encodingName = 0;
-	const ENCODING *encoding = 0;
-	const char *version;
-	int standalone = -1;
-	if (!XmlParseXmlDecl(0,
-			     *enc,
-			     s,
-			     next,
-			     nextPtr,
-			     &version,
-			     &encodingName,
-			     &encoding,
-			     &standalone))
-	  return syntaxError;
-	if (encoding) {
-	  if (encoding->minBytesPerChar != (*enc)->minBytesPerChar) {
-	    *nextPtr = encodingName;
-	    return incorrectEncoding;
-	  }
-	  *enc = encoding;
-	}
-	else if (encodingName) {
-	  *nextPtr = encodingName;
-	  return unknownEncoding;
-	}
-	if (standalone == 1)
-	  dtd->standalone = 1;
-	break;
-      }
-    case XML_ROLE_DOCTYPE_SYSTEM_ID:
-      dtd->containsRef = 1;
-      break;
-    case XML_ROLE_DOCTYPE_PUBLIC_ID:
-    case XML_ROLE_ENTITY_PUBLIC_ID:
-    case XML_ROLE_NOTATION_PUBLIC_ID:
-      if (!XmlIsPublicId(*enc, s, next, nextPtr))
-	return syntaxError;
-      break;
-    case XML_ROLE_INSTANCE_START:
-      *nextPtr = s;
-      return wellFormed;
-    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
-    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
-      {
-	const char *tem = 0;
-	enum WfCheckResult result
-	  = checkAttributeValue(dtd, *enc, s + (*enc)->minBytesPerChar,
-				next - (*enc)->minBytesPerChar,
-				&tem);
-	if (result) {
-	  if (tem)
-	    *nextPtr = tem;
-	  return result;
-	}
-	break;
-      }
-    case XML_ROLE_ENTITY_VALUE:
-      {
-	enum WfCheckResult result
-	  = storeEntity(dtd,
-			*enc,
-			entityIsParam,
-			entityNamePtr,
-			entityNameEnd,
-			s,
-			next,
-			nextPtr);
-	if (result != wellFormed)
-	  return result;
-      }
-      break;
-    case XML_ROLE_ENTITY_SYSTEM_ID:
-      {
-	const char *name = poolStoreString(&dtd->pool, *enc, entityNamePtr, entityNameEnd);
-	entity = (ENTITY *)lookup(entityIsParam ? &dtd->paramEntities : &dtd->generalEntities,
-				  name, sizeof(ENTITY));
-	if (entity->name != name) {
-	  poolDiscard(&dtd->pool);
-	  entity = 0;
-	}
-	else {
-	  poolFinish(&dtd->pool);
-	  entity->systemId = poolStoreString(&dtd->pool, *enc,
-					     s + (*enc)->minBytesPerChar,
-					     next - (*enc)->minBytesPerChar);
-	  poolFinish(&dtd->pool);
-	}
-      }
-      break;
-    case XML_ROLE_PARAM_ENTITY_REF:
-      {
-	const char *name = poolStoreString(&dtd->pool, *enc,
-					   s + (*enc)->minBytesPerChar,
-					   next - (*enc)->minBytesPerChar);
-	ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
-	poolDiscard(&dtd->pool);
-	if (!entity) {
-	  if (!dtd->containsRef || dtd->standalone) {
-	    *nextPtr = s;
-	    return undefinedEntity;
-	  }
-	}
-      }
-      break;
-    case XML_ROLE_ENTITY_NOTATION_NAME:
-      if (entity) {
-	entity->notation = poolStoreString(&dtd->pool, *enc, s, next);
-	poolFinish(&dtd->pool);
-      }
-      break;
-    case XML_ROLE_GENERAL_ENTITY_NAME:
-      entityNamePtr = s;
-      entityNameEnd = next;
-      entityIsParam = 0;
-      break;
-    case XML_ROLE_PARAM_ENTITY_NAME:
-      entityNamePtr = s;
-      entityNameEnd = next;
-      entityIsParam = 1;
-      break;
-    case XML_ROLE_ERROR:
-      *nextPtr = s;
-      switch (tok) {
-      case XML_TOK_PARAM_ENTITY_REF:
-	return paramEntityRef;
-      case XML_TOK_INVALID:
-	*nextPtr = next;
-	return invalidToken;
-      case XML_TOK_NONE:
-	return noElements;
-      case XML_TOK_PARTIAL:
-	return unclosedToken;
-      case XML_TOK_PARTIAL_CHAR:
-	return partialChar;
-      case XML_TOK_TRAILING_CR:
-	*nextPtr = s + (*enc)->minBytesPerChar;
-	return noElements;
-      case XML_TOK_XML_DECL:
-	return misplacedXmlPi;
-      default:
-	return syntaxError;
-      }
-    case XML_ROLE_GROUP_OPEN:
-      if (state.level >= dtd->groupSize) {
-	if (dtd->groupSize)
-	  dtd->groupConnector = realloc(dtd->groupConnector, dtd->groupSize *= 2);
-	else
-	  dtd->groupConnector = malloc(dtd->groupSize = 32);
-	if (!dtd->groupConnector)
-	  return noMemory;
-      }
-      dtd->groupConnector[state.level] = 0;
-      break;
-    case XML_ROLE_GROUP_SEQUENCE:
-      if (dtd->groupConnector[state.level] == '|') {
-	*nextPtr = s;
-	return syntaxError;
-      }
-      dtd->groupConnector[state.level] = ',';
-      break;
-    case XML_ROLE_GROUP_CHOICE:
-      if (dtd->groupConnector[state.level] == ',') {
-	*nextPtr = s;
-	return syntaxError;
-      }
-      dtd->groupConnector[state.level] = '|';
-      break;
-    case XML_ROLE_NONE:
-      if (tok == XML_TOK_PARAM_ENTITY_REF)
-	dtd->containsRef = 1;
-      break;
-    }
-    s = next;
-  }
-  /* not reached */
-}
-
-static enum WfCheckResult
-checkParsedEntities(CONTEXT *context, const char **badPtr)
-{
-  HASH_TABLE_ITER iter;
-  hashTableIterInit(&iter, &context->dtd.generalEntities);
-  for (;;) {
-    ENTITY *entity = (ENTITY *)hashTableIterNext(&iter);
-    if (!entity)
-      break;
-    if (entity->textPtr && !entity->wfInContent && !entity->magic) {
-      enum WfCheckResult result;
-      const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
-      entity->open = 1;
-      result = checkContent(1, context, internalEnc,
-			    entity->textPtr, entity->textPtr + entity->textLen,
-			    badPtr);
-      entity->open = 0;
-      if (result && *badPtr) {
-	*badPtr = entity->docTextPtr;
-	return result;
-      }
-      entity->wfInContent = 1;
-    }
-  }
-  return wellFormed;
-}
-
-static enum WfCheckResult
-checkGeneralTextEntity(CONTEXT *context,
-		       const char *s, const char *end,
-		       const char **nextPtr,
-		       const ENCODING **enc)
-{
-  INIT_ENCODING initEnc;
-  const char *next;
-  int tok;
-
-  XmlInitEncoding(&initEnc, enc);
-  tok = XmlContentTok(*enc, s, end, &next);
-
-  if (tok == XML_TOK_BOM) {
-    s = next;
-    tok = XmlContentTok(*enc, s, end, &next);
-  }
-  if (tok == XML_TOK_XML_DECL) {
-    const char *encodingName = 0;
-    const ENCODING *encoding = 0;
-    const char *version;
-    if (!XmlParseXmlDecl(1,
-			 *enc,
-			 s,
-			 next,
-			 nextPtr,
-			 &version,
-			 &encodingName,
-			 &encoding,
-			 0))
-      return syntaxError;
-    if (encoding) {
-      if (encoding->minBytesPerChar != (*enc)->minBytesPerChar) {
-	*nextPtr = encodingName;
-	return incorrectEncoding;
-      }
-      *enc = encoding;
-    }
-    else if (encodingName) {
-      *nextPtr = encodingName;
-      return unknownEncoding;
-    }
-    s = next;
-  }
-  context->dtd.containsRef = 1;
-  return checkContent(1, context, *enc, s, end, nextPtr);
-}
-
-static enum WfCheckResult
-checkAttributeValue(DTD *dtd, const ENCODING *enc,
-		    const char *ptr, const char *end, const char **badPtr)
-{
-  for (;;) {
-    const char *next;
-    int tok = XmlAttributeValueTok(enc, ptr, end, &next);
-    switch (tok) {
-    case XML_TOK_TRAILING_CR:
-    case XML_TOK_NONE:
-      return wellFormed;
-    case XML_TOK_INVALID:
-      *badPtr = next;
-      return invalidToken;
-    case XML_TOK_PARTIAL:
-      *badPtr = ptr;
-      return invalidToken;
-    case XML_TOK_CHAR_REF:
-      if (XmlCharRefNumber(enc, ptr) < 0) {
-	*badPtr = ptr;
-	return badCharRef;
-      }
-      break;
-    case XML_TOK_DATA_CHARS:
-    case XML_TOK_DATA_NEWLINE:
-      break;
-    case XML_TOK_ENTITY_REF:
-      {
-	const char *name = poolStoreString(&dtd->pool, enc,
-					   ptr + enc->minBytesPerChar,
-					   next - enc->minBytesPerChar);
-	ENTITY *entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
-	poolDiscard(&dtd->pool);
-	if (!entity) {
-	  if (!dtd->containsRef) {
-	    *badPtr = ptr;
-	    return undefinedEntity;
-	  }
-	  break;
-	}
-	if (entity->wfInAttribute)
-	  break;
-	if (entity->open) {
-	  *badPtr = ptr;
-	  return recursiveEntityRef;
-	}
-	if (entity->notation) {
-	  *badPtr = ptr;
-	  return binaryEntityRef;
-	}
-	if (entity) {
-	  if (entity->textPtr) {
-	    enum WfCheckResult result;
-	    const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
-	    const char *textEnd = entity->textPtr + entity->textLen;
-	    entity->open = 1;
-	    result = checkAttributeValue(dtd, internalEnc, entity->textPtr, textEnd, badPtr);
-	    entity->open = 0;
-	    if (result && *badPtr) {
-	      *badPtr = ptr;
-	      return result;
-	    }
-	    entity->wfInAttribute = 1;
-	  }
-	  else {
-	    *badPtr = ptr;
-	    return attributeExternalEntityRef;
-	  }
-	}
-	break;
-      }
-      break;
-    default:
-      abort();
-    }
-    ptr = next;
-  }
-  /* not reached */
-}
-
-static
-void poolInit(STRING_POOL *pool)
-{
-  pool->blocks = 0;
-  pool->start = 0;
-  pool->ptr = 0;
-  pool->end = 0;
-}
-
-static
-void poolDestroy(STRING_POOL *pool)
-{
-  BLOCK *p = pool->blocks;
-  while (p) {
-    BLOCK *tem = p->next;
-    free(p);
-    p = tem;
-  }
-  pool->blocks = 0;
-  pool->ptr = 0;
-  pool->start = 0;
-  pool->end = 0;
-}
-
-static
-const char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
-		       const char *ptr, const char *end)
-{
-  for (;;) {
-    XmlConvert(enc, XML_UTF8_ENCODING, &ptr, end, &(pool->ptr), pool->end);
-    if (ptr == end)
-      break;
-    if (!poolGrow(pool))
-      return 0;
-  }
-  return pool->start;
-}
-
-static
-const char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
-			    const char *ptr, const char *end)
-{
-  if (!poolAppend(pool, enc, ptr, end))
-    return 0;
-  if (pool->ptr == pool->end && !poolGrow(pool))
-    return 0;
-  *(pool->ptr)++ = 0;
-  return pool->start;
-}
-
-static
-int poolGrow(STRING_POOL *pool)
-{
-  if (pool->blocks && pool->start == pool->blocks->s) {
-    size_t blockSize = (pool->end - pool->start)*2;
-    pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize);
-    if (!pool->blocks)
-      return 0;
-    pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
-    pool->start = pool->blocks->s;
-    pool->end = pool->start + blockSize;
-  }
-  else {
-    BLOCK *tem;
-    size_t blockSize = pool->end - pool->start;
-    if (blockSize < INIT_BLOCK_SIZE)
-      blockSize = INIT_BLOCK_SIZE;
-    else
-      blockSize *= 2;
-    tem = malloc(offsetof(BLOCK, s) + blockSize);
-    if (!tem)
-      return 0;
-    tem->next = pool->blocks;
-    pool->blocks = tem;
-    memcpy(tem->s, pool->start, pool->ptr - pool->start);
-    pool->ptr = tem->s + (pool->ptr - pool->start);
-    pool->start = tem->s;
-    pool->end = tem->s + blockSize;
-  }
-  return 1;
-}
-
-static int dtdInit(DTD *dtd)
-{
-  static const char *names[] = { "lt", "amp", "gt", "quot", "apos" };
-  static const char chars[] = { '<', '&', '>', '"', '\'' };
-  int i;
-
-  poolInit(&(dtd->pool));
-  hashTableInit(&(dtd->generalEntities));
-  for (i = 0; i < 5; i++) {
-    ENTITY *entity = (ENTITY *)lookup(&(dtd->generalEntities), names[i], sizeof(ENTITY));
-    if (!entity)
-      return 0;
-    entity->textPtr = chars + i;
-    entity->textLen = 1;
-    entity->magic = 1;
-    entity->wfInContent = 1;
-    entity->wfInAttribute = 1;
-  }
-  hashTableInit(&(dtd->paramEntities));
-  dtd->containsRef = 0;
-  dtd->groupSize = 0;
-  dtd->groupConnector = 0;
-  return 1;
-}
-
-static void dtdDestroy(DTD *dtd)
-{
-  poolDestroy(&(dtd->pool));
-  hashTableDestroy(&(dtd->generalEntities));
-  hashTableDestroy(&(dtd->paramEntities));
-  free(dtd->groupConnector);
-}
-
-static
-enum WfCheckResult storeEntity(DTD *dtd,
-			       const ENCODING *enc,
-			       int isParam,
-			       const char *entityNamePtr,
-			       const char *entityNameEnd,
-			       const char *entityTextPtr,
-			       const char *entityTextEnd,
-			       const char **badPtr)
-{
-  ENTITY *entity;
-  const ENCODING *utf8 = XmlGetInternalEncoding(XML_UTF8_ENCODING);
-  STRING_POOL *pool = &(dtd->pool);
-  if (!poolStoreString(pool, enc, entityNamePtr, entityNameEnd))
-    return noMemory;
-  entity = (ENTITY *)lookup(isParam ? &(dtd->paramEntities) : &(dtd->generalEntities),
-			    pool->start,
-			    sizeof(ENTITY));
-  if (entity->name != pool->start) {
-    poolDiscard(pool);
-    entityNamePtr = 0;
-  }
-  else
-    poolFinish(pool);
-  entityTextPtr += enc->minBytesPerChar;
-  entityTextEnd -= enc->minBytesPerChar;
-  entity->docTextPtr = entityTextPtr;
-  for (;;) {
-    const char *next;
-    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
-    switch (tok) {
-    case XML_TOK_PARAM_ENTITY_REF:
-      *badPtr = entityTextPtr;
-      return syntaxError;
-    case XML_TOK_NONE:
-      if (entityNamePtr) {
-	entity->textPtr = pool->start;
-	entity->textLen = pool->ptr - pool->start;
-	poolFinish(pool);
-      }
-      else
-	poolDiscard(pool);
-      return wellFormed;
-    case XML_TOK_ENTITY_REF:
-    case XML_TOK_DATA_CHARS:
-      if (!poolAppend(pool, enc, entityTextPtr, next))
-	return noMemory;
-      break;
-    case XML_TOK_TRAILING_CR:
-      next = entityTextPtr + enc->minBytesPerChar;
-      /* fall through */
-    case XML_TOK_DATA_NEWLINE:
-      if (pool->end == pool->ptr && !poolGrow(pool))
-	return noMemory;
-      *(pool->ptr)++ = '\n';
-      break;
-    case XML_TOK_CHAR_REF:
-      {
-	char buf[XML_MAX_BYTES_PER_CHAR];
-	int i;
-	int n = XmlCharRefNumber(enc, entityTextPtr);
-	if (n < 0) {
-	  *badPtr = entityTextPtr;
-	  return badCharRef;
-	}
-	n = XmlEncode(utf8, n, buf);
-	if (!n) {
-	  *badPtr = entityTextPtr;
-	  return badCharRef;
-	}
-	for (i = 0; i < n; i++) {
-	  if (pool->end == pool->ptr && !poolGrow(pool))
-	    return noMemory;
-	  *(pool->ptr)++ = buf[i];
-	}
-      }
-      break;
-    case XML_TOK_PARTIAL:
-      *badPtr = entityTextPtr;
-      return invalidToken;
-    case XML_TOK_INVALID:
-      *badPtr = next;
-      return invalidToken;
-    default:
-      abort();
-    }
-    entityTextPtr = next;
-  }
-  /* not reached */
-}
diff --git a/xmlwf/wfcheck.h b/xmlwf/wfcheck.h
deleted file mode 100755
index ea8fe57..0000000
--- a/xmlwf/wfcheck.h
+++ /dev/null
@@ -1,38 +0,0 @@
-
-#include <stddef.h>
-
-enum WfCheckResult {
-  wellFormed,
-  noMemory,
-  syntaxError,
-  noElements,
-  invalidToken,
-  unclosedToken,
-  partialChar,
-  tagMismatch,
-  duplicateAttribute,
-  junkAfterDocElement,
-  paramEntityRef,
-  undefinedEntity,
-  recursiveEntityRef,
-  asyncEntity,
-  badCharRef,
-  binaryEntityRef,
-  attributeExternalEntityRef,
-  misplacedXmlPi,
-  unknownEncoding,
-  incorrectEncoding
-};
-
-enum EntityType {
-  documentEntity,
-  generalTextEntity
-};
-
-enum WfCheckResult wfCheck(enum EntityType entityType,
-			   const char *s, size_t n,
-			   const char **errorPtr,
-			   unsigned long *errorLineNumber,
-			   unsigned long *errorColNumber);
-const char *wfCheckMessage(enum WfCheckResult);
-
diff --git a/xmlwf/wfcheckmessage.c b/xmlwf/wfcheckmessage.c
deleted file mode 100755
index 95e811f..0000000
--- a/xmlwf/wfcheckmessage.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "wfcheck.h"
-
-const char *wfCheckMessage(enum WfCheckResult result)
-{
-  static const char *message[] = {
-    0,
-    "out of memory",
-    "syntax error",
-    "no element found",
-    "not well-formed",
-    "unclosed token",
-    "unclosed token",
-    "mismatched tag",
-    "duplicate attribute",
-    "junk after document element",
-    "parameter entity reference not allowed within declaration in internal subset",
-    "undefined entity",
-    "recursive entity reference",
-    "asynchronous entity",
-    "reference to invalid character number",
-    "reference to binary entity",
-    "reference to external entity in attribute",
-    "xml pi not at start of external entity",
-    "unknown encoding",
-    "encoding specified in XML declaration is incorrect"
-  };
-  if (result > 0 && result < sizeof(message)/sizeof(message[0]))
-    return message[result];
-  return 0;
-}