---

PropertyCompiler.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/JobOptionsSvc/PropertyCompiler.cpp,v 1.1.1.3 2001/04/18 18:32:50 tlindner Exp $

// PropertyCompiler:
//
// 1.) get tokens
// 2.) get NTS and TS
// 3.) create Property-Objects

//
// Changes 9/3/2001 By M.Frank:
// - Add value-of operator '@' to assign a job option the value of another option
//   Usage:
//        MyAlg.OutputLevel = @MessageSvc.OutputLevel;
//        ApplicationMgr.TopAlgs += { @ApplicationMgr.ExtSvc };
//   Note:
//        The value-of of a vector addresses the elements, not the vector itself.
// - Allow reset of vector lists to empty lists.
//   Usage:
//        ApplicationMgr.TopAlgs += {};
//
//
#ifdef _WIN32
#pragma warning( disable : 4786 )
#endif
// STL include files 
#include <iostream>
#include <strstream>
#include <fstream>
#include <string>
#include <vector>

#include "PropertyCompiler.h"
#include "GaudiKernel/xtoa.h"
#include "GaudiKernel/Property.h"

#ifdef WIN32
   static const bool win_32=true;
#else
   static const bool win_32=false;
#endif

// ---- LEXICAL ANALYZER ----

PropertyCompiler::PropertyCompiler(std::string sourcefile, MsgStream& my_log, JobOptionsCatalogue& my_Cat, PropertyCompiler* parent)
: m_log(&my_log), m_Cat(&my_Cat)
{
   if ( 0 != parent )   {
     includeFiles = parent->includeFiles;
     unitsDefined = parent->unitsDefined;
     units        = parent->units;
     hasParent    = true;
   }
   else   {
     includeFiles = new std::vector <std::string>();
     units        = new UnitsExtension();
     unitsDefined = false;
     hasParent    = false;
   }

   // Resolve include-File
   sourcefile=resolveEnv(sourcefile);
   // put include-file into list with includes
   m_errorCount=0;m_warningCount=0;
   m_srcName=sourcefile;
   m_sy=BOFSy;                            // Begin of File
   // BUG-Fix #009: First line with comments is not printed out!
   m_error=false; 
   // EOBF

   m_in=new std::ifstream(sourcefile.c_str());
   if (m_in->fail())
   {
      *m_log << endreq << MSG::ERROR << "Error #001: Specified property-file " << sourcefile 
             << " does not exists or can not be opened! " << endreq;
      m_errorCount++;
      return;
   } // if
   
   for(std::vector<std::string>::iterator i = includeFiles->begin(); i != includeFiles->end(); i++ )  {
     if (sourcefile == *i)       {           // File already included!
         *m_log << endreq << MSG::WARNING << "Warning #001: Specified property-file " 
                << sourcefile << " was already included by another property-file! " << endreq;
         m_warningCount++;
         return;
     } // if
   } // for
   includeFiles->push_back(sourcefile);         // File not included yet! 
} // Constructor


PropertyCompiler::~PropertyCompiler()
{
  if ( !hasParent )   {
    delete includeFiles;
    delete units;
  }
  units = 0;
  includeFiles = 0;
  m_in->close();
} // Destructor

std::string PropertyCompiler::resolveEnv(const std::string& sourcefile)    {
   std::string originalName = sourcefile;
   std::string environmentVar="";
   std::string resolvedFile  ="";
   bool        inEnvironmentVar=false;
   bool        unixStyle       =false;
   unsigned int i;
  
   // resolve environment-settings
   // search for special character $ or %
   for (i=0;i<sourcefile.length();i++)   {
     if (sourcefile[i]=='$')      {           // read in until end or next /
         inEnvironmentVar = true;
         unixStyle        = true;
      }
      else if (sourcefile[i]=='%')      {
         inEnvironmentVar = (!inEnvironmentVar);
         unixStyle = false;
      }
      else if (inEnvironmentVar)      {
         if ((sourcefile[i]=='/') || (sourcefile[i]=='\\'))         {
            if (unixStyle)                // character which shows that end of environment-variable is reached
               inEnvironmentVar=false;
                                          // under NT these characters can be part of variable!
         } // if
         if (inEnvironmentVar)
            environmentVar=environmentVar+sourcefile[i];
      } // else if     
      else      {
         resolvedFile = resolvedFile + sourcefile[i];
      }

      if ((! inEnvironmentVar) && (environmentVar!=""))      {
         char* resFile;
         resFile = ::getenv(environmentVar.c_str());
         if (resFile==0)    {
           return originalName;
         }
         else   {
           resolvedFile=resolvedFile + resFile;
         }
         if (unixStyle)         {
            resolvedFile=resolvedFile+'/';         // add missing end-character!
            unixStyle=false;
         }
         environmentVar="";
      }
   } // for

   if ((inEnvironmentVar) && (environmentVar!="") && (unixStyle))   {
      // was at the end of the string!
      char* resFile;

      resFile = getenv(environmentVar.c_str());
      if (resFile==0)
         return originalName;
      else
         resolvedFile=resolvedFile + resFile;

      environmentVar="";
      unixStyle=false;
      inEnvironmentVar=false;
   } // if

   if (inEnvironmentVar)
      // ERROR!
      return originalName;

   return resolvedFile;
}


