Merge lp:~tapaal-ctl/verifypn/verifypnCTL into lp:~verifypn-maintainers/verifypn/trunk

[Søren Moss Nielsen]

Please disregard commit messages about compression

Post-review proposal:
1. Help options updated
2. Reachability query section logic fixed
3. Output format updated
4. Structural reductions disabled for CTL queries (promts error message instead)

[Jiri Srba (srba)]

I have a few things:

1. options, the help says:

  -ctl <algorithm> CTL query verification in VerifyPN-CTL:
                                     czero-i Certain zero early termination algorithm
                                     local-i Local algorithm
                                     gobal-i Global algorithm (very memory expensive)

but these options are not accepted, there is a typo in gobal and the engine only accepts czero and local (no global). The help should say which one is the default option.

2. in the main VerifyPN.cpp file there is the following:

 if (!isCTLlogic) {
                string querystring; // excluding EF and AG
                if (!statespaceexploration || !isCTLlogic) {

Of couse, once we enter the branch because !isCTLlogic holds, the next if statement will also always hold. Weird ...

3. Finally, the ctl algorithm does not seem to report the results according to the competition required keywords "TRUE/FALSE TECHNIQUES ..."

Can you take a look at this, please?

review: Needs Fixing

[Jiri Srba (srba)]

Also another problem:

4. It appears that you allow to use reductions even for CTL queries (there is a code prepares for using the reduction on CTL queries). But reduction for CTL queries should be disabled (if a ctl query is used and reduction of type 1 or 2 is used, we should report a problem and terminated).

This needs also fixing.

review: Needs Fixing

[lp:~tapaal-ctl/verifypn/verifypnCTL]

242. By Søren Moss Nielsen <email address hidden> on 2016-03-31

Minor fix to outputformat

243. By Søren Moss Nielsen <email address hidden> on 2016-03-31

Added support for inhibitor arcs

244. By Søren Moss Nielsen <email address hidden> on 2016-04-01

Added breaks in fireable transitions traversion

245. By Søren Moss Nielsen <email address hidden> on 2016-04-01

Added another break in fireable transitions traversion

246. By Jiri Srba <email address hidden> on 2016-04-03

FORMULA is now printed just before the results are printed and printstatistics flag is used to suppress printing CTL debugging info

247. By Jiri Srba <email address hidden> on 2016-04-03

the info about the net is printed only if -n switch is not present

248. By Jiri Srba <email address hidden> on 2016-04-04

fixed the check of CTL engine and reductions that should be disabled

249. By Isabella Kaufmann <email address hidden> on 2016-04-05

still no deadlock (needs parser fixing as well if it should be possible) but only DFS is allowed and that is now the default

250. By Jiri Srba <email address hidden> on 2016-04-06

small fix in the way search strategy is search for CTL logic

Unmerged revisions

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2016-03-31 07:42:46 +0000
@@ -0,0 +1,29 @@
+makefile
+nbproject
+verifypn-linux64
+verifypn.config
+verifypn.creator
+verifypn.creator.user
+verifypn.files
+verifypn.includes
+verifypnCTL.config
+verifypnCTL.creator
+verifypnCTL.creator.user
+verifypnCTL.files
+verifypnCTL.includes
+log.txt
+testlog.log
+testFramework/analysis.log
+testFramework/CZERO.log
+testFramework/log.log
+*/*/*.log
+*/*.log
+*/*/*/*.log
+cdfs_czero.log
+dfs_czero.log
+*.directory
+verifypn-ctl.config
+verifypn-ctl.creator
+verifypn-ctl.creator.user
+verifypn-ctl.files
+verifypn-ctl.includes

=== added directory 'CTL'
=== added file 'CTL/CertainZeroFPA.cpp'
--- CTL/CertainZeroFPA.cpp	1970-01-01 00:00:00 +0000
+++ CTL/CertainZeroFPA.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,144 @@
+#include "CertainZeroFPA.h"
+
+namespace ctl{
+
+bool CertainZeroFPA::search(DependencyGraph &t_graph, AbstractSearchStrategy &W)
+{
+    PriorityQueue N;
+
+    Configuration &v = t_graph.initialConfiguration();
+    v.assignment = ZERO;
+
+    for(Edge *e : t_graph.successors(v)){
+        W.push(e);
+        if(e->source->IsNegated)
+            N.push(e);
+    }
+
+    while(!W.empty() || !N.empty()){
+        Edge *e;
+
+        if(!W.empty()) {
+            e = W.pop();
+        }
+        else if (!N.empty()) {
+            e = N.top();
+            N.pop();
+        }
+
+        /*****************************************************************/
+        /*Data handling*/
+        int targetONEassignments = 0;
+        int targetZEROassignments = 0;
+        int targetUKNOWNassignments = 0;
+        bool czero = false;
+
+        for(auto c : e->targets){
+            if (c->assignment == ONE) {
+                targetONEassignments++;
+            }
+            else if (c->assignment == ZERO) {
+                targetZEROassignments++;
+            }
+            else if (c->assignment == CZERO){
+                czero = true;
+                break;
+            }
+            else if(c-> assignment == UNKNOWN){
+                targetUKNOWNassignments++;
+            }
+
+        }
+        /*****************************************************************/
+
+        if(e->isDeleted || e->source->assignment == ONE || e->source->assignment == CZERO){
+            //std::cout << "== Ignored ==\n" << std::flush;
+        }
+        /*****************************************************************/
+
+        else if(e->targets.size() == targetONEassignments){
+
+            if(e->source->IsNegated){
+                e->source->assignment = CZERO;
+                e->source->removeSuccessor(e);
+            }
+            else{
+                e->source->assignment = ONE;
+            }
+            if(e->source == &v) break;
+
+            for(Edge *de : e->source->DependencySet){
+                W.push_dependency(de);
+            }
+            e->source->DependencySet.clear();
+        }
+        else if(czero){
+            if(e->source->IsNegated){
+                e->source->assignment = ONE;
+                if(e->source == &v) break;
+
+                for(Edge *de : e->source->DependencySet){
+                    W.push_dependency(de);
+                }
+                e->source->DependencySet.clear();
+            }
+            else{
+                if(e->source->Successors.size() <= 1){
+                    e->source->assignment = CZERO;
+                    if(e->source == &v) break;
+
+                    for(Edge *de : e->source->DependencySet){
+                        W.push_dependency(de);
+                    }
+                    e->source->DependencySet.clear();
+                }
+            }
+            e->source->removeSuccessor(e);
+        }
+        else if(targetZEROassignments > 0){
+            if(e->source->IsNegated && e->processed){
+                e->source->assignment = ONE;
+                if(e->source == &v) break;
+                for(Edge *de : e->source->DependencySet){
+                    W.push_dependency(de);
+                }
+                e->source->DependencySet.clear();
+            }
+            else {
+                for(auto c : e->targets){
+                    if(c->assignment == ZERO) {
+                        c->DependencySet.push_back(e);
+                    }
+                }
+            }
+        }
+        else if(targetUKNOWNassignments > 0){
+            for(Configuration *tc : e->targets){
+                if(tc->assignment == UNKNOWN){
+                    tc->assignment = ZERO;
+                    tc->DependencySet.push_back(e);
+                    t_graph.successors(*tc);
+
+                    if(tc->Successors.empty()){
+                        tc->assignment = CZERO;
+                       W.push_dependency(e);
+                    }
+                    else {
+                        for(Edge *succ : tc->Successors){
+                            W.push(succ);
+                            if(succ->source->IsNegated){
+                                N.push(succ);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        e->processed = true;
+    }
+
+    //std::cout << "Final Assignment: " << v.assignment << " " << ((v.assignment == ONE) ? true : false) << std::endl;
+    return (v.assignment == ONE) ? true : false;
+}
+
+}

=== added file 'CTL/CertainZeroFPA.h'
--- CTL/CertainZeroFPA.h	1970-01-01 00:00:00 +0000
+++ CTL/CertainZeroFPA.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,28 @@
+#ifndef CERTAINZEROFPA_H
+#define CERTAINZEROFPA_H
+
+#include "FixedPointAlgorithm.h"
+#include "edge.h"
+#include "configuration.h"
+
+#include <list>
+#include <queue>
+#include <vector>
+
+namespace ctl {
+
+class CertainZeroFPA : public FixedPointAlgorithm
+{
+public:
+    bool search(DependencyGraph &t_graph, AbstractSearchStrategy &t_strategy);
+
+private:
+    struct edge_prioritizer{
+        bool operator()(const Edge *lhs, const Edge *rhs) const {
+            return (lhs->source->query->max_depth > rhs->source->query->max_depth);
+        }
+    };
+    typedef std::priority_queue<Edge*, std::vector<Edge*>, ctl::CertainZeroFPA::edge_prioritizer> PriorityQueue;
+};
+}
+#endif // CERTAINZEROFPA_H

=== added file 'CTL/DependencyGraph.cpp'
--- CTL/DependencyGraph.cpp	1970-01-01 00:00:00 +0000
+++ CTL/DependencyGraph.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,19 @@
+#include "DependencyGraph.h"
+#include <iostream>
+
+namespace ctl{
+
+DependencyGraph::DependencyGraph(PetriEngine::PetriNet *t_net, PetriEngine::MarkVal *t_initial) :
+    _petriNet(t_net),
+    _initialMarking(t_initial),
+    _nplaces(t_net->numberOfPlaces()),
+    _ntransitions(t_net->numberOfTransitions()){}
+
+void DependencyGraph::initialize(CTLTree &t_query){
+    if(_query != NULL)
+        clear(false);
+    _query = &t_query;
+}
+
+
+}//ctl

=== added file 'CTL/DependencyGraph.h'
--- CTL/DependencyGraph.h	1970-01-01 00:00:00 +0000
+++ CTL/DependencyGraph.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,39 @@
+#ifndef DEPENDENCYGRAPH_H
+#define DEPENDENCYGRAPH_H
+
+#include "../PetriEngine/PetriNet.h"
+#include "../CTLParser/CTLParser.h"
+#include <list>
+#include <iostream>
+
+namespace ctl{
+
+class Configuration;
+class Edge;
+
+class DependencyGraph
+{
+public:
+
+    DependencyGraph(PetriEngine::PetriNet *t_net,
+                    PetriEngine::MarkVal *t_initial);
+
+    virtual ~DependencyGraph(){};
+
+    virtual std::list<Edge*> successors(Configuration &v) =0;
+    virtual Configuration &initialConfiguration()=0;
+    virtual void clear(bool t_clear_all = false) =0;
+    virtual int configuration_count() =0;
+    virtual int marking_count() =0;
+
+    void initialize(CTLTree &t_query);
+
+protected:
+    CTLTree *_query;
+    PetriEngine::PetriNet *_petriNet;
+    PetriEngine::MarkVal *_initialMarking;
+    int _nplaces;
+    int _ntransitions;
+};
+}
+#endif // DEPENDENCYGRAPH_H

=== added file 'CTL/FixedPointAlgorithm.h'
--- CTL/FixedPointAlgorithm.h	1970-01-01 00:00:00 +0000
+++ CTL/FixedPointAlgorithm.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,16 @@
+#ifndef FIXEDPOINTALGORITHM_H
+#define FIXEDPOINTALGORITHM_H
+
+#include "DependencyGraph.h"
+#include "SearchStrategies/AbstractSearchStrategy.h"
+
+namespace ctl{
+
+class FixedPointAlgorithm
+{
+public:
+    virtual bool search(DependencyGraph &t_graph,
+                        AbstractSearchStrategy &t_strategy)=0;
+};
+}
+#endif // FIXEDPOINTALGORITHM_H

=== added file 'CTL/LocalFPA.cpp'
--- CTL/LocalFPA.cpp	1970-01-01 00:00:00 +0000
+++ CTL/LocalFPA.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,106 @@
+#include "LocalFPA.h"
+
+bool ctl::LocalFPA::search(ctl::DependencyGraph &t_graph, ctl::AbstractSearchStrategy &W)
+{
+    PriorityQueue N;
+
+    Configuration &v = t_graph.initialConfiguration();
+    v.assignment = ZERO;
+
+    for(Edge *e : t_graph.successors(v)){
+        W.push(e);
+        if(e->source->IsNegated)
+            N.push(e);
+    }
+
+    while(!W.empty() || !N.empty()){
+        Edge *e;
+
+        if(!W.empty()) {
+            e = W.pop();
+            //std::cout << "Popped negation edge from N: \n" << std::flush;
+           // e->edgePrinter();
+        }
+        else if (!N.empty()) {
+            e = N.top();
+            N.pop();
+            //std::cout << "Popped negation edge from N: \n" << std::flush;
+            //e->edgePrinter();
+        }
+
+        /*****************************************************************/
+        /*Data handling*/
+        int targetONEassignments = 0;
+        int targetZEROassignments = 0;
+        int targetUKNOWNassignments = 0;
+
+        for(auto c : e->targets){
+            if (c->assignment == ONE) {
+                targetONEassignments++;
+            }
+            else if (c->assignment == ZERO) {
+                targetZEROassignments++;
+            }
+            else if(c-> assignment == UNKNOWN){
+                targetUKNOWNassignments++;
+            }
+
+        }
+        /*****************************************************************/
+
+        if(e->source->assignment == ONE){
+            //std::cout << "== Ignored ==\n" << std::flush;
+        }
+        else if(e->targets.size() == targetONEassignments){
+            if(e->source->IsNegated){
+                e->source->assignment = ZERO;
+            }
+            else{
+                e->source->assignment = ONE;
+                if(e->source == &v) break;
+
+                for(Edge *de : e->source->DependencySet){
+                    W.push_dependency(de);
+                }
+                e->source->DependencySet.clear();
+            }
+        }
+        else if(targetZEROassignments > 0){
+            if(e->source->IsNegated && e->processed){
+                e->source->assignment = ONE;
+                //std::cout << "== Assigned ONE to NEG Edge ==\n" << std::flush;
+                if(e->source == &v) break;
+
+                for(Edge *de : e->source->DependencySet){
+                    W.push_dependency(de);
+                }
+                e->source->DependencySet.clear();
+            }
+            else{
+                for(auto c : e->targets){
+                    if(c->assignment == ZERO) {
+                        c->DependencySet.push_back(e);
+                    }
+                }
+            }
+        }
+        else if(targetUKNOWNassignments > 0){
+            for(Configuration *tc : e->targets){
+                if(tc->assignment == UNKNOWN){
+                    tc->assignment = ZERO;
+                    tc->DependencySet.push_back(e);
+
+                    for(Edge *succ : t_graph.successors(*tc)){
+                        W.push(succ);
+                        if(succ->source->IsNegated){
+                            N.push(succ);
+                        }
+                    }
+                }
+            }
+        }
+        e->processed = true;
+    }
+
+    return v.assignment == ONE ? true : false;
+}

=== added file 'CTL/LocalFPA.h'
--- CTL/LocalFPA.h	1970-01-01 00:00:00 +0000
+++ CTL/LocalFPA.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,28 @@
+#ifndef LOCALFPA_H
+#define LOCALFPA_H
+
+#include "FixedPointAlgorithm.h"
+#include "edge.h"
+#include "configuration.h"
+
+#include <list>
+#include <queue>
+#include <vector>
+
+namespace ctl {
+
+class LocalFPA : public FixedPointAlgorithm
+{
+public:
+    bool search(DependencyGraph &t_graph, AbstractSearchStrategy &t_strategy);
+
+private:
+    struct edge_prioritizer{
+        bool operator()(const Edge *lhs, const Edge *rhs) const {
+            return (lhs->source->query->max_depth > rhs->source->query->max_depth);
+        }
+    };
+    typedef std::priority_queue<Edge*, std::vector<Edge*>, ctl::LocalFPA::edge_prioritizer> PriorityQueue;
+};
+}
+#endif // LOCALFPA_H

=== added file 'CTL/OnTheFlyDG.cpp'
--- CTL/OnTheFlyDG.cpp	1970-01-01 00:00:00 +0000
+++ CTL/OnTheFlyDG.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,367 @@
+#include "OnTheFlyDG.h"
+
+#include <string.h>
+
+namespace ctl{
+
+OnTheFlyDG::OnTheFlyDG(PetriEngine::PetriNet *t_net, PetriEngine::MarkVal *t_initial):
+    DependencyGraph(t_net, t_initial){_compressoption = false;}
+
+std::list<Edge *> OnTheFlyDG::successors(Configuration &v)
+{
+    std::list<Edge*> succ;
+    //All
+    if(v.query->quantifier == A){
+        //All Until
+        if(v.query->path == U){
+            Configuration* c = createConfiguration(*(v.marking), *(v.query->second));
+            Edge* e = new Edge(&v);
+            e->targets.push_back(c);
+
+            auto targets = nextState (*(v.marking));
+
+            if(!targets.empty()){
+                Edge* e1 = new Edge(&v);
+                Configuration* b = createConfiguration(*(v.marking), *(v.query->first));
+
+                for(auto m : targets){
+                    Configuration* c = createConfiguration(*m, *(v.query));
+                    e1->targets.push_back(c);
+                }
+                e1->targets.push_back(b);
+                succ.push_back(e1);
+            }
+
+            succ.push_back(e);
+
+        } //All Until end
+
+        //All Next begin
+        else if(v.query->path == X){
+            auto targets = nextState(*v.marking);
+            if(!targets.empty())
+            {
+                Edge* e = new Edge(&v);
+
+                for (auto m : targets){
+                    Configuration* c = createConfiguration(*m, *(v.query->first));
+                    e->targets.push_back(c);
+                }
+                succ.push_back(e);
+            }
+        } //All Next End
+
+        //All Finally start
+        else if(v.query->path == F){
+            Edge* e = new Edge(&v);
+            Configuration* c = createConfiguration(*(v.marking), *(v.query->first));
+            e->targets.push_back(c);
+
+            auto targets = nextState(*(v.marking));
+
+            if(!targets.empty()){
+                Edge* e1 = new Edge();
+                e1->source = &v;
+
+                for(auto m : targets){
+                    Configuration* c = createConfiguration(*m, *(v.query));
+                    e1->targets.push_back(c);
+                }
+                succ.push_back(e1);
+            }
+            succ.push_back(e);
+        }//All Finally end
+    } //All end
+
+    //Exists start
+    else if (v.query->quantifier == E){
+
+        //Exists Untill start
+        if(v.query->path == U){
+            Configuration* c = createConfiguration(*(v.marking), *(v.query->second));
+            Edge* e = new Edge(&v);
+            e->targets.push_back(c);
+
+            auto targets = nextState(*(v.marking));
+
+            if(!targets.empty()){
+                Configuration* c = createConfiguration(*(v.marking), *(v.query->first));
+                for(auto m : targets){
+                    Edge* e = new Edge(&v);
+                    Configuration* c1 = createConfiguration(*m, *(v.query));
+                    e->targets.push_back(c1);
+                    e->targets.push_back(c);
+                    succ.push_back(e);
+                }
+            }
+            succ.push_back(e);
+        } //Exists Until end
+
+        //Exists Next start
+        else if(v.query->path == X){
+            auto targets = nextState(*(v.marking));
+            CTLTree* query = v.query->first;
+
+            if(!targets.empty())
+            {
+                for(auto m : targets){
+                    Edge* e = new Edge(&v);
+                    Configuration* c = createConfiguration(*m, *query);
+                    e->targets.push_back(c);
+                    succ.push_back(e);
+                }
+            }
+        }//Exists Next end
+
+        //Exists Finally start
+        else if(v.query->path == F){
+            Configuration* c = createConfiguration(*(v.marking), *(v.query->first));
+            Edge* e = new Edge(&v);
+            e->targets.push_back(c);
+            
+            auto targets = nextState(*(v.marking));
+
+            if(!targets.empty()){
+                for(auto m : targets){
+                    Edge* e = new Edge(&v);
+                    Configuration* c = createConfiguration(*m, *(v.query));
+                    e->targets.push_back(c);
+                    succ.push_back(e);
+                }
+            }
+            succ.push_back(e);
+
+        }//Exists Finally end
+    } //Exists end
+
+    //And start
+    else if (v.query->quantifier == AND){
+        Configuration* c = createConfiguration(*(v.marking), *(v.query->first));
+        Configuration* c1 = createConfiguration(*(v.marking), *(v.query->second));
+        Edge* e = new Edge(&v);
+        e->targets.push_back(c);
+        e->targets.push_back(c1);
+        succ.push_back(e);
+    } //And end
+
+    //Or start
+    else if (v.query->quantifier == OR){
+        Configuration* c = createConfiguration(*(v.marking), *(v.query->first));
+        Configuration* c1 = createConfiguration(*(v.marking), *(v.query->second));
+        Edge* e = new Edge(&v);
+        Edge* e1 = new Edge(&v);
+        e->targets.push_back(c);
+        e1->targets.push_back(c1);
+        succ.push_back(e);
+        succ.push_back(e1);
+    } //Or end
+
+    //Negate start
+    else if (v.query->quantifier == NEG){
+            Configuration* c = createConfiguration(*(v.marking), *(v.query->first));
+            Edge* e = new Edge(&v);
+            e->targets.push_back(c);
+            succ.push_back(e);
+    } //Negate end
+
+    //Evaluate Query Begin
+    else {
+        //Edge* e = new Edge(&v);
+        //e->targets.push_back(&v);
+       // v.configPrinter();
+        if (evaluateQuery(v)){
+            //assignConfiguration(&v, ONE);
+            succ.push_back(new Edge(&v));
+        } else {
+            //assignConfiguration(&v, CZERO);
+        }
+        //succ.push_back(e);
+
+    }
+
+    v.Successors = succ;
+    return succ;
+    //computedSucc += succ.size();
+    //std::cout << "-----------EDGES NOW : " << computedSucc << "\n" << std::flush;
+}
+
+Configuration &OnTheFlyDG::initialConfiguration()
+{
+    Marking *initial = new Marking(_initialMarking, _nplaces);
+    return *createConfiguration(*initial, *_query);
+}
+
+bool OnTheFlyDG::evaluateQuery(Configuration &t_config){
+
+    CTLTree* query = t_config.query;
+
+    bool result = false;
+
+    if (t_config.query->a.isFireable) {
+        std::list<int> transistions = calculateFireableTransistions(*(t_config.marking));
+
+        for (auto t : transistions) {
+            int fs_transition = 0;
+            for(fs_transition = 0; fs_transition < query->a.firesize; fs_transition++){
+                int dpc_place = 0;
+                int truedependencyplaces = 0;
+                for (dpc_place = 0; dpc_place < query->a.fireset[fs_transition].sizeofdenpencyplaces; dpc_place++){
+
+                    if((query->a.fireset[fs_transition].denpencyplaces[dpc_place].intSmaller - 1) < t_config.marking->Value()[query->a.fireset[fs_transition].denpencyplaces[dpc_place].placeLarger]){
+                        //std::cout<<_net->placeNames()[query->a.fireset[fs_transition].denpencyplaces[dpc_place].placeLarger]<<" is true"<<std::endl;
+                        truedependencyplaces++;
+                    }
+                }
+                if (truedependencyplaces == query->a.fireset[fs_transition].sizeofdenpencyplaces){
+                    result = true;
+                }
+            }
+        }
+        return result;
+    }
+
+    ///std::cout<<"Evaluating cardinality... "<<std::endl;
+ //   t_config.configPrinter();
+ //   std::cout<<"Less: ";
+    int less = query->a.cardinality.intSmaller;
+    int greater= query->a.cardinality.intLarger;
+    if( less == -1 ){
+        int i = 0;
+        less = 0;
+        for (i = 0; i < query->a.cardinality.placeSmaller.sizeoftokencount; i++){
+            int index = query->a.cardinality.placeSmaller.cardinality[i];
+            less += t_config.marking->Value()[index];
+ //           std::cout<<t_config.marking->Value()[index]<<" + ";
+        }
+    }
+//    std::cout<<" = "<<less<<std::endl;
+//    std::cout<<"Greater: ";
+    if (greater == -1){
+        int i = 0;
+        greater = 0;
+       // std::cout<<"::: Number of places: "<<query->a.cardinality.placeLarger.sizeoftokencount<<std::endl;
+        for (i = 0; i < query->a.cardinality.placeLarger.sizeoftokencount; i++){
+            //std::cout<<"::::: i: "<<i<<std::endl;
+            int index = query->a.cardinality.placeLarger.cardinality[i];
+            //std::cout<<"::::: Index: "<<index<<" - Value: "<<t_config.marking->Value()[index]<<std::endl;
+            greater += t_config.marking->Value()[index];
+  //          std::cout<<t_config.marking->Value()[index]<<" + ";
+       //     std::cout<<"::::: greater: "<<greater<<std::endl;
+        }
+
+    }
+  //  std::cout<<" = "<<greater<<std::endl;
+
+    result = less <= greater;
+   // std::cout<<"... evaluation Done"<<std::endl;
+    return result;
+}
+
+int OnTheFlyDG::indexOfPlace(char *t_place){
+    for (int i = 0; i < _nplaces; i++) {
+        if (0 == (strcmp(t_place, _petriNet->placeNames()[i].c_str()))){
+                //cout << "place " << query->a.tokenCount.placeLarger << " " << flush;
+                return i;
+        }
+    }
+    return -1;
+}
+
+std::list<Marking*> OnTheFlyDG::nextState(Marking& t_marking){
+
+    std::list<int> fireableTransistions = calculateFireableTransistions(t_marking);
+    std::list<Marking*> nextStates;
+
+    auto iter = fireableTransistions.begin();
+    auto iterEnd = fireableTransistions.end();
+
+    //Create new markings for each fireable transistion
+    for(; iter != iterEnd; iter++){
+        nextStates.push_back(createMarking(t_marking, *iter));
+    }
+
+    //return the set of reachable markings
+
+    return nextStates;
+}
+
+std::list<int> OnTheFlyDG::calculateFireableTransistions(Marking &t_marking){
+
+    std::list<int> fireableTransistions;
+
+    for(int t = 0; t < _ntransitions; t++){
+        bool transitionFound = true;
+        for(int p = 0; p < _nplaces; p++){
+            if(t_marking[p] < _petriNet->inArc(p,t))
+                transitionFound = false;
+        }
+
+        if(transitionFound)
+            fireableTransistions.push_back(t);
+    }
+    return fireableTransistions;
+}
+
+
+void OnTheFlyDG::clear(bool t_clear_all)
+{
+    for(auto c : Configurations){
+        delete c;
+    }
+    Configurations.clear();
+
+    if(t_clear_all){
+        for(auto m : Markings){
+            delete m;
+        }
+        Markings.clear();
+    }
+}
+
+Configuration *OnTheFlyDG::createConfiguration(Marking &t_marking, CTLTree &t_query)
+{
+    Configuration* newConfig = new Configuration();
+    newConfig->marking = &t_marking;
+    newConfig->query = &t_query;
+
+    //Default value is false
+    if(t_query.quantifier == NEG){
+        newConfig->IsNegated = true;
+    }
+    auto pair = Configurations.insert(newConfig);
+
+    if(!pair.second) {
+        delete newConfig;
+    }
+
+    return *(pair.first);
+}
+
+
+
+Marking *OnTheFlyDG::createMarking(const Marking& t_marking, int t_transition){
+    Marking* new_marking = new Marking();
+
+    new_marking->CopyMarking(t_marking);
+
+    for(int p = 0; p < _nplaces; p++){
+        int place = (*new_marking)[p] - _petriNet->inArc(p,t_transition);
+        (*new_marking)[p] = place + _petriNet->outArc(t_transition,p);
+    }
+
+    auto result = Markings.find(new_marking);
+
+    if(result == Markings.end()){
+    //   std::cout << "Inserted marking - Size now: " << Markings.size() << std::endl;
+        return *(Markings.insert(new_marking).first);
+    }
+    else{
+        delete new_marking;
+    //    std::cout << "Marking exists - Size now: " << Markings.size() << std::endl;
+    }
+
+
+    return *result;
+}
+
+}//ctl

=== added file 'CTL/OnTheFlyDG.h'
--- CTL/OnTheFlyDG.h	1970-01-01 00:00:00 +0000
+++ CTL/OnTheFlyDG.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,49 @@
+#ifndef ONTHEFLYDG_H
+#define ONTHEFLYDG_H
+
+#include "DependencyGraph.h"
+#include "marking.h"
+#include "configuration.h"
+#include "edge.h"
+
+#include <boost/unordered_set.hpp>
+#include <list>
+
+namespace ctl {
+
+class OnTheFlyDG : public DependencyGraph
+{
+public:
+    OnTheFlyDG(PetriEngine::PetriNet *t_net,
+               PetriEngine::MarkVal *t_initial);
+
+    // DependencyGraph interface
+    std::list<Edge *> successors(Configuration &v);
+    Configuration &initialConfiguration();
+    void clear(bool t_clear_all);
+    int configuration_count() { return Configurations.size();}
+    int marking_count() { return Markings.size(); }
+
+
+    boost::unordered_set< Marking*,
+                        boost::hash<Marking*>,
+                        Marking::Marking_Equal_To> Markings;
+
+    boost::unordered_set< Configuration*,
+                        boost::hash<Configuration*>,
+                        Configuration::Configuration_Equal_To> Configurations;
+    bool isCompressing() {return _compressoption;};
+                        
+protected:
+    bool evaluateQuery(Configuration &t_config);
+    bool _compressoption;
+    int indexOfPlace(char *t_place);
+    std::list<Marking *> nextState(Marking &t_marking);
+    std::list<int> calculateFireableTransistions(Marking &t_marking);
+    Configuration *createConfiguration(Marking &t_marking, CTLTree &t_query);
+    Marking *createMarking(const Marking &t_marking, int t_transition);
+    void initCompressOption();
+
+};
+}
+#endif // ONTHEFLYDG_H

=== added directory 'CTL/SearchStrategies'
=== added file 'CTL/SearchStrategies/AbstractSearchStrategy.h'
--- CTL/SearchStrategies/AbstractSearchStrategy.h	1970-01-01 00:00:00 +0000
+++ CTL/SearchStrategies/AbstractSearchStrategy.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,23 @@
+#ifndef ABSTRACTSEARCHSTRATEGY_H
+#define ABSTRACTSEARCHSTRATEGY_H
+
+#include <cstddef>
+
+namespace ctl {
+
+class Edge; //Forward declaration of edge
+
+class AbstractSearchStrategy {
+public:
+    virtual void push(Edge *e) =0;
+    virtual void push_dependency(Edge *e) =0;
+    virtual Edge *pop() =0;
+    virtual bool remove(Edge *e) =0;
+    virtual size_t size() =0;
+    virtual bool empty() =0;
+    virtual void clear()=0;
+};
+
+}
+
+#endif // ABSTRACTSEARCHSTRATEGY_H

=== added file 'CTL/SearchStrategies/DepthFirstSearch.cpp'
--- CTL/SearchStrategies/DepthFirstSearch.cpp	1970-01-01 00:00:00 +0000
+++ CTL/SearchStrategies/DepthFirstSearch.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,37 @@
+#include "DepthFirstSearch.h"
+
+ctl::DepthFirstSearch::DepthFirstSearch()
+{
+}
+
+void ctl::DepthFirstSearch::push(ctl::Edge *e)
+{
+    W.push_back(e);
+}
+
+void ctl::DepthFirstSearch::push_dependency(ctl::Edge *e)
+{
+    W.push_back(e);
+}
+
+ctl::Edge *ctl::DepthFirstSearch::pop()
+{
+    Edge *e = W.back();
+    W.pop_back();
+    return e;
+}
+
+bool ctl::DepthFirstSearch::remove(ctl::Edge *e)
+{
+    iterator current = W.begin();
+    iterator end = W.end();
+
+    while(current != end){
+        if((*current) == e){
+            W.erase(current);
+            return true;
+        }
+    }
+
+    return false;
+}

=== added file 'CTL/SearchStrategies/DepthFirstSearch.h'
--- CTL/SearchStrategies/DepthFirstSearch.h	1970-01-01 00:00:00 +0000
+++ CTL/SearchStrategies/DepthFirstSearch.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,28 @@
+#ifndef DEPTHFIRSTSEARCH_H
+#define DEPTHFIRSTSEARCH_H
+
+#include <deque>
+#include "AbstractSearchStrategy.h"
+
+namespace ctl{
+
+class DepthFirstSearch : public ctl::AbstractSearchStrategy
+{
+public:
+    DepthFirstSearch();
+
+    // AbstractSearchStrategy interface
+    void push(Edge *e);
+    void push_dependency(Edge *e);
+    Edge *pop();
+    bool remove(Edge *e);
+    size_t size() {return W.size();}
+    bool empty() {return W.empty();}
+    void clear(){ W.clear();}
+
+private:
+    std::deque<Edge*> W; //Waiting list
+    typedef std::deque<Edge*>::iterator iterator;
+};
+}
+#endif // DEPTHFIRSTSEARCH_H

=== added file 'CTL/configuration.cpp'
--- CTL/configuration.cpp	1970-01-01 00:00:00 +0000
+++ CTL/configuration.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,62 @@
+#include "configuration.h"
+
+namespace ctl{
+
+Configuration::Configuration(Marking * t_marking, CTLTree * t_query){
+    marking = t_marking;
+    query = t_query;
+}
+
+Configuration::~Configuration(){
+
+    for(Edge* e: Successors){
+        delete (e);
+    }
+    for(Edge* e: deletedSuccessors){
+        delete e;
+    }
+}
+
+void Configuration::removeSuccessor(Edge *t_successor){
+    {
+        if (t_successor->isDeleted)
+            return;
+        Successors.remove(t_successor);
+
+        for(auto t : t_successor->targets){
+            t->DependencySet.remove(t_successor);
+        }
+
+        t_successor->isDeleted = true;
+        deletedSuccessors.push_front(t_successor);
+        //delete t_successor;
+        return;
+    }
+}
+
+
+void Configuration::configPrinter(){
+    CTLParser ctlParser = CTLParser();
+    int i = 0;
+    std::cout << "Marking: ";
+    marking->print();
+    std::cout << " Q: " << std::flush;
+    ctlParser.printQuery(query);
+    std::cout << " D: "<<query->depth  << std::flush;
+    std::cout << " Assign: " << assignment << std::flush;
+
+    std::cout << " NEG: " << IsNegated << "\n" << std::flush;
+}
+
+bool Configuration::operator ==(const Configuration& rhs) const{
+    if(query != rhs.query)
+        return false;
+    else if(IsNegated != rhs.IsNegated)
+        return false;
+    else if(*marking == *(rhs.marking))//Use equality from marking
+        return true;
+    else
+        return false;
+}
+
+}

=== added file 'CTL/configuration.h'
--- CTL/configuration.h	1970-01-01 00:00:00 +0000
+++ CTL/configuration.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,73 @@
+#ifndef CONFIGURATION_H
+#define CONFIGURATION_H
+
+#include "../CTLParser/CTLParser.h"
+#include "marking.h"
+#include "edge.h"
+#include <list>
+#include <stdint.h>
+
+namespace ctl {
+
+class Edge;
+
+enum Assignment {
+    ONE = 1, UNKNOWN = 0, ZERO = -1, CZERO = -2
+};
+
+class Configuration
+{
+public:
+
+    struct Configuration_Equal_To{
+        bool operator()(const Configuration* rhs, const Configuration* lhs) const{
+            return (*rhs)==(*lhs);
+        }
+    };
+
+    Configuration(){}
+    Configuration(Marking* t_marking, CTLTree* t_query);
+    virtual ~Configuration();
+
+    void removeSuccessor(Edge *t_successor);
+    void configPrinter();
+
+    bool operator==(const Configuration& rhs)const;
+    bool operator!=(const Configuration &rhs) const {return !(*this == rhs);}
+
+    Marking* marking;
+    CTLTree* query;
+    std::list<Edge*> Successors;
+    std::list<Edge*> DependencySet;
+    bool IsNegated = false;
+    Assignment assignment = UNKNOWN;
+
+private:
+    std::list<Edge*> deletedSuccessors;
+};
+}// end of ctl
+
+namespace boost {
+    //Hash specialization implementations
+    template<>
+    struct hash<ctl::Configuration>{
+        size_t operator()(const ctl::Configuration& t_config) const {
+            hash<ctl::Marking> hasher;
+            size_t seed = (size_t)reinterpret_cast<uintptr_t>(t_config.query);
+            //Combine query ptr adr with marking hashing
+            size_t result = hasher.operator ()(*t_config.marking);
+            result ^= seed + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+
+            return result;
+        }
+    };
+    template<>
+    struct hash<ctl::Configuration*>{
+        size_t operator()(const ctl::Configuration* t_config) const {
+            hash<ctl::Configuration> hasher;
+            return hasher.operator ()(*t_config);
+        }
+    };
+}
+
+#endif // CONFIGURATION_H

=== added file 'CTL/edge.cpp'
--- CTL/edge.cpp	1970-01-01 00:00:00 +0000
+++ CTL/edge.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,75 @@
+#include "edge.h"
+#include "configuration.h"
+
+namespace ctl{
+
+//    bool Edge::operator ==(const Edge& rhs) const {
+//        if(source != rhs.source)
+//            return false;
+//        if(!(targets == rhs.targets))
+//            return false;
+        
+//        return true;
+//    }
+
+
+
+void Edge::edgePrinter(){
+    std::cout << "--------------- Edge Information -------------------\n";
+	    std::cout << "--------------- source config----------------------\n";
+	    	source->configPrinter();
+        std::cout << "--------------- target configs----------------------\n";
+	    for( auto c : targets){
+	    	c->configPrinter();
+        }
+        std::cout << "-------------------------------------------------------\n";
+    }
+
+void Edge::rateEdge(){
+
+    if(Rating > -1){
+        return;
+    }
+    int alpha = 1;
+    int beta = 1;
+    int gamma = 1;
+
+    int dist = source->query->depth;
+    int breath = 0;
+    int succ = source->Successors.size();
+
+    for(auto t : targets){
+        breath++;
+    }
+    //make equation
+    Rating = (alpha*dist) + (beta*breath) + (gamma*succ);
+}
+
+}
+//namespace std{
+//    // Specializations of hash functions.
+//    // Normal
+//    template<>
+//    struct hash<ctl::Edge>{
+//        size_t operator()(const ctl::Edge& t_edge ) const {
+//            size_t seed = 0x9e3779b9;
+//            hash<ctl::Configuration> hasher;
+//            size_t result = hasher.operator()(*t_edge.source);
+
+//            for(auto t : t_edge.targets){
+//                result ^= hasher.operator()(*t);
+//            }
+//            result ^= seed + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+
+//            return result;
+//        }
+//    };
+//    //
+//    template<>
+//    struct hash<ctl::Edge*>{
+//        size_t operator()(const ctl::Edge* t_edge ) const {
+//            hash<ctl::Edge> hasher;
+//            return hasher.operator ()(*t_edge);
+//        }
+//    };
+//}

=== added file 'CTL/edge.h'
--- CTL/edge.h	1970-01-01 00:00:00 +0000
+++ CTL/edge.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,44 @@
+#ifndef EDGE_H
+#define EDGE_H
+
+#include <list>
+#include <iostream>
+
+
+namespace ctl {
+
+//To avoid circular dependency
+class Configuration;
+
+class Edge
+{
+public:
+    class EdgePointerEqual{
+        bool operator()(const Edge& lhs, const Edge& rhs) const{
+            return &lhs == &rhs;
+        }
+    };
+    class EdgePointerHash{
+        size_t operator()(const Edge* e)const{
+            return (size_t)e;
+        }
+    };
+
+    Edge(){};
+    Edge(Configuration* t_source) : source(t_source) {}
+    //virtual ~Edge(){std::cout << "Destroying Edge" << std::endl;}
+
+    bool processed = false;
+    //bool isDeleted = false;
+    int Rating = -1;
+    bool isDeleted = false;
+    Configuration* source;
+    std::list<Configuration*> targets;
+
+    //bool operator==(const Edge & rhs) const;
+    void edgePrinter();
+    void rateEdge();
+};
+}
+
+#endif // EDGE_H

=== added file 'CTL/marking.cpp'
--- CTL/marking.cpp	1970-01-01 00:00:00 +0000
+++ CTL/marking.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,38 @@
+#include <string.h>
+#include <iostream>
+
+#include "../PetriEngine/PetriNet.h"
+
+#include "marking.h"
+
+using namespace PetriEngine;
+
+namespace ctl {
+
+    bool Marking::operator ==(const Marking& rhs) const {
+        for(int i = 0; i < this->Length(); i++){
+            if(!(this->Value()[i] == rhs.Value()[i])){
+                return false;
+            }
+        } return true;
+        //return (0 == (memcmp(this->Value(), rhs.Value(), this->Length())));
+    }
+
+    void Marking::CopyMarking(const Marking& t_marking){
+        this->m_marking = (MarkVal*)malloc(sizeof(MarkVal) * t_marking.Length());
+        this->m_length = t_marking.Length();
+
+        for(int i = 0; i < m_length; i++){
+            m_marking[i] = t_marking[i];
+        }
+    }
+
+
+    void Marking::print() const {
+        for(int i = 0; i < m_length; i++){
+            std::cout << m_marking[i] <<std::flush;
+        }
+    }
+    
+}
+

=== added file 'CTL/marking.h'
--- CTL/marking.h	1970-01-01 00:00:00 +0000
+++ CTL/marking.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,76 @@
+#ifndef MARKING_H
+#define MARKING_H
+
+#include <vector>
+#include <boost/functional/hash/hash.hpp>
+#include "../PetriEngine/PetriNet.h"
+
+namespace ctl {
+
+//A Marking is essentially just an Array.
+//However since C++ does not support
+//VLA we must make use of a variable to
+//said length.
+//Along with that we are going make a few
+//inline functions to make the class
+//act/look/feel like an array.
+
+class Marking
+{
+    public:
+    // Equality checker for containers
+    // with pointers to markings
+    struct Marking_Equal_To{
+        bool operator()(const Marking* rhs, const Marking* lhs) const{
+            return (*rhs)==(*lhs);
+        }
+    };
+
+    Marking(){}
+    Marking(PetriEngine::MarkVal* t_marking, size_t t_length)
+        : m_marking(t_marking), m_length(t_length){}
+
+    virtual ~Marking(){ free(m_marking); }
+
+    void CopyMarking(const Marking& t_marking);
+
+    bool operator==(const Marking& rhs) const;
+
+    //Hopefully the compiler with agree with this inlining
+    inline PetriEngine::MarkVal& operator[](const int index) const {
+        return m_marking[index];
+    }
+    inline PetriEngine::MarkVal* Value() const {return m_marking;}
+    void print() const;
+    inline size_t Length() const {return m_length;}
+private:
+    PetriEngine::MarkVal* m_marking;
+    size_t m_length;
+};
+}
+
+namespace boost {
+    // Specializations of hash functions.
+    // Normal
+    template<>
+    struct hash<ctl::Marking>{
+        size_t operator()(const ctl::Marking& t_marking ) const {
+            size_t seed = 0x9e3779b9;
+
+            for(int i = 0; i < t_marking.Length(); i++){
+                seed ^= t_marking[i] + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+            }
+
+            return seed;
+        }
+    };
+    // Pointer to Marking
+    template<>
+    struct hash<ctl::Marking*>{
+        size_t operator()(const ctl::Marking* t_marking ) const {
+            hash<ctl::Marking> hasher;
+            return hasher.operator ()(*t_marking);
+        }
+    };
+}
+#endif // MARKING_H

=== added directory 'CTLParser'
=== added file 'CTLParser/CTLParser.cpp'
--- CTLParser/CTLParser.cpp	1970-01-01 00:00:00 +0000
+++ CTLParser/CTLParser.cpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,575 @@
+/* 
+ * File:   CTLParser.cpp
+ * Author: mossns
+ * 
+ * Created on September 30, 2015, 10:39 AM
+ */
+
+#include <string>
+#include <fstream>
+#include <string.h>
+#include <iostream>
+#include <stdio.h>
+#include <vector>
+#include "rapidxml-1.13/rapidxml.hpp"
+ 
+#include "CTLParser.h"
+
+
+using namespace rapidxml;
+
+CTLParser::CTLParser() {
+}
+
+CTLParser::CTLParser(PetriEngine::PetriNet* net) {
+    _net = net;
+}
+
+CTLParser::CTLParser(const CTLParser& orig) {
+}
+
+CTLParser::~CTLParser() {
+}
+
+void CTLParser::ParseXMLQuery(std::vector<char> buffer, CTLFormula *queryList[]) {
+    #ifdef DEBUG
+    std::cout << "Creating doc\n" << std::flush;
+    #endif
+//    CTLquery ctlquery;
+    xml_document<> doc;
+    xml_node<> * root_node;
+    
+    #ifdef DEBUG
+    std::cout << "Size of Path enum: " << sizeof(Path)*8 <<"\n";
+    #endif
+    doc.parse<0>(&buffer[0]);
+    
+
+#ifdef DEBUG
+    std::cout << "First node id: " << doc.first_node()->name() << std::endl;
+#endif
+
+    root_node = doc.first_node();
+
+#ifdef Analysis
+    std::cout << "\nAnalysis:: Queries:" << std::endl;
+#endif
+
+    int i = 0;
+    for (xml_node<> * property_node = root_node->first_node("property"); property_node; property_node = property_node->next_sibling()) {
+        xml_node<> * id_node = property_node->first_node("id"); 
+        queryList[i] = (CTLFormula*)malloc(sizeof(CTLFormula));
+
+        //Set competition information
+        int size = id_node->value_size();
+        queryList[i]->Name = strcpy((char*)calloc(size, sizeof(char)*size),
+                                    id_node->value());
+        queryList[i]->Result = false;
+        queryList[i]->Techniques = new std::vector<std::string>();
+
+        //Fill list with individual queries
+        xml_node<> * formula_node = id_node->next_sibling("description")->next_sibling("formula");
+        queryList[i]->Query = xmlToCTLquery(formula_node->first_node());
+
+       // printQuery(queryList[i]->Query);
+      //  std::cout << "\n";
+
+        i++;
+    }
+}
+
+CTLTree* CTLParser::xmlToCTLquery(xml_node<> * root) {
+    bool isA = false;
+    bool isE = false;
+    CTLTree *query = (CTLTree*)malloc(sizeof(CTLTree));
+    char *root_name = root->name();
+    char firstLetter = root_name[0];
+    
+    //Parse query segment
+    if (firstLetter == 'a') {
+        //Construct All (Transformed if AG)
+        isA = true;
+        query->quantifier = A;
+        query->path = setPathOperator(root->first_node(), isA, isE);
+        isA = false;
+        if(isAG){
+            createAGquery(root, query);
+            return query;
+        }
+        
+    }
+    else if (firstLetter == 'e' ) {
+        //Construct Exist (Transformed if EG)
+    	isE = true;
+        query->quantifier = E;
+        query->path = setPathOperator(root->first_node(), isA, isE);
+        isE = false;
+        if(isEG){
+            createEGquery(root, query);
+            return query;
+        }
+        
+    }
+    else if (firstLetter == 'n' ) {
+        //Construct negation
+        query->quantifier = NEG;
+        
+    }
+    else if (firstLetter == 'c' ) {
+        //Construct conjunction
+        query->quantifier = AND;
+    }
+    else if (firstLetter == 'd' ) {
+        //Construct disjunction
+        query->quantifier = OR;
+    }
+    else if (firstLetter == 'i' ) {
+        //Construct Atom
+        query->quantifier = EMPTY;
+        query->depth = 0;
+        query->max_depth = 0;
+        if (root_name[1] == 's' ) { // Check if Fireability query
+            constructFireAtom(query, root);
+            return query; 
+        }
+        else if (root_name[1] == 'n') { // Check if Cardinality query
+            constructCardinalityAtom(query, root);
+            return query; 
+        }
+        else {
+            #ifdef DEBUG
+            std::cout << "ERROR in xmlToCTLquery: Invalid atom " << root_name << "\n";
+            #endif
+        }
+    }
+    else {
+        #ifdef DEBUG
+        std::cout << "ERROR in xmlToCTLquery: Invalid boolean operator: " << root_name << "\n";
+        #endif
+    }
+    
+    
+    //Create query children
+    if (query->path == pError) {
+        #ifdef DEBUG
+        std::cout << "ERROR in xmlToCTLquery: !!Exiting - parse error!!\n";
+        #endif
+    }
+    else if (query->path == U) {
+        xml_node<> * child_node = root->first_node()->first_node();
+        query->first = xmlToCTLquery(child_node->first_node());
+        child_node = child_node->next_sibling();
+        query->second = xmlToCTLquery(child_node->first_node());
+    }
+    else if (query->quantifier == AND || query->quantifier == OR) {
+        xml_node<> * child_node = root->first_node();
+        query->first = xmlToCTLquery(child_node);
+        child_node = child_node->next_sibling();
+        query->second = xmlToCTLquery(child_node);
+    }
+    else if (query->quantifier == NEG) {
+        query->first = xmlToCTLquery(root->first_node());
+    }
+    else {
+        query->first = xmlToCTLquery(root->first_node()->first_node());
+    }
+    
+    
+    //Update query depth information
+    if (query->quantifier == AND || query->quantifier == OR || query->path == U){
+        int first_depth = query->first->depth, second_depth = query->second->depth;
+        query->depth = (lowerDepth(first_depth, second_depth) + 1);
+        
+        int first_max_depth = query->first->max_depth, second_max_depth = query->second->max_depth;
+        query->max_depth = (higherDepth(first_max_depth, second_max_depth) + 1);
+    }
+    else {
+        query->depth = (query->first->depth + 1);
+        query->max_depth = (query->first->max_depth + 1);
+    }
+    
+    return query;
+}
+
+Path CTLParser::setPathOperator(xml_node<> * root, bool isA, bool isE) {
+    char *root_name = root->name();
+    char firstLetter = root_name[0];
+    
+    if (firstLetter == 'g') {
+        if(isA) { isAG = true; }
+        if(isE){ isEG = true; }
+        return G;
+    }
+    else if (firstLetter == 'f') {
+        isEG = false;
+        isAG = false;
+        return F;
+    }
+    else if (firstLetter == 'n') {
+        isEG = false;
+        isAG = false;
+        return X;
+    }
+    else if (firstLetter == 'u') {
+        isEG = false;
+        isAG = false;
+        return U;
+    }
+    else {
+        #ifdef DEBUG
+        std::cout << "ERROR in setPathOperator: Invalid path operator: " << root_name << "\n";
+        #endif
+    }
+    return pError;
+}
+
+void CTLParser::printQuery(CTLTree *query) {
+    if(query->quantifier == EMPTY) {
+        Atom a = query->a;
+        if(a.isFireable){
+            std::cout<< " IsFireable(" << std::flush;
+            int i = 0;
+            for(i = 0; i < query->a.firesize; i++){
+                int j = 0;
+                for (j = 0; j < query->a.fireset[i].sizeofdenpencyplaces; j++){
+                    std::cout<<"t_name_not_available" << std::flush;
+                    if(j < (query->a.fireset[i].sizeofdenpencyplaces - 1))
+                        std::cout << ", ";
+                }
+            }
+            std::cout << ")";
+            return;
+        }
+        else {
+            std::cout<< " Tokencount(" << std::flush;
+            if (a.cardinality.intSmaller == -1){
+                int i = 0;
+                for (i = 0; i < a.cardinality.placeSmaller.sizeoftokencount; i++){
+                    std::cout<< a.cardinality.placeSmaller.cardinality[i]<<" ";
+                }
+            }
+            else 
+                std::cout << a.cardinality.intSmaller;
+            
+            std::cout<< " le " << std::flush;
+            
+            if (a.cardinality.intLarger == -1) {
+                int i = 0;
+                for (i = 0; i < a.cardinality.placeLarger.sizeoftokencount; i++){
+                    std::cout<< a.cardinality.placeLarger.cardinality[i]<<" ";
+                }
+            }
+            else 
+                std::cout<< a.cardinality.intLarger;
+            std::cout << ")";
+        }
+        return;
+    }
+    else if (query->quantifier == NEG){
+        std::cout << "!("; printQuery(query->first) ;std::cout <<")" << std::flush;
+    }
+    else if (query->quantifier == AND){
+        std::cout << "(" ; printQuery(query->first);std::cout <<") AND ("; printQuery(query->second);std::cout<< ")" << std::flush;
+    }
+    else if (query->quantifier == OR){
+        std::cout << "("; printQuery(query->first);std::cout <<") OR ("; printQuery(query->second);std::cout << ")" << std::flush;
+    }
+    else if (query->quantifier == A){
+        std::cout << "A" << std::flush;
+        printPath(query);
+    }
+    else if ( query->quantifier == E){
+        std::cout << "E" << std::flush;
+        printPath(query);
+    }
+    else return;
+}
+
+void CTLParser::printPath(CTLTree *query) {
+    if (query->path == G)
+        std::cout << "G";
+    else if (query->path == F)
+        std::cout << "F";
+    else if (query->path == U)
+        {std::cout << "("; printQuery(query->first);std::cout <<") U ("; printQuery(query->second);std::cout << ")"; return;}
+    else if (query->path == X)
+        std::cout << "X";
+    printQuery(query->first);
+}
+
+bool CTLParser::charEmpty(char *query) {
+    if (query == NULL) {
+        return true;
+    }
+    return false;
+}
+
+void CTLParser::constructCardinalityAtom(CTLTree *query, xml_node<> *root){
+    xml_node<> * integerNode = root->first_node();
+    query->a.isFireable = false;
+    query->a.firesize = 0;
+    
+    constructPreOperator(integerNode, query);
+    
+    integerNode = integerNode->next_sibling();
+    
+    constructPostOperator(integerNode, query);
+}
+
+void CTLParser::constructPreOperator(xml_node<> * integerNode, CTLTree *query){
+    if (integerNode->name()[0] == 't') {
+        int smallPlacecount = 0, numberofplaces = 0;
+        for (xml_node<> * place_node = integerNode->first_node(); place_node; place_node = place_node->next_sibling()) {
+            numberofplaces++;
+        }
+        //std::cout<<"Number of places: "<<numberofplaces<<std::flush;
+
+        query->a.cardinality.placeSmaller.cardinality = (int*) calloc(numberofplaces, sizeof(int));
+        query->a.cardinality.placeSmaller.sizeoftokencount = numberofplaces;
+
+        for (xml_node<> * place_node = integerNode->first_node(); place_node; place_node = place_node->next_sibling()) {
+            int p_index = 0;
+            for (p_index = 0; p_index < _net->numberOfPlaces(); p_index++){
+                if(strcmp(_net->placeNames()[p_index].c_str(),place_node->value()) == 0){
+                    query->a.cardinality.placeSmaller.cardinality[smallPlacecount] = p_index;
+                    smallPlacecount++;
+                    break;
+                }
+            }
+        }
+        query->a.cardinality.intSmaller = -1;
+       // std::cout<< query->a.tokenCount.placeSmaller << " should be a smaller PLACE than ";
+    }
+    else if (integerNode->name()[0] == 'i') {
+        char *temp;
+        temp = integerNode->value();
+        query->a.cardinality.intSmaller = atoi(temp);
+        query->a.cardinality.placeSmaller.sizeoftokencount = 0;         
+        //std::cout<< query->a.cardinality.intSmaller << " should be a smaller INTEGER-CONTANT than ";
+    }
+}
+
+void CTLParser::constructPostOperator(xml_node<> * integerNode, CTLTree *query){
+    if (integerNode->name()[0] == 't') {
+        int largePlacecount = 0, numberofplaces = 0;
+        for (xml_node<> * place_node = integerNode->first_node(); place_node; place_node = place_node->next_sibling()) {
+            numberofplaces++;
+        }
+        //std::cout<<"Number of places: "<<numberofplaces<<std::endl;
+        query->a.cardinality.placeLarger.cardinality = (int*) calloc(numberofplaces, sizeof(int));
+        query->a.cardinality.placeLarger.sizeoftokencount = numberofplaces;
+        for (xml_node<> * place_node = integerNode->first_node(); place_node; place_node = place_node->next_sibling()) {
+            int p_index = 0;
+            for (p_index = 0; p_index < _net->numberOfPlaces(); p_index++){
+                if(strcmp(_net->placeNames()[p_index].c_str(),place_node->first_node()->value()) == 0){
+                    query->a.cardinality.placeLarger.cardinality[largePlacecount] = p_index;
+                    largePlacecount++;
+                    break;
+                }
+            }
+        }
+        query->a.cardinality.intLarger = -1;
+    }
+
+    else if (integerNode->name()[0] == 'i') {
+        char *temp;
+        temp = integerNode->value();
+        query->a.cardinality.intLarger = atoi(temp);
+        query->a.cardinality.placeLarger.sizeoftokencount = 0;
+        //std::cout<< query->a.cardinality.intLarger << " - witch is an INTEGER-CONTANT ";
+    }
+}
+
+void CTLParser::constructFireAtom(CTLTree *query, xml_node<> *root){
+    numberoftransitions = 0;
+    int i = 0, numberofdependencyplaces = 0;
+    query->a.isFireable = true;
+    //std::cout << "TEST:: Current set made" <<std::endl;
+    for (xml_node<> * transition_node = root->first_node(); transition_node; transition_node = transition_node->next_sibling()) {
+        numberoftransitions++;
+    }
+    //numberoftransitions++;
+    //std::cout << "TEST:: Number of transitions: "<<numberoftransitions <<std::endl;
+    query->a.firesize = numberoftransitions;
+    query->a.fireset = (Fireability*) calloc(numberoftransitions, sizeof(Fireability));
+
+
+    for (xml_node<> * transition_node = root->first_node(); transition_node; transition_node = transition_node->next_sibling()) {
+        int t_count = 0;
+        for (t_count = 0; t_count < _net->numberOfTransitions(); t_count++){
+            if (strcmp( _net->transitionNames()[t_count].c_str(), transition_node->value()) == 0){
+                numberofdependencyplaces = countNumberofDependencies(t_count);
+                query->a.fireset[i].denpencyplaces = (Dependency*) calloc(numberofdependencyplaces, sizeof(Dependency));
+                query->a.fireset[i].sizeofdenpencyplaces = numberofdependencyplaces;
+            }
+        }
+        for (t_count = 0; t_count < _net->numberOfTransitions(); t_count++){
+            if (strcmp( _net->transitionNames()[t_count].c_str(), transition_node->value()) == 0){
+                convertToCardinality(i, query, t_count);
+            }
+        }
+
+        i++;
+    }
+}
+
+void CTLParser::convertToCardinality(int i, CTLTree *query, int t_index){
+    int p_count = 0;
+    int dependent_count = 0;
+    for(p_count = 0; p_count < _net->numberOfPlaces(); p_count++){
+        int arc_weight = _net->inArc(p_count, t_index);
+        if (arc_weight > 0){
+            query->a.fireset[i].denpencyplaces[dependent_count].intSmaller = arc_weight;
+            query->a.fireset[i].denpencyplaces[dependent_count].placeLarger = p_count;
+            dependent_count++;
+        }
+    }
+}
+
+int CTLParser::countNumberofDependencies(int t_index){
+    //Returns how many places the transition is dependent on
+    int p_count = 0, res = 0;
+    for(p_count = 0; p_count < _net->numberOfPlaces(); p_count++){
+        int arc_weight = _net->inArc(p_count, t_index);
+        if (arc_weight > 0){
+            res++;
+        }
+    }
+    return res;
+}
+
+void CTLParser::createAGquery(xml_node<> * root, CTLTree *query){
+    //Function for converting AG to !EF!
+    CTLTree *query1 = (CTLTree*)malloc(sizeof(CTLTree));
+    CTLTree *query2 = (CTLTree*)malloc(sizeof(CTLTree));
+
+    //Set the first operator to neg
+    query->quantifier = NEG;
+    query->a.fireset = NULL;
+    query->first = query1;
+
+    //Set the second operator to EF
+    query1->quantifier = E;
+    query1->path = F;
+    query1->a.fireset = NULL;
+    query1->first = query2;
+
+    ////Set the third operator to neg
+    query2->quantifier = NEG;
+    query2->a.fireset = NULL;
+    
+    //Recursively find successor query
+    query2->first = xmlToCTLquery(root->first_node()->first_node());
+
+    //Update depth information
+    isAG = false;
+    query2->max_depth = (query2->first->max_depth + 1);
+    query2->depth = (query2->first->depth + 1);
+    query1->depth = (query2->depth + 1);
+    query1->max_depth = (query2->max_depth + 1);
+    query->depth = (query1->depth + 1);
+    query->max_depth = (query1->max_depth + 1);
+}
+
+void CTLParser::createEGquery(xml_node<> * root, CTLTree *query){
+    //Function for converting EG to !AF!
+    CTLTree *query1 = (CTLTree*)malloc(sizeof(CTLTree));
+    CTLTree *query2 = (CTLTree*)malloc(sizeof(CTLTree));
+    
+    //Set the first operator to neg
+    query->quantifier = NEG;
+    query->a.fireset = NULL;
+    query->first = query1;
+
+    //Set the second operator to AF
+    query1->quantifier = A;
+    query1->path = F;
+    query1->a.fireset = NULL;
+    query1->first = query2;
+    
+    ////Set the third operator to neg
+    query2->quantifier = NEG;
+    query2->a.fireset = NULL;
+    
+    //Recursively find successor query
+    query2->first = xmlToCTLquery(root->first_node()->first_node());
+    
+    //Update depth information
+    isEG = false;
+    query2->depth = (query2->first->depth + 1);
+    query2->max_depth = (query2->first->max_depth + 1);
+    query1->depth = (query2->depth + 1);
+    query1->max_depth = (query2->max_depth + 1);
+    query->depth = (query1->depth + 1);
+    query->max_depth = (query1->max_depth + 1);
+}
+
+unsigned int CTLParser::lowerDepth(unsigned int a, unsigned int b){
+    if (a < b)
+        return a;
+    else if (a == b)
+        return a;
+    else return b;
+}
+
+unsigned int CTLParser::higherDepth(unsigned int a, unsigned int b){
+    if (b > a)
+        return b;
+    else if (a == b)
+        return b;
+    else return a;
+}
+
+//Test functions
+void CTLParser::RunParserTest(){
+    CTLFormula *queryList[12];
+    std::string querypath = "testFramework/unitTestResources/TEST_CTLFireabilitySimple.xml";
+            //"testFramework/unitTestResources/TEST_CTLFireabilitySimple.xml";
+    const char* queryfile = querypath.c_str();
+    std::ifstream xmlfile (queryfile);
+    std::vector<char> buffer((std::istreambuf_iterator<char>(xmlfile)), std::istreambuf_iterator<char>());
+    buffer.push_back('\0');
+    
+    
+    //Test 1 - charEmpty
+    char* test1input = NULL;
+    bool resTest1 = charEmpty(test1input);
+    assert(resTest1 == true);
+  
+    
+    //Test 2 - Correct queries
+    ParseXMLQuery(buffer, queryList);
+        //Confirm AF becomes AF
+        assert(queryList[0]->Query->quantifier == A);
+        assert(queryList[0]->Query->path == F);
+        //Confirm EF becomes EF
+        assert(queryList[1]->Query->quantifier == E);
+        assert(queryList[1]->Query->path == F);
+        //Confirm AG becomes !EF!()
+        assert(queryList[2]->Query->quantifier == NEG);
+        assert(queryList[2]->Query->first->quantifier == E);
+        assert(queryList[2]->Query->first->path == F);
+        assert(queryList[2]->Query->first->first->quantifier == NEG);
+        //Confirm EG becomes !AF!()
+        assert(queryList[3]->Query->quantifier == NEG);
+        assert(queryList[3]->Query->first->quantifier == A);
+        assert(queryList[3]->Query->first->path == F);
+        assert(queryList[3]->Query->first->first->quantifier == NEG);
+        //Confirm AU becomes AU
+        assert(queryList[4]->Query->quantifier == A);
+        assert(queryList[4]->Query->path == U);
+        //Confirm EU becomes EU
+        assert(queryList[5]->Query->quantifier == E);
+        assert(queryList[5]->Query->path == U);
+        //Confirm AX becomes AX
+        assert(queryList[6]->Query->quantifier == A);
+        assert(queryList[6]->Query->path == X);
+        //Confirm EX becomes EX
+        assert(queryList[7]->Query->quantifier == E);
+        assert(queryList[7]->Query->path == X);
+        //Confirm Houseconstructions
+        int i = 0;
+        
+        std::cout<<"::::::::::::::::::::::::::::::::\n:::::::: Parse Test End ::::::::\n::::::::::::::::::::::::::::::::\n"<<std::endl;
+        
+}

=== added file 'CTLParser/CTLParser.h'
--- CTLParser/CTLParser.h	1970-01-01 00:00:00 +0000
+++ CTLParser/CTLParser.h	2016-03-31 07:42:46 +0000
@@ -0,0 +1,126 @@
+/* 
+ * File:   CTLParser.h
+ * Author: moss
+ *
+ * Created on September 30, 2015, 10:39 AM
+ */
+
+#ifndef CTLPARSER_H
+#define	CTLPARSER_H
+
+#include "rapidxml-1.13/rapidxml.hpp"
+#include <vector>
+#include <string>
+#include <iostream>
+#include "../PetriEngine/PetriNet.h"
+
+enum Quantifier { AND = 1, OR = 2, A = 3, E = 4, NEG = 5, EMPTY = -1 };
+enum Path { G = 1, X = 2, F = 3, U = 4, pError = -1 };
+
+struct TokenCount{
+    int sizeoftokencount;
+    int* cardinality;
+};
+
+struct Cardinality {
+    int intSmaller;
+    TokenCount placeSmaller;
+    int intLarger;
+    TokenCount placeLarger;
+};
+
+struct Dependency{
+    int intSmaller;
+    int placeSmaller;
+    int intLarger;
+    int placeLarger;
+};
+
+struct Fireability{
+    int sizeofdenpencyplaces;
+    Dependency* denpencyplaces;
+};
+
+struct Atom {
+    bool isFireable;
+    int firesize;
+    Fireability* fireset;
+    Cardinality cardinality;
+};
+
+struct CTLTree {
+  Quantifier quantifier;
+  Path path;
+  CTLTree *first;
+  CTLTree *second;
+  Atom a;
+  unsigned int depth;
+  unsigned int max_depth;
+} ;
+
+struct CTLFormula {
+    char* Name;
+    bool Result;
+    std::vector<std::string>* Techniques;
+    CTLTree* Query;
+
+    std::string boolToString(){
+        if(Result)
+            return " TRUE ";
+        else if (!Result)
+            return " FALSE ";
+        else
+            return " ERROR ";
+    }
+
+    //MCC2015 result printer
+    void pResult(){
+        std::cout << "FORMULA "
+                  << Name
+                  << boolToString()
+                  << "TECHNIQUES SEQUENTIAL_PROCESSING EXPLICIT";
+
+        for(std::vector<std::string>::const_iterator iter = Techniques->begin();
+            iter != Techniques->end();
+            iter++ )
+        {
+            std::cout << *iter << " ";
+        }
+        std::cout << std::endl;
+    }
+};
+
+class CTLParser {
+public:
+    CTLParser();
+    CTLParser(PetriEngine::PetriNet* net);
+    CTLParser(const CTLParser& orig);
+    virtual ~CTLParser();
+    void ParseXMLQuery(std::vector<char> buffer, CTLFormula **queryList);
+    void printQuery(CTLTree *query);
+    void RunParserTest();
+private:
+    PetriEngine::PetriNet* _net;
+    bool isAG = false;
+    bool isEG = false;
+    int numberoftransitions;
+    unsigned int lowerDepth(unsigned int a, unsigned int b);
+    unsigned int higherDepth(unsigned int a, unsigned int b);
+    CTLTree* xmlToCTLquery(rapidxml::xml_node<> * root);
+    Path setPathOperator(rapidxml::xml_node<> * root, bool isA, bool isE);
+    void createAGquery(rapidxml::xml_node<> * root, CTLTree *query);
+    void createEGquery(rapidxml::xml_node<> * root, CTLTree *query);
+    void constructFireAtom(CTLTree *query, rapidxml::xml_node<> *root);
+    void constructCardinalityAtom(CTLTree *query, rapidxml::xml_node<> *root);
+    int countNumberofDependencies(int t_index);
+    void convertToCardinality(int i, CTLTree *query, int t_index);
+    void constructPreOperator(rapidxml::xml_node<> * integerNode, CTLTree *query);
+    void constructPostOperator(rapidxml::xml_node<> * integerNode, CTLTree *query);
+    
+    bool charEmpty(char *query);
+    void printPath(CTLTree *query);
+    
+};
+
+#endif	/* CTLPARSER_H */
+

=== added directory 'CTLParser/rapidxml-1.13'
=== added file 'CTLParser/rapidxml-1.13/license.txt'
--- CTLParser/rapidxml-1.13/license.txt	1970-01-01 00:00:00 +0000
+++ CTLParser/rapidxml-1.13/license.txt	2016-03-31 07:42:46 +0000
@@ -0,0 +1,52 @@
+Use of this software is granted under one of the following two licenses,
+to be chosen freely by the user.
+
+1. Boost Software License - Version 1.0 - August 17th, 2003
+===============================================================================
+
+Copyright (c) 2006, 2007 Marcin Kalicinski
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+2. The MIT License
+===============================================================================
+
+Copyright (c) 2006, 2007 Marcin Kalicinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the "Software"), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 
+IN THE SOFTWARE.

=== added file 'CTLParser/rapidxml-1.13/rapidxml.hpp'
--- CTLParser/rapidxml-1.13/rapidxml.hpp	1970-01-01 00:00:00 +0000
+++ CTLParser/rapidxml-1.13/rapidxml.hpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,2596 @@
+#ifndef RAPIDXML_HPP_INCLUDED
+#define RAPIDXML_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation
+
+// If standard library is disabled, user must provide implementations of required functions and typedefs
+#if !defined(RAPIDXML_NO_STDLIB)
+    #include <cstdlib>      // For std::size_t
+    #include <cassert>      // For assert
+    #include <new>          // For placement new
+#endif
+
+// On MSVC, disable "conditional expression is constant" warning (level 4). 
+// This warning is almost impossible to avoid with certain types of templated code
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable:4127)   // Conditional expression is constant
+#endif
+
+///////////////////////////////////////////////////////////////////////////
+// RAPIDXML_PARSE_ERROR
+    
+#if defined(RAPIDXML_NO_EXCEPTIONS)
+
+#define RAPIDXML_PARSE_ERROR(what, where) { parse_error_handler(what, where); assert(0); }
+
+namespace rapidxml
+{
+    //! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, 
+    //! this function is called to notify user about the error.
+    //! It must be defined by the user.
+    //! <br><br>
+    //! This function cannot return. If it does, the results are undefined.
+    //! <br><br>
+    //! A very simple definition might look like that:
+    //! <pre>
+    //! void %rapidxml::%parse_error_handler(const char *what, void *where)
+    //! {
+    //!     std::cout << "Parse error: " << what << "\n";
+    //!     std::abort();
+    //! }
+    //! </pre>
+    //! \param what Human readable description of the error.
+    //! \param where Pointer to character data where error was detected.
+    void parse_error_handler(const char *what, void *where);
+}
+
+#else
+    
+#include <exception>    // For std::exception
+
+#define RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where)
+
+namespace rapidxml
+{
+
+    //! Parse error exception. 
+    //! This exception is thrown by the parser when an error occurs. 
+    //! Use what() function to get human-readable error message. 
+    //! Use where() function to get a pointer to position within source text where error was detected.
+    //! <br><br>
+    //! If throwing exceptions by the parser is undesirable, 
+    //! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.
+    //! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.
+    //! This function must be defined by the user.
+    //! <br><br>
+    //! This class derives from <code>std::exception</code> class.
+    class parse_error: public std::exception
+    {
+    
+    public:
+    
+        //! Constructs parse error
+        parse_error(const char *what, void *where)
+            : m_what(what)
+            , m_where(where)
+        {
+        }
+
+        //! Gets human readable description of error.
+        //! \return Pointer to null terminated description of the error.
+        virtual const char *what() const throw()
+        {
+            return m_what;
+        }
+
+        //! Gets pointer to character data where error happened.
+        //! Ch should be the same as char type of xml_document that produced the error.
+        //! \return Pointer to location within the parsed string where error occured.
+        template<class Ch>
+        Ch *where() const
+        {
+            return reinterpret_cast<Ch *>(m_where);
+        }
+
+    private:  
+
+        const char *m_what;
+        void *m_where;
+
+    };
+}
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////
+// Pool sizes
+
+#ifndef RAPIDXML_STATIC_POOL_SIZE
+    // Size of static memory block of memory_pool.
+    // Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
+    // No dynamic memory allocations are performed by memory_pool until static memory is exhausted.
+    #define RAPIDXML_STATIC_POOL_SIZE (64 * 1024)
+#endif
+
+#ifndef RAPIDXML_DYNAMIC_POOL_SIZE
+    // Size of dynamic memory block of memory_pool.
+    // Define RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
+    // After the static block is exhausted, dynamic blocks with approximately this size are allocated by memory_pool.
+    #define RAPIDXML_DYNAMIC_POOL_SIZE (64 * 1024)
+#endif
+
+#ifndef RAPIDXML_ALIGNMENT
+    // Memory allocation alignment.
+    // Define RAPIDXML_ALIGNMENT before including rapidxml.hpp if you want to override the default value, which is the size of pointer.
+    // All memory allocations for nodes, attributes and strings will be aligned to this value.
+    // This must be a power of 2 and at least 1, otherwise memory_pool will not work.
+    #define RAPIDXML_ALIGNMENT sizeof(void *)
+#endif
+
+namespace rapidxml
+{
+    // Forward declarations
+    template<class Ch> class xml_node;
+    template<class Ch> class xml_attribute;
+    template<class Ch> class xml_document;
+    
+    //! Enumeration listing all node types produced by the parser.
+    //! Use xml_node::type() function to query node type.
+    enum node_type
+    {
+        node_document,      //!< A document node. Name and value are empty.
+        node_element,       //!< An element node. Name contains element name. Value contains text of first data node.
+        node_data,          //!< A data node. Name is empty. Value contains data text.
+        node_cdata,         //!< A CDATA node. Name is empty. Value contains data text.
+        node_comment,       //!< A comment node. Name is empty. Value contains comment text.
+        node_declaration,   //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
+        node_doctype,       //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
+        node_pi             //!< A PI node. Name contains target. Value contains instructions.
+    };
+
+    ///////////////////////////////////////////////////////////////////////
+    // Parsing flags
+
+    //! Parse flag instructing the parser to not create data nodes. 
+    //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_no_data_nodes = 0x1;            
+
+    //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
+    //! Can be combined with other flags by use of | operator.
+    //! Note that child data nodes of element node take precendence over its value when printing. 
+    //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
+    //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_no_element_values = 0x2;
+    
+    //! Parse flag instructing the parser to not place zero terminators after strings in the source text.
+    //! By default zero terminators are placed, modifying source text.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_no_string_terminators = 0x4;
+    
+    //! Parse flag instructing the parser to not translate entities in the source text.
+    //! By default entities are translated, modifying source text.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_no_entity_translation = 0x8;
+    
+    //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
+    //! By default, UTF-8 handling is enabled.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_no_utf8 = 0x10;
+    
+    //! Parse flag instructing the parser to create XML declaration node.
+    //! By default, declaration node is not created.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_declaration_node = 0x20;
+    
+    //! Parse flag instructing the parser to create comments nodes.
+    //! By default, comment nodes are not created.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_comment_nodes = 0x40;
+    
+    //! Parse flag instructing the parser to create DOCTYPE node.
+    //! By default, doctype node is not created.
+    //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_doctype_node = 0x80;
+    
+    //! Parse flag instructing the parser to create PI nodes.
+    //! By default, PI nodes are not created.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_pi_nodes = 0x100;
+    
+    //! Parse flag instructing the parser to validate closing tag names. 
+    //! If not set, name inside closing tag is irrelevant to the parser.
+    //! By default, closing tags are not validated.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_validate_closing_tags = 0x200;
+    
+    //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
+    //! By default, whitespace is not trimmed. 
+    //! This flag does not cause the parser to modify source text.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_trim_whitespace = 0x400;
+
+    //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
+    //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
+    //! By default, whitespace is not normalized. 
+    //! If this flag is specified, source text will be modified.
+    //! Can be combined with other flags by use of | operator.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_normalize_whitespace = 0x800;
+
+    // Compound flags
+    
+    //! Parse flags which represent default behaviour of the parser. 
+    //! This is always equal to 0, so that all other flags can be simply ored together.
+    //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
+    //! This also means that meaning of each flag is a <i>negation</i> of the default setting. 
+    //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
+    //! and using the flag will disable it.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_default = 0;
+    
+    //! A combination of parse flags that forbids any modifications of the source text. 
+    //! This also results in faster parsing. However, note that the following will occur:
+    //! <ul>
+    //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>
+    //! <li>entities will not be translated</li>
+    //! <li>whitespace will not be normalized</li>
+    //! </ul>
+    //! See xml_document::parse() function.
+    const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;
+    
+    //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_fastest = parse_non_destructive | parse_no_data_nodes;
+    
+    //! A combination of parse flags resulting in largest amount of data being extracted. 
+    //! This usually results in slowest parsing.
+    //! <br><br>
+    //! See xml_document::parse() function.
+    const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Internals
+
+    //! \cond internal
+    namespace internal
+    {
+
+        // Struct that contains lookup tables for the parser
+        // It must be a template to allow correct linking (because it has static data members, which are defined in a header file).
+        template<int Dummy>
+        struct lookup_tables
+        {
+            static const unsigned char lookup_whitespace[256];              // Whitespace table
+            static const unsigned char lookup_node_name[256];               // Node name table
+            static const unsigned char lookup_text[256];                    // Text table
+            static const unsigned char lookup_text_pure_no_ws[256];         // Text table
+            static const unsigned char lookup_text_pure_with_ws[256];       // Text table
+            static const unsigned char lookup_attribute_name[256];          // Attribute name table
+            static const unsigned char lookup_attribute_data_1[256];        // Attribute data table with single quote
+            static const unsigned char lookup_attribute_data_1_pure[256];   // Attribute data table with single quote
+            static const unsigned char lookup_attribute_data_2[256];        // Attribute data table with double quotes
+            static const unsigned char lookup_attribute_data_2_pure[256];   // Attribute data table with double quotes
+            static const unsigned char lookup_digits[256];                  // Digits
+            static const unsigned char lookup_upcase[256];                  // To uppercase conversion table for ASCII characters
+        };
+
+        // Find length of the string
+        template<class Ch>
+        inline std::size_t measure(const Ch *p)
+        {
+            const Ch *tmp = p;
+            while (*tmp) 
+                ++tmp;
+            return tmp - p;
+        }
+
+        // Compare strings for equality
+        template<class Ch>
+        inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive)
+        {
+            if (size1 != size2)
+                return false;
+            if (case_sensitive)
+            {
+                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
+                    if (*p1 != *p2)
+                        return false;
+            }
+            else
+            {
+                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
+                    if (lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p1)] != lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p2)])
+                        return false;
+            }
+            return true;
+        }
+    }
+    //! \endcond
+
+    ///////////////////////////////////////////////////////////////////////
+    // Memory pool
+    
+    //! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.
+    //! In most cases, you will not need to use this class directly. 
+    //! However, if you need to create nodes manually or modify names/values of nodes, 
+    //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory. 
+    //! Not only is this faster than allocating them by using <code>new</code> operator, 
+    //! but also their lifetime will be tied to the lifetime of document, 
+    //! possibly simplyfing memory management. 
+    //! <br><br>
+    //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool. 
+    //! You can also call allocate_string() function to allocate strings.
+    //! Such strings can then be used as names or values of nodes without worrying about their lifetime.
+    //! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called, 
+    //! or when the pool is destroyed.
+    //! <br><br>
+    //! It is also possible to create a standalone memory_pool, and use it 
+    //! to allocate nodes, whose lifetime will not be tied to any document.
+    //! <br><br>
+    //! Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory. 
+    //! Until static memory is exhausted, no dynamic memory allocations are done.
+    //! When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each,
+    //! by using global <code>new[]</code> and <code>delete[]</code> operators. 
+    //! This behaviour can be changed by setting custom allocation routines. 
+    //! Use set_allocator() function to set them.
+    //! <br><br>
+    //! Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes.
+    //! This value defaults to the size of pointer on target architecture.
+    //! <br><br>
+    //! To obtain absolutely top performance from the parser,
+    //! it is important that all nodes are allocated from a single, contiguous block of memory.
+    //! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.
+    //! If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code> 
+    //! to obtain best wasted memory to performance compromise.
+    //! To do it, define their values before rapidxml.hpp file is included.
+    //! \param Ch Character type of created nodes. 
+    template<class Ch = char>
+    class memory_pool
+    {
+        
+    public:
+
+        //! \cond internal
+        typedef void *(alloc_func)(std::size_t);       // Type of user-defined function used to allocate memory
+        typedef void (free_func)(void *);              // Type of user-defined function used to free memory
+        //! \endcond
+        
+        //! Constructs empty pool with default allocator functions.
+        memory_pool()
+            : m_alloc_func(0)
+            , m_free_func(0)
+        {
+            init();
+        }
+
+        //! Destroys pool and frees all the memory. 
+        //! This causes memory occupied by nodes allocated by the pool to be freed.
+        //! Nodes allocated from the pool are no longer valid.
+        ~memory_pool()
+        {
+            clear();
+        }
+
+        //! Allocates a new node from the pool, and optionally assigns name and value to it. 
+        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
+        //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
+        //! will call rapidxml::parse_error_handler() function.
+        //! \param type Type of node to create.
+        //! \param name Name to assign to the node, or 0 to assign no name.
+        //! \param value Value to assign to the node, or 0 to assign no value.
+        //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
+        //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
+        //! \return Pointer to allocated node. This pointer will never be NULL.
+        xml_node<Ch> *allocate_node(node_type type, 
+                                    const Ch *name = 0, const Ch *value = 0, 
+                                    std::size_t name_size = 0, std::size_t value_size = 0)
+        {
+            void *memory = allocate_aligned(sizeof(xml_node<Ch>));
+            xml_node<Ch> *node = new(memory) xml_node<Ch>(type);
+            if (name)
+            {
+                if (name_size > 0)
+                    node->name(name, name_size);
+                else
+                    node->name(name);
+            }
+            if (value)
+            {
+                if (value_size > 0)
+                    node->value(value, value_size);
+                else
+                    node->value(value);
+            }
+            return node;
+        }
+
+        //! Allocates a new attribute from the pool, and optionally assigns name and value to it.
+        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
+        //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
+        //! will call rapidxml::parse_error_handler() function.
+        //! \param name Name to assign to the attribute, or 0 to assign no name.
+        //! \param value Value to assign to the attribute, or 0 to assign no value.
+        //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
+        //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
+        //! \return Pointer to allocated attribute. This pointer will never be NULL.
+        xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0, 
+                                              std::size_t name_size = 0, std::size_t value_size = 0)
+        {
+            void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));
+            xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;
+            if (name)
+            {
+                if (name_size > 0)
+                    attribute->name(name, name_size);
+                else
+                    attribute->name(name);
+            }
+            if (value)
+            {
+                if (value_size > 0)
+                    attribute->value(value, value_size);
+                else
+                    attribute->value(value);
+            }
+            return attribute;
+        }
+
+        //! Allocates a char array of given size from the pool, and optionally copies a given string to it.
+        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
+        //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
+        //! will call rapidxml::parse_error_handler() function.
+        //! \param source String to initialize the allocated memory with, or 0 to not initialize it.
+        //! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.
+        //! \return Pointer to allocated char array. This pointer will never be NULL.
+        Ch *allocate_string(const Ch *source = 0, std::size_t size = 0)
+        {
+            assert(source || size);     // Either source or size (or both) must be specified
+            if (size == 0)
+                size = internal::measure(source) + 1;
+            Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));
+            if (source)
+                for (std::size_t i = 0; i < size; ++i)
+                    result[i] = source[i];
+            return result;
+        }
+
+        //! Clones an xml_node and its hierarchy of child nodes and attributes.
+        //! Nodes and attributes are allocated from this memory pool.
+        //! Names and values are not cloned, they are shared between the clone and the source.
+        //! Result node can be optionally specified as a second parameter, 
+        //! in which case its contents will be replaced with cloned source node.
+        //! This is useful when you want to clone entire document.
+        //! \param source Node to clone.
+        //! \param result Node to put results in, or 0 to automatically allocate result node
+        //! \return Pointer to cloned node. This pointer will never be NULL.
+        xml_node<Ch> *clone_node(const xml_node<Ch> *source, xml_node<Ch> *result = 0)
+        {
+            // Prepare result node
+            if (result)
+            {
+                result->remove_all_attributes();
+                result->remove_all_nodes();
+                result->type(source->type());
+            }
+            else
+                result = allocate_node(source->type());
+
+            // Clone name and value
+            result->name(source->name(), source->name_size());
+            result->value(source->value(), source->value_size());
+
+            // Clone child nodes and attributes
+            for (xml_node<Ch> *child = source->first_node(); child; child = child->next_sibling())
+                result->append_node(clone_node(child));
+            for (xml_attribute<Ch> *attr = source->first_attribute(); attr; attr = attr->next_attribute())
+                result->append_attribute(allocate_attribute(attr->name(), attr->value(), attr->name_size(), attr->value_size()));
+
+            return result;
+        }
+
+        //! Clears the pool. 
+        //! This causes memory occupied by nodes allocated by the pool to be freed.
+        //! Any nodes or strings allocated from the pool will no longer be valid.
+        void clear()
+        {
+            while (m_begin != m_static_memory)
+            {
+                char *previous_begin = reinterpret_cast<header *>(align(m_begin))->previous_begin;
+                if (m_free_func)
+                    m_free_func(m_begin);
+                else
+                    delete[] m_begin;
+                m_begin = previous_begin;
+            }
+            init();
+        }
+
+        //! Sets or resets the user-defined memory allocation functions for the pool.
+        //! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.
+        //! Allocation function must not return invalid pointer on failure. It should either throw,
+        //! stop the program, or use <code>longjmp()</code> function to pass control to other place of program. 
+        //! If it returns invalid pointer, results are undefined.
+        //! <br><br>
+        //! User defined allocation functions must have the following forms:
+        //! <br><code>
+        //! <br>void *allocate(std::size_t size);
+        //! <br>void free(void *pointer);
+        //! </code><br>
+        //! \param af Allocation function, or 0 to restore default function
+        //! \param ff Free function, or 0 to restore default function
+        void set_allocator(alloc_func *af, free_func *ff)
+        {
+            assert(m_begin == m_static_memory && m_ptr == align(m_begin));    // Verify that no memory is allocated yet
+            m_alloc_func = af;
+            m_free_func = ff;
+        }
+
+    private:
+
+        struct header
+        {
+            char *previous_begin;
+        };
+
+        void init()
+        {
+            m_begin = m_static_memory;
+            m_ptr = align(m_begin);
+            m_end = m_static_memory + sizeof(m_static_memory);
+        }
+        
+        char *align(char *ptr)
+        {
+            std::size_t alignment = ((RAPIDXML_ALIGNMENT - (std::size_t(ptr) & (RAPIDXML_ALIGNMENT - 1))) & (RAPIDXML_ALIGNMENT - 1));
+            return ptr + alignment;
+        }
+        
+        char *allocate_raw(std::size_t size)
+        {
+            // Allocate
+            void *memory;   
+            if (m_alloc_func)   // Allocate memory using either user-specified allocation function or global operator new[]
+            {
+                memory = m_alloc_func(size);
+                assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
+            }
+            else
+            {
+                memory = new char[size];
+#ifdef RAPIDXML_NO_EXCEPTIONS
+                if (!memory)            // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
+                    RAPIDXML_PARSE_ERROR("out of memory", 0);
+#endif
+            }
+            return static_cast<char *>(memory);
+        }
+        
+        void *allocate_aligned(std::size_t size)
+        {
+            // Calculate aligned pointer
+            char *result = align(m_ptr);
+
+            // If not enough memory left in current pool, allocate a new pool
+            if (result + size > m_end)
+            {
+                // Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)
+                std::size_t pool_size = RAPIDXML_DYNAMIC_POOL_SIZE;
+                if (pool_size < size)
+                    pool_size = size;
+                
+                // Allocate
+                std::size_t alloc_size = sizeof(header) + (2 * RAPIDXML_ALIGNMENT - 2) + pool_size;     // 2 alignments required in worst case: one for header, one for actual allocation
+                char *raw_memory = allocate_raw(alloc_size);
+                    
+                // Setup new pool in allocated memory
+                char *pool = align(raw_memory);
+                header *new_header = reinterpret_cast<header *>(pool);
+                new_header->previous_begin = m_begin;
+                m_begin = raw_memory;
+                m_ptr = pool + sizeof(header);
+                m_end = raw_memory + alloc_size;
+
+                // Calculate aligned pointer again using new pool
+                result = align(m_ptr);
+            }
+
+            // Update pool and return aligned pointer
+            m_ptr = result + size;
+            return result;
+        }
+
+        char *m_begin;                                      // Start of raw memory making up current pool
+        char *m_ptr;                                        // First free byte in current pool
+        char *m_end;                                        // One past last available byte in current pool
+        char m_static_memory[RAPIDXML_STATIC_POOL_SIZE];    // Static raw memory
+        alloc_func *m_alloc_func;                           // Allocator function, or 0 if default is to be used
+        free_func *m_free_func;                             // Free function, or 0 if default is to be used
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // XML base
+
+    //! Base class for xml_node and xml_attribute implementing common functions: 
+    //! name(), name_size(), value(), value_size() and parent().
+    //! \param Ch Character type to use
+    template<class Ch = char>
+    class xml_base
+    {
+
+    public:
+        
+        ///////////////////////////////////////////////////////////////////////////
+        // Construction & destruction
+    
+        // Construct a base with empty name, value and parent
+        xml_base()
+            : m_name(0)
+            , m_value(0)
+            , m_parent(0)
+        {
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Node data access
+    
+        //! Gets name of the node. 
+        //! Interpretation of name depends on type of node.
+        //! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
+        //! <br><br>
+        //! Use name_size() function to determine length of the name.
+        //! \return Name of node, or empty string if node has no name.
+        Ch *name() const
+        {
+            return m_name ? m_name : nullstr();
+        }
+
+        //! Gets size of node name, not including terminator character.
+        //! This function works correctly irrespective of whether name is or is not zero terminated.
+        //! \return Size of node name, in characters.
+        std::size_t name_size() const
+        {
+            return m_name ? m_name_size : 0;
+        }
+
+        //! Gets value of node. 
+        //! Interpretation of value depends on type of node.
+        //! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
+        //! <br><br>
+        //! Use value_size() function to determine length of the value.
+        //! \return Value of node, or empty string if node has no value.
+        Ch *value() const
+        {
+            return m_value ? m_value : nullstr();
+        }
+
+        //! Gets size of node value, not including terminator character.
+        //! This function works correctly irrespective of whether value is or is not zero terminated.
+        //! \return Size of node value, in characters.
+        std::size_t value_size() const
+        {
+            return m_value ? m_value_size : 0;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Node modification
+    
+        //! Sets name of node to a non zero-terminated string.
+        //! See \ref ownership_of_strings.
+        //! <br><br>
+        //! Note that node does not own its name or value, it only stores a pointer to it. 
+        //! It will not delete or otherwise free the pointer on destruction.
+        //! It is reponsibility of the user to properly manage lifetime of the string.
+        //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
+        //! on destruction of the document the string will be automatically freed.
+        //! <br><br>
+        //! Size of name must be specified separately, because name does not have to be zero terminated.
+        //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
+        //! \param name Name of node to set. Does not have to be zero terminated.
+        //! \param size Size of name, in characters. This does not include zero terminator, if one is present.
+        void name(const Ch *name, std::size_t size)
+        {
+            m_name = const_cast<Ch *>(name);
+            m_name_size = size;
+        }
+
+        //! Sets name of node to a zero-terminated string.
+        //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).
+        //! \param name Name of node to set. Must be zero terminated.
+        void name(const Ch *name)
+        {
+            this->name(name, internal::measure(name));
+        }
+
+        //! Sets value of node to a non zero-terminated string.
+        //! See \ref ownership_of_strings.
+        //! <br><br>
+        //! Note that node does not own its name or value, it only stores a pointer to it. 
+        //! It will not delete or otherwise free the pointer on destruction.
+        //! It is reponsibility of the user to properly manage lifetime of the string.
+        //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
+        //! on destruction of the document the string will be automatically freed.
+        //! <br><br>
+        //! Size of value must be specified separately, because it does not have to be zero terminated.
+        //! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).
+        //! <br><br>
+        //! If an element has a child node of type node_data, it will take precedence over element value when printing.
+        //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
+        //! \param value value of node to set. Does not have to be zero terminated.
+        //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
+        void value(const Ch *value, std::size_t size)
+        {
+            m_value = const_cast<Ch *>(value);
+            m_value_size = size;
+        }
+
+        //! Sets value of node to a zero-terminated string.
+        //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
+        //! \param value Vame of node to set. Must be zero terminated.
+        void value(const Ch *value)
+        {
+            this->value(value, internal::measure(value));
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Related nodes access
+    
+        //! Gets node parent.
+        //! \return Pointer to parent node, or 0 if there is no parent.
+        xml_node<Ch> *parent() const
+        {
+            return m_parent;
+        }
+
+    protected:
+
+        // Return empty string
+        static Ch *nullstr()
+        {
+            static Ch zero = Ch('\0');
+            return &zero;
+        }
+
+        Ch *m_name;                         // Name of node, or 0 if no name
+        Ch *m_value;                        // Value of node, or 0 if no value
+        std::size_t m_name_size;            // Length of node name, or undefined of no name
+        std::size_t m_value_size;           // Length of node value, or undefined if no value
+        xml_node<Ch> *m_parent;             // Pointer to parent node, or 0 if none
+
+    };
+
+    //! Class representing attribute node of XML document. 
+    //! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
+    //! Note that after parse, both name and value of attribute will point to interior of source text used for parsing. 
+    //! Thus, this text must persist in memory for the lifetime of attribute.
+    //! \param Ch Character type to use.
+    template<class Ch = char>
+    class xml_attribute: public xml_base<Ch>
+    {
+
+        friend class xml_node<Ch>;
+    
+    public:
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Construction & destruction
+    
+        //! Constructs an empty attribute with the specified type. 
+        //! Consider using memory_pool of appropriate xml_document if allocating attributes manually.
+        xml_attribute()
+        {
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Related nodes access
+    
+        //! Gets document of which attribute is a child.
+        //! \return Pointer to document that contains this attribute, or 0 if there is no parent document.
+        xml_document<Ch> *document() const
+        {
+            if (xml_node<Ch> *node = this->parent())
+            {
+                while (node->parent())
+                    node = node->parent();
+                return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
+            }
+            else
+                return 0;
+        }
+
+        //! Gets previous attribute, optionally matching attribute name. 
+        //! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found attribute, or 0 if not found.
+        xml_attribute<Ch> *previous_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_attribute<Ch> *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute)
+                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                        return attribute;
+                return 0;
+            }
+            else
+                return this->m_parent ? m_prev_attribute : 0;
+        }
+
+        //! Gets next attribute, optionally matching attribute name. 
+        //! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found attribute, or 0 if not found.
+        xml_attribute<Ch> *next_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)
+                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                        return attribute;
+                return 0;
+            }
+            else
+                return this->m_parent ? m_next_attribute : 0;
+        }
+
+    private:
+
+        xml_attribute<Ch> *m_prev_attribute;        // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
+        xml_attribute<Ch> *m_next_attribute;        // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero
+    
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // XML node
+
+    //! Class representing a node of XML document. 
+    //! Each node may have associated name and value strings, which are available through name() and value() functions. 
+    //! Interpretation of name and value depends on type of the node.
+    //! Type of node can be determined by using type() function.
+    //! <br><br>
+    //! Note that after parse, both name and value of node, if any, will point interior of source text used for parsing. 
+    //! Thus, this text must persist in the memory for the lifetime of node.
+    //! \param Ch Character type to use.
+    template<class Ch = char>
+    class xml_node: public xml_base<Ch>
+    {
+
+    public:
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Construction & destruction
+    
+        //! Constructs an empty node with the specified type. 
+        //! Consider using memory_pool of appropriate document to allocate nodes manually.
+        //! \param type Type of node to construct.
+        xml_node(node_type type)
+            : m_type(type)
+            , m_first_node(0)
+            , m_first_attribute(0)
+        {
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Node data access
+    
+        //! Gets type of node.
+        //! \return Type of node.
+        node_type type() const
+        {
+            return m_type;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Related nodes access
+    
+        //! Gets document of which node is a child.
+        //! \return Pointer to document that contains this node, or 0 if there is no parent document.
+        xml_document<Ch> *document() const
+        {
+            xml_node<Ch> *node = const_cast<xml_node<Ch> *>(this);
+            while (node->parent())
+                node = node->parent();
+            return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
+        }
+
+        //! Gets first child node, optionally matching node name.
+        //! \param name Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found child, or 0 if not found.
+        xml_node<Ch> *first_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_node<Ch> *child = m_first_node; child; child = child->next_sibling())
+                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
+                        return child;
+                return 0;
+            }
+            else
+                return m_first_node;
+        }
+
+        //! Gets last child node, optionally matching node name. 
+        //! Behaviour is undefined if node has no children.
+        //! Use first_node() to test if node has children.
+        //! \param name Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found child, or 0 if not found.
+        xml_node<Ch> *last_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            assert(m_first_node);  // Cannot query for last child if node has no children
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_node<Ch> *child = m_last_node; child; child = child->previous_sibling())
+                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
+                        return child;
+                return 0;
+            }
+            else
+                return m_last_node;
+        }
+
+        //! Gets previous sibling node, optionally matching node name. 
+        //! Behaviour is undefined if node has no parent.
+        //! Use parent() to test if node has a parent.
+        //! \param name Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found sibling, or 0 if not found.
+        xml_node<Ch> *previous_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            assert(this->m_parent);     // Cannot query for siblings if node has no parent
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
+                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
+                        return sibling;
+                return 0;
+            }
+            else
+                return m_prev_sibling;
+        }
+
+        //! Gets next sibling node, optionally matching node name. 
+        //! Behaviour is undefined if node has no parent.
+        //! Use parent() to test if node has a parent.
+        //! \param name Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found sibling, or 0 if not found.
+        xml_node<Ch> *next_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            assert(this->m_parent);     // Cannot query for siblings if node has no parent
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
+                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
+                        return sibling;
+                return 0;
+            }
+            else
+                return m_next_sibling;
+        }
+
+        //! Gets first attribute of node, optionally matching attribute name.
+        //! \param name Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found attribute, or 0 if not found.
+        xml_attribute<Ch> *first_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
+                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                        return attribute;
+                return 0;
+            }
+            else
+                return m_first_attribute;
+        }
+
+        //! Gets last attribute of node, optionally matching attribute name.
+        //! \param name Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
+        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
+        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
+        //! \return Pointer to found attribute, or 0 if not found.
+        xml_attribute<Ch> *last_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        {
+            if (name)
+            {
+                if (name_size == 0)
+                    name_size = internal::measure(name);
+                for (xml_attribute<Ch> *attribute = m_last_attribute; attribute; attribute = attribute->m_prev_attribute)
+                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                        return attribute;
+                return 0;
+            }
+            else
+                return m_first_attribute ? m_last_attribute : 0;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Node modification
+    
+        //! Sets type of node.
+        //! \param type Type of node to set.
+        void type(node_type type)
+        {
+            m_type = type;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Node manipulation
+
+        //! Prepends a new child node.
+        //! The prepended child becomes the first child, and all existing children are moved one position back.
+        //! \param child Node to prepend.
+        void prepend_node(xml_node<Ch> *child)
+        {
+            assert(child && !child->parent() && child->type() != node_document);
+            if (first_node())
+            {
+                child->m_next_sibling = m_first_node;
+                m_first_node->m_prev_sibling = child;
+            }
+            else
+            {
+                child->m_next_sibling = 0;
+                m_last_node = child;
+            }
+            m_first_node = child;
+            child->m_parent = this;
+            child->m_prev_sibling = 0;
+        }
+
+        //! Appends a new child node. 
+        //! The appended child becomes the last child.
+        //! \param child Node to append.
+        void append_node(xml_node<Ch> *child)
+        {
+            assert(child && !child->parent() && child->type() != node_document);
+            if (first_node())
+            {
+                child->m_prev_sibling = m_last_node;
+                m_last_node->m_next_sibling = child;
+            }
+            else
+            {
+                child->m_prev_sibling = 0;
+                m_first_node = child;
+            }
+            m_last_node = child;
+            child->m_parent = this;
+            child->m_next_sibling = 0;
+        }
+
+        //! Inserts a new child node at specified place inside the node. 
+        //! All children after and including the specified node are moved one position back.
+        //! \param where Place where to insert the child, or 0 to insert at the back.
+        //! \param child Node to insert.
+        void insert_node(xml_node<Ch> *where, xml_node<Ch> *child)
+        {
+            assert(!where || where->parent() == this);
+            assert(child && !child->parent() && child->type() != node_document);
+            if (where == m_first_node)
+                prepend_node(child);
+            else if (where == 0)
+                append_node(child);
+            else
+            {
+                child->m_prev_sibling = where->m_prev_sibling;
+                child->m_next_sibling = where;
+                where->m_prev_sibling->m_next_sibling = child;
+                where->m_prev_sibling = child;
+                child->m_parent = this;
+            }
+        }
+
+        //! Removes first child node. 
+        //! If node has no children, behaviour is undefined.
+        //! Use first_node() to test if node has children.
+        void remove_first_node()
+        {
+            assert(first_node());
+            xml_node<Ch> *child = m_first_node;
+            m_first_node = child->m_next_sibling;
+            if (child->m_next_sibling)
+                child->m_next_sibling->m_prev_sibling = 0;
+            else
+                m_last_node = 0;
+            child->m_parent = 0;
+        }
+
+        //! Removes last child of the node. 
+        //! If node has no children, behaviour is undefined.
+        //! Use first_node() to test if node has children.
+        void remove_last_node()
+        {
+            assert(first_node());
+            xml_node<Ch> *child = m_last_node;
+            if (child->m_prev_sibling)
+            {
+                m_last_node = child->m_prev_sibling;
+                child->m_prev_sibling->m_next_sibling = 0;
+            }
+            else
+                m_first_node = 0;
+            child->m_parent = 0;
+        }
+
+        //! Removes specified child from the node
+        // \param where Pointer to child to be removed.
+        void remove_node(xml_node<Ch> *where)
+        {
+            assert(where && where->parent() == this);
+            assert(first_node());
+            if (where == m_first_node)
+                remove_first_node();
+            else if (where == m_last_node)
+                remove_last_node();
+            else
+            {
+                where->m_prev_sibling->m_next_sibling = where->m_next_sibling;
+                where->m_next_sibling->m_prev_sibling = where->m_prev_sibling;
+                where->m_parent = 0;
+            }
+        }
+
+        //! Removes all child nodes (but not attributes).
+        void remove_all_nodes()
+        {
+            for (xml_node<Ch> *node = first_node(); node; node = node->m_next_sibling)
+                node->m_parent = 0;
+            m_first_node = 0;
+        }
+
+        //! Prepends a new attribute to the node.
+        //! \param attribute Attribute to prepend.
+        void prepend_attribute(xml_attribute<Ch> *attribute)
+        {
+            assert(attribute && !attribute->parent());
+            if (first_attribute())
+            {
+                attribute->m_next_attribute = m_first_attribute;
+                m_first_attribute->m_prev_attribute = attribute;
+            }
+            else
+            {
+                attribute->m_next_attribute = 0;
+                m_last_attribute = attribute;
+            }
+            m_first_attribute = attribute;
+            attribute->m_parent = this;
+            attribute->m_prev_attribute = 0;
+        }
+
+        //! Appends a new attribute to the node.
+        //! \param attribute Attribute to append.
+        void append_attribute(xml_attribute<Ch> *attribute)
+        {
+            assert(attribute && !attribute->parent());
+            if (first_attribute())
+            {
+                attribute->m_prev_attribute = m_last_attribute;
+                m_last_attribute->m_next_attribute = attribute;
+            }
+            else
+            {
+                attribute->m_prev_attribute = 0;
+                m_first_attribute = attribute;
+            }
+            m_last_attribute = attribute;
+            attribute->m_parent = this;
+            attribute->m_next_attribute = 0;
+        }
+
+        //! Inserts a new attribute at specified place inside the node. 
+        //! All attributes after and including the specified attribute are moved one position back.
+        //! \param where Place where to insert the attribute, or 0 to insert at the back.
+        //! \param attribute Attribute to insert.
+        void insert_attribute(xml_attribute<Ch> *where, xml_attribute<Ch> *attribute)
+        {
+            assert(!where || where->parent() == this);
+            assert(attribute && !attribute->parent());
+            if (where == m_first_attribute)
+                prepend_attribute(attribute);
+            else if (where == 0)
+                append_attribute(attribute);
+            else
+            {
+                attribute->m_prev_attribute = where->m_prev_attribute;
+                attribute->m_next_attribute = where;
+                where->m_prev_attribute->m_next_attribute = attribute;
+                where->m_prev_attribute = attribute;
+                attribute->m_parent = this;
+            }
+        }
+
+        //! Removes first attribute of the node. 
+        //! If node has no attributes, behaviour is undefined.
+        //! Use first_attribute() to test if node has attributes.
+        void remove_first_attribute()
+        {
+            assert(first_attribute());
+            xml_attribute<Ch> *attribute = m_first_attribute;
+            if (attribute->m_next_attribute)
+            {
+                attribute->m_next_attribute->m_prev_attribute = 0;
+            }
+            else
+                m_last_attribute = 0;
+            attribute->m_parent = 0;
+            m_first_attribute = attribute->m_next_attribute;
+        }
+
+        //! Removes last attribute of the node. 
+        //! If node has no attributes, behaviour is undefined.
+        //! Use first_attribute() to test if node has attributes.
+        void remove_last_attribute()
+        {
+            assert(first_attribute());
+            xml_attribute<Ch> *attribute = m_last_attribute;
+            if (attribute->m_prev_attribute)
+            {
+                attribute->m_prev_attribute->m_next_attribute = 0;
+                m_last_attribute = attribute->m_prev_attribute;
+            }
+            else
+                m_first_attribute = 0;
+            attribute->m_parent = 0;
+        }
+
+        //! Removes specified attribute from node.
+        //! \param where Pointer to attribute to be removed.
+        void remove_attribute(xml_attribute<Ch> *where)
+        {
+            assert(first_attribute() && where->parent() == this);
+            if (where == m_first_attribute)
+                remove_first_attribute();
+            else if (where == m_last_attribute)
+                remove_last_attribute();
+            else
+            {
+                where->m_prev_attribute->m_next_attribute = where->m_next_attribute;
+                where->m_next_attribute->m_prev_attribute = where->m_prev_attribute;
+                where->m_parent = 0;
+            }
+        }
+
+        //! Removes all attributes of node.
+        void remove_all_attributes()
+        {
+            for (xml_attribute<Ch> *attribute = first_attribute(); attribute; attribute = attribute->m_next_attribute)
+                attribute->m_parent = 0;
+            m_first_attribute = 0;
+        }
+        
+    private:
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Restrictions
+
+        // No copying
+        xml_node(const xml_node &);
+        void operator =(const xml_node &);
+    
+        ///////////////////////////////////////////////////////////////////////////
+        // Data members
+    
+        // Note that some of the pointers below have UNDEFINED values if certain other pointers are 0.
+        // This is required for maximum performance, as it allows the parser to omit initialization of 
+        // unneded/redundant values.
+        //
+        // The rules are as follows:
+        // 1. first_node and first_attribute contain valid pointers, or 0 if node has no children/attributes respectively
+        // 2. last_node and last_attribute are valid only if node has at least one child/attribute respectively, otherwise they contain garbage
+        // 3. prev_sibling and next_sibling are valid only if node has a parent, otherwise they contain garbage
+
+        node_type m_type;                       // Type of node; always valid
+        xml_node<Ch> *m_first_node;             // Pointer to first child node, or 0 if none; always valid
+        xml_node<Ch> *m_last_node;              // Pointer to last child node, or 0 if none; this value is only valid if m_first_node is non-zero
+        xml_attribute<Ch> *m_first_attribute;   // Pointer to first attribute of node, or 0 if none; always valid
+        xml_attribute<Ch> *m_last_attribute;    // Pointer to last attribute of node, or 0 if none; this value is only valid if m_first_attribute is non-zero
+        xml_node<Ch> *m_prev_sibling;           // Pointer to previous sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
+        xml_node<Ch> *m_next_sibling;           // Pointer to next sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
+
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // XML document
+    
+    //! This class represents root of the DOM hierarchy. 
+    //! It is also an xml_node and a memory_pool through public inheritance.
+    //! Use parse() function to build a DOM tree from a zero-terminated XML text string.
+    //! parse() function allocates memory for nodes and attributes by using functions of xml_document, 
+    //! which are inherited from memory_pool.
+    //! To access root node of the document, use the document itself, as if it was an xml_node.
+    //! \param Ch Character type to use.
+    template<class Ch = char>
+    class xml_document: public xml_node<Ch>, public memory_pool<Ch>
+    {
+    
+    public:
+
+        //! Constructs empty XML document
+        xml_document()
+            : xml_node<Ch>(node_document)
+        {
+        }
+
+        //! Parses zero-terminated XML string according to given flags.
+        //! Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used.
+        //! The string must persist for the lifetime of the document.
+        //! In case of error, rapidxml::parse_error exception will be thrown.
+        //! <br><br>
+        //! If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning.
+        //! Make sure that data is zero-terminated.
+        //! <br><br>
+        //! Document can be parsed into multiple times. 
+        //! Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.
+        //! \param text XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.
+        template<int Flags>
+        void parse(Ch *text)
+        {
+            assert(text);
+            
+            // Remove current contents
+            this->remove_all_nodes();
+            this->remove_all_attributes();
+            
+            // Parse BOM, if any
+            parse_bom<Flags>(text);
+            
+            // Parse children
+            while (1)
+            {
+                // Skip whitespace before node
+                skip<whitespace_pred, Flags>(text);
+                if (*text == 0)
+                    break;
+
+                // Parse and append new child
+                if (*text == Ch('<'))
+                {
+                    ++text;     // Skip '<'
+                    if (xml_node<Ch> *node = parse_node<Flags>(text))
+                        this->append_node(node);
+                }
+                else
+                    RAPIDXML_PARSE_ERROR("expected <", text);
+            }
+
+        }
+
+        //! Clears the document by deleting all nodes and clearing the memory pool.
+        //! All nodes owned by document pool are destroyed.
+        void clear()
+        {
+            this->remove_all_nodes();
+            this->remove_all_attributes();
+            memory_pool<Ch>::clear();
+        }
+        
+    private:
+
+        ///////////////////////////////////////////////////////////////////////
+        // Internal character utility functions
+        
+        // Detect whitespace character
+        struct whitespace_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                return internal::lookup_tables<0>::lookup_whitespace[static_cast<unsigned char>(ch)];
+            }
+        };
+
+        // Detect node name character
+        struct node_name_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                return internal::lookup_tables<0>::lookup_node_name[static_cast<unsigned char>(ch)];
+            }
+        };
+
+        // Detect attribute name character
+        struct attribute_name_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                return internal::lookup_tables<0>::lookup_attribute_name[static_cast<unsigned char>(ch)];
+            }
+        };
+
+        // Detect text character (PCDATA)
+        struct text_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                return internal::lookup_tables<0>::lookup_text[static_cast<unsigned char>(ch)];
+            }
+        };
+
+        // Detect text character (PCDATA) that does not require processing
+        struct text_pure_no_ws_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                return internal::lookup_tables<0>::lookup_text_pure_no_ws[static_cast<unsigned char>(ch)];
+            }
+        };
+
+        // Detect text character (PCDATA) that does not require processing
+        struct text_pure_with_ws_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                return internal::lookup_tables<0>::lookup_text_pure_with_ws[static_cast<unsigned char>(ch)];
+            }
+        };
+
+        // Detect attribute value character
+        template<Ch Quote>
+        struct attribute_value_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                if (Quote == Ch('\''))
+                    return internal::lookup_tables<0>::lookup_attribute_data_1[static_cast<unsigned char>(ch)];
+                if (Quote == Ch('\"'))
+                    return internal::lookup_tables<0>::lookup_attribute_data_2[static_cast<unsigned char>(ch)];
+                return 0;       // Should never be executed, to avoid warnings on Comeau
+            }
+        };
+
+        // Detect attribute value character
+        template<Ch Quote>
+        struct attribute_value_pure_pred
+        {
+            static unsigned char test(Ch ch)
+            {
+                if (Quote == Ch('\''))
+                    return internal::lookup_tables<0>::lookup_attribute_data_1_pure[static_cast<unsigned char>(ch)];
+                if (Quote == Ch('\"'))
+                    return internal::lookup_tables<0>::lookup_attribute_data_2_pure[static_cast<unsigned char>(ch)];
+                return 0;       // Should never be executed, to avoid warnings on Comeau
+            }
+        };
+
+        // Insert coded character, using UTF8 or 8-bit ASCII
+        template<int Flags>
+        static void insert_coded_character(Ch *&text, unsigned long code)
+        {
+            if (Flags & parse_no_utf8)
+            {
+                // Insert 8-bit ASCII character
+                // Todo: possibly verify that code is less than 256 and use replacement char otherwise?
+                text[0] = static_cast<unsigned char>(code);
+                text += 1;
+            }
+            else
+            {
+                // Insert UTF8 sequence
+                if (code < 0x80)    // 1 byte sequence
+                {
+	                text[0] = static_cast<unsigned char>(code);
+                    text += 1;
+                }
+                else if (code < 0x800)  // 2 byte sequence
+                {
+	                text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
+	                text[0] = static_cast<unsigned char>(code | 0xC0);
+                    text += 2;
+                }
+	            else if (code < 0x10000)    // 3 byte sequence
+                {
+	                text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
+	                text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
+	                text[0] = static_cast<unsigned char>(code | 0xE0);
+                    text += 3;
+                }
+	            else if (code < 0x110000)   // 4 byte sequence
+                {
+	                text[3] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
+	                text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
+	                text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
+	                text[0] = static_cast<unsigned char>(code | 0xF0);
+                    text += 4;
+                }
+                else    // Invalid, only codes up to 0x10FFFF are allowed in Unicode
+                {
+                    RAPIDXML_PARSE_ERROR("invalid numeric character entity", text);
+                }
+            }
+        }
+
+        // Skip characters until predicate evaluates to true
+        template<class StopPred, int Flags>
+        static void skip(Ch *&text)
+        {
+            Ch *tmp = text;
+            while (StopPred::test(*tmp))
+                ++tmp;
+            text = tmp;
+        }
+
+        // Skip characters until predicate evaluates to true while doing the following:
+        // - replacing XML character entity references with proper characters (&apos; &amp; &quot; &lt; &gt; &#...;)
+        // - condensing whitespace sequences to single space character
+        template<class StopPred, class StopPredPure, int Flags>
+        static Ch *skip_and_expand_character_refs(Ch *&text)
+        {
+            // If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
+            if (Flags & parse_no_entity_translation && 
+                !(Flags & parse_normalize_whitespace) &&
+                !(Flags & parse_trim_whitespace))
+            {
+                skip<StopPred, Flags>(text);
+                return text;
+            }
+            
+            // Use simple skip until first modification is detected
+            skip<StopPredPure, Flags>(text);
+
+            // Use translation skip
+            Ch *src = text;
+            Ch *dest = src;
+            while (StopPred::test(*src))
+            {
+                // If entity translation is enabled    
+                if (!(Flags & parse_no_entity_translation))
+                {
+                    // Test if replacement is needed
+                    if (src[0] == Ch('&'))
+                    {
+                        switch (src[1])
+                        {
+
+                        // &amp; &apos;
+                        case Ch('a'): 
+                            if (src[2] == Ch('m') && src[3] == Ch('p') && src[4] == Ch(';'))
+                            {
+                                *dest = Ch('&');
+                                ++dest;
+                                src += 5;
+                                continue;
+                            }
+                            if (src[2] == Ch('p') && src[3] == Ch('o') && src[4] == Ch('s') && src[5] == Ch(';'))
+                            {
+                                *dest = Ch('\'');
+                                ++dest;
+                                src += 6;
+                                continue;
+                            }
+                            break;
+
+                        // &quot;
+                        case Ch('q'): 
+                            if (src[2] == Ch('u') && src[3] == Ch('o') && src[4] == Ch('t') && src[5] == Ch(';'))
+                            {
+                                *dest = Ch('"');
+                                ++dest;
+                                src += 6;
+                                continue;
+                            }
+                            break;
+
+                        // &gt;
+                        case Ch('g'): 
+                            if (src[2] == Ch('t') && src[3] == Ch(';'))
+                            {
+                                *dest = Ch('>');
+                                ++dest;
+                                src += 4;
+                                continue;
+                            }
+                            break;
+
+                        // &lt;
+                        case Ch('l'): 
+                            if (src[2] == Ch('t') && src[3] == Ch(';'))
+                            {
+                                *dest = Ch('<');
+                                ++dest;
+                                src += 4;
+                                continue;
+                            }
+                            break;
+
+                        // &#...; - assumes ASCII
+                        case Ch('#'): 
+                            if (src[2] == Ch('x'))
+                            {
+                                unsigned long code = 0;
+                                src += 3;   // Skip &#x
+                                while (1)
+                                {
+                                    unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
+                                    if (digit == 0xFF)
+                                        break;
+                                    code = code * 16 + digit;
+                                    ++src;
+                                }
+                                insert_coded_character<Flags>(dest, code);    // Put character in output
+                            }
+                            else
+                            {
+                                unsigned long code = 0;
+                                src += 2;   // Skip &#
+                                while (1)
+                                {
+                                    unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
+                                    if (digit == 0xFF)
+                                        break;
+                                    code = code * 10 + digit;
+                                    ++src;
+                                }
+                                insert_coded_character<Flags>(dest, code);    // Put character in output
+                            }
+                            if (*src == Ch(';'))
+                                ++src;
+                            else
+                                RAPIDXML_PARSE_ERROR("expected ;", src);
+                            continue;
+
+                        // Something else
+                        default:
+                            // Ignore, just copy '&' verbatim
+                            break;
+
+                        }
+                    }
+                }
+                
+                // If whitespace condensing is enabled
+                if (Flags & parse_normalize_whitespace)
+                {
+                    // Test if condensing is needed                 
+                    if (whitespace_pred::test(*src))
+                    {
+                        *dest = Ch(' '); ++dest;    // Put single space in dest
+                        ++src;                      // Skip first whitespace char
+                        // Skip remaining whitespace chars
+                        while (whitespace_pred::test(*src))
+                            ++src;
+                        continue;
+                    }
+                }
+
+                // No replacement, only copy character
+                *dest++ = *src++;
+
+            }
+
+            // Return new end
+            text = src;
+            return dest;
+
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        // Internal parsing functions
+        
+        // Parse BOM, if any
+        template<int Flags>
+        void parse_bom(Ch *&text)
+        {
+            // UTF-8?
+            if (static_cast<unsigned char>(text[0]) == 0xEF && 
+                static_cast<unsigned char>(text[1]) == 0xBB && 
+                static_cast<unsigned char>(text[2]) == 0xBF)
+            {
+                text += 3;      // Skup utf-8 bom
+            }
+        }
+
+        // Parse XML declaration (<?xml...)
+        template<int Flags>
+        xml_node<Ch> *parse_xml_declaration(Ch *&text)
+        {
+            // If parsing of declaration is disabled
+            if (!(Flags & parse_declaration_node))
+            {
+                // Skip until end of declaration
+                while (text[0] != Ch('?') || text[1] != Ch('>'))
+                {
+                    if (!text[0])
+                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                    ++text;
+                }
+                text += 2;    // Skip '?>'
+                return 0;
+            }
+
+            // Create declaration
+            xml_node<Ch> *declaration = this->allocate_node(node_declaration);
+
+            // Skip whitespace before attributes or ?>
+            skip<whitespace_pred, Flags>(text);
+
+            // Parse declaration attributes
+            parse_node_attributes<Flags>(text, declaration);
+            
+            // Skip ?>
+            if (text[0] != Ch('?') || text[1] != Ch('>'))
+                RAPIDXML_PARSE_ERROR("expected ?>", text);
+            text += 2;
+            
+            return declaration;
+        }
+
+        // Parse XML comment (<!--...)
+        template<int Flags>
+        xml_node<Ch> *parse_comment(Ch *&text)
+        {
+            // If parsing of comments is disabled
+            if (!(Flags & parse_comment_nodes))
+            {
+                // Skip until end of comment
+                while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
+                {
+                    if (!text[0])
+                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                    ++text;
+                }
+                text += 3;     // Skip '-->'
+                return 0;      // Do not produce comment node
+            }
+
+            // Remember value start
+            Ch *value = text;
+
+            // Skip until end of comment
+            while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
+            {
+                if (!text[0])
+                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                ++text;
+            }
+
+            // Create comment node
+            xml_node<Ch> *comment = this->allocate_node(node_comment);
+            comment->value(value, text - value);
+            
+            // Place zero terminator after comment value
+            if (!(Flags & parse_no_string_terminators))
+                *text = Ch('\0');
+            
+            text += 3;     // Skip '-->'
+            return comment;
+        }
+
+        // Parse DOCTYPE
+        template<int Flags>
+        xml_node<Ch> *parse_doctype(Ch *&text)
+        {
+            // Remember value start
+            Ch *value = text;
+
+            // Skip to >
+            while (*text != Ch('>'))
+            {
+                // Determine character type
+                switch (*text)
+                {
+                
+                // If '[' encountered, scan for matching ending ']' using naive algorithm with depth
+                // This works for all W3C test files except for 2 most wicked
+                case Ch('['):
+                {
+                    ++text;     // Skip '['
+                    int depth = 1;
+                    while (depth > 0)
+                    {
+                        switch (*text)
+                        {
+                            case Ch('['): ++depth; break;
+                            case Ch(']'): --depth; break;
+                            case 0: RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                        }
+                        ++text;
+                    }
+                    break;
+                }
+                
+                // Error on end of text
+                case Ch('\0'):
+                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                
+                // Other character, skip it
+                default:
+                    ++text;
+
+                }
+            }
+            
+            // If DOCTYPE nodes enabled
+            if (Flags & parse_doctype_node)
+            {
+                // Create a new doctype node
+                xml_node<Ch> *doctype = this->allocate_node(node_doctype);
+                doctype->value(value, text - value);
+                
+                // Place zero terminator after value
+                if (!(Flags & parse_no_string_terminators))
+                    *text = Ch('\0');
+
+                text += 1;      // skip '>'
+                return doctype;
+            }
+            else
+            {
+                text += 1;      // skip '>'
+                return 0;
+            }
+
+        }
+
+        // Parse PI
+        template<int Flags>
+        xml_node<Ch> *parse_pi(Ch *&text)
+        {
+            // If creation of PI nodes is enabled
+            if (Flags & parse_pi_nodes)
+            {
+                // Create pi node
+                xml_node<Ch> *pi = this->allocate_node(node_pi);
+
+                // Extract PI target name
+                Ch *name = text;
+                skip<node_name_pred, Flags>(text);
+                if (text == name)
+                    RAPIDXML_PARSE_ERROR("expected PI target", text);
+                pi->name(name, text - name);
+                
+                // Skip whitespace between pi target and pi
+                skip<whitespace_pred, Flags>(text);
+
+                // Remember start of pi
+                Ch *value = text;
+                
+                // Skip to '?>'
+                while (text[0] != Ch('?') || text[1] != Ch('>'))
+                {
+                    if (*text == Ch('\0'))
+                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                    ++text;
+                }
+
+                // Set pi value (verbatim, no entity expansion or whitespace normalization)
+                pi->value(value, text - value);     
+                
+                // Place zero terminator after name and value
+                if (!(Flags & parse_no_string_terminators))
+                {
+                    pi->name()[pi->name_size()] = Ch('\0');
+                    pi->value()[pi->value_size()] = Ch('\0');
+                }
+                
+                text += 2;                          // Skip '?>'
+                return pi;
+            }
+            else
+            {
+                // Skip to '?>'
+                while (text[0] != Ch('?') || text[1] != Ch('>'))
+                {
+                    if (*text == Ch('\0'))
+                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                    ++text;
+                }
+                text += 2;    // Skip '?>'
+                return 0;
+            }
+        }
+
+        // Parse and append data
+        // Return character that ends data.
+        // This is necessary because this character might have been overwritten by a terminating 0
+        template<int Flags>
+        Ch parse_and_append_data(xml_node<Ch> *node, Ch *&text, Ch *contents_start)
+        {
+            // Backup to contents start if whitespace trimming is disabled
+            if (!(Flags & parse_trim_whitespace))
+                text = contents_start;     
+            
+            // Skip until end of data
+            Ch *value = text, *end;
+            if (Flags & parse_normalize_whitespace)
+                end = skip_and_expand_character_refs<text_pred, text_pure_with_ws_pred, Flags>(text);   
+            else
+                end = skip_and_expand_character_refs<text_pred, text_pure_no_ws_pred, Flags>(text);
+
+            // Trim trailing whitespace if flag is set; leading was already trimmed by whitespace skip after >
+            if (Flags & parse_trim_whitespace)
+            {
+                if (Flags & parse_normalize_whitespace)
+                {
+                    // Whitespace is already condensed to single space characters by skipping function, so just trim 1 char off the end
+                    if (*(end - 1) == Ch(' '))
+                        --end;
+                }
+                else
+                {
+                    // Backup until non-whitespace character is found
+                    while (whitespace_pred::test(*(end - 1)))
+                        --end;
+                }
+            }
+            
+            // If characters are still left between end and value (this test is only necessary if normalization is enabled)
+            // Create new data node
+            if (!(Flags & parse_no_data_nodes))
+            {
+                xml_node<Ch> *data = this->allocate_node(node_data);
+                data->value(value, end - value);
+                node->append_node(data);
+            }
+
+            // Add data to parent node if no data exists yet
+            if (!(Flags & parse_no_element_values)) 
+                if (*node->value() == Ch('\0'))
+                    node->value(value, end - value);
+
+            // Place zero terminator after value
+            if (!(Flags & parse_no_string_terminators))
+            {
+                Ch ch = *text;
+                *end = Ch('\0');
+                return ch;      // Return character that ends data; this is required because zero terminator overwritten it
+            }
+
+            // Return character that ends data
+            return *text;
+        }
+
+        // Parse CDATA
+        template<int Flags>
+        xml_node<Ch> *parse_cdata(Ch *&text)
+        {
+            // If CDATA is disabled
+            if (Flags & parse_no_data_nodes)
+            {
+                // Skip until end of cdata
+                while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
+                {
+                    if (!text[0])
+                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                    ++text;
+                }
+                text += 3;      // Skip ]]>
+                return 0;       // Do not produce CDATA node
+            }
+
+            // Skip until end of cdata
+            Ch *value = text;
+            while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
+            {
+                if (!text[0])
+                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                ++text;
+            }
+
+            // Create new cdata node
+            xml_node<Ch> *cdata = this->allocate_node(node_cdata);
+            cdata->value(value, text - value);
+
+            // Place zero terminator after value
+            if (!(Flags & parse_no_string_terminators))
+                *text = Ch('\0');
+
+            text += 3;      // Skip ]]>
+            return cdata;
+        }
+        
+        // Parse element node
+        template<int Flags>
+        xml_node<Ch> *parse_element(Ch *&text)
+        {
+            // Create element node
+            xml_node<Ch> *element = this->allocate_node(node_element);
+
+            // Extract element name
+            Ch *name = text;
+            skip<node_name_pred, Flags>(text);
+            if (text == name)
+                RAPIDXML_PARSE_ERROR("expected element name", text);
+            element->name(name, text - name);
+            
+            // Skip whitespace between element name and attributes or >
+            skip<whitespace_pred, Flags>(text);
+
+            // Parse attributes, if any
+            parse_node_attributes<Flags>(text, element);
+
+            // Determine ending type
+            if (*text == Ch('>'))
+            {
+                ++text;
+                parse_node_contents<Flags>(text, element);
+            }
+            else if (*text == Ch('/'))
+            {
+                ++text;
+                if (*text != Ch('>'))
+                    RAPIDXML_PARSE_ERROR("expected >", text);
+                ++text;
+            }
+            else
+                RAPIDXML_PARSE_ERROR("expected >", text);
+
+            // Place zero terminator after name
+            if (!(Flags & parse_no_string_terminators))
+                element->name()[element->name_size()] = Ch('\0');
+
+            // Return parsed element
+            return element;
+        }
+
+        // Determine node type, and parse it
+        template<int Flags>
+        xml_node<Ch> *parse_node(Ch *&text)
+        {
+            // Parse proper node type
+            switch (text[0])
+            {
+
+            // <...
+            default: 
+                // Parse and append element node
+                return parse_element<Flags>(text);
+
+            // <?...
+            case Ch('?'): 
+                ++text;     // Skip ?
+                if ((text[0] == Ch('x') || text[0] == Ch('X')) &&
+                    (text[1] == Ch('m') || text[1] == Ch('M')) && 
+                    (text[2] == Ch('l') || text[2] == Ch('L')) &&
+                    whitespace_pred::test(text[3]))
+                {
+                    // '<?xml ' - xml declaration
+                    text += 4;      // Skip 'xml '
+                    return parse_xml_declaration<Flags>(text);
+                }
+                else
+                {
+                    // Parse PI
+                    return parse_pi<Flags>(text);
+                }
+            
+            // <!...
+            case Ch('!'): 
+
+                // Parse proper subset of <! node
+                switch (text[1])    
+                {
+                
+                // <!-
+                case Ch('-'):
+                    if (text[2] == Ch('-'))
+                    {
+                        // '<!--' - xml comment
+                        text += 3;     // Skip '!--'
+                        return parse_comment<Flags>(text);
+                    }
+                    break;
+
+                // <![
+                case Ch('['):
+                    if (text[2] == Ch('C') && text[3] == Ch('D') && text[4] == Ch('A') && 
+                        text[5] == Ch('T') && text[6] == Ch('A') && text[7] == Ch('['))
+                    {
+                        // '<![CDATA[' - cdata
+                        text += 8;     // Skip '![CDATA['
+                        return parse_cdata<Flags>(text);
+                    }
+                    break;
+
+                // <!D
+                case Ch('D'):
+                    if (text[2] == Ch('O') && text[3] == Ch('C') && text[4] == Ch('T') && 
+                        text[5] == Ch('Y') && text[6] == Ch('P') && text[7] == Ch('E') && 
+                        whitespace_pred::test(text[8]))
+                    {
+                        // '<!DOCTYPE ' - doctype
+                        text += 9;      // skip '!DOCTYPE '
+                        return parse_doctype<Flags>(text);
+                    }
+
+                }   // switch
+
+                // Attempt to skip other, unrecognized node types starting with <!
+                ++text;     // Skip !
+                while (*text != Ch('>'))
+                {
+                    if (*text == 0)
+                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                    ++text;
+                }
+                ++text;     // Skip '>'
+                return 0;   // No node recognized
+
+            }
+        }
+
+        // Parse contents of the node - children, data etc.
+        template<int Flags>
+        void parse_node_contents(Ch *&text, xml_node<Ch> *node)
+        {
+            // For all children and text
+            while (1)
+            {
+                // Skip whitespace between > and node contents
+                Ch *contents_start = text;      // Store start of node contents before whitespace is skipped
+                skip<whitespace_pred, Flags>(text);
+                Ch next_char = *text;
+
+            // After data nodes, instead of continuing the loop, control jumps here.
+            // This is because zero termination inside parse_and_append_data() function
+            // would wreak havoc with the above code.
+            // Also, skipping whitespace after data nodes is unnecessary.
+            after_data_node:    
+                
+                // Determine what comes next: node closing, child node, data node, or 0?
+                switch (next_char)
+                {
+                
+                // Node closing or child node
+                case Ch('<'):
+                    if (text[1] == Ch('/'))
+                    {
+                        // Node closing
+                        text += 2;      // Skip '</'
+                        if (Flags & parse_validate_closing_tags)
+                        {
+                            // Skip and validate closing tag name
+                            Ch *closing_name = text;
+                            skip<node_name_pred, Flags>(text);
+                            if (!internal::compare(node->name(), node->name_size(), closing_name, text - closing_name, true))
+                                RAPIDXML_PARSE_ERROR("invalid closing tag name", text);
+                        }
+                        else
+                        {
+                            // No validation, just skip name
+                            skip<node_name_pred, Flags>(text);
+                        }
+                        // Skip remaining whitespace after node name
+                        skip<whitespace_pred, Flags>(text);
+                        if (*text != Ch('>'))
+                            RAPIDXML_PARSE_ERROR("expected >", text);
+                        ++text;     // Skip '>'
+                        return;     // Node closed, finished parsing contents
+                    }
+                    else
+                    {
+                        // Child node
+                        ++text;     // Skip '<'
+                        if (xml_node<Ch> *child = parse_node<Flags>(text))
+                            node->append_node(child);
+                    }
+                    break;
+
+                // End of data - error
+                case Ch('\0'):
+                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+
+                // Data node
+                default:
+                    next_char = parse_and_append_data<Flags>(node, text, contents_start);
+                    goto after_data_node;   // Bypass regular processing after data nodes
+
+                }
+            }
+        }
+        
+        // Parse XML attributes of the node
+        template<int Flags>
+        void parse_node_attributes(Ch *&text, xml_node<Ch> *node)
+        {
+            // For all attributes 
+            while (attribute_name_pred::test(*text))
+            {
+                // Extract attribute name
+                Ch *name = text;
+                ++text;     // Skip first character of attribute name
+                skip<attribute_name_pred, Flags>(text);
+                if (text == name)
+                    RAPIDXML_PARSE_ERROR("expected attribute name", name);
+
+                // Create new attribute
+                xml_attribute<Ch> *attribute = this->allocate_attribute();
+                attribute->name(name, text - name);
+                node->append_attribute(attribute);
+
+                // Skip whitespace after attribute name
+                skip<whitespace_pred, Flags>(text);
+
+                // Skip =
+                if (*text != Ch('='))
+                    RAPIDXML_PARSE_ERROR("expected =", text);
+                ++text;
+
+                // Add terminating zero after name
+                if (!(Flags & parse_no_string_terminators))
+                    attribute->name()[attribute->name_size()] = 0;
+
+                // Skip whitespace after =
+                skip<whitespace_pred, Flags>(text);
+
+                // Skip quote and remember if it was ' or "
+                Ch quote = *text;
+                if (quote != Ch('\'') && quote != Ch('"'))
+                    RAPIDXML_PARSE_ERROR("expected ' or \"", text);
+                ++text;
+
+                // Extract attribute value and expand char refs in it
+                Ch *value = text, *end;
+                const int AttFlags = Flags & ~parse_normalize_whitespace;   // No whitespace normalization in attributes
+                if (quote == Ch('\''))
+                    end = skip_and_expand_character_refs<attribute_value_pred<Ch('\'')>, attribute_value_pure_pred<Ch('\'')>, AttFlags>(text);
+                else
+                    end = skip_and_expand_character_refs<attribute_value_pred<Ch('"')>, attribute_value_pure_pred<Ch('"')>, AttFlags>(text);
+                
+                // Set attribute value
+                attribute->value(value, end - value);
+                
+                // Make sure that end quote is present
+                if (*text != quote)
+                    RAPIDXML_PARSE_ERROR("expected ' or \"", text);
+                ++text;     // Skip quote
+
+                // Add terminating zero after value
+                if (!(Flags & parse_no_string_terminators))
+                    attribute->value()[attribute->value_size()] = 0;
+
+                // Skip whitespace after attribute value
+                skip<whitespace_pred, Flags>(text);
+            }
+        }
+
+    };
+
+    //! \cond internal
+    namespace internal
+    {
+
+        // Whitespace (space \n \r \t)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_whitespace[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,  0,  // 0
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 1
+             1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 2
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 3
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 4
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 5
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 6
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 7
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 8
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 9
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // A
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // B
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // C
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // D
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // E
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   // F
+        };
+
+        // Node name (anything but space \n \r \t / > ? \0)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_node_name[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Text (i.e. PCDATA) (anything but < \0)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_text[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Text (i.e. PCDATA) that does not require processing when ws normalization is disabled 
+        // (anything but < \0 &)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_text_pure_no_ws[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
+        // (anything but < \0 & space \n \r \t)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_text_pure_with_ws[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             0,  1,  1,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Attribute name (anything but space \n \r \t / < > = ? ! \0)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_attribute_name[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Attribute data with single quote (anything but ' \0)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_1[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Attribute data with single quote that does not require processing (anything but ' \0 &)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_1_pure[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Attribute data with double quote (anything but " \0)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_2[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Attribute data with double quote that does not require processing (anything but " \0 &)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_2_pure[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
+             1,  1,  0,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
+             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
+        };
+
+        // Digits (dec and hex, 255 denotes end of numeric character reference)
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_digits[256] = 
+        {
+          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 0
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 1
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 2
+             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,255,255,255,255,255,255,  // 3
+           255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255,  // 4
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 5
+           255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255,  // 6
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 7
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 8
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 9
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // A
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // B
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // C
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // D
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // E
+           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255   // F
+        };
+    
+        // Upper case conversion
+        template<int Dummy>
+        const unsigned char lookup_tables<Dummy>::lookup_upcase[256] = 
+        {
+          // 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  A   B   C   D   E   F
+           0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,   // 0
+           16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,   // 1
+           32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,   // 2
+           48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,   // 3
+           64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,   // 4
+           80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,   // 5
+           96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,   // 6
+           80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123,124,125,126,127,  // 7
+           128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,  // 8
+           144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,  // 9
+           160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,  // A
+           176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,  // B
+           192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,  // C
+           208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,  // D
+           224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,  // E
+           240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255   // F
+        };
+    }
+    //! \endcond
+
+}
+
+// Undefine internal macros
+#undef RAPIDXML_PARSE_ERROR
+
+// On MSVC, restore warnings state
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif
+
+#endif

