replace opengexparser by using openddl-parser.

Signed-off-by: Kim Kulling <kim.kulling@googlemail.com>

contrib/openddlparser/code/OpenDDLParser.cpp

@@ -104,22 +104,18 @@ static void logMessage( LogSeverity severity, const std::string &msg ) {
 
 OpenDDLParser::OpenDDLParser()
 : m_logCallback( logMessage )
-, m_ownsBuffer( false )
-, m_buffer( ddl_nullptr )
-, m_len( 0 )
+, m_buffer()
 , m_stack()
 , m_context( ddl_nullptr ) {
     // empty
 }
 
-OpenDDLParser::OpenDDLParser( char *buffer, size_t len, bool ownsIt )
+OpenDDLParser::OpenDDLParser( char *buffer, size_t len )
 : m_logCallback( &logMessage )
-, m_ownsBuffer( false )
-, m_buffer( ddl_nullptr )
-, m_len( 0 ) 
+, m_buffer()
 , m_context( ddl_nullptr ) {
-    if( 0 != m_len ) {
-        setBuffer( buffer, len, ownsIt );
+    if( 0 != len ) {
+        setBuffer( buffer, len );
     }
 }
 
@@ -141,41 +137,36 @@ OpenDDLParser::logCallback OpenDDLParser::getLogCallback() const {
     return m_logCallback;
 }
 
-void OpenDDLParser::setBuffer( char *buffer, size_t len, bool ownsIt ) {
-    if( m_buffer && m_ownsBuffer ) {
-        delete[] m_buffer;
-        m_buffer = ddl_nullptr;
-        m_len = 0;
+void OpenDDLParser::setBuffer( char *buffer, size_t len ) {
+    clear();
+    if( 0 == len ) {
+        return;
     }
 
-    m_ownsBuffer = ownsIt;
-    if( m_ownsBuffer ) {
-        // when we are owning the buffer we will do a deep copy
-        m_buffer = new char[ len ];
-        m_len = len;
-        ::memcpy( m_buffer, buffer, len );
-    } else {
-        // when we are not owning the buffer, we just do a shallow copy
-        m_buffer = buffer;
-        m_len = len;
-    }
+    m_buffer.resize( len );
+    ::memcpy(&m_buffer[ 0 ], buffer, len );
 }
 
-char *OpenDDLParser::getBuffer() const {
-    return m_buffer;
+void OpenDDLParser::setBuffer( const std::vector<char> &buffer ) {
+    clear();
+    m_buffer.resize( buffer.size() );
+    std::copy( buffer.begin(), buffer.end(), m_buffer.begin() );
+}
+
+const char *OpenDDLParser::getBuffer() const {
+    if( m_buffer.empty() ) {
+        return ddl_nullptr;
+    }
+
+    return &m_buffer[ 0 ];
 }
 
 size_t OpenDDLParser::getBufferSize() const {
-    return m_len;
+    return m_buffer.size();
 }
 
 void OpenDDLParser::clear() {
-    if( m_ownsBuffer ) {
-        delete [] m_buffer;
-    }
-    m_buffer = ddl_nullptr;
-    m_len = 0;
-
+    m_buffer.resize( 0 );
     if( m_context ) {
         m_context->m_root = ddl_nullptr;
     }
@@ -184,11 +175,11 @@ void OpenDDLParser::clear() {
 }
 
 bool OpenDDLParser::parse() {
-    if( 0 == m_len ) {
+    if( m_buffer.empty() ) {
         return false;
     }
     
-    normalizeBuffer( m_buffer, m_len );
+    normalizeBuffer( m_buffer );
 
     m_context = new Context;
     m_context->m_root = DDLNode::create( "root", "", ddl_nullptr );
@@ -196,9 +187,11 @@ bool OpenDDLParser::parse() {
 
     // do the main parsing
     char *current( &m_buffer[ 0 ] );
-    char *end( &m_buffer[ m_len - 1 ] + 1 );
-    while( current != end ) {
+    char *end( &m_buffer[ m_buffer.size() - 1 ] + 1 );
+    size_t pos( current - &m_buffer[ 0 ] );
+    while( pos < m_buffer.size() ) {
         current = parseNextNode( current, end );
+        pos = current - &m_buffer[ 0 ];
     }
     return true;
 }
@@ -219,7 +212,7 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
     in = OpenDDLParser::parseIdentifier( in, end, &id );
 
 #ifdef DEBUG_HEADER_NAME    
-    if( id ) {
+    if( ddl_nullptr != id ) {
         std::cout << id->m_buffer << std::endl;
     }
 #endif // DEBUG_HEADER_NAME
@@ -253,7 +246,11 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
 
         // set the properties
         if( ddl_nullptr != first ) {
-            m_context->setProperties( first );
+            std::cout << id->m_buffer << std::endl;
+            DDLNode *current( top() );
+            if( current ) {
+                current->setProperties( first );
+            }
         }
 
         // store the node
@@ -317,6 +314,9 @@ char *OpenDDLParser::parseStructure( char *in, char *end ) {
             if( *in != '}' ) {
                 logInvalidTokenError( in, "}", m_logCallback );
             }
+            else {
+                in++;
+            }
         } else {
             in = parseHeader( in, end );
             in = parseStructure( in, end );
@@ -327,6 +327,7 @@ char *OpenDDLParser::parseStructure( char *in, char *end ) {
         return in;
 
     }
+    in = getNextToken( in, end );
 
     in++;
 
@@ -373,33 +374,29 @@ Context *OpenDDLParser::getContext() const {
     return m_context;
 }
 
-void OpenDDLParser::normalizeBuffer( char *buffer, size_t len ) {
-    if( nullptr == buffer || 0 == len ) {
+void OpenDDLParser::normalizeBuffer( std::vector<char> &buffer) {
+    if( buffer.empty() ) {
         return;
     }
 
-    size_t writeIdx( 0 );
-    char *end( &buffer[ len ] + 1 );
+    std::vector<char> newBuffer;
+    const size_t len( buffer.size() );
+    char *end( &buffer[ len-1 ] + 1 );
     for( size_t readIdx = 0; readIdx<len; ++readIdx ) {
         char *c( &buffer[readIdx] );
         // check for a comment
         if( !isComment<char>( c, end ) ) {
-            buffer[ writeIdx ] = buffer[ readIdx ];
-            writeIdx++;
+            newBuffer.push_back( buffer[ readIdx ] );
         } else {
             readIdx++;
             // skip the comment and the rest of the line
             while( !isEndofLine( buffer[ readIdx ] ) ) {
                 readIdx++;
             }
-            buffer[writeIdx] = '\n';
-            writeIdx++;
+            newBuffer.push_back( '\n' );
         }
     }
-
-    if( writeIdx < len ) {
-        buffer[ writeIdx ] = '\0';
-    }
+    buffer = newBuffer;
 }
 
 char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {