decompile.c

Go to the documentation of this file.

/* ==================================================================== 
 * The Kannel Software License, Version 1.0 
 * 
 * Copyright (c) 2001-2018 Kannel Group  
 * Copyright (c) 1998-2001 WapIT Ltd.   
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 * 
 * 1. Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer. 
 * 
 * 2. Redistributions in binary form must reproduce the above copyright 
 *    notice, this list of conditions and the following disclaimer in 
 *    the documentation and/or other materials provided with the 
 *    distribution. 
 * 
 * 3. The end-user documentation included with the redistribution, 
 *    if any, must include the following acknowledgment: 
 *       "This product includes software developed by the 
 *        Kannel Group (http://www.kannel.org/)." 
 *    Alternately, this acknowledgment may appear in the software itself, 
 *    if and wherever such third-party acknowledgments normally appear. 
 * 
 * 4. The names "Kannel" and "Kannel Group" must not be used to 
 *    endorse or promote products derived from this software without 
 *    prior written permission. For written permission, please  
 *    contact org@kannel.org. 
 * 
 * 5. Products derived from this software may not be called "Kannel", 
 *    nor may "Kannel" appear in their name, without prior written 
 *    permission of the Kannel Group. 
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED.  IN NO EVENT SHALL THE KANNEL GROUP OR ITS CONTRIBUTORS 
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,  
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR  
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,  
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE  
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 * ==================================================================== 
 * 
 * This software consists of voluntary contributions made by many 
 * individuals on behalf of the Kannel Group.  For more information on  
 * the Kannel Group, please see <http://www.kannel.org/>. 
 * 
 * Portions of this software are based upon software originally written at  
 * WapIT Ltd., Helsinki, Finland for the Kannel project.  
 */ 

/*
 * decompile.c - A program to test the WML compiler. This tool was written
 *               from the WBXML 1.2 and WML 1.1 specs.
 *
 * Author: Chris Wulff, Vanteon (cwulff@vanteon.com)
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>

#include "decompile.h"

const WBXML_MB_U_INT32 ZERO_WBXML_MB_U_INT32 = {0,0,0,0};
long dtd_id;

#define INDENT_SIZE     4

DTD_TYPE_LIST DTDTypeList[] =
{
    {1, "UNKNOWN"},
    {2, "-//WAPFORUM//DTD WML 1.0//EN\"\n"
     "\"http://www.wapforum.org/DTD/wml.xml"},
    {3, "-//WAPFORUM//DTD WTA 1.0//EN"},
    {4, "-//WAPFORUM//DTD WML 1.1//EN\"\n"
     "\"http://www.wapforum.org/DTD/wml_1.1.xml"},
    {5, "-//WAPFORUM//DTD SI 1.0//EN\"\n"
     "\"http://www.wapforum.org/DTD/si.dtd"},
    {6, "-//WAPFORUM//DTD SL 1.0//EN\"\n"
     "\"http://www.wapforum.org/DTD/sl.dtd"},
    {7, "-//WAPFORUM//DTD CO 1.0//EN"},
    {8, "-//WAPFORUM//DTD CHANNEL 1.1//EN"},
    {9, "-//WAPFORUM//DTD WML 1.2//EN\"\n"
     "\"http://www.wapforum.org/DTD/wml12.dtd"},
    {0, NULL}
};


/**************************************
 * DTD Public Type 4 (WML 1.1) Tables *
 **************************************/

CODEPAGE_TAG_NAME_LIST CodepageTagNames[] =
{
    {4, "a",         0, 0x1c},
    {4, "anchor",    0, 0x22},
    {4, "access",    0, 0x23},
    {4, "b",         0, 0x24},
    {4, "big",       0, 0x25},
    {4, "br",        0, 0x26},
    {4, "card",      0, 0x27},
    {4, "do",        0, 0x28},
    {4, "em",        0, 0x29},
    {4, "fieldset",  0, 0x2a},
    {4, "go",        0, 0x2b},
    {4, "head",      0, 0x2c},
    {4, "i",         0, 0x2d},
    {4, "img",       0, 0x2e},
    {4, "input",     0, 0x2f},
    {4, "meta",      0, 0x30},
    {4, "noop",      0, 0x31},
    {4, "p",         0, 0x20},
    {4, "postfield", 0, 0x21},
    {4, "pre",       0, 0x1b},
    {4, "prev",      0, 0x32},
    {4, "onevent",   0, 0x33},
    {4, "optgroup",  0, 0x34},
    {4, "option",    0, 0x35},
    {4, "refresh",   0, 0x36},
    {4, "select",    0, 0x37},
    {4, "setvar",    0, 0x3e},
    {4, "small",     0, 0x38},
    {4, "strong",    0, 0x39},
    {4, "table",     0, 0x1f},
    {4, "td",        0, 0x1d},
    {4, "template",  0, 0x3b},
    {4, "timer",     0, 0x3c},
    {4, "tr",        0, 0x1e},
    {4, "u",         0, 0x3d},
    {4, "wml",       0, 0x3f},

    {6, "TAG_05",    1, 0x05},
    {6, "TAG_06",    1, 0x06},
    {6, "TAG_07",    1, 0x07},

    {0, NULL, 0, 0}
};