=== added file 'CTLParser/rapidxml-1.13/rapidxml_iterators.hpp'
--- CTLParser/rapidxml-1.13/rapidxml_iterators.hpp	1970-01-01 00:00:00 +0000
+++ CTLParser/rapidxml-1.13/rapidxml_iterators.hpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,174 @@
+#ifndef RAPIDXML_ITERATORS_HPP_INCLUDED
+#define RAPIDXML_ITERATORS_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! \file rapidxml_iterators.hpp This file contains rapidxml iterators
+
+#include "rapidxml.hpp"
+
+namespace rapidxml
+{
+
+    //! Iterator of child nodes of xml_node
+    template<class Ch>
+    class node_iterator
+    {
+    
+    public:
+
+        typedef typename xml_node<Ch> value_type;
+        typedef typename xml_node<Ch> &reference;
+        typedef typename xml_node<Ch> *pointer;
+        typedef std::ptrdiff_t difference_type;
+        typedef std::bidirectional_iterator_tag iterator_category;
+        
+        node_iterator()
+            : m_node(0)
+        {
+        }
+
+        node_iterator(xml_node<Ch> *node)
+            : m_node(node->first_node())
+        {
+        }
+        
+        reference operator *() const
+        {
+            assert(m_node);
+            return *m_node;
+        }
+
+        pointer operator->() const
+        {
+            assert(m_node);
+            return m_node;
+        }
+
+        node_iterator& operator++()
+        {
+            assert(m_node);
+            m_node = m_node->next_sibling();
+            return *this;
+        }
+
+        node_iterator operator++(int)
+        {
+            node_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        node_iterator& operator--()
+        {
+            assert(m_node && m_node->previous_sibling());
+            m_node = m_node->previous_sibling();
+            return *this;
+        }
+
+        node_iterator operator--(int)
+        {
+            node_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        bool operator ==(const node_iterator<Ch> &rhs)
+        {
+            return m_node == rhs.m_node;
+        }
+
+        bool operator !=(const node_iterator<Ch> &rhs)
+        {
+            return m_node != rhs.m_node;
+        }
+
+    private:
+
+        xml_node<Ch> *m_node;
+
+    };
+
+    //! Iterator of child attributes of xml_node
+    template<class Ch>
+    class attribute_iterator
+    {
+    
+    public:
+
+        typedef typename xml_attribute<Ch> value_type;
+        typedef typename xml_attribute<Ch> &reference;
+        typedef typename xml_attribute<Ch> *pointer;
+        typedef std::ptrdiff_t difference_type;
+        typedef std::bidirectional_iterator_tag iterator_category;
+        
+        attribute_iterator()
+            : m_attribute(0)
+        {
+        }
+
+        attribute_iterator(xml_node<Ch> *node)
+            : m_attribute(node->first_attribute())
+        {
+        }
+        
+        reference operator *() const
+        {
+            assert(m_attribute);
+            return *m_attribute;
+        }
+
+        pointer operator->() const
+        {
+            assert(m_attribute);
+            return m_attribute;
+        }
+
+        attribute_iterator& operator++()
+        {
+            assert(m_attribute);
+            m_attribute = m_attribute->next_attribute();
+            return *this;
+        }
+
+        attribute_iterator operator++(int)
+        {
+            attribute_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        attribute_iterator& operator--()
+        {
+            assert(m_attribute && m_attribute->previous_attribute());
+            m_attribute = m_attribute->previous_attribute();
+            return *this;
+        }
+
+        attribute_iterator operator--(int)
+        {
+            attribute_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        bool operator ==(const attribute_iterator<Ch> &rhs)
+        {
+            return m_attribute == rhs.m_attribute;
+        }
+
+        bool operator !=(const attribute_iterator<Ch> &rhs)
+        {
+            return m_attribute != rhs.m_attribute;
+        }
+
+    private:
+
+        xml_attribute<Ch> *m_attribute;
+
+    };
+
+}
+
+#endif

=== added file 'CTLParser/rapidxml-1.13/rapidxml_print.hpp'
--- CTLParser/rapidxml-1.13/rapidxml_print.hpp	1970-01-01 00:00:00 +0000
+++ CTLParser/rapidxml-1.13/rapidxml_print.hpp	2016-03-31 07:42:46 +0000
@@ -0,0 +1,421 @@
+#ifndef RAPIDXML_PRINT_HPP_INCLUDED
+#define RAPIDXML_PRINT_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! \file rapidxml_print.hpp This file contains rapidxml printer implementation
+
+#include "rapidxml.hpp"
+
+// Only include streams if not disabled
+#ifndef RAPIDXML_NO_STREAMS
+    #include <ostream>
+    #include <iterator>
+#endif
+
+namespace rapidxml
+{
+
+    ///////////////////////////////////////////////////////////////////////
+    // Printing flags
+
+    const int print_no_indenting = 0x1;   //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.
+
+    ///////////////////////////////////////////////////////////////////////
+    // Internal
+
+    //! \cond internal
+    namespace internal
+    {
+        
+        ///////////////////////////////////////////////////////////////////////////
+        // Internal character operations
+    
+        // Copy characters from given range to given output iterator
+        template<class OutIt, class Ch>
+        inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)
+        {
+            while (begin != end)
+                *out++ = *begin++;
+            return out;
+        }
+        
+        // Copy characters from given range to given output iterator and expand
+        // characters into references (&lt; &gt; &apos; &quot; &amp;)
+        template<class OutIt, class Ch>
+        inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out)
+        {
+            while (begin != end)
+            {
+                if (*begin == noexpand)
+                {
+                    *out++ = *begin;    // No expansion, copy character
+                }
+                else
+                {
+                    switch (*begin)
+                    {
+                    case Ch('<'):
+                        *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');
+                        break;
+                    case Ch('>'): 
+                        *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');
+                        break;
+                    case Ch('\''): 
+                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');
+                        break;
+                    case Ch('"'):