xml_parser.cpp

// xml_parser.cpp
// utility to parse XML stream from a large file

//#define NDEBUG    // define before assert.h to stop assertions from being compiled 
//#define CTTL_TRACE_EVERYTHING //define to turn tracing on
//#define CTTL_TRACE_RULES  //define to turn light tracing on
//#define CTTL_LAMBDA_SINGULAR   // turns off multidimensional depositories
#define DISPOSE_CONSUMED_DATA   // when defined, free up memory as we read data from the stream

#include <iostream>
#include <stack>
#include "utils/win32_specific.h"
#include "cttl/cttl.h"
#include "utils/fileio.h"
#include "utils/timeutils.h"
#include "lambda/lambda.h"
#include "utils/offset_stack_guard.h"
#include "utils/inode.h"
#include <algorithm>

#include "example/lambda/xml/xml_tree_struct.h"
#include "example/lambda/xml/xml_tree_show.h"
#include "example/lambda/xml/xml_stream_policy.h"

using namespace cttl;

namespace {
    // common xml alphabet
    const std::string LITERAL_XML_NAME          = CTTL_QWERTY_123_ ":-";
    const std::string LITERAL_XML_COMMENT_OPEN  = "<!--";
    const std::string LITERAL_XML_COMMENT_CLOSE = "-->";
    const std::string LITERAL_XML_PI_OPEN       = "<?";
    const std::string LITERAL_XML_PI_CLOSE      = "?>";
    const std::string LITERAL_XML_CLOSE_ELEM    = "</";
    const std::string LITERAL_XML_ELEM_CLOSED   = "/>";
}

#include "example/lambda/xml/xml_parser.h"
#include "example/lambda/xml/xml_lexer.h"

int main(int argc, char* argv[])
{
    if ( argc < 2 ) {
        std::cout
            << "Usage: "
            << std::endl
            << '\t'
            << argv[ 0 ]
            << " path/file.xml [-o]"
            << std::endl
            << "If -o switch is specified, results will be sent to the standard output."
            << std::endl
            ;
        return 1;

    } else if ( ( argc > 2 ) && strcmp( argv[ 2 ], "-o" ) ) {
        std::cout
            << "ERROR: unknown switch "
            << argv[ 2 ]
            << std::endl
            ;
        return 1;
    }


    input<> inp;
    edge<> consumed_data( new_edge( inp ) ); 

    policy_relaxed_stream file_stream( consumed_data );
    if ( !file_stream.init( argv[ 1 ] ) ) {
        std::cout
            << "ERROR: failed to open input file "
            << std::endl
            << '\t'
            << argv[ 1 ]
            << std::endl
            ;
        return 1;
    }

    typedef edge< policy_relaxed_stream > universe_T;
    universe_T universe( new_edge( inp ), file_stream );
    lexer< parser< universe_T > > xml_parser( consumed_data );

    std::cout
        << time2string( current_time() )
        << " parsing "
        << argv[ 1 ]
        << std::endl
        ;

    if ( xml_parser.xml_grammar( universe ) == universe_T::string_T::npos ) {
        std::cout
            << time2string( current_time() )
            << " parser failed"
            << std::endl
            ;

        return 1;
    }

    std::cout
        << time2string( current_time() )
        << " done"
        << std::endl
        ;

    if ( ( argc > 2 ) && !strcmp( argv[ 2 ], "-o" ) ) {
        inode_reader<> root( xml_parser.vect_xml_tree, 1 );
        std::for_each(
            root,
            root.end(),
            xml_tree_show(
                1,
                xml_parser.vect_xml_names,
                xml_parser.vect_xml_text
                )
            );
    }
    return 0;
}

---