// -*- mode: c++; c-basic-offset:4 -*-

// This file is part of libdap, A C++ implementation of the OPeNDAP Data

// Access Protocol.

// Copyright (c) 2012 OPeNDAP, Inc.

// Author: James Gallagher <jgallagher@opendap.org>

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.

//

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

//

// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.

#include "config.h"

//#define DODS_DEBUG 1

#include <iostream>

#include <sstream>

#include <cstring>

#include <cstdarg>

#include <cassert>

#include <libxml/parserInternals.h>

#include "DMR.h"

#include "BaseType.h"

#include "Array.h"

#include "D4Group.h"

#include "D4Attributes.h"

#include "D4Maps.h"

#include "D4Enum.h"

#include "D4BaseTypeFactory.h"

#include "DapXmlNamespaces.h"

#include "D4ParserSax2.h"

#include "util.h"

#include "debug.h"

namespace libdap {

static const char *states[] = {

        "parser_start",

        "inside_dataset",

        // inside_group is the state just after parsing the start of a Group

        // element.

        "inside_group",

        "inside_attribute_container",

        "inside_attribute",

        "inside_attribute_value",

        "inside_other_xml_attribute",

        "inside_enum_def",

        "inside_enum_const",

        "inside_dim_def",

        // This covers Byte, ..., Url, Opaque

        "inside_simple_type",

        // "inside_array",

        "inside_dim",

        "inside_map",

        "inside_constructor",

        "not_dap4_element",

        "parser_unknown",

        "parser_error",

        "parser_fatal_error",

        "parser_end"

};

static bool is_not(const char *name, const char *tag)

{

    return strcmp(name, tag) != 0;

}

/** @brief Return the current Enumeration definition

 * Allocate the Enumeration definition if needed and return it. Once parsing the current

 * enumeration definition is complete, the pointer allocated/returned by this method will

 * be copied into the current Group and this internal storage will be 'reset' using

 * clear_enum_def().

 *

 * @return

 */

D4EnumDef *

D4ParserSax2::enum_def()

{

    if (!d_enum_def) d_enum_def = new D4EnumDef;

    return d_enum_def;

}

/** @brief Return the current Dimension definition

 * Allocate the Dimension definition if needed and return it.

 * @see enum_def() for an explanation of how this is used by the parser.

 *

 * @return

 */

D4Dimension *

D4ParserSax2::dim_def()    {

    if (!d_dim_def) d_dim_def = new D4Dimension;

    return d_dim_def;

}

/** Dump XML attributes to local store so they can be easily manipulated.

 * XML attribute names are always folded to lower case.

 * @param attributes The XML attribute array

 * @param nb_attributes The number of attributes

 */

void D4ParserSax2::transfer_xml_attrs(const xmlChar **attributes, int nb_attributes)

{

    if (!xml_attrs.empty())

        xml_attrs.clear(); // erase old attributes

    // Make a value using the attribute name and the prefix, namespace URI

    // and the value. The prefix might be null.

    unsigned int index = 0;

    for (int i = 0; i < nb_attributes; ++i, index += 5) {

        xml_attrs.insert(map<string, XMLAttribute>::value_type(string((const char *)attributes[index]),

                                                               XMLAttribute(attributes + index + 1)));

        DBG(cerr << "XML Attribute '" << (const char *)attributes[index] << "': "

                << xml_attrs[(const char *)attributes[index]].value << endl);

    }

}

/** Transfer the XML namespaces to the local store so they can be manipulated

 * more easily.

 *

 * @param namespaces Array of xmlChar*

 * @param nb_namespaces The number of namespaces in the array.

 */

void D4ParserSax2::transfer_xml_ns(const xmlChar **namespaces, int nb_namespaces)

{

    // make a value with the prefix and namespace URI. The prefix might be null.

    for (int i = 0; i < nb_namespaces; ++i) {

        namespace_table.insert(map<string, string>::value_type(namespaces[i * 2] != 0 ? (const char *)namespaces[i * 2] : "",

                                                               (const char *)namespaces[i * 2 + 1]));

    }

}

/** Is a required XML attribute present? Attribute names are always lower case.

 * @note To use this method, first call transfer_xml_attrs.

 * @param attr The XML attribute

 * @return True if the XML attribute was present in the last tag, otherwise

 * it sets the global error state and returns false.

 */

bool D4ParserSax2::check_required_attribute(const string & attr)

{

    if (xml_attrs.find(attr) == xml_attrs.end()) {

        dmr_error(this, "Required attribute '%s' not found.", attr.c_str());

        return false;

    }

    else

        return true;

}

/** Is a XML attribute present? Attribute names are always lower case.

 * @note To use this method, first call transfer_xml_attrs.

 * @param attr The XML attribute

 * @return True if the XML attribute was present in the last/current tag,

 * false otherwise.

 */

bool D4ParserSax2::check_attribute(const string & attr)

{

    return (xml_attrs.find(attr) != xml_attrs.end());

}

bool D4ParserSax2::process_dimension_def(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "Dimension"))

        return false;

    transfer_xml_attrs(attrs, nb_attributes);

    if (!(check_required_attribute("name") && check_required_attribute("size"))) {

        dmr_error(this, "The required attribute 'name' or 'size' was missing from a Dimension element.");

        return false;

    }

    // This getter (dim_def) allocates a new object if needed.

    dim_def()->set_name(xml_attrs["name"].value);

    try {

        dim_def()->set_size(xml_attrs["size"].value);

    }

    catch (Error &e) {

        dmr_error(this, e.get_error_message().c_str());

        return false;

    }

    return true;

}

