xml.l File Reference

#include <stdint.h>
#include <ctype.h>
#include <vector>
#include <stdio.h>
#include "xml.h"

Include dependency graph for xml.l:

Go to the source code of this file.

Classes
struct	xmlYY_state
struct	XMLParser::Private

Macros
#define	YY_NEVER_INTERACTIVE   1
#define	YY_NO_INPUT   1
#define	YY_NO_UNISTD_H   1
#define	YY_INPUT(buf, result, max_size)

Functions
static int	yyread (yyscan_t yyscanner, char *buf, int max_size)
static void	initElement (yyscan_t yyscanner)
static void	addCharacters (yyscan_t yyscanner)
static void	addElement (yyscan_t yyscanner)
static void	addAttribute (yyscan_t yyscanner)
static void	countLines (yyscan_t yyscanner, const char *txt, yy_size_t len)
static void	reportError (yyscan_t yyscanner, const std::string &msg)
static std::string	processData (yyscan_t yyscanner, const char *txt, yy_size_t len)
int	yylex (yyscan_t yyscanner)
static void	checkAndUpdatePath (yyscan_t yyscanner)
static std::string	trimSpaces (const std::string &str)

Variables
static const char *	entities_enc [] = { "amp", "quot", "gt", "lt", "apos" }
static const char	entities_dec [] = { '&', '"', '>', '<', '\'' }
static const int	num_entities = 5

Macro Definition Documentation

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size )

Value:

result=yyread(yyscanner,buf,max_size);

Definition at line 75 of file xml.l.

YY_NEVER_INTERACTIVE

#define YY_NEVER_INTERACTIVE   1

Definition at line 35 of file xml.l.

YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 36 of file xml.l.

YY_NO_UNISTD_H

#define YY_NO_UNISTD_H   1

Definition at line 37 of file xml.l.

Function Documentation

addAttribute()

static void addAttribute ( yyscan_t yyscanner )

static

Definition at line 350 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  std::string val = yyextra->attrValue;
  if (!yyextra->encoding.empty() && !yyextra->transcodeFunc(val,yyextra->encoding.c_str()))
  {
    reportError(yyscanner,"failed to transcode string '"+val+"' from encoding '"+yyextra->encoding+"' to UTF-8");
  }
  yyextra->attrs.insert(std::make_pair(yyextra->attrName,val));
}

References reportError().

addCharacters()

static void addCharacters ( yyscan_t yyscanner )

static

Definition at line 329 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  std::string data = trimSpaces(yyextra->data);
  if (!yyextra->encoding.empty() && !yyextra->transcodeFunc(data,yyextra->encoding.c_str()))
  {
    reportError(yyscanner,"failed to transcode string '"+data+"' from encoding '"+yyextra->encoding+"' to UTF-8");
  }
  if (yyextra->handlers.characters)
  {
    yyextra->handlers.characters(data);
  }
  if (!data.empty())
  {
    if (yy_flex_debug)
    {
      fprintf(stderr,"characters(%s)\n",data.c_str());
    }
  }
}

References reportError(), and trimSpaces().

addElement()

static void addElement ( yyscan_t yyscanner )

static

Definition at line 286 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (!yyextra->isEnd)
  {
    yyextra->xpath.push_back(yyextra->name);
    if (yyextra->handlers.startElement)
    {
      yyextra->handlers.startElement(yyextra->name,yyextra->attrs);
    }
    if (yy_flex_debug)
    {
      fprintf(stderr,"%d: startElement(%s,attr=[",yyextra->lineNr,yyextra->name.data());
      for (auto attr : yyextra->attrs)
      {
        fprintf(stderr,"%s='%s' ",attr.first.c_str(),attr.second.c_str());
      }
      fprintf(stderr,"])\n");
    }
  }
  if (yyextra->isEnd || yyextra->selfClose)
  {
    if (yy_flex_debug)
    {
      fprintf(stderr,"%d: endElement(%s)\n",yyextra->lineNr,yyextra->name.data());
    }
    checkAndUpdatePath(yyscanner);
    if (yyextra->handlers.endElement)
    {
      yyextra->handlers.endElement(yyextra->name);
    }
  }
}

References checkAndUpdatePath().

checkAndUpdatePath()

static void checkAndUpdatePath ( yyscan_t yyscanner )

static

