--- /dev/null
+
+Build
+*~
-
+#
+# Antcc main entry
+#
ADD_EXECUTABLE(antcc main.cpp)
TARGET_LINK_LIBRARIES(antcc libantcc_parser libantcc_os libantcc propertylib ${EXPAT_LIBRARY} ltdl)
+#
+# ReqIf main entry
+#
+ADD_EXECUTABLE(reqif reqif.cpp)
+
+TARGET_LINK_LIBRARIES(reqif reqif_parser libantcc_os libantcc propertylib ${EXPAT_LIBRARY} ltdl)
+#
+#
+#
OPTION(ANTCC_WITH_BOOST "Build antcc with boost dependency" OFF)
OPTION(ANTCC_WITH_AEB "Build antcc with aeb shared pointer" ON)
--- /dev/null
+#include <iostream>
+#include <fstream>
+
+#include <antcc/config.h>
+#include <os/path.h>
+#include <os/file.h>
+#include <utils/aeb/optionparser.h>
+
+#include <expat.h>
+#include <location.h>
+
+#include "xml/reqif/parser_base.h"
+#include "xml/reqif/reqif_elements_parser.h"
+#include "xml/reqif/document.h"
+
+#include <logger.h>
+#include "xml/reqif/reqif_element.h"
+#include "xml/element_factory.h"
+//#include <projectComponent.h>
+//#include <tasks/ITaskContainer.h>
+//#include <target.h>
+//#include <project.h>
+
+#include <properties/property_file.h>
+
+//#include <antcc/antcc.h>
+
+void parse(const std::string &file)
+{
+ std::cout<<"Build Parser"<<std::endl;
+ //xml::reqif::ReqifParser project_parser(&m_Project,&m_Project);
+ xml::reqif::ReqifParser project_parser(nullptr,nullptr);
+ xml::reqif::Document doc(project_parser,"project");
+
+ std::ifstream bf(file);
+ if (bf.is_open())
+ {
+ std::cout<<"Main Got build rules:"<<file<<std::endl;
+ doc.parse(bf);
+ }
+}
+
+
+int main(int argc,char **argv)
+{
+ std::cout<<"Hello world ReqIf Parsing"<<std::endl;
+}
#include <iostream>
#include <antcc/config.h>
#include <logger.h>
-#include <reqif/element_factory.h>
-#include <reqif/elements.h>
+#include "xml/element_factory.h"
+#include "xml/reqif/reqif_element.h"
namespace reqif {
INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR})
ADD_LIBRARY(reqif_parser STATIC
- #document.cpp
+ document.cpp
+ ../element_factory.cpp
# ant_elements_parser.cpp
# ant_elements_parser_root.cpp
reqif_elements_parser.cpp
--- /dev/null
+#include <cstring>
+#include <iostream>
+#include <expat.h>
+
+#include "antcc/config.h"
+#include "logger.h"
+#include "location.h"
+#include "xml/reqif/reqif_element.h"
+#include "xml/reqif/parser_base.h"
+#include "xml/reqif/document.h"
+
+namespace xml
+{
+ namespace reqif
+ {
+
+
+ /**
+ * Funny fact to parse a xml entity....
+ */
+ bool Document::parse(std::istream &is)
+ {
+ char buf[16384];
+ parser_auto_ptr parser = XML_ParserCreateNS(0,XML_Char(' '));
+ m_parser = parser;
+ parser_init();
+ do
+ {
+ is.read(buf,sizeof(buf));
+ if (is.bad() || (is.fail() && !is.eof()))
+ {
+ break; /* End of parsing */
+ }
+ if (XML_Parse ( m_parser,buf,is.gcount(),is.eof()) == XML_STATUS_ERROR)
+ {
+ break;
+ }
+ } while (! is.eof());
+ parser_clear();
+ return true;
+ }
+
+ void Document::parser_init()
+ {
+ XML_SetUserData(m_parser,this);
+ XML_SetStartElementHandler(m_parser,startElement_glb);
+ XML_SetEndElementHandler(m_parser,endElement_glb);
+ XML_SetCharacterDataHandler(m_parser,characters_glb);
+ /**
+ * XML_SetNamespaveDecHandler(m_parser,start,end);
+ */
+ XML_SetNamespaceDeclHandler(m_parser,startNamespace_glb,endNamespace_glb);
+ }
+
+ void Document::parser_clear()
+ {
+ XML_SetUserData(m_parser,0);
+ XML_SetStartElementHandler(m_parser,0);
+ XML_SetEndElementHandler(m_parser,0);
+ XML_SetNamespaceDeclHandler(m_parser,0,0);
+ }
+
+ void Document::startElement_glb(void *d,const XML_Char *ns, const XML_Char **attr)
+ {
+ Document &doc = (*reinterpret_cast<Document*>(d));
+ doc.startElement(ns,attr);
+ }
+
+ void Document::endElement_glb(void *d,const XML_Char *ns)
+ {
+ Document &doc = (*reinterpret_cast<Document*>(d));
+ doc.endElement(ns);
+ }
+
+ void Document::characters_glb(void *d,const XML_Char *ns,int ds)
+ {
+ Document &doc = (*reinterpret_cast<Document*>(d));
+ doc.Characters(ns,ds);
+ }
+
+ void Document::split_name(const XML_Char *s,const char *&ns,size_t &ns_s,
+ const char *&name,size_t &name_s)
+ {
+ const char *p = std::strchr(s,' ');
+ ns=s;
+ if (p)
+ {
+ ns_s=p-s;
+ name=p+1;
+ } else
+ {
+ ns_s =0;
+ name=s;
+ }
+ name_s = strlen(name);
+
+ }
+ /**
+ * Well first see how it works. Right now, I do not really now
+ * But it's important for soap.
+ *
+ */
+ void Document::startNamespace_glb(void *d,const XML_Char *prefix, const XML_Char *uri)
+ {
+ Document &doc = (*reinterpret_cast<Document*>(d));
+ }
+ void Document::endNamespace_glb(void *d,const XML_Char *prefix)
+ {
+ Document &doc = (*reinterpret_cast<Document*>(d));
+ }
+
+ /* Ok, call the parser objects with the given events ... */
+ void Document::startElement(const XML_Char *name,const XML_Char **attr)
+ {
+ const char *ns;
+ const char *nm;
+ size_t ns_s,nm_s;
+
+ split_name(name,ns,ns_s,nm,nm_s);
+ updateLocation();
+ if (m_depth++ > 0 )
+ {
+ /* under root */
+ m_root_parser._startElement(std::string(ns,ns_s),std::string(nm,nm_s),std::string(""));
+ ANTCC_PARSER_DEBUG("**** Document after having called _startElement %s *****",name);
+ m_root_parser.updateLocation(m_location);
+ } else
+ {
+ ANTCC_PARSER_DEBUG("**** Document root start %s*****",name);
+ /* root element */
+ std::string n(nm,nm_s);
+ if (n == m_name)
+ {
+ /* Yes we are right */
+ //std::cout<<" Yes, start root "<<m_name<<std::endl;
+ m_root_parser.preImpl();
+ m_root_parser.updateLocation(m_location);
+ } else
+ {
+ ANTCC_LOG_CRITICAL("**** Document wrong root start %s-%s*****",m_name,n);
+ }
+ /* I think I shoud proceed with the attributes now */
+ }
+ const XML_Char **p = attr;
+ for (p ; *p != 0 ; p+=2)
+ {
+ split_name(*p,ns,ns_s,nm,nm_s);
+ Attribute(std::string(ns,ns_s),std::string(nm,nm_s),std::string(*(p+1)));
+ }
+ }
+ void Document::endElement(const XML_Char *name)
+ {
+ const char *ns;
+ const char *nm;
+ size_t ns_s,nm_s;
+ split_name(name,ns,ns_s,nm,nm_s);
+ if (--m_depth > 0)
+ {
+ m_root_parser._endElement(std::string(ns,ns_s),std::string(nm,nm_s));
+ } else
+ {
+ /* end root element */
+ m_root_parser.postImpl();
+ }
+ }
+ void Document::Characters(const XML_Char *name,size_t sz)
+ {
+ m_root_parser._Characters(std::string(name,sz));
+ }
+ void Document::Attribute(const std::string &ns,const std::string &n,const std::string &val)
+ {
+ m_root_parser._Attribute(ns,n,val);
+ }
+ void Document::updateLocation()
+ {
+ m_location.m_Column = XML_GetCurrentColumnNumber(m_parser);
+ m_location.m_Line = XML_GetCurrentLineNumber(m_parser);
+ }
+ } /* end ns parser */
+}
--- /dev/null
+#ifndef REQIF_PARSER_DOC_H
+#define REQIF_PARSER_DOC_H
+#include <iostream>
+
+namespace xml
+{
+
+ namespace reqif
+ {
+
+ /**
+ *
+ */
+ class DocumentBase
+ {
+ public:
+ DocumentBase(xml::reqif::ParserBase &p,const char *root) : m_root_parser(p) ,m_depth(0) ,m_name(root) {};
+ virtual ~DocumentBase() {};
+
+ virtual void startElement(std::string &ns,std::string &name,std::string tp){};
+ protected:
+ ParserBase &m_root_parser;
+ std::size_t m_depth;
+ std::string m_name; /* Root name of the document */
+ };
+
+
+ struct parser_auto_ptr
+ {
+ ~parser_auto_ptr()
+ {
+ if (m_parser!= 0)
+ {
+ XML_ParserFree(m_parser);
+ }
+ };
+ parser_auto_ptr(XML_Parser p = 0) :m_parser(p) {};
+
+ parser_auto_ptr& operator =(XML_Parser p)
+ {
+ if(m_parser != 0) XML_ParserFree(m_parser);
+ m_parser = p;
+ return *this;
+ }
+ public:
+ operator XML_Parser()
+ {
+ return m_parser;
+ };
+ private:
+ XML_Parser m_parser;
+ };
+
+
+ /**
+ * \brief First try to parse an xml document
+ * I do not yet have all the information.
+ *
+ * \author EBERSOLD Andre
+ * \date 11/09/09
+ */
+ class Document : public DocumentBase {
+ public:
+ /**
+ * \brief default constructor, see ParseBase
+ * \param root, is the root element we want to parse
+ * \param root_element_name is the name of the root element
+ */
+ Document( ParserBase &root,const char *root_element_name)
+ : xml::reqif::DocumentBase(root,root_element_name),m_location(NULL,0,0) {};
+ /* What do I realy need */
+ ~Document() { };
+ bool parse(std::string filename);
+ /**
+ *
+ */
+ bool parse(std::istream &is);
+ private:
+ void split_name(const XML_Char *s,const char *&ns,size_t &ns_s, const char *&name,size_t &name_s);
+ /* For expact we need static functions .... */
+
+ static void XMLCALL startElement_glb(void *, const XML_Char *,const XML_Char **attr);
+ static void XMLCALL endElement_glb(void *,const XML_Char *name);
+ static void XMLCALL characters_glb(void *d,const XML_Char *ns,int dt);
+
+ static void XMLCALL startNamespace_glb(void *, const XML_Char *prefix,const XML_Char *uri);
+ static void XMLCALL endNamespace_glb(void *, const XML_Char *prefix);
+ /*
+ *
+ */
+ void parser_init();
+ /**
+ *
+ *
+ */
+ void parser_clear();
+
+ void startElement(const XML_Char *name,const XML_Char **attr);
+ void endElement(const XML_Char *name);
+ void Characters(const XML_Char *name,size_t sz);
+ void Attribute(const std::string &ns,const std::string &name,const std::string &val);
+ void updateLocation();
+ protected:
+ XML_Parser m_parser;
+ antcc::Location m_location;
+ };
+
+
+ } // End ns
+}
+#endif
-#ifndef ANTCC_PARSER_ELEMENTS_H
-#define ANTCC_PARSER_ELEMENTS_H
+#ifndef XML_REQIF_PARSER_ELEMENTS_H
+#define XML_REQIF_PARSER_ELEMENTS_H
#include <iostream>
+
namespace reqif
{
struct Element;
- namespace parser {
+}
+namespace xml {
+namespace reqif
+{
+
+
class Document;
class ComplexElement;
class SimpleElement;
ParserBase() {};
virtual void pre() {};
- virtual Element *post() { return NULL; };
+ virtual ::reqif::Element *post() { return NULL; };
virtual void preInternal() {};
virtual void postInternal() {};
virtual const std::string &dynamicType() {static std::string s="base";return s;};
virtual void updateLocation(const antcc::Location &l) {};
- friend class reqif::parser::Document;
- friend class reqif::parser::ComplexElement;
- friend class reqif::parser::RootElement;
- friend class reqif::parser::SimpleElement;
+ friend class xml::reqif::Document;
+ friend class xml::reqif::ComplexElement;
+ friend class xml::reqif::RootElement;
+ friend class xml::reqif::SimpleElement;
};
- }
-}
-
+} // end ns reqid
+} // end ns xml
#endif
//SIMPLE_PARSER(SOURCE-TOOL-ID,DescriptionParser)
//SIMPLE_PARSER(TITLE,DescriptionParser)
-
COMPLEX_PARSER(CORE-CONTENT,CoreContentParser)
COMPLEX_PARSER(REQ-IF-CONTENT,ReqifContentParser)
COMPLEX_PARSER(DATATYPES,DatatypesParser)
//SIMPLE_PARSER(SPEC-OBJECT-REF,DatatypeRefParser)
-
//COMPLEX_PARSER(TOOL-EXTENSIONS,ChildrenParser)
inline const char *getName() const { return m_Name.c_str(); };
// what are the public methods available on all elements ?
- virtual void addChild(const char *_name,reqif::Element *_task) {} ;
+ virtual void addChild(const char *_name,::reqif::Element *_task) {} ;
///
- virtual void setProject(::antcc::project *_p) {};
+ //virtual void setProject(::antcc::project *_p) {};
virtual void setLocation(const ::antcc::Location &_loc) {} ;
/**
#include <os/path.h>
#include <os/file.h>
#include <location.h>
-#include <parser_base.h>
+#include "xml/reqif/parser_base.h"
#include <logger.h>
//#include <xml/element.h>
//#define PARSER_DEBUG 1
-namespace reqif {
- namespace parser {
+namespace xml {
+ namespace reqif {
-EmptyElement::EmptyElement(reqif::Element *_elt )
+EmptyElement::EmptyElement(::reqif::Element *_elt )
: m_str(""), m_CurrentElement(_elt)
{
ANTCC_PARSER_DEBUG("%s(%0x) ctor m_CurrentElement=%0x"
* Implement ComplexElement parsing function
*/
-ComplexElement::ComplexElement(reqif::Element *_elt )
+ComplexElement::ComplexElement(::reqif::Element *_elt )
: EmptyElement(_elt)
{
ANTCC_PARSER_DEBUG("Cplx(%0x)::Cplx ctor m_CurElt=%0x"
}
ComplexElement::ComplexElement(const ComplexElement &c)
- : reqif::parser::EmptyElement(c.m_CurrentElement)
+ : xml::reqif::EmptyElement(c.m_CurrentElement)
{
ANTCC_PARSER_DEBUG("Cplx(%0x)::Cplx copy c.m_CurElt=%0x"
,this
}
}
}
-}
-
+#if 1
+} // end ns bas
+#endif
void ComplexElement::_endElement(const std::string &ns,const std::string &name)
{
,_c.m_CurrentElement \
); \
} \
-cls::cls(antcc::project *_project,reqif::Element *_elt) \
+cls::cls(antcc::project *_project,::reqif::Element *_elt) \
: RootElement(_elt) , m_Project(_project) \
{ \
ANTCC_PARSER_DEBUG("%s(%0x)::%s elt=%0x" \
); \
} else \
{ \
- _elt->setProject(_project);\
+ /*_elt->setProject(_project);*/\
} \
} \
cls::~cls() \
,_c.m_CurrentElement \
); \
} \
-cls::cls(antcc::project *_project,reqif::Element *_elt) \
+cls::cls(antcc::project *_project,::reqif::Element *_elt) \
: ComplexElement(_elt) ,m_Project(_project) \
{ \
ANTCC_PARSER_DEBUG("%s(%0x)::%s elt=%0x" \
); \
} else \
{ \
- _elt->setProject(_project);\
+ /*_elt->setProject(_project); */ \
} \
} \
cls::~cls() \
} \
#define SIMPLE_PARSER(cls,attr) \
-cls :: cls(const cls &_c) : SimpleElement() \
+cls :: cls(const cls &_c) : xml::reqif::SimpleElement() \
{ \
ANTCC_PARSER_DEBUG("%s::%s cp elt=%0x" \
,#cls \
,_c.m_CurrentElement \
); \
} \
-cls::cls(antcc::project *_project,reqif::Element *_elt) \
+cls::cls(antcc::project *_project,::reqif::Element *_elt) \
: SimpleElement(_elt), m_Project(_project) \
{ \
ANTCC_PARSER_DEBUG("%s(%0x)::%s elt=%0x" \
); \
} else \
{ \
- _elt->setProject(_project);\
+ /* _elt->setProject(_project);*/ \
} \
} \
cls::~cls() \
if (name == "THE-HEADER" && ns.empty())
{
s.m_parser = SHARED_PTR<TargetParser>(new TargetParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
} else if (name == "TOOL-EXTENSION" && ns.empty())
{
} else if (name == "CORE-CONTENT" && ns.empty())
{
s.m_parser = SHARED_PTR<CoreContentParser>(new CoreContentParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
)
);
} else
if (name == "REQ-IF-HEADER" && ns.empty())
{
s.m_parser = SHARED_PTR<DescriptionParser>(new DescriptionParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
} else if (name == "exec" && ns.empty())
{
s.m_parser = SHARED_PTR<DescriptionParser>(new DescriptionParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
}
else
{
s.m_parser = SHARED_PTR<DescriptionParser>(new DescriptionParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
}
return true;
,name.c_str()
,m_context.size());
s.m_parser = SHARED_PTR<DatatypesParser>(new DatatypesParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
}
else if (name == "SPEC-TYPES" && ns.empty())
} else
{
s.m_parser = SHARED_PTR<TypeParser>(new TypeParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
}
return true;
COMPLEX_PARSER(DatatypesParser,
{
s.m_parser = SHARED_PTR<DatatypeParser>(new DatatypeParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
return true;
if (name == "include" && ns.empty())
{
s.m_parser = SHARED_PTR<TypeParser>(new TypeParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
return true;
}
COMPLEX_PARSER(SpecObjectTypeParser,
{
s.m_parser = SHARED_PTR<SpecAttributesParser>(new SpecAttributesParser(m_Project
- , reqif::ElementFactory::get().orderElement(name.c_str())
+ , ::reqif::ElementFactory::get().orderElement(name.c_str())
));
return true;
,name.c_str()
,m_context.size());
s.m_parser = SHARED_PTR<TypeParser>(new TypeParser(m_Project
- , reqif::ElementFactory::get().orderElement("TYPE")
+ , ::reqif::ElementFactory::get().orderElement("TYPE")
));
return true;
}
#include <stdlib.h>
-namespace reqif
+namespace xml
{
class project;
- namespace parser
+ namespace reqif
{
template <typename T>
struct _parser_data
{ };
- class EmptyElement : public reqif::parser::ParserBase
+ class EmptyElement : public xml::reqif::ParserBase
{
protected:
public:
- EmptyElement(reqif::Element *_elt ) ;
+ EmptyElement(::reqif::Element *_elt ) ;
EmptyElement(const EmptyElement &_e)
: m_str(""), m_CurrentElement(_e.m_CurrentElement) {}
virtual ~EmptyElement() {};
std::cerr<<"post(bool) with bad value:"<<m_str<<std::endl;
}
};
- virtual reqif::Element *post() { return m_CurrentElement; };
+ virtual ::reqif::Element *post() { return m_CurrentElement; };
//virtual void post(xsd::decimal &v) {v = atoi(m_str.c_str());};
//
protected:
/** Characters in element */
std::string m_str;
- reqif::Element *m_CurrentElement;
+ ::reqif::Element *m_CurrentElement;
};
/**
class SimpleElement : public EmptyElement
{
public:
- SimpleElement(reqif::Element *_elt=NULL)
+ SimpleElement(::reqif::Element *_elt=NULL)
: EmptyElement(_elt) {};
virtual ~SimpleElement() { };
private:
* \param
*
*/
- class ComplexElement : public ::reqif::parser::EmptyElement
+ class ComplexElement : public xml::reqif::EmptyElement
{
protected:
ComplexElement(const ComplexElement &c);
*/
virtual void postImpl();
public:
- ComplexElement(reqif::Element *_elt ) ;
+ ComplexElement(::reqif::Element *_elt ) ;
virtual ~ComplexElement() {};
virtual ~State();
bool m_any;
int m_depth; /* I need to find another name for this*/
- SHARED_PTR<reqif::parser::ParserBase> m_parser;
- reqif::Element *m_data; /* To solve recurse issue ....*/
+ SHARED_PTR<xml::reqif::ParserBase> m_parser;
+ ::reqif::Element *m_data; /* To solve recurse issue ....*/
};
std::vector<State> m_context;
};
* \param
*
*/
- class RootElement : public ::reqif::parser::EmptyElement
+ class RootElement : public xml::reqif::EmptyElement
{
private:
RootElement(const RootElement &c);
*/
virtual void postImpl();
public:
- RootElement(reqif::Element *_elt ) ;
+ RootElement(::reqif::Element *_elt ) ;
virtual ~RootElement() {};
virtual ~State();
bool m_any;
int m_depth; /* I need to find another name for this*/
- SHARED_PTR<reqif::parser::ParserBase> m_parser;
- reqif::Element *m_data; /* To solve recurse issue ....*/
+ SHARED_PTR<xml::reqif::ParserBase> m_parser;
+ ::reqif::Element *m_data; /* To solve recurse issue ....*/
};
std::vector<State> m_context;
};
#define ROOT_PARSER(nm,cls) class cls;
#define SIMPLE_PARSER(nm,cls) class cls;
-#include <xml/parser/parsers.h.inc>
+#include <xml/reqif/parsers.h.inc>
#undef SIMPLE_PARSER
#undef COMPLEX_PARSER
#undef ROOT_PARSER
protected: \
cls(const cls &_c) ; \
public: \
- cls(antcc::project *_project,reqif::Element *_elt = NULL ) ; \
+ cls(antcc::project *_project,::reqif::Element *_elt = NULL ) ; \
virtual ~cls() ; \
\
virtual bool startElementImpl(const std::string &ns,const std::string &name,const std::string &type) ; \
protected: \
cls(const cls &_c) ; \
public: \
- cls(antcc::project *_project,reqif::Element *_elt = NULL ) ; \
+ cls(antcc::project *_project,::reqif::Element *_elt = NULL ) ; \
virtual ~cls() ; \
\
virtual bool startElementImpl(const std::string &ns,const std::string &name,const std::string &type) ; \
protected: \
cls(const cls &_c) ; \
public: \
- cls(antcc::project *_project,reqif::Element *_elt = NULL ) ; \
+ cls(antcc::project *_project,::reqif::Element *_elt = NULL ) ; \
virtual ~cls() ; \
\
virtual bool AttributeImpl(const std::string &ns,const std::string &name,const std::string &val); \
// Parser DataType Specialization before usage
#define COMPLEX_DATA_PARSER(eltname,parse,data) \
template <> \
-struct _parser_data< ::reqif::parser:: parse> \
+struct _parser_data< ::xml::reqif:: parse> \
data ; \
+#if 0
COMPLEX_DATA_PARSER(target,TargetParser,{
TaskParser *m_TaskParser;
CopyParser *m_CopyParser;
COMPLEX_DATA_PARSER(fileset,TypeParser,{})
COMPLEX_DATA_PARSER(redirector,RedirectorParser,{})
COMPLEX_DATA_PARSER(macrodef,MacrodefParser,{})
-
+#endif
#include <xml/reqif/parsers.h.inc>
#undef COMPLEX_PARSER
#include <os/path.h>
#include <os/file.h>
#include <location.h>
-#include <parser_base.h>
+#include <xml/reqif/parser_base.h>
#include <logger.h>
#include "reqif/reqif_element.h"
#include "reqif/reqif_elements_parser.h"
//#include <project.h>
//#include <projectComponent.h>
-namespace reqif {
- namespace parser {
+namespace xml {
+ namespace reqif {
* Implement RootElement parsing function
*/
-RootElement::RootElement(reqif::Element *_elt )
+RootElement::RootElement(::reqif::Element *_elt )
: EmptyElement(_elt)
{
ANTCC_PARSER_DEBUG("Cplx(%0x)::Cplx ctor m_CurElt=%0x"
}
RootElement::RootElement(const RootElement &c)
- : reqif::parser::EmptyElement(c.m_CurrentElement)
+ : xml::reqif::EmptyElement(c.m_CurrentElement)
{
ANTCC_PARSER_DEBUG("Cplx(%0x)::Cplx copy c.m_CurElt=%0x"
,this
projects / antcc.git / commitdiff