/**

 * @brief Process a Dim element.

 * If a Dim element is found, the current variable is an Array. If the BaseType

 * on the TOS is not already an Array, make it one. Append the dimension

 * information to the Array variable on the TOS.

 *

 * @note Dim elements can have two attributes: name or size. The latter defines

 * an 'anonymous' dimension (one without a name that does not reference a

 * shared dimension object. If the \c name attribute is used, then the shared

 * dimension used is the one defined by the enclosing group or found using the

 * fully qualified name. The \name and \c size attributes are mutually exclusive.

 *

 * @param name XML element name; must be Dim

 * @param attrs XML Attributes

 * @param nb_attributes The number of XML Attributes

 * @return True if the element is a Dim, false otherwise.

 */

bool D4ParserSax2::process_dimension(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "Dim"))

        return false;

    transfer_xml_attrs(attrs, nb_attributes);

	if (check_attribute("size") && check_attribute("name")) {

		dmr_error(this, "Only one of 'size' and 'name' are allowed in a Dim element, but both were used.");

		return false;

	}

	if (!(check_attribute("size") || check_attribute("name"))) {

		dmr_error(this, "Either 'size' or 'name' must be used in a Dim element.");

		return false;

	}

	if (!top_basetype()->is_vector_type()) {

		// Make the top BaseType* an array

		BaseType *b = top_basetype();

		pop_basetype();

		Array *a = static_cast<Array*>(dmr()->factory()->NewVariable(dods_array_c, b->name()));

		a->set_is_dap4(true);

		a->add_var_nocopy(b);

		a->set_attributes_nocopy(b->attributes());

		// trick: instead of popping b's attributes, copying them and then pushing

		// a's copy, just move the pointer (but make sure there's only one object that

		// references that pointer).

		b->set_attributes_nocopy(0);

		push_basetype(a);

	}

	assert(top_basetype()->is_vector_type());

	Array *a = static_cast<Array*>(top_basetype());

    if (check_attribute("size")) {

    	a->append_dim(atoi(xml_attrs["size"].value.c_str())); // low budget code for now. jhrg 8/20/13

        return true;

    }

    else if (check_attribute("name")) {

    	string name = xml_attrs["name"].value;

    	D4Dimension *dim = 0;

    	if (name[0] == '/')		// lookup the Dimension in the root group

    		dim = dmr()->root()->find_dim(name);

    	else					// get enclosing Group and lookup Dimension there

    		dim = top_group()->find_dim(name);

    	if (!dim)

    		throw Error("The dimension '" + name + "' was not found while parsing the variable '" + a->name() + "'.");

    	a->append_dim(dim);

    	return true;

    }

    return false;

}