Definition at line 263 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->xpath.empty())
  {
    std::string msg = "found closing tag '"+yyextra->name+"' without matching opening tag";
    reportError(yyscanner,msg);
  }
  else
  {
    std::string expectedTagName = yyextra->xpath.back();
    if (expectedTagName!=yyextra->name)
    {
      std::string msg = "Found closing tag '"+yyextra->name+"' that does not match the opening tag '"+expectedTagName+"' at the same level";
      reportError(yyscanner,msg);
    }
    else // matching end tag
    {
      yyextra->xpath.pop_back();
    }
  }
}

References msg(), and reportError().

Referenced by addElement().

countLines()

static void countLines ( yyscan_t yyscanner, const char * txt, yy_size_t len )

static

Definition at line 245 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  for (yy_size_t i=0;i<len;i++)
  {
    if (txt[i]=='\n') yyextra->lineNr++;
  }
}

initElement()

static void initElement ( yyscan_t yyscanner )

static

Definition at line 254 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->isEnd = false;     // true => </tag>
  yyextra->selfClose = false; // true => <tag/>
  yyextra->name = "";
  yyextra->attrs.clear();
}

processData()

static std::string processData ( yyscan_t yyscanner, const char * txt, yy_size_t len )

static

Definition at line 380 of file xml.l.

{
  std::string result;
  result.reserve(len);
  for (yy_size_t i=0; i<len; i++)
  {
    char c = txt[i];
    if (c=='&')
    {
      const int maxEntityLen = 10;
      char entity[maxEntityLen+1];
      entity[maxEntityLen]='\0';
      for (yy_size_t j=0; j<maxEntityLen && i+j+1<len; j++)
      {
        if (txt[i+j+1]!=';')
        {
          entity[j]=txt[i+j+1];
        }
        else
        {
          entity[j]=0;
          break;
        }
      }
      bool found=false;
      for (int e=0; !found && e<num_entities; e++)
      {
        if (strcmp(entity,entities_enc[e])==0)
        {
          result+=entities_dec[e];
          i+=strlen(entities_enc[e])+1;
          found=true;
        }
      }
      if (!found)
      {
        std::string msg = std::string("Invalid character entity '&") + entity + ";' found\n";
        reportError(yyscanner,msg);
      }
    }
    else
    {
      result+=c;
    }
  }
  return result;
}

References entities_dec, entities_enc, found, msg(), num_entities, and reportError().

reportError()

static void reportError ( yyscan_t yyscanner, const std::string & msg )

static

Definition at line 361 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yy_flex_debug)
  {
    fprintf(stderr,"%s:%d: Error '%s'\n",yyextra->fileName.c_str(),yyextra->lineNr,msg.c_str());
  }
  if (yyextra->handlers.error)
  {
    yyextra->handlers.error(yyextra->fileName,yyextra->lineNr,msg);
  }
}

References msg().

Referenced by addAttribute(), addCharacters(), checkAndUpdatePath(), XMLParser::parse(), and processData().

trimSpaces()

static std::string trimSpaces ( const std::string & str )

static

Definition at line 320 of file xml.l.

{
  const int l = static_cast<int>(str.length());
  int s=0, e=l-1;
  while (s<l && isspace(str.at(s))) s++;
  while (e>s && isspace(str.at(e))) e--;
  return str.substr(s,1+e-s);
}

Referenced by addCharacters().

yylex()

int yylex

(

yyscan_t

yyscanner

)

