rewrote pixmap::read to do more sanity checks

1 files changed, 243 insertions, 179 deletions

diff --git a/ue2/imgsynth2/cpixmap.cpp b/ue2/imgsynth2/cpixmap.cpp
index 6f8c8d6..d3e10d8 100644
--- a/ue2/imgsynth2/cpixmap.cpp
+++ b/ue2/imgsynth2/cpixmap.cpp
@@ -5,25 +5,23 @@
  * @date   27.04.2009
  */
 
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-
 #ifdef DEBUG
 # include <iostream>
 #endif
-#include <cstdlib>
-#include <stdint.h>
-# include <string>
-# include <map>
-
-
-
 #include "cpixmap.h"
 #include "cpixelformat_indexed8.h"
 
 using namespace std;
+using namespace boost;
 
 CPixmap::CPixmap()
+  : m_imagename("")
 {
   m_types.insert("XPM");
 
@@ -33,236 +31,302 @@ CPixmap::CPixmap()
 
 /*----------------------------------------------------------------------------*/
 
-void CPixmap::read(std::ifstream& in)
+std::string CPixmap::getLine(std::ifstream& in, bool ignore_comments)
 {
+  string line("");
+  while(!in.eof() && in.good())
+  {
+    getline(in, line);
+    trim(line);
+    /* ignore simple ansi c comments. only one-liners */
+    if (ignore_comments && line.find_first_of("/*") == 0)
+      continue;
+    if (!line.empty())
+      break;
+  }
+  return line;
+}
 
-  string str;
-  m_fileheader._XPMEXT = false;
-  m_fileheader._HOTSPOT = false;
+/*----------------------------------------------------------------------------*/
 
-  /* parse the values section */
-  getline( in, str, '"');
-  getline( in, str, '"');
-  stringstream istr (str );
+std::string CPixmap::getArrayLine(std::ifstream& in, bool ignore_comments)
+{
+  string line = getLine(in, ignore_comments);
+  if (line.empty())
+    return line;
+
+  /* this stuff isn't correct too, but we are no c-parser anyway */
+  if (line[0] != '"')
+    throw FileError("Pixmap array has invalid c-syntax.");
+  if (line[line.length() - 1] != ',' && line[line.length() - 1] != '}')
+    throw FileError("Pixmap array has invalid c-syntax.");
+  size_t end = line.find_last_of("\"");
+  if (end == string::npos)
+    throw FileError("Pixmap array has invalid c-syntax.");
+
+  return line.substr(1, end - 1);
+}
 
-  istr >> m_fileheader.xpmWidth ;
-  istr >> m_fileheader.xpmHeight ;
-  istr >> m_fileheader.nColor ;
-  istr >> m_fileheader.nChar ;
+/*----------------------------------------------------------------------------*/
+
+void CPixmap::read(std::ifstream& in)
+{
+  /*
+   * <C-Comment> XPM <C-Comment>
+   * static char * <pixmap_name>[] = {
+   * <Values>
+   * <Colors>
+   * <Pixels>
+   * <Extensions>
+   * };
+   */
+
+  string line, tmp;
+  stringstream istr;
+  std::vector<std::string> list;
+  m_fileheader._XPMEXT  = false;
+  m_fileheader._HOTSPOT = false;
 
-  /*optional values */
-  if  (istr.good())
+  /* first line has to be PIXMAP_IDENTIFIER */
+  line = getLine(in, false);
+  if (line != PIXMAP_IDENTIFIER)
+    throw FileError("Pixmap has no identifier.");
+
+  /* second line is a c array. we don't do much syntax checking */
+  line = getLine(in);
+  istr.str(line);
+  while(m_imagename.empty() && !istr.eof() && istr.good())
   {
-    string tmp;
+    size_t end;
     istr >> tmp;
-    if(tmp.compare("XPMEXT") == 0)
-      m_fileheader._XPMEXT = true;
-    else
+    if ((end = tmp.find_first_of("[]")) != string::npos)
     {
-      m_fileheader._HOTSPOT = true;
-      m_fileheader.xHotspot = static_cast<unsigned int>(strtoul(tmp.c_str(), NULL, 16));
-      istr >> m_fileheader.yHotspot;
+      /* <xxx>*<imagename>[]<yyy> */
+      size_t start = tmp.find_first_of('*');
+      start = (start == string::npos) ? 0 : start + 1;
+      m_imagename = tmp.substr(start, end - start);
     }
-    if (istr.good())
+  }
+  if (m_imagename.empty())
+    throw FileError("Pixmap has no imagename.");
+
+  /* additional: check "{" exists */
+  if (line[line.length() - 1] != '{')
+    throw FileError("Pixmap array has no opening bracket.");
+
+  /* parse <Values>-section */
+  line = getArrayLine(in);
+  if (line.empty())
+    throw FileError("Pixmap has no Values-section.");
+  algorithm::split(list, line, is_any_of(" \t"));
+  if (list.size() < 4)
+    throw FileError("Pixmap has invalid Values-section.");
+  try
+  {
+    m_fileheader.width  = lexical_cast<uint32_t>(list[0]);
+    m_fileheader.height = lexical_cast<uint32_t>(list[1]);
+    m_fileheader.nColor = lexical_cast<uint32_t>(list[2]);
+    m_fileheader.nChar  = lexical_cast<uint32_t>(list[3]);
+
+    if (list.size() > 4)
     {
-      istr >> tmp;
-      if (tmp.compare("XPMEXT") == 0)
-        m_fileheader._XPMEXT = true;
+      if (list.size() >= 6)
+      {
+        m_fileheader._HOTSPOT = true;
+        m_fileheader.xHotspot = lexical_cast<uint32_t>(list[4]);
+        m_fileheader.yHotspot = lexical_cast<uint32_t>(list[5]);
+      }
+      if (list.size() != 6)
+      {
+        if (list[list.size() - 1] != "XPMEXT")
+          throw FileError("Unknown parameter count in Values-Section.");
+        else
+          m_fileheader._XPMEXT = true;
+      }
     }
   }
+  catch(bad_lexical_cast& ex)
+  {
+    throw FileError("Value of Values-section is invalid: " + string(ex.what()));
+  }
 
+  /* parse <Colors>-table */
+  string character;
+  map<string, CPixelFormat::RGBPIXEL *> colors;
+  for(uint32_t i = 0; i < m_fileheader.nColor; i++)
+  {
+    line = getArrayLine(in);
+    if (line.empty())
+      throw FileError("Pixmap has missing colortable-entry.");
+    algorithm::split(list, line, is_any_of(" \t"));
+    if (list.size() < 3)
+      throw FileError("Pixmap colortable-entry is invalid.");
+
+    /* read pixel character */
+    character = list[0];
+    if (character.length() != m_fileheader.nChar)
+      throw FileError("Pixmap colorcharacter is invalid.");
+
+    /* read colors */
+    string color("");
+    if ((list.size() - 1) % 2 != 0)
+      throw FileError("Pixmap color entrys are invalid.");
+    for(uint32_t j = 1; j < list.size(); j = j + 2)
+    {
+      if (list[j + 1].length() != 7)
+        throw FileError("Pixmap color value is invalid.");
+      if (list[j + 1].at(0) != '#')
+        throw FileError("Pixmap color table value is not hexadecimal.");
+
+      /* we only support c-colors! */
+      if (list[j] != "c")
+        continue;
+
+      CPixelFormat::RGBPIXEL *pixel = new CPixelFormat::RGBPIXEL;
+      pixel->red   = strtoul(list[j + 1].substr(1, 2).c_str(), NULL, 16);
+      pixel->green = strtoul(list[j + 1].substr(3, 2).c_str(), NULL, 16);
+      pixel->blue  = strtoul(list[j + 1].substr(5, 2).c_str(), NULL, 16);
+      colors[ list[j] ] = pixel;
+    }
 
+    /* we only support c-colors! */
+    if (colors.find("c") == colors.end())
+      throw FileError("Pixmap color entry has missing c-value.");
 
-  /* parse color table*/
-  getline( in, str, '"');
-  string character, mode, colors;
-  for (unsigned int i = 0; i < m_fileheader.nColor; i++ )
-  {
-    getline( in, str, '"' );
-    stringstream istr2 (str );
-
-    istr2 >> character;
-    istr2 >> mode;
-    istr2 >> colors;
-
-    if ( colors.size() != 7)
-      throw FileError("Pixmap color tabel is invalid.");
-    if ( colors.at(0) != '#') 
-      throw FileError("Pixmap color tabel value is not hexadecimal.");
-
-    xpmColors[character][mode] = new (nothrow) unsigned int[3];
-    if (xpmColors[character][mode] == 0)
-       throw FileError("Bad color table allocation.");
-       
-    xpmColors[character][mode][0] = 
-      static_cast<unsigned int>(strtoul(colors.substr(1,2).c_str(), NULL, 16));
-    xpmColors[character][mode][1] =   
-      static_cast<unsigned int>(strtoul(colors.substr(3,2).c_str(), NULL, 16));
-    xpmColors[character][mode][2] = 
-      static_cast<unsigned int>(strtoul(colors.substr(5,2).c_str(), NULL, 16));
-    
-  
-   
-   
-
-    
-    getline( in, str, '"' );
+    /* add pixel to colortable */
+    m_colortable[character] = colors["c"];
   }
-  
-  /* read pixel data using separate class */
+
+  /* read pixel data */
   if (getPixelDataSize() > 0)
   {
     if (m_pixeldata != NULL)
       delete[] m_pixeldata;
     m_pixeldata = new uint8_t[getPixelDataSize()];
-  
-    for (unsigned int y = 0; y <  getHeight(); y++ )
-    {
-      for (unsigned int x = 0; x <  getWidth(); x++ )
-        m_pixeldata[y * getWidth() + x] = static_cast<uint8_t>(in.get());
 
-      getline( in, str);
-      if ( y  != ( getHeight() - 1 ))
-        in.get();
-    
+    for (uint32_t y = 0; y < getHeight(); y++)
+    {
+      line = getArrayLine(in);
+      if (line.empty())
+        throw FileError("Pixmap has no pixel data.");
+      if (line.length() != getWidth())
+        throw FileError("Pixmap pixeldata width is larger than header width.");
+      copy(line.c_str(), line.c_str() + line.length(), m_pixeldata + y * getWidth());
     }
   }
 
-  /* parse extension */
-  if ( m_fileheader._XPMEXT  )
-    getline( in, m_fileheader.extension, '}' );
-  /* debug*/
-  CPixmap::dump (cout);
-   
+  /* get extension */
+  if (m_fileheader._XPMEXT)
+    getline(in, m_fileheader.extension, '}');
+  if (!in.good())
+    throw FileError("Pixmap array isn't closed properly.");
+
   /* get pixelformat instance */
   m_pixelformat = NULL;
   set<CPixelFormat *>::iterator it;
   for (it = m_handlers.begin(); it != m_handlers.end(); it++)
   {
-    /* check color mode */
-    //TODO if (mode.compare((*it)->getColorMode()) == 0)
-    if (mode == "c")
-    {
-      m_pixelformat = *it;
-      break;
-    }
+    /* we only have one! */
+    m_pixelformat = *it;
+    break;
   }
   if (m_pixelformat == NULL)
-    throw FileError("Pixmap color mode \""+mode+"\" is not supported.");
+    throw FileError("Pixmap color mode is not supported.");
+
+#ifdef DEBUG
+  /* debug*/
+  CPixmap::dump(cout);
+#endif
 }
 
 /*----------------------------------------------------------------------------*/
 
-void CPixmap::write(std::ofstream& out, std::string& filename)
+void CPixmap::write(std::ofstream& out)
 {
-
   /* header comment */
-  out<<"/* XPM */"<<endl;
- 
+  out << PIXMAP_IDENTIFIER << endl;
+
   /* variables*/
-  out<<"static char * "
-      <<filename.substr(filename.find_last_of("/\\") + 1, filename.size())
-      <<"[] = {"<<endl;
-  out<<"\""<<m_fileheader.xpmWidth<<" "<<m_fileheader.xpmHeight
-        <<" "<<m_fileheader.nColor<<" "<<m_fileheader.nChar;
- 
-   /*optional values*/
-  if( m_fileheader._HOTSPOT )
-    out<<" "<<m_fileheader.xHotspot<<" "<<m_fileheader.yHotspot;
-  if( m_fileheader._XPMEXT )
-    out<<" "<<"XPMEXT";
-  out <<"\","<<endl;
-
- /* color table */
-  map<string, map<string,  uint32_t* > >::iterator it1;
-  map<string, uint32_t* >::iterator it2;
-
-  for ( it1= xpmColors.begin() ; it1 != xpmColors.end(); it1++ )
- {
-    out << "\""<<(*it1).first;
-    for ( it2=(*it1).second.begin() ; it2 != (*it1).second.end(); it2++ )
-    {
-      
-      out<<"\t" <<(*it2).first<<"\t#";
-      
-      for (int i = 0 ; i < 3; i++ )
-      {
-        out.width(2);
-        out << hex <<uppercase<<(*it2).second[i];
-        out.fill('0');
-      }
-    }
-    out<<"\","<<endl;
+  out << "static char * " << m_imagename << "[] = {" << endl;
+  out << "\"" << m_fileheader.width << " " << m_fileheader.height
+      << " " << m_fileheader.nColor << " " << m_fileheader.nChar;
+
+  /* optional values */
+  if (m_fileheader._HOTSPOT)
+    out << " " << m_fileheader.xHotspot << " " << m_fileheader.yHotspot;
+  if (m_fileheader._XPMEXT)
+    out << " " << "XPMEXT";
+  out << "\"," << endl;
+
+  /* color table */
+  map<string, CPixelFormat::RGBPIXEL *>::iterator it;
+  for (it = m_colortable.begin(); it != m_colortable.end(); it++)
+  {
+    out << "\"" << (*it).first;
+    /* we only support c-colors! */
+    out << "\tc #";
+    out << setfill('0') << setw(2) << hex << uppercase << (*it).second->red
+        << setfill('0') << setw(2) << hex << uppercase << (*it).second->green
+        << setfill('0') << setw(2) << hex << uppercase << (*it).second->blue;
+    out << "\"," << endl;
   }
-  
+
   /* pixel data */
-  for (unsigned int y = 0; y <  getHeight(); y++ ){
-  out <<"\"";
-    for (unsigned int x = 0; x <  getWidth(); x++ )
+  //TODO: better via copy?
+  for (uint32_t y = 0; y < getHeight(); y++)
+  {
+    out << "\"";
+    for (uint32_t x = 0; x < getWidth(); x++)
       out << m_pixeldata[y * getWidth() + x];
-    out <<"\"";
-    if ( y  != ( getHeight() - 1 ))
-      out <<",";
-     out <<endl;
+    out << "\"," << endl;
   }
-  
- /* extension */ 
+
+  /* extension */
   if (m_fileheader._XPMEXT)
     out << m_fileheader.extension;
-    
-  out <<"};";
 
+  out <<"};";
 }
 
-
 /*----------------------------------------------------------------------------*/
 
 #ifdef DEBUG
 void CPixmap::dump(std::ostream& out)
 {
-
-  /* pixeldata */ 
-  cout<<endl<<"(_Pixel data:_)"<<endl;
-  for (unsigned int y = 0; y <  getHeight(); y++ ){
-    for (unsigned int x = 0; x <  getWidth(); x++ )
+  /* pixeldata */
+  cout << "[XPM Pixel Data]" << endl;
+  for (uint32_t y = 0; y <  getHeight(); y++)
+  {
+    for (uint32_t x = 0; x <  getWidth(); x++)
       out << m_pixeldata[y * getWidth() + x];
     out << endl;
   }
-  
+  out << endl;
+
   /* values*/
-  cout<<endl<<"(_Values:_)"<<endl;
-  out << "XPM  Header:" << endl
-    << "xpmWidth="  << m_fileheader.xpmWidth<< endl
-    << "xpmHeight=" << m_fileheader.xpmHeight<< endl
-    << "nColor=" << m_fileheader.nColor<< endl
-    << "nChar=" << m_fileheader.nChar<< endl
-    << "Hotspot=" << m_fileheader.xHotspot<< endl
-     << "yHotspot=" << m_fileheader.yHotspot<< endl
-     << "_HOTSPOT=" << m_fileheader._HOTSPOT<< endl
-    << "_XPMEXT=" << m_fileheader._XPMEXT<< endl
-     << "extension=" << m_fileheader.extension<< endl
-    << endl;
+  cout << "[XPM Header Values]" << endl
+       << "width="     << m_fileheader.width     << endl
+       << "height="    << m_fileheader.height    << endl
+       << "nColor="    << m_fileheader.nColor    << endl
+       << "nChar="     << m_fileheader.nChar     << endl
+       << "Hotspot="   << m_fileheader.xHotspot  << endl
+       << "yHotspot="  << m_fileheader.yHotspot  << endl
+       << "_HOTSPOT="  << m_fileheader._HOTSPOT  << endl
+       << "_XPMEXT="   << m_fileheader._XPMEXT   << endl
+       << "extension=" << m_fileheader.extension << endl
+       << endl;
 
   /* colors*/
-  map<string, map<string,  uint32_t* > >::iterator it1;
-  map<string, uint32_t* >::iterator it2;
-  cout<<"(_Color table:_)"<<endl;
-  for ( it1= xpmColors.begin() ; it1 != xpmColors.end(); it1++ )
- {
-    out << (*it1).first;
-    for ( it2=(*it1).second.begin() ; it2 != (*it1).second.end(); it2++ )
-    {
-      out <<" "<< (*it2).first <<" ";
-      for (int i = 0 ; i < 3; i++ )
-      {
-        out.width(3);
-        out << (*it2).second[i]<<" ";
-        out.fill('0');
-      }
-      out<<endl;
-    }
+  map<string, CPixelFormat::RGBPIXEL *>::iterator it;
+  cout << "[Color Table]" << endl;
+  for (it = m_colortable.begin(); it != m_colortable.end(); it++)
+  {
+    out << (*it).first << " "
+        << setfill('0') << setw(3) << (*it).second->red   << " "
+        << setfill('0') << setw(3) << (*it).second->green << " "
+        << setfill('0') << setw(3) << (*it).second->blue  << " "
+        << endl;
   }
-  
 }
 #endif