bool D4ParserSax2::process_map(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "Map"))

        return false;

    transfer_xml_attrs(attrs, nb_attributes);

	if (!check_attribute("name")) {

		dmr_error(this, "The 'name' attribute must be used in a Map element.");

		return false;

	}

	if (!top_basetype()->is_vector_type()) {

		// Make the top BaseType* an array

		BaseType *b = top_basetype();

		pop_basetype();

		Array *a = static_cast<Array*>(dmr()->factory()->NewVariable(dods_array_c, b->name()));

		a->set_is_dap4(true);

		a->add_var_nocopy(b);

		a->set_attributes_nocopy(b->attributes());

		// trick: instead of popping b's attributes, copying them and then pushing

		// a's copy, just move the pointer (but make sure there's only one object that

		// references that pointer).

		b->set_attributes_nocopy(0);

		push_basetype(a);

	}

	assert(top_basetype()->is_vector_type());

	Array *a = static_cast<Array*>(top_basetype());

	string map_name = xml_attrs["name"].value;

	if (xml_attrs["name"].value[0] != '/')

		map_name = top_group()->FQN() + map_name;

    Array *map_source = 0;	// The array variable that holds the data for the Map

	if (map_name[0] == '/')		// lookup the Map in the root group

		map_source = dmr()->root()->find_map_source(map_name);

	else					// get enclosing Group and lookup Map there

		map_source = top_group()->find_map_source(map_name);

	// Change: If the parser is in 'strict' mode (the default) and the Array named by

	// the Map cannot be fond, it is an error. If 'strict' mode is false (permissive

	// mode), then this is not an error. However, the Array referenced by the Map will

	// be null. This is a change in the parser's behavior to accommodate requests for

	// Arrays that include Maps that do not also include the Map(s) in the request.

	// See https://opendap.atlassian.net/browse/HYRAX-98. jhrg 4/13/16

	if (!map_source && d_strict)

		throw Error("The Map '" + map_name + "' was not found while parsing the variable '" + a->name() + "'.");

	a->maps()->add_map(new D4Map(map_name, map_source));

	return true;

}

bool D4ParserSax2::process_group(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "Group"))

        return false;

    transfer_xml_attrs(attrs, nb_attributes);

    if (!check_required_attribute("name")) {

        dmr_error(this, "The required attribute 'name' was missing from a Group element.");

        return false;

    }

    BaseType *btp = dmr()->factory()->NewVariable(dods_group_c, xml_attrs["name"].value);

    if (!btp) {

        dmr_fatal_error(this, "Could not instantiate the Group '%s'.", xml_attrs["name"].value.c_str());

        return false;

    }

    D4Group *grp = static_cast<D4Group*>(btp);

    // Need to set this to get the D4Attribute behavior in the type classes

    // shared between DAP2 and DAP4. jhrg 4/18/13

    grp->set_is_dap4(true);

    // link it up and change the current group

    D4Group *parent = top_group();

	if (!parent) {

		dmr_fatal_error(this, "No Group on the Group stack.");

		return false;

	}

	grp->set_parent(parent);

	parent->add_group_nocopy(grp);

    push_group(grp);

    push_attributes(grp->attributes());

    return true;

}

/** Check to see if the current tag is either an \c Attribute or an \c Alias

 start tag. This method is a glorified macro...

 @param name The start tag name

 @param attrs The tag's XML attributes

 @return True if the tag was an \c Attribute or \c Alias tag */

inline bool D4ParserSax2::process_attribute(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "Attribute"))

        return false;

    // These methods set the state to parser_error if a problem is found.

    transfer_xml_attrs(attrs, nb_attributes);

    // add error

    if (!(check_required_attribute(string("name")) && check_required_attribute(string("type")))) {

        dmr_error(this, "The required attribute 'name' or 'type' was missing from an Attribute element.");

        return false;

    }

    if (xml_attrs["type"].value == "Container") {

        push_state(inside_attribute_container);

        DBG(cerr << "Pushing attribute container " << xml_attrs["name"].value << endl);

        D4Attribute *child = new D4Attribute(xml_attrs["name"].value, attr_container_c);

        D4Attributes *tos = top_attributes();

        // add return

        if (!tos) {

            delete child;

            dmr_fatal_error(this, "Expected an Attribute container on the top of the attribute stack.");

            return false;

        }

        tos->add_attribute_nocopy(child);

        push_attributes(child->attributes());

    }

    else if (xml_attrs["type"].value == "OtherXML") {

        push_state(inside_other_xml_attribute);

        dods_attr_name = xml_attrs["name"].value;

        dods_attr_type = xml_attrs["type"].value;

    }

    else {

        push_state(inside_attribute);

        dods_attr_name = xml_attrs["name"].value;

        dods_attr_type = xml_attrs["type"].value;

    }

    return true;

}

