---

CTBxmlLexer.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*----------------------------------------------------------------------------*/

#include <ctype.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"
#include "CTBosFill.hxx"
#include "CTBexceptionBugcheck.hxx"

#include "CTBxmlLexer.hxx"

//------------------------------------------+-----------------------------------

CTBxmlLexer::CTBxmlLexer()
  : mi_mode(0),
    mi_nline_t(1),
    mi_ncolumn_t(1),
    mi_nline_s(1),
    mi_ncolumn_s(1)
{
  CTB_Trace("CTBxmlLexer()");
}

//------------------------------------------+-----------------------------------

void CTBxmlLexer::Get(istream& is, CTBxmlLexerToken& lt)
{
  CTB_Trace("CTBxmlLexer::Get(istream&, CTBxmlLexerToken&)");
  int i_c1;
  int i_quote;
  
  mi_nline_t   = mi_nline_s;
  mi_ncolumn_t = mi_ncolumn_s;

  lt.Clear();                               // set type to invalid ...
 
  i_c1 = GetChar(is);                       // get leading character

  if (i_c1 == EOF) {                        // this signals some error
    if (is.eof()) {                         // if at end-of-file
      lt.Type(CTBxmlLexerToken::eof);
    } else {                                // otherwise
      lt.Type(CTBxmlLexerToken::fail);
    }
    return;
  }

  lt += (char) i_c1;
  
  switch (mi_mode) {                        // handle different lexer modes

  case tagordata:
    if (i_c1 == '<') {                      // "<" -- any tag start ...
      int i_cp = is.peek();

      if (i_cp == '/') {                    // "</" -- empty tag open
        lt += (char) GetChar(is);
        lt.Type(CTBxmlLexerToken::etagopen);
        return;
      }

      if (i_cp == '?') {                    // "<?" -- pi open
        lt += (char) GetChar(is);
        lt.Type(CTBxmlLexerToken::piopen);
        return;
      }
    
      if (i_cp == '!') {                    // "<!" -- definition or comment
        lt += (char) GetChar(is);
        
        if (is.peek() == '-') {             // "<!-" -- begin of comment 
          lt += (char) GetChar(is);
          if (is.peek() == '-') {           // "<!--" -- comment start
            int i_cstate = 0;
            
            lt += (char) GetChar(is);
            
            for (;;) {                      // gobble up rest of comment
              int i_c2 = GetChar(is);
              
              if (i_c2 == EOF) {            // early end of comment
                lt.Type(CTBxmlLexerToken::fail);
                return;
              }
              
              lt += (char) i_c2;
              switch (i_cstate) {           // --> state machine
              case 0:                       // "^-->" state
                if (i_c2 == '-') i_cstate = 1;
                break;
              case 1:                       // "-^->" state
                i_cstate = (i_c2 == '-') ? 2 : 0;
                break;
              case 2:                       // "--^>" state
                if (i_c2 == '>') {
                  lt.Type(CTBxmlLexerToken::comment);
                  return;
                }
                if (i_c2 != '-') i_cstate = 0; // this rule allows for ---> ....
                break;
              }
            }
            return;
            
          } else {                          // "<!-x" -- bad comment start
            lt.Type(CTBxmlLexerToken::fail);
            return;
          }
        }

        lt.Type(CTBxmlLexerToken::defopen); // "<!" -- definition start
        return;
      }

      lt.Type(CTBxmlLexerToken::tagopen);   // "<" -- simple tag open
      return;  
    }

    if (i_c1 == '&') {                      // "&" -- entity
      GetEntity(is,lt);
      return;
    }    

    if (isspace(i_c1)) {                    // white space found
      GetWhite(is,lt);
      return;
    }
    
    lt.Type(CTBxmlLexerToken::data);        // must be PCDATA here
    for (;;) {                              // gobble up rest of data
      int i_c2 = is.peek();
      
      if (i_c2 == EOF) break;               // eof end data ...
      if (isspace(i_c2)) break;             // a white space interrupts data
      if (i_c2 == '<' || i_c2 == '&') break; // a < or & ends data
      
      lt += (char) GetChar(is);             // accumulate data 
    }
    return;

  case tagattr:
    if (i_c1 == '/') {                      // / found
      if (is.peek() == '>') {
        lt += (char) GetChar(is);
        lt.Type(CTBxmlLexerToken::etagclose); // "/>" -- end tag close
        return;
      }
      return; 
    }

    if (i_c1 == '?') {                      // ? found
      if (is.peek() == '>') {
        lt += (char) GetChar(is);
        lt.Type(CTBxmlLexerToken::piclose); // "?>" -- pi tag close
        return;
      }
      return; 
    }
  
    if (i_c1 == '>') {                      // simple > here, no / or ? before
      lt.Type(CTBxmlLexerToken::tagclose);    // ">" -- tag close
      return; 
    }

    if (i_c1 == '=') {
      lt.Type(CTBxmlLexerToken::equal);     // "=" -- equal char
      return; 
    }
  
    if (isspace(i_c1)) {                    // white space found
      GetWhite(is,lt);
      return;
    }
    
    if (isalpha(i_c1) || i_c1 == '_' || i_c1 == ':') { // name begin found ...
      GetName(is,lt);
      return;
    }
    return;

  case attrval:
    if (i_c1 == '\'') {
      lt.Type(CTBxmlLexerToken::squote);    // "'" -- single quote
      return; 
    }
  
    if (i_c1 == '"') {
      lt.Type(CTBxmlLexerToken::dquote);    // '"'-- double quote
      return; 
    }
  
    if (isspace(i_c1)) {                    // white space found
      GetWhite(is,lt);
      return;
    }
    
    if (isalpha(i_c1) || i_c1 == '_' || i_c1 == ':') { // name begin found ...
      GetName(is,lt);
      return;
    }
    return;

  case valsquote:
  case valdquote:
    i_quote = (mi_mode == valsquote) ? '\'' : '"';
    
    if (mi_mode == valsquote && i_c1 == '\'') {
      lt.Type(CTBxmlLexerToken::squote);    // "'" -- single quote
      return; 
    }

    if (mi_mode == valdquote && i_c1 == '"') {
      lt.Type(CTBxmlLexerToken::dquote);    // '"'-- double quote
      return; 
    }
    
    if (i_c1 == '&') {                      // "&" -- entity
      GetEntity(is,lt);
      return;
    }    

    if (isspace(i_c1)) {                    // white space found
      GetWhite(is,lt);
      return;
    }
    
    lt.Type(CTBxmlLexerToken::data);        // must be value data here
    for (;;) {                              // gobble up rest of data
      int i_c2 = is.peek();
      
      if (i_c2 == EOF) break;               // eof end data ...
      if (isspace(i_c2)) break;     // a white space interrupts data
      if (i_c2 == '<' || i_c2 == '&') break; // a < or & ends data
      if (i_c2 == i_quote) break;           // matching quote data
      
      lt += (char) GetChar(is);             // accumulate data 
    }
    return;

  default:
    throw CTBexceptionBugcheck("illegal state","CTBxmlLexer::Get()");
  }  
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlLexer::Clear()
{
  CTB_Trace("CTBxmlLexer::Clear()");

  mi_nline_t   = 1;
  mi_ncolumn_t = 1;
  mi_nline_s   = 1;
  mi_ncolumn_s = 1;
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlLexer::Dump(int i_indent, ostream& os, const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBxmlLexer ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;

  os << bl << "    mi_mode:      " << mi_mode << endl;
  os << bl << "    mi_nline_t:   " << mi_nline_t << endl;
  os << bl << "    mi_ncolumn_t: " << mi_ncolumn_t << endl;
  os << bl << "    mi_nline_s:   " << mi_nline_s << endl;
  os << bl << "    mi_ncolumn_s: " << mi_ncolumn_s << endl;

  return;
}

//------------------------------------------+-----------------------------------

int CTBxmlLexer::GetChar(istream& is)
{
  CTB_Trace("CTBxmlLexer::GetChar(istream&)");
  int i_char = is.get();

  if (i_char != EOF) {
    if (i_char == '\n') {
      mi_nline_s   += 1;
      mi_ncolumn_s  = 1;
    } else {
      mi_ncolumn_s += 1;
    }
  }
  return i_char;
}

//------------------------------------------+-----------------------------------

void CTBxmlLexer::GetEntity(istream& is, CTBxmlLexerToken& lt)
{
  CTB_Trace("CTBxmlLexer::GetEntity(istream&, CTBxmlLexerToken&)");

  if (is.peek() == '#') {                   // "&#" found
    lt += (char) GetChar(is);
    lt.Type(CTBxmlLexerToken::charref);     // "&#..;" -- character reference
  } else {
    lt.Type(CTBxmlLexerToken::entref);      // "&..;" -- entity reference
  }
    
  for (;;) {                                // gobble up rest of reference
    int i_c2 = GetChar(is);
    
    if (i_c2 == EOF) {                      // early end of reference
      lt.Type(CTBxmlLexerToken::fail);
      return;
    }
    
    lt += (char) i_c2;
    if (i_c2 == ';') break;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlLexer::GetWhite(istream& is, CTBxmlLexerToken& lt)
{
  CTB_Trace("CTBxmlLexer::GetWhite(istream&, CTBxmlLexerToken&)");

  lt.Type(CTBxmlLexerToken::white);
  while(isspace(is.peek())) {               // get remaining white space
    lt += (char) GetChar(is);
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlLexer::GetName(istream& is, CTBxmlLexerToken& lt)
{
  CTB_Trace("CTBxmlLexer::GetName(istream&, CTBxmlLexerToken&)");

  lt.Type(CTBxmlLexerToken::name);
  for (;;) {
    int i_c2 = is.peek();
    if (isalnum(i_c2) || i_c2 == '.' || i_c2 == '-' || 
        i_c2 == '_' || i_c2 == ':') {       // if name char ...
      lt += GetChar(is);                    // add
    } else {
      break;                                // else stop
    }
  }
  return;
}

//##############################################################################

//------------------------------------------+-----------------------------------

void CTBxmlLexerToken::ToStream(ostream& os) const
{
  os << "type: ";  

  switch (Type()) {
  case invalid:    os << "invalid";   break;
  case fail:       os << "fail";      break;
  case eof:        os << "eof";       break;
  case tagopen:    os << "tagopen";   break;
  case etagopen:   os << "etagopen";  break;
  case tagclose:   os << "tagclose";  break;
  case etagclose:  os << "etagclose"; break;
  case comment:    os << "comment";   break;
  case defopen:    os << "defopen";   break;
  case piopen:     os << "piopen";    break;
  case piclose:    os << "piclose";   break;
  case charref:    os << "charref";   break;
  case entref:     os << "entref";    break;
  case equal:      os << "equal";     break;
  case squote:     os << "squote";    break;
  case dquote:     os << "dquote";    break;
  case name:       os << "name";      break;
  case white:      os << "white";     break;
  case data:       os << "data";      break;
  default:         os << "???";       break;
  }

  os << " -- \"" << m_text.Escape() << "\"";
  
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlLexerToken::Dump(int i_indent, ostream& os, const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBxmlLexerToken ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;

  os << bl << "    mi_type:      " << mi_type << endl;
  m_text.Dump(i_indent+2,os,"m_text");

  return;
}

---