CODEPAGE_ATTRSTART_NAME_LIST CodepageAttrstartNames[] =
{
    {4, "accept-charset",  NULL,                                0, 0x05},
    {4, "accesskey",       NULL,                                0, 0x5e},
    {4, "align",           NULL,                                0, 0x52},
    {4, "align",           "bottom",                            0, 0x06},
    {4, "align",           "center",                            0, 0x07},
    {4, "align",           "left",                              0, 0x08},
    {4, "align",           "middle",                            0, 0x09},
    {4, "align",           "right",                             0, 0x0a},
    {4, "align",           "top",                               0, 0x0b},
    {4, "alt",             NULL,                                0, 0x0c},
    {4, "class",           NULL,                                0, 0x54},
    {4, "columns",         NULL,                                0, 0x53},
    {4, "content",         NULL,                                0, 0x0d},
    {4, "content",         "application/vnd.wap.wmlc;charset=", 0, 0x5c},
    {4, "domain",          NULL,                                0, 0x0f},
    {4, "emptyok",         "false",                             0, 0x10},
    {4, "emptyok",         "true",                              0, 0x11},
    {4, "enctype",         NULL,                                0, 0x5f},
    {4, "enctype",         "application/x-www-form-urlencoded", 0, 0x60},
    {4, "enctype",         "multipart/form-data",               0, 0x61},
    {4, "format",          NULL,                                0, 0x12},
    {4, "forua",           "false",                             0, 0x56},
    {4, "forua",           "true",                              0, 0x57},
    {4, "height",          NULL,                                0, 0x13},
    {4, "href",            NULL,                                0, 0x4a},
    {4, "href",            "http://",                           0, 0x4b},
    {4, "href",            "https://",                          0, 0x4c},
    {4, "hspace",          NULL,                                0, 0x14},
    {4, "http-equiv",      NULL,                                0, 0x5a},
    {4, "http-equiv",      "Content-Type",                      0, 0x5b},
    {4, "http-equiv",      "Expires",                           0, 0x5d},
    {4, "id",              NULL,                                0, 0x55},
    {4, "ivalue",          NULL,                                0, 0x15},
    {4, "iname",           NULL,                                0, 0x16},
    {4, "label",           NULL,                                0, 0x18},
    {4, "localsrc",        NULL,                                0, 0x19},
    {4, "maxlength",       NULL,                                0, 0x1a},
    {4, "method",          "get",                               0, 0x1b},
    {4, "method",          "post",                              0, 0x1c},
    {4, "mode",            "nowrap",                            0, 0x1d},
    {4, "mode",            "wrap",                              0, 0x1e},
    {4, "multiple",        "false",                             0, 0x1f},
    {4, "multiple",        "true",                              0, 0x20},
    {4, "name",            NULL,                                0, 0x21},
    {4, "newcontext",      "false",                             0, 0x22},
    {4, "newcontext",      "true",                              0, 0x23},
    {4, "onenterbackward", NULL,                                0, 0x25},
    {4, "onenterforward",  NULL,                                0, 0x26},
    {4, "onpick",          NULL,                                0, 0x24},
    {4, "ontimer",         NULL,                                0, 0x27},
    {4, "optional",        "false",                             0, 0x28},
    {4, "optional",        "true",                              0, 0x29},
    {4, "path",            NULL,                                0, 0x2a},
    {4, "scheme",          NULL,                                0, 0x2e},
    {4, "sendreferer",     "false",                             0, 0x2f},
    {4, "sendreferer",     "true",                              0, 0x30},
    {4, "size",            NULL,                                0, 0x31},
    {4, "src",             NULL,                                0, 0x32},
    {4, "src",             "http://",                           0, 0x58},
    {4, "src",             "https://",                          0, 0x59},
    {4, "ordered",         "true",                              0, 0x33},
    {4, "ordered",         "false",                             0, 0x34},
    {4, "tabindex",        NULL,                                0, 0x35},
    {4, "title",           NULL,                                0, 0x36},
    {4, "type",            NULL,                                0, 0x37},
    {4, "type",            "accept",                            0, 0x38},
    {4, "type",            "delete",                            0, 0x39},
    {4, "type",            "help",                              0, 0x3a},
    {4, "type",            "password",                          0, 0x3b},
    {4, "type",            "onpick",                            0, 0x3c},
    {4, "type",            "onenterbackward",                   0, 0x3d},
    {4, "type",            "onenterforward",                    0, 0x3e},
    {4, "type",            "ontimer",                           0, 0x3f},
    {4, "type",            "options",                           0, 0x45},
    {4, "type",            "prev",                              0, 0x46},
    {4, "type",            "reset",                             0, 0x47},
    {4, "type",            "text",                              0, 0x48},
    {4, "type",            "vnd.",                              0, 0x49},
    {4, "value",           NULL,                                0, 0x4d},
    {4, "vspace",          NULL,                                0, 0x4e},
    {4, "width",           NULL,                                0, 0x4f},
    {4, "xml:lang",        NULL,                                0, 0x50},

    {6, "ATTR_06",         NULL,                                1, 0x06},
    {6, "ATTR_07",         NULL,                                1, 0x07},
    {6, "ATTR_08",         NULL,                                1, 0x08},
    {6, "ATTR_11",         NULL,                                1, 0x11},
    {6, "ATTR_12",         NULL,                                1, 0x12},
    {6, "ATTR_13",         NULL,                                1, 0x13},
    {6, "ATTR_14",         NULL,                                1, 0x14},
    {6, "ATTR_15",         NULL,                                1, 0x15},
    {6, "ATTR_21",         NULL,                                1, 0x21},
    {6, "ATTR_22",         NULL,                                1, 0x22},
    {6, "ATTR_23",         NULL,                                1, 0x23},
    {6, "ATTR_24",         NULL,                                1, 0x24},
    {6, "ATTR_28",         NULL,                                1, 0x28},
    {6, "ATTR_29",         NULL,                                1, 0x29},
    {6, "ATTR_45",         NULL,                                1, 0x45},
    {6, "ATTR_61",         NULL,                                1, 0x61},
    {6, "ATTR_62",         NULL,                                1, 0x62},
    {6, "ATTR_63",         NULL,                                1, 0x63},
    {6, "ATTR_64",         NULL,                                1, 0x64},
    {6, "ATTR_6A",         NULL,                                1, 0x6A},
    {6, "ATTR_6B",         NULL,                                1, 0x6B},
    {6, "ATTR_6C",         NULL,                                1, 0x6C},
    {6, "ATTR_70",         NULL,                                1, 0x70},
    {6, "ATTR_71",         NULL,                                1, 0x71},
    {6, "ATTR_73",         NULL,                                1, 0x73},
    {6, "ATTR_74",         NULL,                                1, 0x74},

    {0, NULL,              NULL,                                0, 0}
};

CODEPAGE_ATTRVALUE_NAME_LIST CodepageAttrvalueNames[] =
{
    {4, ".com/",           0, 0x85},
    {4, ".edu/",           0, 0x86},
    {4, ".net/",           0, 0x87},
    {4, ".org/",           0, 0x88},
    {4, "accept",          0, 0x89},
    {4, "bottom",          0, 0x8a},
    {4, "clear",           0, 0x8b},
    {4, "delete",          0, 0x8c},
    {4, "help",            0, 0x8d},
    {4, "http://",         0, 0x8e},
    {4, "http://www.",     0, 0x8f},
    {4, "https://",        0, 0x90},
    {4, "https://www.",    0, 0x91},
    {4, "middle",          0, 0x93},
    {4, "nowrap",          0, 0x94},
    {4, "onenterbackward", 0, 0x96},
    {4, "onenterforward",  0, 0x97},
    {4, "onpick",          0, 0x95},
    {4, "ontimer",         0, 0x98},
    {4, "options",         0, 0x99},
    {4, "password",        0, 0x9a},
    {4, "reset",           0, 0x9b},
    {4, "text",            0, 0x9d},
    {4, "top",             0, 0x9e},
    {4, "unknown",         0, 0x9f},
    {4, "wrap",            0, 0xa0},
    {4, "www.",            0, 0xa1},
    {0, NULL, 0, 0}
};


/**************************
 * Node Tree Construction *
 **************************/