/** Check to see if the current tag is an \c Enumeration start tag.

 @param name The start tag name

 @param attrs The tag's XML attributes

 @return True if the tag was an \c Enumeration */

inline bool D4ParserSax2::process_enum_def(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "Enumeration"))

        return false;

    transfer_xml_attrs(attrs, nb_attributes);

    if (!(check_required_attribute("name") && check_required_attribute("basetype"))) {

        dmr_error(this, "The required attribute 'name' or 'basetype' was missing from an Enumeration element.");

        return false;

    }

    Type t = get_type(xml_attrs["basetype"].value.c_str());

    if (!is_integer_type(t)) {

        dmr_error(this, "The Enumeration '%s' must have an integer type, instead the type '%s' was used.",

                xml_attrs["name"].value.c_str(), xml_attrs["basetype"].value.c_str());

        return false;

    }

    // This getter allocates a new object if needed.

    string enum_def_path = xml_attrs["name"].value;

#if 0

	// Use FQNs when things are referenced, not when they are defined

    if (xml_attrs["name"].value[0] != '/')

    	enum_def_path = top_group()->FQN() + enum_def_path;

#endif

    enum_def()->set_name(enum_def_path);

    enum_def()->set_type(t);

    return true;

}

inline bool D4ParserSax2::process_enum_const(const char *name, const xmlChar **attrs, int nb_attributes)

{

    if (is_not(name, "EnumConst"))

        return false;

    // These methods set the state to parser_error if a problem is found.

    transfer_xml_attrs(attrs, nb_attributes);

    if (!(check_required_attribute("name") && check_required_attribute("value"))) {

        dmr_error(this, "The required attribute 'name' or 'value' was missing from an EnumConst element.");

        return false;

    }

    istringstream iss(xml_attrs["value"].value);

    long long value = 0;

    iss >> skipws >> value;

    if (iss.fail() || iss.bad()) {

        dmr_error(this, "Expected an integer value for an Enumeration constant, got '%s' instead.",

                xml_attrs["value"].value.c_str());

    }

    else if (!enum_def()->is_valid_enum_value(value)) {

        dmr_error(this, "In an Enumeration constant, the value '%s' cannot fit in a variable of type '%s'.",

                xml_attrs["value"].value.c_str(), D4type_name(d_enum_def->type()).c_str());

    }

    else {

        // unfortunate choice of names... args are 'label' and 'value'

        enum_def()->add_value(xml_attrs["name"].value, value);

    }

    return true;

}

/** Check to see if the current element is the start of a variable declaration.

 If so, process it. A glorified macro...

 @param name The start element name

 @param attrs The element's XML attributes

 @return True if the element was a variable */

inline bool D4ParserSax2::process_variable(const char *name, const xmlChar **attrs, int nb_attributes)

{

    Type t = get_type(name);

    if (is_simple_type(t)) {

        process_variable_helper(t, inside_simple_type, attrs, nb_attributes);

        return true;

    }

    else {

    	switch(t) {

    	case dods_structure_c:

            process_variable_helper(t, inside_constructor, attrs, nb_attributes);

            return true;

    	case dods_sequence_c:

            process_variable_helper(t, inside_constructor, attrs, nb_attributes);

            return true;

    	default:

    		return false;

    	}

    }

}

/** Given that a tag which opens a variable declaration has just been read,

 create the variable. Once created, push the variable onto the stack of

 variables, push that variable's attribute table onto the attribute table

 stack and update the state of the parser.

 @param t The type of variable to create.

 @param s The next state of the parser (e.g., inside_simple_type, ...)

 @param attrs the attributes read with the tag */