void PropertyCompiler::newCh()
{
   char readedSrcChar='\0';

   if (m_cnr < m_srcLine.length())
   {
      m_cnr=m_cnr+1;
      m_ch=m_srcLine[m_cnr-1];                       // -1 because m_in C++ strings begins with 0!
   } // if
   else                                              // have to read next line
   {
      if (m_compiledLine=="")                        // Check first, if printout of compilation-code
         m_compiledLine='\n'+m_srcLine;              // is possible... (only if statement is compiled)
      else 
         m_compiledLine=m_compiledLine+'\n'+m_srcLine;    // not printed out yet, add new statement!

      if (! m_in->eof())                                // read next line
      {
         m_srcLine="";
         while ((readedSrcChar != '\n') && (! m_in->eof()))  {
            readedSrcChar='\0';
            m_in->get(readedSrcChar);
            if ((readedSrcChar != '\n') && (! m_in->eof()))
               m_srcLine=m_srcLine+readedSrcChar;
         } // while 
         m_lnr=m_lnr+1;
         m_cnr=0;
         m_ch='\n';
      } // if
      else
      {
         m_ch=0;                                          // EOF is detected.
      } // else
   } // else
} // newCh


std::string PropertyCompiler::newSy()   {
   if (m_sy==noSy)               // There was already an error before from which compiler could not recover!
      return "";

   std::string numberStr="";
   std::string stringStr="";
   std::string identifierStr="";

   // Output-relevant: m_error-Indicator of Line and Column...
   m_tokenlnr=m_lnr;
   m_tokencnr=m_cnr+1;                              // because character of next token not read yet!

   while ((m_ch==' ') || (m_ch==9) || (m_ch=='\n') || (m_ch=='\r'))   // overread blanks, tabs and newlines
   {
      newCh();
   } // while

   if (m_ch=='/')                                 // overread possible comments
   {
      char oldCh=' ';
      int inComment=0;     // 0: no comment
                           // 1: /*...*/ comment
                           // 2: // comment

      newCh();
      if (m_ch=='*')
      {
         inComment=1;
         newCh();
      } // if
      else if (m_ch=='/')
      {
         inComment=2;
         newCh();
      } // else if

      while (inComment != 0)
      {
         // BUG-FIX #008: Compiler hangs up if // is m_in last line or /* not terminated by */
         if (m_ch==0)
         {
            inComment=0;
            m_sy=EOFSy;
            return "";
         } // if
         // EOBF

         if ((inComment==1) && (oldCh=='*') && (m_ch=='/'))
         {
            inComment=0;
         } // if
         else if ((inComment==2) && (m_ch=='\n'))
         {
            inComment=0;
         } // else if
         oldCh=m_ch; 
         newCh();
      } // while
      return newSy();                             // Restart Symbol detection by recursive call!
   } // if
                   
   if (m_ch==0)                                   // EOF detected!
   {
      m_sy=EOFSy;
   } // if
   else if (m_ch=='=')                            // Assign-Symbol detected.
   {
      m_sy=assignSy;
      newCh();
   } // else if
   else if (m_ch==';')                            // Semicolon-Symbol detected.
   {
      m_sy=semicolonSy;
      newCh();
   } // else if
   else if (m_ch==',')                            // Comma-Symbol detected.
   {
      m_sy=commaSy;
      newCh();
   } // else if
   else if (m_ch=='-')
   {
      m_sy=minusSy;
      newCh();
   } // else if
   else if (m_ch=='{')
   {
      m_sy=vectorStartSy;
      newCh();
   } // else if
   else if (m_ch=='+')
   {
      newCh();
      if (m_ch=='=')
      {
         m_sy=appendSy;
         newCh();
      }
      else
         m_sy=plusSy;
   } // else if
   else if (m_ch=='}')
   {
      m_sy=vectorEndSy;
      newCh();
   } // else if
   else if (m_ch=='"')                            // String-Symbol detected.
   {
      m_sy=stringSy;
      newCh();
      while (m_ch!='"')
      {
         stringStr += m_ch;
         newCh();
         while (m_ch=='\n')
            newCh();

         if (m_ch==0) // EOF -> final " is missing!!!
         {
            *m_log << endreq << MSG::ERROR << "Error #006 in line " << m_tokenlnr 
                   << " at column " << m_tokencnr-1 << ": String not terminated by \" " << endreq;
            m_errorCount++;
            m_error=true;
            m_ch='"';                             // add missing " to get out of loop!
            m_sy=EOFSy;
         } // if
      } // while
      newCh();
      return stringStr;
   } // else if
   else if ((m_ch>='0') && (m_ch<='9'))                 // Number-Symbol detected.
   {
      m_sy=numberSy;
      while ((m_ch>='0') && (m_ch<='9'))
      {
         numberStr=numberStr+m_ch;
         newCh();
      } // while
      return numberStr;
   } // else if
   else if (m_ch=='.')                                // Dot-Symbol detected.
   {
      m_sy=dotSy;
      newCh();
   } // else if
   else if ( ((m_ch>='A') && (m_ch<='Z')) ||             
             ((m_ch>='_') && (m_ch<='z')) )          // Identifier-Symbol detected.
   {
      m_sy=identifierSy;
      while (((m_ch>='0') && (m_ch<='9')) || ((m_ch>='A') && (m_ch<='Z')) || ((m_ch>='_') && (m_ch<='z')))
      {
         identifierStr=identifierStr+m_ch;
         newCh();
      } // while

      if ((identifierStr=="true") || (identifierStr=="false"))  // boolean-Symbol detected.
      {
         m_sy=booleanSy;
      } // recognizes boolean-type!
      return identifierStr;
   } // else if   
   else if (m_ch=='#')                                          // special functions
   {
      newCh();
      while (((m_ch>='0') && (m_ch<='9')) || ((m_ch>='A') && (m_ch<='Z')) || ((m_ch>='_') && (m_ch<='z')))
      {
         identifierStr=identifierStr+m_ch;
         newCh();
      } // while
      if (identifierStr=="include")
         m_sy=includeSy;
      else if (identifierStr=="ifdef")
         m_sy=ifDefSy;
      else if (identifierStr=="ifndef")
         m_sy=ifNDefSy;
      else if (identifierStr=="endif")
         m_sy=endIfSy;
      else if (identifierStr=="else")
         m_sy=elseSy;
      else if (identifierStr=="units")
         m_sy=unitsSy;
      else
         m_sy=noSy;
   } // else if
   else if (m_ch=='$')   {
     identifierStr = m_ch;
     newCh();
     while (((m_ch>='0') && (m_ch<='9')) || ((m_ch>='A') && (m_ch<='Z')) || ((m_ch>='_') && (m_ch<='z')))    {
       identifierStr += m_ch;
       newCh();
     } // while
     m_sy = envSy;
     return identifierStr;
   }
   else if (m_ch=='@')   {
     identifierStr = m_ch;
     newCh();
     while (((m_ch>='0') && (m_ch<='9')) || ((m_ch>='A') && (m_ch<='Z')) || ((m_ch>='_') && (m_ch<='z')) || m_ch=='.' )    {
       identifierStr += m_ch;
       newCh();
     } // while
     m_sy = propSy;
     return identifierStr;
   }
   else   {
      m_sy=noSy;
   } // else

   return "";       // if nothing other is returned before then returned zero-string
} // NewSymbol