/*
 * Function: NewNode
 *
 * Description:
 *
 *  Allocate and initialize a new node. This links the new node
 *  as the first child of the current node in the buffer. This causes
 *  child nodes to be linked in reverse order. If there is no current
 *  node, then the new node will be linked in as the first child at the
 *  top of the tree.
 *
 * Parameters:
 *
 *  buffer - WBXML buffer to link the new node into
 *  type   - Type of node to allocate
 *
 * Return value:
 *
 *  P_WBXML_NODE - A pointer to the newly allocated node.
 *
 */
static P_WBXML_NODE NewNode(P_WBXML_INFO buffer, WBXML_NODE_TYPE type)
{
    if (buffer)
    {
        P_WBXML_NODE newnode = malloc(sizeof(WBXML_NODE));

        if (newnode)
        {
            newnode->m_prev = NULL;
            newnode->m_child = NULL;

            if (buffer->m_curnode)
            {
                /* Insert this node as the first child of the current node */
                newnode->m_parent = buffer->m_curnode;
                newnode->m_next = buffer->m_curnode->m_child;

                if (buffer->m_curnode->m_child)
                {
                    ((P_WBXML_NODE)buffer->m_curnode->m_child)->m_prev = newnode;
                }

                buffer->m_curnode->m_child = newnode;
            }
            else
            {
                /* Insert this node at the top of the tree */
                newnode->m_parent = NULL;
                newnode->m_next = buffer->m_tree;
                
                if (buffer->m_tree)
                {
                    buffer->m_tree->m_prev = newnode;
                }

                buffer->m_tree = newnode;
            }

            newnode->m_page = buffer->m_curpage;
            newnode->m_type = type;
            newnode->m_data = NULL;
        }
        else
        {
            ParseError(ERR_NOT_ENOUGH_MEMORY);
        }

        return newnode;
    }
    else
    {
        ParseError(ERR_INTERNAL_BAD_PARAM);
    }

    return NULL;
}

/*
 * Function: FreeNode
 *
 * Description:
 *
 *  Free a node, all its children and forward siblings.
 *
 * Parameters:
 *
 *  node - The node to free
 *
 */
static void FreeNode(P_WBXML_NODE node)
{
    if (node)
    {
        if (node->m_child)
        {
            FreeNode(node->m_child);
        }

        if (node->m_next)
        {
            FreeNode(node->m_next);
        }

        free(node);
    }
}

static void AddDTDNode(P_WBXML_INFO buffer, const WBXML_DTD_TYPE dtdnum, const WBXML_MB_U_INT32 index)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_DTD_TYPE);
    newnode->m_data = malloc(sizeof(DTD_NODE_DATA));
    memcpy( &( ((DTD_NODE_DATA*)newnode->m_data)->m_dtdnum ), &(dtdnum[0]), sizeof(WBXML_MB_U_INT32) );
    memcpy( &( ((DTD_NODE_DATA*)newnode->m_data)->m_index ), &(index[0]), sizeof(WBXML_MB_U_INT32) );
    dtd_id = (long) dtdnum[0];
}

static void AddStringTableNode(P_WBXML_INFO buffer, const P_WBXML_STRING_TABLE strings)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_STRING_TABLE);
    newnode->m_data = malloc(sizeof(WBXML_STRING_TABLE));
    memcpy( newnode->m_data, strings, sizeof(WBXML_STRING_TABLE) );
}

static void AddCodepageTagNode(P_WBXML_INFO buffer, WBXML_TAG tag)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_CODEPAGE_TAG);
    newnode->m_data = malloc(sizeof(WBXML_TAG));
    *((P_WBXML_TAG)newnode->m_data) = tag;
}

static void AddCodepageLiteralTagNode(P_WBXML_INFO buffer, WBXML_MB_U_INT32 index)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_CODEPAGE_LITERAL_TAG);
    newnode->m_data = malloc(sizeof(WBXML_MB_U_INT32));
    memcpy( ((P_WBXML_MB_U_INT32)newnode->m_data), &index, sizeof(WBXML_MB_U_INT32) );
}

static void AddAttrStartNode(P_WBXML_INFO buffer, WBXML_TAG tag)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTRSTART);
    newnode->m_data = malloc(sizeof(WBXML_TAG));
    *((P_WBXML_TAG)newnode->m_data) = tag;
}

static void AddAttrStartLiteralNode(P_WBXML_INFO buffer, WBXML_MB_U_INT32 index)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTRSTART_LITERAL);
    newnode->m_data = malloc(sizeof(WBXML_MB_U_INT32));
    memcpy( ((P_WBXML_MB_U_INT32)newnode->m_data), &index, sizeof(WBXML_MB_U_INT32) );
}

static void AddAttrValueNode(P_WBXML_INFO buffer, WBXML_TAG tag)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTRVALUE);
    newnode->m_data = malloc(sizeof(WBXML_TAG));
    *((P_WBXML_TAG)newnode->m_data) = tag;
}

static void AddAttrEndNode(P_WBXML_INFO buffer)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_ATTREND);
    newnode->m_data = NULL;
}

static void AddStringNode(P_WBXML_INFO buffer, char* string)
{
    P_WBXML_NODE newnode = NewNode(buffer, NODE_STRING);
    newnode->m_data = strdup(string);
}

static void AddVariableStringNode(P_WBXML_INFO buffer, char* string, WBXML_VARIABLE_TYPE type)
{
    /* TODO: add this node */
}

static void AddVariableIndexNode(P_WBXML_INFO buffer, char* string, WBXML_VARIABLE_TYPE type)
{
    /* TODO: add this node */
}


/****************
 * Flow Control *
 ****************/

void Message(char* msg)
{
  printf("%s\n", msg);
}

void ParseError(WBXML_PARSE_ERROR error)
{
  switch (error)
  {
    case ERR_END_OF_DATA:
      Message("Input stream is incomplete (EOF).");
      break;

    case ERR_INTERNAL_BAD_PARAM:
      Message("Internal error: Bad parameter.");
      break;

    case ERR_TAG_NOT_FOUND:
      Message("Tag not found.");
      break;
        
    case ERR_FILE_NOT_FOUND:
      Message("File not found.");
      break;

    case ERR_FILE_NOT_READ:
      Message("File read error.");
      break;

    case ERR_NOT_ENOUGH_MEMORY:
      Message("Not enough memory");
      break;

    default:
      Message("Unknown error.");
      break;
  }

  exit(error);
}

void ParseWarning(WBXML_PARSE_WARNING warning)
{
  switch (warning)
  {
    case WARN_FUTURE_EXPANSION_EXT_0:
      Message("Token EXT_0 encountered. This token is reserved for future expansion.");
      break;

    case WARN_FUTURE_EXPANSION_EXT_1:
      Message("Token EXT_1 encountered. This token is reserved for future expansion.");
      break;

    case WARN_FUTURE_EXPANSION_EXT_2:
      Message("Token EXT_2 encountered. This token is reserved for future expansion.");
      break;

    default:
      Message("Unknown warning.");
      break;
  }
}

