GLIMSView Source Code Documentation

odlparser.cpp

Go to the documentation of this file.

#include "odlparser.h"
#include <algorithm>

ODLParser::ODLParser( const std::string &odldata ) :
mODLData( odldata ) {
  ipos = jpos = 0;
  if ( odldata != "" )
    parse( mTop );
}

bool ODLParser::parse( ODLTree &tree ) {
  std::string::size_type   tpos1;
  std::string              line;
  int                      objcnt = 0;
  int                      grpcnt = 0;


  const unsigned int  DATALEN = mODLData.length();
  bool                retval;

  jpos        = ipos;
  retval      = true;

  while ( ipos < DATALEN-1 ) {
    // GET NEXT LINE
    // ODL STANDARD FORM EFFECTOR CONSTANTS ARE
    // CARRAIGE RETURN, NEW LINE, FORM FEED,
    // VERTICAL TAB
    tpos1 = mODLData.find( "\r", ipos );

    tpos1 = _uint_min( tpos1, mODLData.find( "\n", ipos ) );
    tpos1 = _uint_min( tpos1, mODLData.find( "\f", ipos ) );
    tpos1 = _uint_min( tpos1, mODLData.find( "\v", ipos ) );
    jpos  = _uint_min( tpos1, (DATALEN-1) );
    line  = trim( mODLData.substr( ipos, jpos-ipos ) );
    ipos  = jpos+1;

    tpos1 = line.find( '=' );
    if ( (int)tpos1 == -1 ) {
      std::string ustr = ucase( line );
      if ( ustr == "END" ||
           ustr == "END_GROUP" ||
           ustr == "END_OBJECT" )
        return true;
      retval = false;
    } else {
      std::string part1, part2;
      part1 = trim( line.substr( 0, tpos1 ) );
      part2 = trim( line.substr( tpos1 + 1 ) );

      // ODL IS CASE INSENSITIVE SO WE'LL CONVERT ALL NON-LITERALS
      // TO UPPER CASE
      part1 = ucase( part1 );

      if ( part2.find( '\"' ) == 0 ) {
        while ( (int)part2.find( '\"', 1 ) == -1 ) {
          // MULTI LINE STRING -- GET THE REST
          tpos1 = mODLData.find( "\r", ipos );
          tpos1 = _uint_min( tpos1, mODLData.find( "\n", ipos ) );
          tpos1 = _uint_min( tpos1, mODLData.find( "\f", ipos ) );
          tpos1 = _uint_min( tpos1, mODLData.find( "\v", ipos ) );
          jpos  = _uint_min( tpos1, (DATALEN-1) );
          part2 += std::string(" ") + trim( mODLData.substr( ipos, jpos-ipos ) );
          ipos  = jpos+1;
        }
      }

      if ( part1 == "GROUP" ||
           part1 == "BEGIN_GROUP" ) { // PDS
        ODLTree child( part2, ODLGROUP );
        tree.addChild( child );
        grpcnt++;
        parse( *tree.getLastChild() );
      } else if ( part1 == "OBJECT" ||
                  part1 == "BEGIN_OBJECT" ) { // PDS
        ODLTree child( part2, ODLOBJECT );
        tree.addChild( child );
        objcnt++;
        parse( *tree.getLastChild() );
      } else if ( part1 == "END" ||
                  part1 == "END_OBJECT" ||
                  part1 == "END_GROUP" ) {
        return true;
      } else {
        ODLElement elem( part1, part2 );
        tree.addElem( elem );
      }
    }
  }
  return true;
}

std::string ODLParser::trim( const std::string &str ) {
  std::string             tstr;
  char                    *cstr;
  std::string::size_type  ipos;
  std::string::size_type  jpos;

  cstr = (char*)str.c_str();
  ipos = 0;
  while ( ipos < str.length()-1 &&
          ( cstr[ipos] == '\r' ||
            cstr[ipos] == '\n' ||
            cstr[ipos] == '\f' ||
            cstr[ipos] == '\v' ||
            cstr[ipos] == ' '  ||
            cstr[ipos] == '\t' ) ) {
    ipos++;
  }

  jpos = str.length()-1;

  while ( jpos > ipos &&
          ( cstr[jpos] == '\r' ||
            cstr[jpos] == '\n' ||
            cstr[jpos] == '\f' ||
            cstr[jpos] == '\v' ||
            cstr[jpos] == ' '  ||
            cstr[jpos] == '\t' ) ) {
    jpos--;
  }

  return str.substr( ipos, jpos-ipos+1 );
}

std::string ODLParser::ucase( const std::string &str ) {
  std::string     retstr = str;
  char            *cstr = (char*)retstr.c_str();

  for ( int i=0; i < (int)str.length(); i++ )
    cstr[i] = toupper( cstr[i] );

  return retstr;
}

const ODLTree* ODLParser::getObject( const ODLTree& tree,
                                     const std::string &objname ) const {
  if ( tree.getName() == objname )
    return(const ODLTree*)&tree;

  for ( int iChld=0; iChld < tree.getNumChild(); iChld++ ) {
    const ODLTree *test = getObject( *tree.getChild( iChld ), objname );
    if ( test )
      return test;
  }

  return NULL;
}

const ODLTree* ODLParser::getGroup( const ODLTree&,
                                    const std::string & ) const {
  return NULL;
}

---

Home | Search | Disclaimers & Privacy | Contact Us GLIMSView Maintainer: dsoltesz@usgs.gov