icStringBufferFree (&(parser->attribute_name), libCtx);
      icStringBufferFree (&(parser->attribute_value), libCtx);

      VOLT_SET_FNCT_LINE (fnctLine)
      status = icStringBufferCreate (&(parser->attribute_name), libCtx);
      if (status != 0)
        break;

      VOLT_SET_FNCT_LINE (fnctLine)
      status = icStringBufferCreate (&(parser->attribute_value), libCtx);

      break;

    case 7:
      VOLT_SET_ERROR_TYPE (errorType, 0)
      if (parser->text == (icStringBuffer *)0)
      {
        VOLT_SET_FNCT_LINE (fnctLine)
        status = icStringBufferCreate (&(parser->text), libCtx);
        if (status != 0)
          break;
      }

      if (charClass == VOLT_IC_CHAR_OPEN_ANGLE_BRACKET) 
      {
        parser->state = 1;
        VOLT_SET_FNCT_LINE (fnctLine)
        status = parser->handle_text (parser, parser->text->str, libCtx);
        icStringBufferFree (&(parser->text), libCtx);
        parser->text = (icStringBuffer *) 0;
        break;
      }

      if (charClass == VOLT_IC_CHAR_AMPERSAND) 
      {
        parser->state = 11;
        VOLT_SET_FNCT_LINE (fnctLine)
        status = icStringBufferCreate (&(parser->entity_name), libCtx);
        break;
      }

      VOLT_SET_FNCT_LINE (fnctLine)
      status = icStringBufferAppend (parser->text, theChar, libCtx);

      break;

    case 8:
      parser->is_empty_tag = 1;
      if (charClass == VOLT_IC_CHAR_CLOSE_ANGLE_BRACKET)
        parser->state = 7;

      break;

    case 10:
    default:
      VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VT_ERROR_INVALID_INPUT;
      break;

    case 11:
      VOLT_SET_ERROR_TYPE (errorType, 0)
      if (charClass != VOLT_IC_CHAR_SEMICOLON)
      {
        VOLT_SET_FNCT_LINE (fnctLine)
        status = icStringBufferAppend (parser->entity_name, theChar, libCtx);
        break;
      }

      entityChar = translate_entity (parser->entity_name->str, libCtx);
      if (entityChar != -1 )
      {
        VOLT_SET_FNCT_LINE (fnctLine)
        status = icStringBufferAppend (parser->text, entityChar, libCtx);
      }

      icStringBufferFree (&(parser->entity_name), libCtx);
      parser->entity_name = (icStringBuffer *)0;
      parser->state = 7;
  }

  if ( (status == 0) && (parser->state == 7) &&
       (parser->tag_name != (icStringBuffer *)0) ) 
  {
    VOLT_SET_ERROR_TYPE (errorType, 0)
    if (parser->tag_name->str[0] == '/')
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = parser->handle_end_tag (
        parser, parser->tag_name->str + 1, libCtx);

      icTableFree (&(parser->attributes), libCtx);
    }
    else
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = parser->handle_start_tag (
        parser, parser->tag_name->str, parser->attributes,
        parser->is_empty_tag, libCtx);
    }
    icStringBufferFree (&(parser->tag_name), libCtx);
    parser->tag_name = (icStringBuffer *)0;
    parser->attributes = (icTable *) 0;
  }

  VOLT_LOG_ERROR_COMPARE (
    status, (VtLibCtx)libCtx, status, errorType, fnctLine,
    "icXmlParserParseChar", (char *)0)

  return (status);
}

static int icXmlHandleStartTag (
   icXmlParser *parser,
   char *tag_name,
   icTable *attributes,
   int is_empty,
   VoltLibCtx *libCtx
   )
{
  int status;
  icXmlNode *node = (icXmlNode *)0;
  icXmlNode *parent;
  Pointer item;
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = icXmlNodeCreate (&node, IC_XML_NODE_TAG, libCtx);
    if (status != 0)
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = Z2Strdup (tag_name, &(node->tag_name));
    if (status != 0)
      break;

    /* this is technically an error
     */
    icStackTop (parser->tag_stack, &item, libCtx);
    if (parser->main && (item == (Pointer)0))
    {
      VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VT_ERROR_INVALID_INPUT;
      icXmlNodeFree (&node, libCtx);
      break;
    }

    node->attributes = attributes;
    if (parser->main == (icXmlNode *)0)
      parser->main = node;

    icStackTop (parser->tag_stack, (Pointer *)&parent, libCtx);
    if (parent)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = icXmlNodeAddChild (parent, node, libCtx);
      if (status != 0)
        break;
    }

    if (!is_empty)
      icStackPush (parser->tag_stack, (Pointer)node, libCtx);

  } while (0);

  VOLT_LOG_ERROR_COMPARE (
    status, (VtLibCtx)libCtx, status, errorType, fnctLine,
    "icXmlHandleStartTag", (char *)0)

  return (status);
}