WBXML_LENGTH BytesLeft(P_WBXML_INFO buffer)
{
  if (buffer)
  {
    WBXML_LENGTH bytesRead = (buffer->m_curpos - buffer->m_start);
    if (bytesRead >= buffer->m_length)
    {
      return 0;
    }
    else
    {
      return (buffer->m_length - bytesRead);
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }

  return 0;
}

BOOL IsTag(P_WBXML_INFO buffer, WBXML_TAG tag)
{
  BOOL result = FALSE;

  if (buffer)
  {
    if (BytesLeft(buffer) >= sizeof(WBXML_TAG))
    {
      result = ((*((WBXML_TAG*) buffer->m_curpos)) == tag);
    }
    else
    {
        /* No more data, so nope, not this tag */
      result = FALSE;
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }

  return result;
}

BOOL IsCodepageTag(P_WBXML_INFO buffer, CP_TAG_TYPE type)
{
    WBXML_U_INT8 result = *(buffer->m_curpos);

    /* NOTE THAT THESE ARE NOT UNIQUE! */
    switch (type)
    {
        case CP_TAG_TAG:
            return TRUE;
        case CP_TAG_ATTRSTART:
            return ((result & 0x80) != 0x80);
        case CP_TAG_ATTRVALUE:
            return ((result & 0x80) == 0x80);
        default:
            return FALSE;
    }
}

BOOL Is_attrValue  (P_WBXML_INFO buffer)
{
    WBXML_INFO tmpbuffer;
    memcpy(&tmpbuffer, buffer, sizeof(WBXML_INFO));
    tmpbuffer.m_curpos += SWITCHPAGE_SIZE;

    return ((Is_switchPage(buffer) && IsCodepageTag(&tmpbuffer, CP_TAG_ATTRVALUE)) ||
            IsCodepageTag(buffer, CP_TAG_ATTRVALUE) ||
            Is_string(buffer) ||
            Is_extension(buffer) ||
            Is_entity(buffer) ||
            Is_pi(buffer) ||
            Is_opaque(buffer));
}

BOOL Is_extension  (P_WBXML_INFO buffer)
{
    WBXML_INFO tmpbuffer;
    memcpy(&tmpbuffer, buffer, sizeof(WBXML_INFO));
    tmpbuffer.m_curpos += SWITCHPAGE_SIZE;

    return ((Is_switchPage(buffer) &&
             (IsTag(&tmpbuffer, TAG_EXT_0) ||
              IsTag(&tmpbuffer, TAG_EXT_1) ||
              IsTag(&tmpbuffer, TAG_EXT_2) ||
              IsTag(&tmpbuffer, TAG_EXT_T_0) ||
              IsTag(&tmpbuffer, TAG_EXT_T_1) ||
              IsTag(&tmpbuffer, TAG_EXT_T_2) ||
              IsTag(&tmpbuffer, TAG_EXT_I_0) ||
              IsTag(&tmpbuffer, TAG_EXT_I_1) ||
              IsTag(&tmpbuffer, TAG_EXT_I_2))) ||
            (IsTag(buffer, TAG_EXT_0) ||
             IsTag(buffer, TAG_EXT_1) ||
             IsTag(buffer, TAG_EXT_2) ||
             IsTag(buffer, TAG_EXT_T_0) ||
             IsTag(buffer, TAG_EXT_T_1) ||
             IsTag(buffer, TAG_EXT_T_2) ||
             IsTag(buffer, TAG_EXT_I_0) ||
             IsTag(buffer, TAG_EXT_I_1) ||
             IsTag(buffer, TAG_EXT_I_2)));
}

BOOL Is_string     (P_WBXML_INFO buffer)
{
    return (Is_inline(buffer) ||
            Is_tableref(buffer));
}

BOOL Is_switchPage (P_WBXML_INFO buffer)
{
    return IsTag(buffer, TAG_SWITCH_PAGE);
}

BOOL Is_inline     (P_WBXML_INFO buffer)
{
    return IsTag(buffer, TAG_STR_I);
}

BOOL Is_tableref   (P_WBXML_INFO buffer)
{
    return IsTag(buffer, TAG_STR_T);
}

BOOL Is_entity     (P_WBXML_INFO buffer)
{
    return IsTag(buffer, TAG_ENTITY);
}

BOOL Is_pi         (P_WBXML_INFO buffer)
{
    return IsTag(buffer, TAG_PI);
}

BOOL Is_opaque     (P_WBXML_INFO buffer)
{
    return IsTag(buffer, TAG_OPAQUE);
}

BOOL Is_zero(P_WBXML_INFO buffer)
{
  BOOL result = FALSE;

  if (buffer) 
  {
    if (BytesLeft(buffer) >= 1) 
    {
      result = ((*buffer->m_curpos) == 0);
    }
    else
    {
      ParseError(ERR_END_OF_DATA);
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }

  return result;
}


/***********************
 * Basic Type Decoders *
 ***********************/

void Read_u_int8(P_WBXML_INFO buffer, P_WBXML_U_INT8 result)
{
  if (buffer && result)
  {
    if (BytesLeft(buffer) >= 1) 
    {
      *result = *(buffer->m_curpos);
      (buffer->m_curpos)++;
    }
    else
    {
      ParseError(ERR_END_OF_DATA);
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }
}

void Read_mb_u_int32(P_WBXML_INFO buffer, P_WBXML_MB_U_INT32 result)
{
  if (buffer && result)
  {
    int i;
    for (i = 0; i < MAX_MB_U_INT32_BYTES; i++)
    {
      if (BytesLeft(buffer) >= 1)
      {
        (*result)[i] = *(buffer->m_curpos);
        (buffer->m_curpos)++;

        if ( !( (*result)[i] & 0x80 ) )
          break;
      }
      else
      {
        ParseError(ERR_END_OF_DATA);
      }
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }
}

void Read_bytes(P_WBXML_INFO buffer, WBXML_LENGTH length, P_WBXML_BYTES result)
{
  if (buffer && result)
  {
    if (BytesLeft(buffer) >= length) 
    {
      *result = (WBXML_BYTES) malloc(length*sizeof(unsigned char));
      memcpy(*result, buffer->m_curpos, length);
      buffer->m_curpos += length;
    }
    else
    {
      ParseError(ERR_END_OF_DATA);
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }
}

void ReadFixedTag(P_WBXML_INFO buffer, WBXML_TAG tag)
{
  if (buffer)
  {
    if (BytesLeft(buffer) >= sizeof(WBXML_TAG))
    {
      if ((*((WBXML_TAG*) buffer->m_curpos)) == tag)
      {
        buffer->m_curpos += sizeof(WBXML_TAG);
      }
      else
      {
        ParseError(ERR_TAG_NOT_FOUND);
      }
    }
    else
    {
      ParseError(ERR_END_OF_DATA);
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }
}

WBXML_TAG ReadCodepageTag (P_WBXML_INFO buffer, CP_TAG_TYPE type)
{
  WBXML_TAG tag = 0;

  if (buffer)
  {
    if (BytesLeft(buffer) >= sizeof(WBXML_TAG))
    {
      tag = *((WBXML_TAG*) buffer->m_curpos);

      switch (type)
      {
        case CP_TAG_TAG:
          buffer->m_curpos += sizeof(WBXML_TAG);
          break;

        case CP_TAG_ATTRSTART:
          if ((tag & 0x80) != 0x80)
          {
            buffer->m_curpos += sizeof(WBXML_TAG);
          }
          else
          {
              ParseError(ERR_TAG_NOT_FOUND);
          }
          break;

        case CP_TAG_ATTRVALUE:
          if ((tag & 0x80) == 0x80)
          {
            buffer->m_curpos += sizeof(WBXML_TAG);
          }
          else
          {
              ParseError(ERR_TAG_NOT_FOUND);
          }
          break;

        default:
          ParseError(ERR_TAG_NOT_FOUND);
          break;
      }
    }
    else
    {
      ParseError(ERR_END_OF_DATA);
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }

  return tag;
}


/**************************
 * Basic Type Conversions *
 **************************/

long mb_u_int32_to_long(P_WBXML_MB_U_INT32 value)
{
  long result = 0;

  if (value)
  {
    int i;
    for (i = 0; i < MAX_MB_U_INT32_BYTES; i++)
    {
      result <<= 7;
      result |= ((*value)[i] & 0x7f);

      if ( !( (*value)[i] & 0x80 ) )
        break;
    }
  }
  else
  {
    ParseError(ERR_INTERNAL_BAD_PARAM);
  }

  return result;
}

static void OutputEncodedString(const unsigned char* str)
{
    /* Work our way down the string looking for illegal chars */
    while (*str != 0)
    {
        if ((*str < 0x20) || (*str > 0x7F))
        {
            /* Out of range... encode */
            printf("&#x%02x;", *str);
        }
        else
        {
            switch (*str)
            {
                case '<':
                case '>':
                case '&':
                case '\'':
                case '\"':
                    /* Special symbol... encode */
                    printf("&#x%2x", *str);
                    break;

                default:
                    printf("%c", *str);
                    break;
            }
        }

        str++;
    }
}


/*******************************
 * Document Structure Decoders *
 *******************************/

void Read_start      (P_WBXML_INFO buffer)
{
  Read_version(buffer);
  Read_publicid(buffer);
  Read_charset(buffer);
  Read_strtbl(buffer);
  Read_body(buffer);
}

void Read_strtbl     (P_WBXML_INFO buffer)
{
  WBXML_STRING_TABLE result;
  Read_mb_u_int32(buffer, &(result.m_length));
  Read_bytes(buffer, mb_u_int32_to_long(&(result.m_length)), &(result.m_strings));

  AddStringTableNode(buffer, &result);
}

void Read_body       (P_WBXML_INFO buffer)
{
  while (Is_pi(buffer))
  {
    Read_pi(buffer);
  }

  Read_element(buffer);

  while (Is_pi(buffer))
  {
    Read_pi(buffer);
  }
}

void Read_element    (P_WBXML_INFO buffer)
{
  WBXML_TAG stagvalue = 0;

  if (Is_switchPage(buffer))
  {
    Read_switchPage(buffer);
  }

  stagvalue = Read_stag(buffer);

  /* move the current node down to this one in the tree */
  if (buffer->m_curnode)
      buffer->m_curnode = buffer->m_curnode->m_child;
  else buffer->m_curnode = buffer->m_tree;

  if ((stagvalue & CODEPAGE_TAG_HAS_ATTRS) == CODEPAGE_TAG_HAS_ATTRS)
  {
    do
    {
      Read_attribute(buffer);

    } while (!IsTag(buffer, TAG_END));

    ReadFixedTag(buffer, TAG_END);

    AddAttrEndNode(buffer);
  }

  if ((stagvalue & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
  {
    while (!IsTag(buffer, TAG_END))
    {
      Read_content(buffer);
    }

    ReadFixedTag(buffer, TAG_END);
  }

  /* move the current node back up one */
  buffer->m_curnode = buffer->m_curnode->m_parent;
}

void Read_content    (P_WBXML_INFO buffer)
{
    if (Is_string(buffer))
    {
        Read_string(buffer);
    }
    else if (Is_extension(buffer))
    {
        Read_extension(buffer);
    }
    else if (Is_entity(buffer))
    {
        Read_entity(buffer);
    }
    else if (Is_pi(buffer))
    {
        Read_pi(buffer);
    }
    else if (Is_opaque(buffer))
    {
        Read_opaque(buffer);
    }
    else
    {
        /* Assume it is an element */
        Read_element(buffer);
    }
}

WBXML_TAG Read_stag       (P_WBXML_INFO buffer)
{
    if (IsCodepageTag(buffer, CP_TAG_TAG))
    {
        WBXML_TAG tag = ReadCodepageTag(buffer, CP_TAG_TAG);

        AddCodepageTagNode(buffer, tag);

        return tag;
    }
    else if (IsTag(buffer, TAG_LITERAL))
    {
        WBXML_MB_U_INT32 index;

        ReadFixedTag(buffer, TAG_LITERAL);
        Read_index(buffer, &index);

        AddCodepageLiteralTagNode(buffer, index);
    }
    else
    {
        ParseError(ERR_TAG_NOT_FOUND);
    }

    return 0;
}

void Read_attribute  (P_WBXML_INFO buffer)
{
    Read_attrStart(buffer);

    while (Is_attrValue(buffer))
    {
        Read_attrValue(buffer);
    }
}

void Read_attrStart  (P_WBXML_INFO buffer)
{
  if (Is_switchPage(buffer))
  {
    WBXML_TAG tag;
    Read_switchPage(buffer);
    tag = ReadCodepageTag(buffer, CP_TAG_ATTRSTART);

    AddAttrStartNode(buffer, tag);
  }
  else if (IsCodepageTag(buffer, CP_TAG_ATTRSTART))
  {
    WBXML_TAG tag;
    tag = ReadCodepageTag(buffer, CP_TAG_ATTRSTART);

    AddAttrStartNode(buffer, tag);
  }
  else if (IsTag(buffer, TAG_LITERAL))
  {
    WBXML_MB_U_INT32 index;

    ReadFixedTag(buffer, TAG_LITERAL);
    Read_index(buffer, &index);

    AddAttrStartLiteralNode(buffer, index);
  }
  else
  {
    ParseError(ERR_TAG_NOT_FOUND);
  }
}

void Read_attrValue  (P_WBXML_INFO buffer)
{
  if (Is_switchPage(buffer))
  {
    WBXML_TAG tag;
    Read_switchPage(buffer);
    tag = ReadCodepageTag(buffer, CP_TAG_ATTRVALUE);
    AddAttrValueNode(buffer, tag);
  }
  else if (IsCodepageTag(buffer, CP_TAG_ATTRVALUE))
  {
    WBXML_TAG tag;
    tag = ReadCodepageTag(buffer, CP_TAG_ATTRVALUE);
    AddAttrValueNode(buffer, tag);
  }
  else if (Is_string(buffer))
  {
    Read_string(buffer);
  }
  else if (Is_extension(buffer))
  {
    Read_extension(buffer);
  }
  else if (Is_entity(buffer))
  {
    Read_entity(buffer);
  }
  else if (Is_opaque(buffer))
  {
    Read_opaque(buffer);
  }
  else
  {
    ParseError(ERR_TAG_NOT_FOUND);
  }
}

void Read_extension  (P_WBXML_INFO buffer)
{
    if (Is_switchPage(buffer))
    {
        Read_switchPage(buffer);
    }

    if (IsTag(buffer, TAG_EXT_I_0))
    {
        char* str = NULL;

        ReadFixedTag(buffer, TAG_EXT_I_0);
        Read_termstr_rtn(buffer, &str);

        AddVariableStringNode(buffer, str, VAR_ESCAPED); 
    }
    else if (IsTag(buffer, TAG_EXT_I_1))
    {
        char* str = NULL;

        ReadFixedTag(buffer, TAG_EXT_I_1);
        Read_termstr_rtn(buffer, &str);

        AddVariableStringNode(buffer, str, VAR_UNESCAPED); 
    }
    else if (IsTag(buffer, TAG_EXT_I_2))
    {
        char* str = NULL;

        ReadFixedTag(buffer, TAG_EXT_I_2);
        Read_termstr_rtn(buffer, &str);

        AddVariableStringNode(buffer, str, VAR_UNCHANGED); 
    }
    else if (IsTag(buffer, TAG_EXT_T_0))
    {
        WBXML_MB_U_INT32 index;

        ReadFixedTag(buffer, TAG_EXT_T_0);
        Read_index(buffer, &index);

        AddVariableIndexNode(buffer, index, VAR_ESCAPED);
    }
    else if (IsTag(buffer, TAG_EXT_T_1))
    {
        WBXML_MB_U_INT32 index;

        ReadFixedTag(buffer, TAG_EXT_T_1);
        Read_index(buffer, &index);

        AddVariableIndexNode(buffer, index, VAR_UNESCAPED);
    }
    else if (IsTag(buffer, TAG_EXT_T_2))
    {
        WBXML_MB_U_INT32 index;

        ReadFixedTag(buffer, TAG_EXT_T_2);
        Read_index(buffer, &index);

        AddVariableIndexNode(buffer, index, VAR_UNCHANGED);
    }
    else if (IsTag(buffer, TAG_EXT_0))
    {
        ReadFixedTag(buffer, TAG_EXT_0);

        ParseWarning(WARN_FUTURE_EXPANSION_EXT_0);
    }
    else if (IsTag(buffer, TAG_EXT_1))
    {
        ReadFixedTag(buffer, TAG_EXT_1);

        ParseWarning(WARN_FUTURE_EXPANSION_EXT_1);
    }
    else if (IsTag(buffer, TAG_EXT_2))
    {
        ReadFixedTag(buffer, TAG_EXT_2);

        ParseWarning(WARN_FUTURE_EXPANSION_EXT_2);
    }
    else
    {
        ParseError(ERR_TAG_NOT_FOUND);
    }
}

void Read_string     (P_WBXML_INFO buffer)
{
    if (Is_inline(buffer))
    {
        Read_inline(buffer);
    }
    else if (Is_tableref(buffer))
    {
        Read_tableref(buffer);
    }
    else
    {
        ParseError(ERR_TAG_NOT_FOUND);
    }
}

void Read_switchPage (P_WBXML_INFO buffer)
{
  WBXML_U_INT8 pageindex;

  ReadFixedTag(buffer, TAG_SWITCH_PAGE);
  Read_pageindex(buffer, &pageindex);

  /* Use the new codepage */
  buffer->m_curpage = pageindex;
}

void Read_inline     (P_WBXML_INFO buffer)
{
    ReadFixedTag(buffer, TAG_STR_I);
    Read_termstr(buffer);
}

void Read_tableref   (P_WBXML_INFO buffer)
{
  WBXML_MB_U_INT32 index;

  ReadFixedTag(buffer, TAG_STR_T);
  Read_index(buffer, &index);
}

void Read_entity     (P_WBXML_INFO buffer)
{
    ReadFixedTag(buffer, TAG_ENTITY);
    Read_entcode(buffer);
}

void Read_entcode    (P_WBXML_INFO buffer)
{
    WBXML_MB_U_INT32 result;
    Read_mb_u_int32(buffer, &result);
}

void Read_pi         (P_WBXML_INFO buffer)
{
  ReadFixedTag(buffer, TAG_PI);
  Read_attrStart(buffer);
  
  while (Is_attrValue(buffer))
  {
    Read_attrValue(buffer);
  }

  ReadFixedTag(buffer, TAG_END);
}

void Read_opaque     (P_WBXML_INFO buffer)
{
  WBXML_MB_U_INT32 length;
  WBXML_BYTES      data;

  ReadFixedTag(buffer, TAG_OPAQUE);
  Read_length(buffer, &length);
  Read_bytes(buffer, mb_u_int32_to_long(&length), &data);
}

void Read_version    (P_WBXML_INFO buffer)
{
  WBXML_U_INT8 result;

  Read_u_int8(buffer, &result);
}

void Read_publicid   (P_WBXML_INFO buffer)
{
  if (Is_zero(buffer))
  {
    WBXML_MB_U_INT32 index;

    Read_index(buffer, &index);

    AddDTDNode(buffer, ZERO_WBXML_MB_U_INT32, index);
  }
  else
  {
    WBXML_MB_U_INT32 result;

    Read_mb_u_int32(buffer, &result);

    AddDTDNode(buffer, result, ZERO_WBXML_MB_U_INT32);
  }
}

void Read_charset    (P_WBXML_INFO buffer)
{
  WBXML_MB_U_INT32 result;

  Read_mb_u_int32(buffer, &result);
}

void Read_termstr_rtn(P_WBXML_INFO buffer, char** result)
{

#define STRING_BLOCK_SIZE 256

    int buflen = STRING_BLOCK_SIZE;
    char* strbuf = (char*) malloc(buflen);
    BOOL doubled = FALSE;
    int i = 0;

    if (!result)
        ParseError(ERR_INTERNAL_BAD_PARAM);

    while ( (BytesLeft(buffer) >= 1) && (*(buffer->m_curpos) != 0) )
    {
        if (i>=buflen)
        {
            buflen += STRING_BLOCK_SIZE;
            strbuf = realloc(strbuf, buflen);
        }

        if (*(buffer->m_curpos) != '$' || doubled == TRUE)
        {
            strbuf[i] = *(buffer->m_curpos);
            buffer->m_curpos++;
            i++;
            if (doubled == TRUE)
                doubled = FALSE;
        }
        else
        {
            strbuf[i] = *(buffer->m_curpos);
            i++;
            doubled = TRUE;
        }
    }

    strbuf[i] = 0;
    buffer->m_curpos++;

    if (*result)
        free(*result);

    *result = strbuf;
}

void Read_termstr    (P_WBXML_INFO buffer)
{
    char* strbuf = NULL;

    Read_termstr_rtn(buffer, &strbuf);

    AddStringNode(buffer, strbuf);

    free(strbuf);
}

void Read_index      (P_WBXML_INFO buffer, P_WBXML_MB_U_INT32 result)
{
  Read_mb_u_int32(buffer, result);
}

void Read_length     (P_WBXML_INFO buffer, P_WBXML_MB_U_INT32 result)
{
  Read_mb_u_int32(buffer, result);
}

void Read_zero       (P_WBXML_INFO buffer)
{
  WBXML_U_INT8 result;

  Read_u_int8(buffer, &result);

  if (result != (WBXML_U_INT8) 0)
  {
    ParseError(ERR_TAG_NOT_FOUND);
  }
}

void Read_pageindex  (P_WBXML_INFO buffer, P_WBXML_U_INT8 result)
{
  Read_u_int8(buffer, result);
}

static void Init(P_WBXML_INFO buffer)
{
    buffer->m_start = NULL;
    buffer->m_curpos = NULL;
    buffer->m_length = 0;
    buffer->m_tree = NULL;
    buffer->m_curnode = NULL;
    buffer->m_curpage = 0;
}

static size_t BufferLength(P_WBXML_INFO buffer)
{
    size_t ret;

    while (buffer->m_curpos != '\0')
        buffer->m_curpos++;

    ret = buffer->m_curpos - buffer->m_start;
    buffer->m_curpos = buffer->m_start;
    return ret;
}

static void Free(P_WBXML_INFO buffer)
{
    if (buffer->m_start)
    {
        free(buffer->m_start);
        buffer->m_start = NULL;
    }

    buffer->m_curpos = NULL;
    buffer->m_length = 0;

    FreeNode(buffer->m_tree);
    buffer->m_tree = NULL;
}

static long FileSize(FILE* file)
{
    long curpos = ftell(file);
    long endpos;
    fseek(file, 0, SEEK_END);
    endpos = ftell(file);
    fseek(file, curpos, SEEK_SET);

    return endpos;
}

static void ReadBinary(P_WBXML_INFO buffer, FILE* file)
{
    char buf[4096];
    int m = 1;
    long n;

    if (buffer && file)
    {
        if (file != stdin)
        {
            buffer->m_length = FileSize(file);
            buffer->m_start = (P_WBXML) malloc(buffer->m_length);
            buffer->m_curpos = buffer->m_start;

            if (!buffer->m_start)
            {
                fclose(file);
                ParseError(ERR_NOT_ENOUGH_MEMORY);
            }

            if (fread(buffer->m_start, 1, buffer->m_length, file) != buffer->m_length)
            {
                fclose(file);
                ParseError(ERR_FILE_NOT_READ);
            }
            else
            {
                fclose(file);
            }
        }
        else
        {
            while ((n = fread(buf, 1, sizeof(buf), file)) > 0)
            {
                buffer->m_start = (P_WBXML) realloc(buffer->m_start, sizeof(buf) * m);
                memcpy(buffer->m_start + (sizeof(buf) * (m - 1)), buf, sizeof(buf));
                m++;
            }
            buffer->m_length = BufferLength(buffer);
            buffer->m_curpos = buffer->m_start;
        }
                
    }
    else
    {
        ParseError(ERR_INTERNAL_BAD_PARAM);
    }
}

static const char* DTDTypeName(long dtdnum)
{
    int i = 0;

    /* Search the DTD list for a match */
    while (DTDTypeList[i].m_name)
    {
        if (DTDTypeList[i].m_id == dtdnum)
        {
            break;
        }

        i++;
    }

    return DTDTypeList[i].m_name;
}

static const char* CodepageTagName(WBXML_CODEPAGE page, WBXML_TAG tag)
{
    int i = 0;

    /* Strip flags off of the tag */
    tag = (WBXML_TAG) (tag & CODEPAGE_TAG_MASK);

    /* Search the tag list for a match */
    while (CodepageTagNames[i].m_name)
    {
        if ((CodepageTagNames[i].m_dtd_id == dtd_id) &&
            (CodepageTagNames[i].m_page == page) &&
            (CodepageTagNames[i].m_tag == tag))
        {
            break;
        }

        i++;
    }

    return CodepageTagNames[i].m_name;
}

static const char* CodepageAttrstartName(WBXML_CODEPAGE page, WBXML_TAG tag, char** value)
{
    int i = 0;

    /* Check Parameters */
    if (!value)
    {
        ParseError(ERR_INTERNAL_BAD_PARAM);
    }

    /* Search the tag list for a match */
    while (CodepageAttrstartNames[i].m_name)
    {
        if ((CodepageAttrstartNames[i].m_dtd_id == dtd_id) &&
            (CodepageAttrstartNames[i].m_page == page) &&
            (CodepageAttrstartNames[i].m_tag == tag))
        {
            break;
        }

        i++;
    }

    /* Duplicate the value because it may be concatenated to */
    if (CodepageAttrstartNames[i].m_valueprefix)
    {
        *value = strdup(CodepageAttrstartNames[i].m_valueprefix);
    }
    else
    {
        *value = NULL;
    }

    /* Return the tag name */
    return CodepageAttrstartNames[i].m_name;
}

static void CodepageAttrvalueName(WBXML_CODEPAGE page, WBXML_TAG tag, char** value)
{
    int i = 0;

    /* Check Parameters */
    if (!value)
    {
        ParseError(ERR_INTERNAL_BAD_PARAM);
    }

    /* Search the tag list for a match */
    while (CodepageAttrvalueNames[i].m_name)
    {
        if ((CodepageAttrvalueNames[i].m_dtd_id == dtd_id) &&
            (CodepageAttrvalueNames[i].m_page == page) &&
            (CodepageAttrvalueNames[i].m_tag == tag))
        {
            break;
        }

        i++;
    }

    /* concatenate the value */
    if (CodepageAttrvalueNames[i].m_name)
    {
        if (*value)
        {
            *value = realloc(*value, strlen(*value) + strlen(CodepageAttrvalueNames[i].m_name) + 1);
            strcat(*value, CodepageAttrvalueNames[i].m_name);
        }
        else
        {
            *value = strdup(CodepageAttrvalueNames[i].m_name);
        }
    }
}

static const char* GetStringTableString(P_WBXML_NODE node, long index)
{
    /* Find the string table node */

    P_WBXML_NODE pStringsNode = node;

    while (pStringsNode->m_parent)
    {
        pStringsNode = pStringsNode->m_parent;
    }

    while (pStringsNode->m_next)
    {
        pStringsNode = pStringsNode->m_next;
    }

    while (pStringsNode->m_prev && pStringsNode->m_type != NODE_STRING_TABLE)
    {
        pStringsNode = pStringsNode->m_prev;
    }

    if (pStringsNode->m_type != NODE_STRING_TABLE)
    {
        return "!!NO STRING TABLE!!";
    }

    /* Find the indexed string */

    if ((index >= 0) && (index < mb_u_int32_to_long(&((P_WBXML_STRING_TABLE)pStringsNode->m_data)->m_length)))
    {
        return (const char*) &(((P_WBXML_STRING_TABLE)pStringsNode->m_data)->m_strings[index]);
    }
    else
    {
        return "!!STRING TABLE INDEX TOO LARGE!!";
    }
}

static void DumpNode(P_WBXML_NODE node, int indent, BOOL *inattrs, BOOL hascontent, char** value)
{
    P_WBXML_NODE curnode = node->m_child;

    WBXML_TAG nodetype = 0;
    long dtdnum = 0;

    BOOL bAttributesFollow = FALSE;
    BOOL bHasContent = FALSE;

    int i;

    if (!(*inattrs))
    {
        for (i=0; i<indent; i++)
        {
            printf(" ");
        }
    }
    else
    {
        if ((node->m_type != NODE_ATTRVALUE) && (*value))
        {
            printf("=\"");
            OutputEncodedString((unsigned char*) *value);
            printf("\"");
            free(*value);
            *value = NULL;
        }
    }

    switch (node->m_type)
    {
        case NODE_DTD_TYPE:
            printf("<?xml version=\"1.0\"?>\n<!DOCTYPE wml PUBLIC ");

            dtdnum = mb_u_int32_to_long( &((DTD_NODE_DATA*)node->m_data)->m_dtdnum );
            if ( dtdnum == 0)
            {
                printf("\"%s\">\n\n", GetStringTableString(node, mb_u_int32_to_long(&((DTD_NODE_DATA*)node->m_data)->m_index)) );
            }
            else
            {
                printf("\"%s\">\n\n", DTDTypeName(dtdnum) );
            }
            break;

        case NODE_CODEPAGE_TAG:
            nodetype = *((P_WBXML_TAG)node->m_data);
            if ((nodetype & CODEPAGE_TAG_MASK) == nodetype)
            {
                printf("<%s/>\n", CodepageTagName(node->m_page, nodetype));
            }
            else
            {
                if ((nodetype & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
                {
                    bHasContent = TRUE;
                }

                if ((nodetype & CODEPAGE_TAG_HAS_ATTRS) == CODEPAGE_TAG_HAS_ATTRS)
                {
                    printf("<%s", CodepageTagName(node->m_page, nodetype));
                    bAttributesFollow = TRUE;
                }
                else
                {
                    printf("<%s>\n", CodepageTagName(node->m_page, nodetype));
                }
            }
            break;

        case NODE_CODEPAGE_LITERAL_TAG:
            printf("<%s>\n", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
            break;

        case NODE_ATTRSTART:
            printf(" %s", CodepageAttrstartName(node->m_page, *((P_WBXML_TAG)node->m_data), value) );
            break;

        case NODE_ATTRSTART_LITERAL:
            printf(" %s", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
            break;

        case NODE_ATTRVALUE:
            CodepageAttrvalueName(node->m_page, *((P_WBXML_TAG)node->m_data), value);
            break;

        case NODE_ATTREND:
            if (!hascontent)
            {
                printf("/");
            }
            printf(">\n");
            *inattrs = FALSE;
            break;

        case NODE_STRING:
            if (*inattrs)
            {
                /* concatenate the value */
                if (*value)
                {
                    if (node->m_data)
                    {
                        *value = realloc(*value, strlen(*value) + strlen((char*) node->m_data) + 1);
                        strcat(*value, (char*) node->m_data);
                    }
                }
                else
                {
                    if (node->m_data)
                    {
                        *value = strdup((char*) node->m_data);
                    }
                }
            }
            else
            {
                OutputEncodedString((unsigned char*) node->m_data);
                printf("\n");
            }
            break;

        case NODE_VARIABLE_STRING:
            /* TODO: output variable string */
            break;

        case NODE_VARIABLE_INDEX:
            /* TODO: output variable string */
            break;

        default:
            break;
    }

    indent += INDENT_SIZE;

    if (curnode)
    {
        while (curnode->m_next) curnode = curnode->m_next;

        while (curnode)
        {
            DumpNode(curnode, indent, &bAttributesFollow, bHasContent, value);
            curnode = curnode->m_prev;
        }
    }

    indent -= INDENT_SIZE;

    /* Output the element end if we have one */
    if ((nodetype & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
    {
        for (i=0; i<indent; i++)
        {
            printf(" ");
        }

        switch (node->m_type)
        {
            case NODE_CODEPAGE_TAG:
                printf("</%s>\n", CodepageTagName(node->m_page, *((P_WBXML_TAG)node->m_data)) );
                break;

            case NODE_CODEPAGE_LITERAL_TAG:
                printf("</%s>\n", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
                break;

            default:
                break;
        }
    }
}

static void DumpNodes(P_WBXML_INFO buffer)
{
    P_WBXML_NODE curnode = buffer->m_tree;
    BOOL bAttrsFollow = FALSE;
    char* value = NULL;

    if (curnode)
    {
        while (curnode->m_next) curnode = curnode->m_next;

        while (curnode)
        {
            DumpNode(curnode, 0, &bAttrsFollow, FALSE, &value);
            curnode = curnode->m_prev;
        }
    }
}

int main(int argc, char** argv)
{
    WBXML_INFO buffer;
    FILE* file;

    if (argc < 2)
    {
        file = stdin;
    }
    else
    {
            file = fopen(argv[1], "r");
        if (!file)
        {
            ParseError(ERR_FILE_NOT_FOUND);
        }
    }

    Init(&buffer);
    ReadBinary(&buffer, file);
    Read_start(&buffer);
    DumpNodes(&buffer);
    Free(&buffer);

    return 0;
}