void D4ParserSax2::process_variable_helper(Type t, ParseState s, const xmlChar **attrs, int nb_attributes)

{

    transfer_xml_attrs(attrs, nb_attributes);

    if (check_required_attribute("name")) {

        BaseType *btp = dmr()->factory()->NewVariable(t, xml_attrs["name"].value);

        if (!btp) {

            dmr_fatal_error(this, "Could not instantiate the variable '%s'.", xml_attrs["name"].value.c_str());

            return;

        }

        if ((t == dods_enum_c) && check_required_attribute("enum")) {

            D4EnumDef *enum_def = 0;

            string enum_path = xml_attrs["enum"].value;

			if (enum_path[0] == '/')

                enum_def = dmr()->root()->find_enum_def(enum_path);

            else

                enum_def = top_group()->find_enum_def(enum_path);

            if (!enum_def)

                dmr_fatal_error(this, "Could not find the Enumeration definition '%s'.", enum_path.c_str());

            static_cast<D4Enum*>(btp)->set_enumeration(enum_def);

        }

        btp->set_is_dap4(true); // see comment above

        push_basetype(btp);

        push_attributes(btp->attributes());

        push_state(s);

    }

}

/** @name SAX Parser Callbacks

 These methods are declared static in the class header. This gives them C

 linkage which allows them to be used as callbacks by the SAX parser

 engine. */

//@{

/** Initialize the SAX parser state object. This object is passed to each

 callback as a void pointer. The initial state is parser_start.

 @param p The SAX parser  */

void D4ParserSax2::dmr_start_document(void * p)

{

    D4ParserSax2 *parser = static_cast<D4ParserSax2*>(p);

    parser->d_error_msg = "";

    parser->char_data = "";

    // Set this in intern_helper so that the loop test for the parser_end

    // state works for the first iteration. It seems like XMLParseChunk calls this

    // function on it's first run. jhrg 9/16/13

    // parser->push_state(parser_start);

    parser->push_attributes(parser->dmr()->root()->attributes());

    if (parser->debug()) cerr << "Parser start state: " << states[parser->get_state()] << endl;

}

/** Clean up after finishing a parse.

 @param p The SAX parser  */

void D4ParserSax2::dmr_end_document(void * p)

{

    D4ParserSax2 *parser = static_cast<D4ParserSax2*>(p);

    if (parser->debug()) cerr << "Parser end state: " << states[parser->get_state()] << endl;

    if (parser->get_state() != parser_end)

        D4ParserSax2::dmr_error(parser, "The document contained unbalanced tags.");

    // If we've found any sort of error, don't make the DMR; intern() will

    // take care of the error.

    if (parser->get_state() == parser_error || parser->get_state() == parser_fatal_error)

        return;

    if (!parser->empty_basetype() || parser->empty_group())

    	D4ParserSax2::dmr_error(parser, "The document did not contain a valid root Group or contained unbalanced tags.");

    parser->pop_group();     // leave the stack 'clean'

    parser->pop_attributes();

}

/**

 * Callback run when libxml2 reads the start of an element

 *

 * @param p Pointer to the parser object

 * @param l Localname of the element

 * @param prefix Namespace prefix of the element

 * @param URI the Element namespace name if available

 * @param nb_namespaces Number of namespace definitions on that node

 * @param namespaces Pointer to the array of prefix/URI pairs namespace definitions

 * @param nb_attributes The number of attributes on that node

 * @param nb_defaulted The number of defaulted attributes. The defaulted ones are at the end of the array

 * @param attributes Pointer to the array of (localname/prefix/URI/value/end) attribute values.

 */

void D4ParserSax2::dmr_start_element(void *p, const xmlChar *l, const xmlChar *prefix, const xmlChar *URI,

        int nb_namespaces, const xmlChar **namespaces, int nb_attributes, int /*nb_defaulted*/,

        const xmlChar **attributes)