static int icXmlHandleEndTag (
   icXmlParser *parser,
   char *tag_name,
   VoltLibCtx *libCtx
   )
{
  int status;
  icXmlNode *node;
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    icStackTop (parser->tag_stack, (Pointer *)&node, libCtx);

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_NULL_ARG;
    if (node == (icXmlNode *)0)
      break;

    /* nesting order is bad; technically an error
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_INPUT;
    if (Z2Strcmp (node->tag_name, tag_name))
      break;

    icStackPop (parser->tag_stack, (Pointer *)0, libCtx);

    status = 0;

  } while (0);

  VOLT_LOG_ERROR_COMPARE (
    status, (VtLibCtx)libCtx, status, VT_ERROR_TYPE_PRIMARY, fnctLine,
    "icXmlHandleEndTag", (char *)0)

  return (status);
}

static int icXmlHandleText (
   icXmlParser *parser,
   char *text,
   VoltLibCtx *libCtx
   )
{
  int status;
  icXmlNode *node = (icXmlNode *)0;
  icXmlNode *parent;
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    icStackTop (parser->tag_stack, (Pointer *)&parent, libCtx);

    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_NULL_ARG;
    if (parent == (icXmlNode *)0)
      break;

    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = icXmlNodeCreate (&node, IC_XML_NODE_TEXT, libCtx);
    if (status != 0)
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = Z2Strdup (text, &(node->text));
    if (status != 0)
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = icXmlNodeAddChild (parent, node, libCtx);

  } while (0);

  VOLT_LOG_ERROR_COMPARE (
    status, (VtLibCtx)libCtx, status, errorType, fnctLine,
    "icXmlHandleText", (char *)0)

  return (status);
}

static int translate_entity (
   char *entity_name,
   VoltLibCtx *libCtx
   )
{
  int retVal;
  int status;
  long value;
  
  retVal = 0x22;
  if (Z2Strcmp (entity_name, "quot") == 0)
    return (retVal);

  retVal = 0x3c;
  if (Z2Strcmp (entity_name, "lt") == 0)
    return (retVal);

  retVal = 0x3e;
  if (Z2Strcmp (entity_name, "gt") == 0)
    return (retVal);

  retVal = 0x26;
  if (Z2Strcmp (entity_name, "amp") == 0)
    return (retVal);

  retVal = 0x27;
  if (Z2Strcmp (entity_name, "apos") == 0)
    return (retVal);

  /* Handle numeric character references */
  if (entity_name[0] == '#')
  {
    if (entity_name[1] == 'x')
      status = VoltHexStringToNum(entity_name + 2, &value, libCtx);
    else
      status = VoltDecimalStringToNum(entity_name + 1, &value, libCtx);
    if (status == 0)
      return value;
  }
  
  return (-1);
}

static int icClassifyChar (
   int theChar
   )
{
  char val = (char)theChar;

  switch (val)
  {
    case '<':
      return (VOLT_IC_CHAR_OPEN_ANGLE_BRACKET);

    case '>':
      return (VOLT_IC_CHAR_CLOSE_ANGLE_BRACKET);

    case '/':
      return (VOLT_IC_CHAR_SLASH);

    case '=':
      return (VOLT_IC_CHAR_EQUAL);

    case '"':
      return (VOLT_IC_CHAR_QUOTE);

    case '&':
      return (VOLT_IC_CHAR_AMPERSAND);

    case ';':
      return (VOLT_IC_CHAR_SEMICOLON);

    case ' ':
    case '\f':
    case '\n':
    case '\r':
    case '\t':
    case '\v':
      return (0);

    default:
      return (VOLT_IC_CHAR_OTHER);
  }
}