// ---- PARSER / Syntax Analyzer ----
bool PropertyCompiler::isNextEntryPoint() 
{
   if (m_sy==semicolonSy)
   {
      newSy();
      return true;
   } // if
   return false;
} // isNextEntryPoint


PropertyCompiler::Symbols PropertyCompiler::getValueType(std::string& valueStr)   {
   Symbols value=noSy;
   std::string returnValue;
   bool negation=false;

   if (m_sy==stringSy)     {                       // STRING
     newSy();
     value=stringSy;
   } // if
   else if (m_sy == envSy )   {
     newSy();
     value = envSy;
   }
   else if (m_sy == propSy )   {
     newSy();
     value = propSy;
   }
   else if (m_sy==booleanSy)    {                  // BOOLEAN
      newSy();
      value=booleanSy;
   } // else if
   else if (m_sy==minusSy)   {
      returnValue=newSy();
      if (m_sy!=numberSy)
         m_sy=noSy;
      else      {
         negation=true;
         // BUG-Fix #015: Negative values are not represented correctly!
         valueStr='-'+returnValue;
      } // else
   } // else if
   
   if (m_sy==numberSy)      {                 // INTEGER or REAL
      returnValue=newSy();
      value=numberSy;
      if (m_sy==dotSy)     {                      // dot indicates REAL-Type!
         // REAL-Value
         returnValue=newSy();
         value=realSy;
         if (m_sy==numberSy)    {                // optional: digits after dot!
            valueStr=valueStr+"."+returnValue;   // generate in valueStr the real-Type
            returnValue=newSy();
         } // if
      } // if

      // BUG-Fix #011: Introducing scientific numbers
      if ((m_sy==identifierSy) && ((returnValue=="e") || (returnValue=="E")) )      {
         // scientific integer detected
         returnValue=newSy();
         if (m_sy==numberSy)    {
            valueStr=valueStr+"e"+returnValue;  // generate scientifc number
            newSy();
         }
         else     {
            m_sy=noSy;
         } // else
      } // if
      // EOBF

      // Introducing units!
      else if (m_sy==identifierSy) {
        // possible definition of unit...
        if (units->existsUnit(returnValue)) {
          if (value==numberSy) {
            int calculatedValue = atoi(valueStr.c_str());
            calculatedValue = (int)(calculatedValue * units->getFactor(returnValue));
            std::strstream valstr;
            valstr << calculatedValue << std::ends;
            valueStr = valstr.str( );
          }
          else if (value==realSy) {
            double calculatedValue = atof(valueStr.c_str());
            calculatedValue = calculatedValue * units->getFactor(returnValue);
            int decnr, sign;
            char* buffer = _ecvt(calculatedValue,40,&decnr,&sign);
            valueStr = buffer;
            valueStr = valueStr.insert(decnr,".");
          }
          else {
            m_sy=noSy;
          }
          newSy();
        }
        else {
          m_sy=noSy;
        }
      }
   } // else if
   
   else if (m_sy==dotSy)    {                   // dot indicates REAL-Type! .98;
      returnValue=newSy();
      if (m_sy==numberSy)      {
         value=realSy;
         valueStr=valueStr+"."+returnValue;     // generate m_in valueStr the real-Type
         returnValue=newSy();

         // BUG-Fix #011: Introducing scientific numbers
         if ((m_sy==identifierSy) && ((returnValue=="e") || (returnValue=="E")) )   {
            // scientific integer detected
            returnValue=newSy();
            if (m_sy==numberSy)    {
               valueStr=valueStr+"e"+returnValue;  // generate scientifc number
               newSy();
            } // if
            else    {
               m_sy=noSy;
            } // else
         } // if
         // EOBF
         // Introducing units
         else if (m_sy==identifierSy) {
           // possible definition of unit...
           if (units->existsUnit(returnValue)) {
             if (value==numberSy) {
               int calculatedValue = atoi(valueStr.c_str());
               calculatedValue = (int)(calculatedValue * units->getFactor(returnValue));
               std::strstream valstr;
               valstr << calculatedValue << std::ends;
               valueStr = valstr.str( );
             }
             else if (value==realSy) {
               double calculatedValue = atof(valueStr.c_str());
               calculatedValue = calculatedValue * units->getFactor(returnValue);
               int decnr, sign;
               char* buffer = _ecvt(calculatedValue,40,&decnr,&sign);
               valueStr = buffer;
               valueStr = valueStr.insert(decnr,".");
             }
             else {
               m_sy=noSy;
             }
             newSy();
           }
           else {
             m_sy=noSy;
           }
         }
      } // if
      else                                      // dot only: misplaced dot!
         value=noSy;
   } // else if

   return value;
} // getValueType