Definition at line 110 of file xml.l.

         {
  {SP}             { countLines(yyscanner,yytext,yyleng); }
  {DOCTYPE}        { countLines(yyscanner,yytext,yyleng); }
  {OPENSPECIAL}    { countLines(yyscanner,yytext,yyleng); BEGIN(Prolog); }
  {OPEN}           { countLines(yyscanner,yytext,yyleng);
                     initElement(yyscanner);
                     BEGIN(Element); }
  {COMMENT}        { yyextra->commentContext = YY_START;
                     BEGIN(Comment);
                   }
}
<Content>{
  {CDATA}          { countLines(yyscanner,yytext,yyleng);
                     yyextra->cdataContext = YY_START;
                     BEGIN(CDataSection);
                   }
  {PCDATA}         { yyextra->data += processData(yyscanner,yytext,yyleng); }
  {OPEN}           { countLines(yyscanner,yytext,yyleng);
                     addCharacters(yyscanner);
                     initElement(yyscanner);
                     BEGIN(Element);
                   }
  {COMMENT}        { yyextra->commentContext = YY_START;
                     countLines(yyscanner,yytext,yyleng);
                     BEGIN(Comment);
                   }
}
<Element>{
  "/"              { yyextra->isEnd = true; }
  {NAME}           { yyextra->name = yytext;
                     BEGIN(Attributes); }
  {CLOSE}          { addElement(yyscanner);
                     countLines(yyscanner,yytext,yyleng);
                     yyextra->data = "";
                     BEGIN(Content);
                   }
  {SP}             { countLines(yyscanner,yytext,yyleng); }
}
<Attributes>{
  "/"              { yyextra->selfClose = true; }
  {NAME}           { yyextra->attrName = yytext; }
  "="              { BEGIN(AttributeValue); }
  {CLOSE}          { addElement(yyscanner);
                     countLines(yyscanner,yytext,yyleng);
                     yyextra->data = "";
                     BEGIN(Content);
                   }
  {SP}             { countLines(yyscanner,yytext,yyleng); }
}
<AttributeValue>{
  {SP}             { countLines(yyscanner,yytext,yyleng); }
  ['"]             { yyextra->stringChar = *yytext;
                     yyextra->attrValue = "";
                     BEGIN(AttrValueStr);
                   }
  .                { std::string msg = std::string("Missing attribute value. Unexpected character `")+yytext+"` found";
                     reportError(yyscanner,msg);
                     unput(*yytext);
                     BEGIN(Attributes);
                   }
}
<AttrValueStr>{
  [^'"\n]+         { yyextra->attrValue += processData(yyscanner,yytext,yyleng); }
  ['"]             { if (*yytext==yyextra->stringChar)
                     {
                       addAttribute(yyscanner);
                       BEGIN(Attributes);
                     }
                     else
                     {
                       yyextra->attrValue += processData(yyscanner,yytext,yyleng);
                     }
                   }
  \n               { yyextra->lineNr++; yyextra->attrValue+=' '; }
}
<CDataSection>{
  {ENDCDATA}       { BEGIN(yyextra->cdataContext); }
  [^]\n]+          { yyextra->data += yytext; }
  \n               { yyextra->data += yytext;
                     yyextra->lineNr++;
                   }
  .                { yyextra->data += yytext; }
}
<Prolog>{
  "encoding"\s*=\s*\"[^\"]*\" {
                     std::string encoding=yytext;
                     size_t i=encoding.find('"');
                     encoding=encoding.substr(i+1,yyleng-i-2);
                     if (encoding!="UTF-8") // need to transcode to UTF-8
                     {
                       yyextra->encoding=encoding;
                     }
                   }
  {CLOSESPECIAL}   { countLines(yyscanner,yytext,yyleng);
                     BEGIN(Initial);
                   }
  \n               { yyextra->lineNr++; }
  .                { }
}
<Comment>{
  {COMMENTEND}     { countLines(yyscanner,yytext,yyleng);
                     BEGIN(yyextra->commentContext);
                   }
  [^\n-]+          { }
  \n               { yyextra->lineNr++; }
  .                { }
}
\n                 { yyextra->lineNr++; }
.                  { std::string msg = "Unexpected character `";
                     msg+=yytext;
                     msg+="` found";
                     reportError(yyscanner,msg);
                   }
 
%%

yyread()

static int yyread ( yyscan_t yyscanner, char * buf, int max_size )

static

Definition at line 230 of file xml.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  int inputPosition = yyextra->inputPosition;
  const char *s = yyextra->inputString + inputPosition;
  int c=0;
  while( c < max_size && *s)
  {
    *buf++ = *s++;
    c++;
  }
  yyextra->inputPosition += c;
  return c;
}

Variable Documentation

entities_dec

const char entities_dec[] = { '&', '"', '>', '<', '\'' }

static

Definition at line 375 of file xml.l.

{ '&',   '"',    '>',  '<',  '\''   };

Referenced by processData().

entities_enc

const char* entities_enc[] = { "amp", "quot", "gt", "lt", "apos" }

static

Definition at line 374 of file xml.l.

{ "amp", "quot", "gt", "lt", "apos" };

Referenced by processData().

num_entities

const int num_entities = 5

static

Definition at line 376 of file xml.l.

Referenced by processData().