{

    D4ParserSax2 *parser = static_cast<D4ParserSax2*>(p);

    const char *localname = (const char *) l;

    if (parser->debug()) cerr << "Start element " << localname << "  prefix:  "<< (prefix?(char *)prefix:"null") << "  ns: "<< (URI?(char *)URI:"null")

    		   << " (state: " << states[parser->get_state()] << ")" << endl;

    if(parser->get_state() != parser_error){

        string dap4_ns_name = DapXmlNamspaces::getDapNamespaceString(DAP_4_0);

        if (parser->debug()) cerr << "dap4_ns_name:         " << dap4_ns_name << endl;

        string this_element_ns_name = (URI != 0) ? ((char *)URI) : "";

        if (parser->debug()) cerr << "this_element_ns_name: " << this_element_ns_name << endl;

        if(this_element_ns_name.compare(dap4_ns_name)){

            if (parser->debug()) cerr << "Start of non DAP4 element: " << localname << " detected." << endl;

        	parser->push_state(not_dap4_element);

        	// return;

        }

    }

    switch (parser->get_state()) {

        case parser_start:

            if (is_not(localname, "Dataset"))

                D4ParserSax2::dmr_error(parser, "Expected DMR to start with a Dataset element; found '%s' instead.", localname);

            parser->root_ns = URI ? (const char *) URI : "";

            parser->transfer_xml_attrs(attributes, nb_attributes);

            if (parser->check_required_attribute(string("name")))

                parser->dmr()->set_name(parser->xml_attrs["name"].value);

            if (parser->check_attribute("dapVersion"))

                parser->dmr()->set_dap_version(parser->xml_attrs["dapVersion"].value);

            if (parser->check_attribute("dmrVersion"))

                parser->dmr()->set_dmr_version(parser->xml_attrs["dmrVersion"].value);

            if (parser->check_attribute("base"))

                parser->dmr()->set_request_xml_base(parser->xml_attrs["base"].value);

            if (!parser->root_ns.empty())

                parser->dmr()->set_namespace(parser->root_ns);

            // Push the root Group on the stack

            parser->push_group(parser->dmr()->root());

            parser->push_state(inside_dataset);

            break;

            // Both inside dataset and inside group can have the same stuff.

            // The difference is that the Dataset holds the root group, which

            // must be present; other groups are optional

        case inside_dataset:

        case inside_group:

            if (parser->process_enum_def(localname, attributes, nb_attributes))

                parser->push_state(inside_enum_def);

            else if (parser->process_dimension_def(localname, attributes, nb_attributes))

                parser->push_state(inside_dim_def);

            else if (parser->process_group(localname, attributes, nb_attributes))

                parser->push_state(inside_group);

            else if (parser->process_variable(localname, attributes, nb_attributes))

                // This will push either inside_simple_type or inside_structure

                // onto the parser state stack.

               break;

            else if (parser->process_attribute(localname, attributes, nb_attributes))

                // This will push either inside_attribute, inside_attribute_container

                // or inside_otherxml_attribute onto the parser state stack

                break;

            else

                D4ParserSax2::dmr_error(parser, "Expected an Attribute, Enumeration, Dimension, Group or variable element; found '%s' instead.", localname);

            break;

        case inside_attribute_container:

            if (parser->process_attribute(localname, attributes, nb_attributes))

                break;

            else

                D4ParserSax2::dmr_error(parser, "Expected an Attribute element; found '%s' instead.", localname);

            break;

        case inside_attribute:

            if (parser->process_attribute(localname, attributes, nb_attributes))

                break;

            else if (strcmp(localname, "Value") == 0)

                parser->push_state(inside_attribute_value);

            else

                dmr_error(parser, "Expected an 'Attribute' or 'Value' element; found '%s' instead.", localname);

            break;

        case inside_attribute_value:

            // Attribute values are processed by the end element code.

            break;

        case inside_other_xml_attribute:

            parser->other_xml_depth++;

            // Accumulate the elements here

            parser->other_xml.append("<");

            if (prefix) {

                parser->other_xml.append((const char *) prefix);

                parser->other_xml.append(":");

            }

            parser->other_xml.append(localname);

            if (nb_namespaces != 0) {

                parser->transfer_xml_ns(namespaces, nb_namespaces);

                for (map<string, string>::iterator i = parser->namespace_table.begin();

                        i != parser->namespace_table.end(); ++i) {

                    parser->other_xml.append(" xmlns");

                    if (!i->first.empty()) {

                        parser->other_xml.append(":");

                        parser->other_xml.append(i->first);

                    }

                    parser->other_xml.append("=\"");

                    parser->other_xml.append(i->second);

                    parser->other_xml.append("\"");

                }

            }

            if (nb_attributes != 0) {

                parser->transfer_xml_attrs(attributes, nb_attributes);

                for (XMLAttrMap::iterator i = parser->xml_attr_begin(); i != parser->xml_attr_end(); ++i) {

                    parser->other_xml.append(" ");

                    if (!i->second.prefix.empty()) {

                        parser->other_xml.append(i->second.prefix);

                        parser->other_xml.append(":");

                    }

                    parser->other_xml.append(i->first);

                    parser->other_xml.append("=\"");

                    parser->other_xml.append(i->second.value);

                    parser->other_xml.append("\"");

                }

            }

            parser->other_xml.append(">");

            break;

        case inside_enum_def:

            // process an EnumConst element

            if (parser->process_enum_const(localname, attributes, nb_attributes))

                parser->push_state(inside_enum_const);

            else

                dmr_error(parser, "Expected an 'EnumConst' element; found '%s' instead.", localname);

            break;

        case inside_enum_const:

            // No content; nothing to do

            break;

        case inside_dim_def:

            // No content; nothing to do

            break;

#if 0

        case inside_dimension:

            // No content.

            break;

#endif

        case inside_dim:

            // No content.

            break;

        case inside_map:

            // No content.

            break;

        case inside_simple_type:

            if (parser->process_attribute(localname, attributes, nb_attributes))

                break;

            else if (parser->process_dimension(localname, attributes, nb_attributes))

            	parser->push_state(inside_dim);

            else if (parser->process_map(localname, attributes, nb_attributes))

            	parser->push_state(inside_map);

            else

                dmr_error(parser, "Expected an 'Attribute', 'Dim' or 'Map' element; found '%s' instead.", localname);

            break;

        case inside_constructor:

            if (parser->process_variable(localname, attributes, nb_attributes))

                // This will push either inside_simple_type or inside_structure

                // onto the parser state stack.

                break;

            else if (parser->process_attribute(localname, attributes, nb_attributes))

                break;

            else if (parser->process_dimension(localname, attributes, nb_attributes))

                parser->push_state(inside_dim);

            else if (parser->process_map(localname, attributes, nb_attributes))

            	parser->push_state(inside_map);

            else

                D4ParserSax2::dmr_error(parser, "Expected an Attribute, Dim, Map or variable element; found '%s' instead.", localname);

            break;

        case not_dap4_element:

            if (parser->debug()) cerr << "Inside non DAP4 element. localname: " << localname << endl;

        	break;

        case parser_unknown:

            // FIXME?

            // *** Never used? If so remove/error

            parser->push_state(parser_unknown);

            break;

        case parser_error:

        case parser_fatal_error:

            break;

        case parser_end:

            // FIXME Error?

            break;

    }

    if (parser->debug()) cerr << "Start element exit state: " << states[parser->get_state()] << endl;

}

void D4ParserSax2::dmr_end_element(void *p, const xmlChar *l, const xmlChar *prefix, const xmlChar *URI)

{

    D4ParserSax2 *parser = static_cast<D4ParserSax2*>(p);

    const char *localname = (const char *) l;

    if (parser->debug())

        cerr << "End element " << localname << " (state " << states[parser->get_state()] << ")" << endl;

    switch (parser->get_state()) {

    case parser_start:

        dmr_fatal_error(parser, "Unexpected state, inside start state while processing element '%s'.", localname);

        break;

    case inside_dataset:

        if (is_not(localname, "Dataset"))

            D4ParserSax2::dmr_error(parser, "Expected an end Dataset tag; found '%s' instead.", localname);

        parser->pop_state();

        if (parser->get_state() != parser_start)

            dmr_fatal_error(parser, "Unexpected state, expected start state.");