void PropertyCompiler::ignorePlatformDependendLines()   {
   while ((m_sy!=endIfSy) && (m_sy!=elseSy) && (m_sy!=EOFSy))
      newSy();
}

void PropertyCompiler::getEntryPointOfDependendLines()    {
   while ((m_sy!=endIfSy) && (m_sy!=EOFSy))
      newSy();
}


StatusCode PropertyCompiler::checkSyntax()    {
   std::string returnValue;
   std::string objName;
   std::string propName;
   std::string valueStr;
   std::string newName;
   Symbols     oldType;
   Symbols     valueType;
   Operations  operation;
   bool        elsePathValid=false;
   // Synatx is: identifier identifier value
   // whereas value can be a stringSy, a numberSy, a numberSy. (REAL), a numberSy.numberSy (REAL), a Vector

   objName=newSy();                // get first Symbol... must be an identifier-Symbol (Object) or an include!

   while (m_sy != EOFSy )   {
      // Print compiled statement out if m_error-free!
      if ((! m_error) && (m_compiledLine!=""))   {
         if (m_compiledLine.find(";",0)== std::string::npos)   // no statement so far, print out comments!
         {
            *m_log << MSG::INFO << m_compiledLine;
            m_compiledLine="";
         } // if
         else     {
            std::string output=m_compiledLine.substr(0, m_compiledLine.find_last_of(";",0));
            *m_log << MSG::INFO << output;
            
            m_compiledLine.erase(0, m_compiledLine.find_last_of(";",0));
         } // else
      } // if

      // if error, then do not print out compiled statement which contains the error.
      if (m_error)      {
         // BUG-FIX: Missing Comment after wrong statement.
         if ( (m_compiledLine.find("//",0)!=m_compiledLine.npos) &&
              (m_compiledLine.find("//",0) < (m_compiledLine.find(";",0))) )
         {
            m_compiledLine.erase(0, m_compiledLine.find("//",0));
         }
         else if ( (m_compiledLine.find("/*",0)!=m_compiledLine.npos) &&
              (m_compiledLine.find("/*",0) < (m_compiledLine.find(";",0))) )
         {
            m_compiledLine.erase(0, m_compiledLine.find("/*",0));
         }
         else
         {
            if (m_compiledLine.find(";",0)==m_compiledLine.npos)           // missing ;
               m_compiledLine="";
            else
            {
               m_compiledLine.erase(0, m_compiledLine.find(";",0)+1);
            } // else
         }
      }

      m_error=false;

      // first symbol must be an identifier (Object), an include-Symbol or any
      // special-definition-Statement!
      if ((m_sy!=identifierSy) && (m_sy!=includeSy) && (m_sy!=ifDefSy) &&
          (m_sy!=ifNDefSy) && (m_sy!=endIfSy) && (m_sy!=elseSy) && m_sy!=unitsSy)
      {
         *m_log << endreq << MSG::ERROR << "Error #002 in line " << m_tokenlnr 
                << " at column " << m_tokencnr-1 << ": Object expected!" << endreq;
         m_errorCount++;
         m_error=true;
         objName="";
      } // if

      // handle include of units...
      if (m_sy==unitsSy) {
        returnValue = newSy();
        if (m_sy != stringSy) {
          *m_log << endreq << MSG::ERROR << "Error #020 in line " << m_tokenlnr
                 << " at column " << m_tokencnr-1 << ": syntax error: #units \"filename\"!" << endreq;
          m_errorCount++;
          m_error=true;
        }

        m_compiledLine="";

        objName = newSy();
        if (m_sy==semicolonSy)        {
          *m_log << endreq << MSG::ERROR << "Error #008 in line " << m_tokenlnr << " at column " << m_tokencnr-1
                 << ": syntax error: #units doesn't end with a ';'!" << endreq;
          m_errorCount++;
          m_error=true;
          newSy();
        } // if

        if (unitsDefined==true) {
          *m_log << endreq << MSG::WARNING << "Warning #021 in line " << m_tokenlnr
                 << " at column " << m_tokencnr-1 << ": An unit-definition file was already included before! Definition was skipped!" << endreq;
          m_warningCount++;
          
        }
        else {
          // SEMANTIC ACTION: Read unit-table
          returnValue = resolveEnv(returnValue);
          if (units->getUnits(returnValue)) {
            unitsDefined = true;
          }
          else {
            *m_log << endreq << MSG::ERROR << "Error #022 in line " << m_tokenlnr << " at column " << m_tokencnr-1
                   << ": cannot open unit-definition file " << returnValue << endreq;
            m_errorCount++;
            m_error=true;
          }
        }
        continue;
      } // if
        
      // handle include ...
      if (m_sy==includeSy)    {
         returnValue=newSy();
         if (m_sy!=stringSy)   {
            *m_log << endreq << MSG::ERROR << "Error #007 in line " << m_tokenlnr 
                   << " at column " << m_tokencnr-1 << ": syntax error: #include \"filename\"!" <<endreq;
            m_errorCount++;
            m_error=true;
         } // if
         
         m_compiledLine="";      // avoid output of #include-statement!!!
         
         objName=newSy();
         if (m_sy==semicolonSy)    {
            *m_log << endreq << MSG::ERROR << "Error #008 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                   << ": syntax error: #include doesn't end with a ';'!" << endreq;
            m_errorCount++;
            m_error=true;
            newSy();
         } // if

         // SEMANTIC ACTION: PROCESS INCLUDE!!!
         // Include detected: Include other file by generating and executing a new compiler-object
         if (! m_error)   {
            *m_log << MSG::INFO << "// --> Including file " << returnValue << "\n";
            PropertyCompiler *pc=new PropertyCompiler(returnValue, *m_log, *m_Cat, this);
            if (! pc->startCompiler().isSuccess())   {    // BUG-Fix #014...
               // Error message was printed out before... tell this instance that there was a error!
               m_errorCount++;
               m_error=true;
            }

            // If you want to print out also the #include-statement uncomment following lines...
            /*if (pc->startCompiler() != 0)
            {
               m_error=true;
            }*/

            *m_log << MSG::INFO << "// <-- End of including file " << returnValue << "\n";
            delete pc;
         } // if
         // END OF SEMANTIC ACTION
         continue;
      } // if

// handle #ifdef-Statement
      if (m_sy==ifDefSy)      {
         returnValue=newSy();     // read in next symbol!

         if (m_sy!=identifierSy)     {
            *m_log << endreq << MSG::ERROR << "Error #017 in line " << m_tokenlnr 
                   << " at column " << m_tokencnr-1 << ": syntax error: #ifdef not followed by an identifier!" <<endreq;
            getEntryPointOfDependendLines();
            m_errorCount++;
            m_error=true;
         } // if
         
         if (returnValue!="WIN32")     {
            *m_log << endreq << MSG::ERROR << "Error #018 in line " << m_tokenlnr 
                   << " at column " << m_tokencnr-1 << ": syntax error: identifier in #ifdef not known!" <<endreq;
            getEntryPointOfDependendLines();
            m_errorCount++;
            m_error=true;
         } // if

         if ((returnValue=="WIN32") && (! win_32))   {    // only for Win-NT!!!
            if (! m_error)     {
               ignorePlatformDependendLines();
               elsePathValid=true;
            }
         }
         m_compiledLine="";      // avoid output of #ifdef-statement!!!
         
         objName=newSy();
         if (m_sy==semicolonSy)    {
            *m_log << endreq << MSG::ERROR << "Error #019 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                   << ": syntax error: #ifdef doesn't end with a ';'!" << endreq;
            m_errorCount++;
            m_error=true;
            newSy();
         } // if
         continue;
      } // if

// handle #ifndef-Statement
      if (m_sy==ifNDefSy)    {
         returnValue=newSy();     // read in next symbol!

         if (m_sy!=identifierSy)   {
            *m_log << endreq << MSG::ERROR << "Error #017 in line " << m_tokenlnr 
                   << " at column " << m_tokencnr-1 << ": syntax error: #ifndef not followed by an identifier!" <<endreq;
            getEntryPointOfDependendLines();
            m_errorCount++;
            m_error=true;
         } // if
         
         if (returnValue!="WIN32")    {
            *m_log << endreq << MSG::ERROR << "Error #018 in line " << m_tokenlnr 
                   << " at column " << m_tokencnr-1 << ": syntax error: identifier in #ifndef not known!" <<endreq;
            getEntryPointOfDependendLines();
            m_errorCount++;
            m_error=true;
         } // if

         if ((returnValue=="WIN32") && (win_32))   {    // only for Non-Win-NT!!!
            if (! m_error)    {
               ignorePlatformDependendLines();
               elsePathValid=true;
            }
         }
         m_compiledLine="";      // avoid output of #ifndef-statement!!!
         
         objName=newSy();
         if (m_sy==semicolonSy)     {
            *m_log << endreq << MSG::ERROR << "Error #019 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                   << ": syntax error: #ifndef doesn't end with a ';'!" << endreq;
            m_errorCount++;
            m_error=true;
            newSy();
         } // if
         continue;
      } // if

// handle #else-Statement
      if ( m_sy == elseSy )      {
         objName=newSy();
         if (m_sy==semicolonSy)         {
            *m_log << endreq << MSG::ERROR << "Error #019 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                   << ": syntax error: #else doesn't end with a ';'!" << endreq;
            m_errorCount++;
            m_error=true;
            newSy();
         } // if

         if (! elsePathValid)    {   // do not process else-path!
            if (! m_error)    {
               ignorePlatformDependendLines();
            }
         }
         m_compiledLine="";      // avoid output of #else-statement!!!
         
         elsePathValid=false;
         continue;
      } // if

// handle #endif-Statement
      if ( m_sy==endIfSy)      {
         m_compiledLine="";      // avoid output of #endif-statement!!!
         
         objName=newSy();
         if (m_sy==semicolonSy)      {
            *m_log << endreq << MSG::ERROR << "Error #019 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                   << ": syntax error: #endif doesn't end with a ';'!" << endreq;
            m_errorCount++;
            m_error=true;
            newSy();
         } // if
         continue;
      } // if
      
      newName=objName;
      objName="";              // for the first assignment
 
      while (m_sy==identifierSy)      {
         objName=objName+newName;
         newSy();
         if (m_sy==semicolonSy)
            break;  

         if (m_sy==dotSy)         {
            newName="."+newSy();
            if (m_sy==semicolonSy)
               break;
         } // else
      } // while

      if (objName.find(".")==objName.npos)        // no dot in identifier!!!
      {
         *m_log << endreq << MSG::ERROR << "Error #003 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                << ": Object and Property must be divided by a '.'!" << endreq;
         m_errorCount++;
         m_error=true;
      } // if
      if (isNextEntryPoint())
         continue;

      if (objName!="")
         objName.erase(objName.find_last_of("."), objName.length());
      newName.erase(0,1);
      propName=newName;

      operation=noOperation;
      if (m_sy==assignSy)
        operation=assign;
      else if (m_sy==appendSy)
        operation=append;

      if (operation==noOperation)   {
         *m_log << endreq << MSG::ERROR << "Error #005 in line " << m_tokenlnr << " at column " << m_tokencnr-1 
                << ": syntax error: missing operator '=' or '+='!" << endreq;
         m_errorCount++;
         m_error=true;
      } // if

      returnValue=newSy();
      if (isNextEntryPoint())
         continue;
      
      // --- VECTOR-Recognition:
      // --- by finding { start recognition of a vector, values seperated by commas and terminated
      //     by a } and a semicolon!
      // --- without finding { only recognize a new single value followed by a semicolon
      std::vector<std::string> propValues;
      bool isArrayProp = false;
      if (m_sy==vectorStartSy)      {
        returnValue = newSy();
        returnValue = resolveEnv(returnValue);
        valueType   = getValueType(returnValue);
        oldType     = valueType;
        isArrayProp = true;
        if ( valueType == stringSy )    {
          propValues.push_back("\""+returnValue+"\"");
        }
        else if (valueType == booleanSy)   {
          propValues.push_back((::toupper(returnValue[0]) == 'T' || returnValue[0] == '1') ? "1" : "0" );
        }
        else if (valueType!=noSy)   {
          propValues.push_back(returnValue);
        }
        if (m_sy==commaSy)   {
          while ((m_sy!=identifierSy) && (m_sy!=EOFSy) && (m_sy!=semicolonSy) && (m_sy!=vectorEndSy))    {
            returnValue = newSy();
            returnValue = resolveEnv(returnValue);
            valueType=getValueType(returnValue);
            if ( valueType == stringSy )    {
              propValues.push_back("\""+returnValue+"\"");
            }
            else if (valueType == booleanSy)   {
              propValues.push_back((::toupper(returnValue[0]) == 'T' || returnValue[0] == '1') ? "1" : "0" );
            }
            else    {
              propValues.push_back(returnValue);
            }
            if ((m_sy!=commaSy) && (m_sy!=identifierSy) && (m_sy!=EOFSy) && (m_sy!=semicolonSy) && (m_sy!=vectorEndSy))    {
              *m_log << endreq << MSG::ERROR << "Error #009 in line " << m_tokenlnr << " at column " 
                     << m_tokencnr << ": syntax error: Values in vector must be sperated with ','!" << endreq;
              m_errorCount++;
              m_error=true;
            } // if
          } // while
        } // if
        if (m_sy!=vectorEndSy)   {
          *m_log << endreq << MSG::ERROR << "Error #010 in line " << m_tokenlnr << " at column " 
                 << m_tokencnr << ": syntax error: Vector must end with a closing braket '}'!" << endreq;
          m_errorCount++;
          m_error=true;
        }
        newSy();
      } // if (m_sy==vectorStartSy)
      else    {
         returnValue = resolveEnv(returnValue);
         valueType=getValueType(returnValue);
         oldType=valueType;

         if (valueType==noSy)  {
            *m_log << endreq << MSG::ERROR << "Error #015 in line " << m_tokenlnr << " at column " 
                   << m_tokencnr << ": Value(s) expected!" << endreq;
            m_errorCount++;
            m_error=true;
            newSy();
            returnValue="";
         } // if
         else if ( valueType == stringSy )    {
           propValues.push_back("\""+returnValue+"\"");
         }
         else if (valueType == booleanSy)   {
           propValues.push_back((::toupper(returnValue[0]) == 'T' || returnValue[0] == '1') ? "1" : "0" );
         }
         else   {
           propValues.push_back(returnValue);
         }
      } // else

      if (m_sy!=semicolonSy)  {
         *m_log << endreq << MSG::ERROR << "Error #011 in line " << m_tokenlnr << " at column " 
                << m_tokencnr << ": syntax error: missing ';'!" << endreq;
         m_errorCount++;
         m_error=true;
      } // if
      // BUG-Fix #004: else removed!

      // SEMANTIC ACTION: Commit generated property-Entry to JobOptionsCataloge, if no error in statement
      if (!m_error)    {
        // If there was no error, commit new properties to JobOptionsCatalogue!!!
        // SEMANTIC ACTION: Prepare new Property-Entry for JobOptionsCataloge with readed vector
        if ( propValues.size() == 0 )   {
          switch ( operation )    {
          case assign:  
            operation = clear;
            break;
          case append:
            operation = noOperation;
            break;
          default:
            break;
          }
        }
        std::vector<const Property*>* myOpts = 0;
        switch( operation )    {
        case append:
        case assign:   
        case clear:
          if ( m_Cat->optionsOf(objName, myOpts).isSuccess() )   {
            std::vector<const Property*>::iterator itr;
            for ( itr=myOpts->begin(); itr!=myOpts->end(); itr++ )   {
              if ((*itr)->name() == propName )    {
                switch ( operation )    {
                case append:     {
                    const StringArrayProperty* sap = 
                      dynamic_cast<const StringArrayProperty*> (*itr);
                    if ( sap != 0 )    {
                      std::vector<std::string> res = sap->value();
                      for ( unsigned int it = 0; it < propValues.size(); it++ )    
                        res.push_back(propValues[it]);
                      propValues = res;
                    }
                  }
                  break;
                default:
                  break;
                }
                myOpts->erase(itr);           // Delete existing property
                break;
              }
            }
          }
          if ( isArrayProp )    {
            m_Cat->addOption( objName, new StringArrayProperty(propName, propValues));
          }
          else  {
            m_Cat->addOption( objName, new StringProperty(propName, propValues[0]));
          }
          break;
        default:
          break;
        }
      } // if
      // END OF SEMANTIC ACTION

      objName=newSy();

      if (isNextEntryPoint())
         continue;

      if (m_sy==noSy)      {
         m_error=true;
         m_errorCount++;
         *m_log << endreq << MSG::ERROR << "Error #000 in line " << m_tokenlnr << " at column " << m_tokencnr 
                << ": \nFatal compiler error!"
                << "\nThis Error can have several reasons:\n"
                << "* The job-option-file contains invalid characters\n"
                << "* The job-option-file is not valid\n"
                << "* The property-compiler could not recover from previous error\n"
                << "* Memory or Disk-problem\n"
                << "\n\nCompiler will now try to recover.\n"
                << "WARNING: ONE OR MORE LINES ARE IGNORED AND NOT PRINTED OUT BY THE COMPILER.\n"
                << "PLEASE CHECK MANUALLY STATEMENTS BEFORE AND AFTER ERROR-POSITION!!!\n\n" << endreq;
         //return StatusCode::FAILURE;

         m_sy=BOFSy;          // Try to recover!!!
         newCh();

         objName=newSy();
         while ( (m_sy!=semicolonSy) && (m_sy!=EOFSy) )     {
            newSy();
            if (m_sy==noSy)    {
               m_sy=BOFSy;    // Try to recover!!!
               newCh();
            } // if
         }
         if (m_sy==EOFSy)
            return StatusCode::FAILURE;

         m_compiledLine="";
         objName=newSy();  // Compiler recoverd from previous error!
         continue;
      } // if

   } // while

   // BUG-FIX #003: Last line is not printed out after compilation
   // Reason: Compilation breaks at EOF, last line contains EOF!
   if ((! m_error) && (m_compiledLine!=""))   {
      *m_log << MSG::INFO << m_compiledLine << "\n";
      m_compiledLine="";
   } // if

   if (m_error)
      m_compiledLine="";
   // EOBF

   if (m_errorCount != 0)   {
      *m_log << MSG::INFO << m_errorCount << " error(s) in file " << m_srcName << endreq;
      return StatusCode::FAILURE;
   }

   return StatusCode::SUCCESS;                                 // no errors!
} // CheckSyntax



// ---- START COMPILER ----
StatusCode PropertyCompiler::startCompiler()
{
   if ((m_errorCount!=0) || (m_warningCount!=0))
      return StatusCode::FAILURE;                    // Constructor failed!!!

   // start initialization for compile-run
   m_srcLine="";
   m_compiledLine="";
   m_lnr=0;
   m_cnr=0;
   m_errorCount=0;
   newCh();
   StatusCode result=checkSyntax();
   return result;
} // startCompiler

---