1 /******************************************************************************

     2  *

     3  * 

     4  *

     5  * Copyright (C) 1997-2008 by Dimitri van Heesch.

     6  *

     7  * Permission to use, copy, modify, and distribute this software and its

     8  * documentation under the terms of the GNU General Public License is hereby 

     9  * granted. No representations are made about the suitability of this software 

    10  * for any purpose. It is provided "as is" without express or implied warranty.

    11  * See the GNU General Public License for more details.

    12  *

    13  */

    14 

    15 %{

    16 

    17 /*

    18  *	includes

    19  */

    20 #include <stdio.h>

    21 #include <stdlib.h>

    22 #include <assert.h>

    23 #include <ctype.h>

    24 #include <stdarg.h>

    25 #include <errno.h>

    26 

    27 #include <qfileinfo.h>

    28 #include <qdir.h>

    29 #include <qtextstream.h>

    30 #include <qregexp.h>

    31 #include <qstack.h>

    32 #include <qglobal.h>

    33   

    34 #include "config.h"

    35 #include "version.h"

    36 #include "portable.h"

    37 #include "util.h"

    38 

    39 #include "lang_cfg.h"

    40 #include "configoptions.h"

    41 

    42 #undef Config_getString

    43 #undef Config_getInt

    44 #undef Config_getList

    45 #undef Config_getEnum

    46 #undef Config_getBool

    47 

    48 // use in-class definitions

    49 #define Config_getString(val)  getString(__FILE__,__LINE__,val)

    50 #define Config_getInt(val)     getInt(__FILE__,__LINE__,val)

    51 #define Config_getList(val)    getList(__FILE__,__LINE__,val)

    52 #define Config_getEnum(val)    getEnum(__FILE__,__LINE__,val)

    53 #define Config_getBool(val)    getBool(__FILE__,__LINE__,val)

    54   

    55 void config_err(const char *fmt, ...)

    56 {

    57   va_list args;

    58   va_start(args, fmt);

    59   vfprintf(stderr, fmt, args);

    60   va_end(args); 

    61 }

    62 void config_warn(const char *fmt, ...)

    63 {

    64   va_list args;

    65   va_start(args, fmt);

    66   vfprintf(stderr, fmt, args);

    67   va_end(args);

    68 }

    69 

    70 static QCString configStringRecode(

    71     const QCString &str,

    72     const char *fromEncoding,

    73     const char *toEncoding);

    74 

    75 #define MAX_INCLUDE_DEPTH 10

    76 #define YY_NEVER_INTERACTIVE 1

    77 

    78 /* -----------------------------------------------------------------

    79  */

    80 QCString ConfigOption::convertToComment(const QCString &s)

    81 {

    82   QCString result;

    83   if (s.isEmpty()) return result;

    84   else

    85   {

    86     QCString tmp=s.stripWhiteSpace();

    87     char *p=tmp.data();

    88     char c;

    89     result+="#";

    90     if (*p && *p!='\n')

    91       result+=" ";

    92     while ((c=*p++))

    93     {

    94       if (c=='\n')

    95       {

    96         result+="\n#";

    97         if (*p && *p!='\n')

    98           result+=" ";

    99       }

   100       else result+=c;

   101     }

   102     result+='\n';

   103   }

   104   return result;

   105 }

   106 

   107 void ConfigOption::writeBoolValue(QTextStream &t,bool v)

   108 {

   109   t << " ";

   110   if (v) t << "YES"; else t << "NO";

   111 }

   112 

   113 void ConfigOption::writeIntValue(QTextStream &t,int i)

   114 {

   115   t << " " << i;

   116 }

   117 

   118 void ConfigOption::writeStringValue(QTextStream &t,QCString &s)

   119 {

   120   char c;

   121   bool needsEscaping=FALSE;

   122   // convert the string back to it original encoding

   123   QCString se = configStringRecode(s,"UTF-8",m_encoding);

   124   const char *p=se.data();

   125   if (p)

   126   {

   127     t << " ";

   128     while ((c=*p++)!=0 && !needsEscaping) 

   129       needsEscaping = (c==' ' || c=='\n' || c=='\t' || c=='"' || c=='#');

   130     if (needsEscaping)

   131     { 

   132       t << "\"";

   133       p=se.data();

   134       while (*p)

   135       {

   136 	if (*p==' ' && *(p+1)=='\0') break; // skip inserted space at the end

   137 	if (*p=='"') t << "\\"; // escape quotes

   138 	t << *p++;

   139       }

   140       t << "\"";

   141     }

   142     else

   143     {

   144       t << se;

   145     }

   146   }

   147 }

   148 

   149 void ConfigOption::writeStringList(QTextStream &t,QStrList &l)

   150 {

   151   const char *p = l.first();

   152   bool first=TRUE;

   153   while (p)

   154   {

   155     QCString s=p;

   156     if (!first)

   157       t << "                        ";

   158     first=FALSE;

   159     writeStringValue(t,s);

   160     p = l.next();

   161     if (p) t << " \\" << endl;

   162   }

   163 }

   164 

   165 /* -----------------------------------------------------------------

   166  */

   167 

   168 Config *Config::m_instance = 0;

   169 

   170 void ConfigInt::convertStrToVal() 

   171 {

   172   if (!m_valueString.isEmpty())

   173   {

   174     bool ok;

   175     int val = m_valueString.toInt(&ok);

   176     if (!ok || val<m_minVal || val>m_maxVal)

   177     {

   178       config_warn("Warning: argument `%s' for option %s is not a valid number in the range [%d..%d]!\n"

   179                 "Using the default: %d!\n",m_valueString.data(),m_name.data(),m_minVal,m_maxVal,m_value);

   180     }

   181     m_value=val;

   182   }

   183 }

   184 

   185 void ConfigBool::convertStrToVal()

   186 {

   187   QCString val = m_valueString.stripWhiteSpace().lower();

   188   if (!val.isEmpty())

   189   {

   190     if (val=="yes" || val=="true" || val=="1" || val=="all") 

   191     {

   192       m_value=TRUE;

   193     }

   194     else if (val=="no" || val=="false" || val=="0" || val=="none")

   195     {

   196       m_value=FALSE;

   197     }

   198     else

   199     {

   200       config_warn("Warning: argument `%s' for option %s is not a valid boolean value\n"

   201                 "Using the default: %s!\n",m_valueString.data(),m_name.data(),m_value?"YES":"NO");

   202     }

   203   }

   204 }

   205 

   206 QCString &Config::getString(const char *fileName,int num,const char *name) const

   207 {

   208   ConfigOption *opt = m_dict->find(name);

   209   if (opt==0) 

   210   {

   211     config_err("%s<%d>: Internal error: Requested unknown option %s!\n",fileName,num,name);

   212     exit(1);

   213   }

   214   else if (opt->kind()!=ConfigOption::O_String)

   215   {

   216     config_err("%s<%d>: Internal error: Requested option %s not of string type!\n",fileName,num,name);

   217     exit(1);

   218   }

   219   return *((ConfigString *)opt)->valueRef();

   220 }

   221 

   222 QStrList &Config::getList(const char *fileName,int num,const char *name) const

   223 {

   224   ConfigOption *opt = m_dict->find(name);

   225   if (opt==0) 

   226   {

   227     config_err("%s<%d>: Internal error: Requested unknown option %s!\n",fileName,num,name);

   228     exit(1);

   229   }

   230   else if (opt->kind()!=ConfigOption::O_List)

   231   {

   232     config_err("%d<%d>: Internal error: Requested option %s not of list type!\n",fileName,num,name);

   233     exit(1);

   234   }

   235   return *((ConfigList *)opt)->valueRef();

   236 }

   237 

   238 QCString &Config::getEnum(const char *fileName,int num,const char *name) const

   239 {

   240   ConfigOption *opt = m_dict->find(name);

   241   if (opt==0) 

   242   {

   243     config_err("%s<%d>: Internal error: Requested unknown option %s!\n",fileName,num,name);

   244     exit(1);

   245   }

   246   else if (opt->kind()!=ConfigOption::O_Enum)

   247   {

   248     config_err("%s<%d>: Internal error: Requested option %s not of enum type!\n",fileName,num,name);

   249     exit(1);

   250   }

   251   return *((ConfigEnum *)opt)->valueRef();

   252 }

   253 

   254 int &Config::getInt(const char *fileName,int num,const char *name) const

   255 {

   256   ConfigOption *opt = m_dict->find(name);

   257   if (opt==0) 

   258   {

   259     config_err("%s<%d>: Internal error: Requested unknown option %s!\n",fileName,num,name);

   260     exit(1);

   261   }

   262   else if (opt->kind()!=ConfigOption::O_Int)

   263   {

   264     config_err("%s<%d>: Internal error: Requested option %s not of integer type!\n",fileName,num,name);

   265     exit(1);

   266   }

   267   return *((ConfigInt *)opt)->valueRef();

   268 }

   269 

   270 bool &Config::getBool(const char *fileName,int num,const char *name) const

   271 {

   272   ConfigOption *opt = m_dict->find(name);

   273   if (opt==0) 

   274   {

   275     config_err("%s<%d>: Internal error: Requested unknown option %s!\n",fileName,num,name);

   276     exit(1);

   277   }

   278   else if (opt->kind()!=ConfigOption::O_Bool)

   279   {

   280     config_err("%s<%d>: Internal error: Requested option %s not of integer type!\n",fileName,num,name);

   281     exit(1);

   282   }

   283   return *((ConfigBool *)opt)->valueRef();

   284 }

   285 

   286 /* -----------------------------------------------------------------

   287  */

   288 

   289 void ConfigInt::writeXML(QTextStream& t)

   290 {

   291   t << "    <option type='int' "

   292        "id='" << convertToXML(name()) << "' "

   293        "docs='\n" << convertToXML(docs()) << "' "

   294        "minval='" << m_minVal << "' "

   295        "maxval='" << m_maxVal << "' "

   296        "defval='" << m_defValue << "'";

   297   if (!m_dependency.isEmpty()) t << " depends='" << m_dependency << "'";

   298   t << "/>" << endl;

   299 }

   300 

   301 void ConfigBool::writeXML(QTextStream& t)

   302 {

   303   t << "    <option type='bool' "

   304        "id='" << convertToXML(name()) << "' "

   305        "docs='\n" << convertToXML(docs()) << "' "

   306        "defval='" << m_defValue << "'";

   307   if (!m_dependency.isEmpty()) t << " depends='" << m_dependency << "'";

   308   t << "/>" << endl;

   309 }

   310 

   311 void ConfigString::writeXML(QTextStream& t)

   312 {

   313   QString format;

   314   switch (m_widgetType)

   315   {

   316     case String: format="string"; break;

   317     case File:   format="file";   break;

   318     case Dir:    format="dir";    break;

   319   }

   320   t << "    <option type='string' "

   321        "id='" << convertToXML(name()) << "' "

   322        "format='" << format << "' "

   323        "docs='\n" << convertToXML(docs()) << "' "

   324        "defval='" << convertToXML(m_defValue) << "'";

   325   if (!m_dependency.isEmpty()) t << " depends='" << m_dependency << "'";

   326   t << "/>" << endl;

   327 }

   328 

   329 void ConfigEnum::writeXML(QTextStream &t)

   330 {

   331   t << "    <option type='enum' "

   332        "id='" << convertToXML(name()) << "' "

   333        "defval='" << convertToXML(m_defValue) << "' "

   334        "docs='\n" << convertToXML(docs()) << "'";

   335   if (!m_dependency.isEmpty()) t << " depends='" << m_dependency << "'";

   336   t << ">" << endl;

   337 

   338   char *enumVal = m_valueRange.first();

   339   while (enumVal)

   340   {

   341     t << "      <value name='" << convertToXML(enumVal) << "'/>" << endl;

   342     enumVal = m_valueRange.next();

   343   }

   344 

   345   t << "    </option>" << endl;

   346 }

   347 

   348 void ConfigList::writeXML(QTextStream &t)

   349 {

   350   QString format;

   351   switch (m_widgetType)

   352   {

   353     case String:     format="string";  break;

   354     case File:       format="file";    break;

   355     case Dir:        format="dir";     break;

   356     case FileAndDir: format="filedir"; break;

   357   }

   358   t << "    <option type='list' "

   359        "id='" << convertToXML(name()) << "' "

   360        "format='" << format << "' "

   361        "docs='\n" << convertToXML(docs()) << "'";

   362   if (!m_dependency.isEmpty()) t << " depends='" << m_dependency << "'";

   363   t << ">" << endl;

   364   char *enumVal = m_value.first();

   365   while (enumVal)

   366   {

   367     t << "      <value name='" << convertToXML(enumVal) << "'/>" << endl;

   368     enumVal = m_value.next();

   369   }

   370 

   371   t << "    </option>" << endl;

   372 }

   373 

   374 void ConfigObsolete::writeXML(QTextStream &t)

   375 {

   376   t << "    <option type='obsolete' "

   377        "id='" << convertToXML(name()) << "'/>" << endl;

   378 }

   379 

   380 

   381 /* -----------------------------------------------------------------

   382  *

   383  *	static variables

   384  */

   385 

   386 struct ConfigFileState

   387 {

   388   int lineNr;

   389   FILE *filePtr;

   390   YY_BUFFER_STATE oldState;

   391   YY_BUFFER_STATE newState;

   392   QCString fileName;

   393 };  

   394 

   395 static const char       *inputString;

   396 static int	         inputPosition;

   397 static int               yyLineNr;

   398 static QCString          yyFileName;

   399 static QCString          tmpString;

   400 static QCString         *s=0;

   401 static bool             *b=0;

   402 static QStrList         *l=0;

   403 static int               lastState;

   404 static QCString          elemStr;

   405 static QCString          includeName;

   406 static QStrList          includePathList;

   407 static QStack<ConfigFileState> includeStack;  

   408 static int               includeDepth;

   409 

   410 static QCString     tabSizeString;

   411 static QCString     maxInitLinesString;

   412 static QCString     colsInAlphaIndexString;

   413 static QCString     enumValuesPerLineString;

   414 static QCString     treeViewWidthString;

   415 static QCString     maxDotGraphWidthString;

   416 static QCString     maxDotGraphHeightString;

   417 static QCString     encoding;

   418 

   419 static Config      *config;

   420 

   421 /* -----------------------------------------------------------------

   422  */

   423 #undef	YY_INPUT

   424 #define	YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);

   425 

   426 static int yyread(char *buf,int max_size)

   427 {

   428     // no file included

   429     if (includeStack.isEmpty()) 

   430     {

   431         int c=0;

   432 	if (inputString==0) return c;

   433 	while( c < max_size && inputString[inputPosition] )

   434 	{

   435 	      *buf = inputString[inputPosition++] ;

   436 	      c++; buf++;

   437   	}

   438 	return c;

   439     } 

   440     else 

   441     {

   442         //assert(includeStack.current()->newState==YY_CURRENT_BUFFER);

   443 	return (int)fread(buf,1,max_size,includeStack.current()->filePtr);

   444     }

   445 }

   446 

   447 

   448 static QCString configStringRecode(

   449     const QCString &str,

   450     const char *fromEncoding,

   451     const char *toEncoding)

   452 {

   453   QCString inputEncoding = fromEncoding;

   454   QCString outputEncoding = toEncoding;

   455   if (inputEncoding.isEmpty() || outputEncoding.isEmpty() || inputEncoding==outputEncoding) return str;

   456   int inputSize=str.length();

   457   size_t outputSize=inputSize*4+1;

   458   QCString output(outputSize);

   459   void *cd = portable_iconv_open(outputEncoding,inputEncoding);

   460   if (cd==(void *)(-1)) 

   461   {

   462     fprintf(stderr,"Error: unsupported character conversion: '%s'->'%s'\n",

   463         inputEncoding.data(),outputEncoding.data());

   464     exit(1);

   465   }

   466   size_t iLeft=inputSize;

   467   size_t oLeft=outputSize;

   468   const char *inputPtr  = str.data();

   469   char       *outputPtr = output.data();

   470   if (!portable_iconv(cd, &inputPtr, &iLeft, &outputPtr, &oLeft))

   471   {

   472     outputSize-=oLeft;

   473     output.resize(outputSize+1);

   474     output.at(outputSize)='\0';

   475     //printf("iconv: input size=%d output size=%d\n[%s]\n",size,newSize,srcBuf.data());

   476   }

   477   else

   478   {

   479     fprintf(stderr,"Error: failed to translate characters from %s to %s: %s\n",

   480         inputEncoding.data(),outputEncoding.data(),strerror(errno));

   481     exit(1);

   482   }

   483   portable_iconv_close(cd);

   484   return output;

   485 }

   486 

   487 static void checkEncoding()

   488 {

   489   ConfigString *option = (ConfigString*)config->get("DOXYFILE_ENCODING");

   490   encoding = *option->valueRef();

   491 }

   492 

   493 static FILE *tryPath(const char *path,const char *fileName)

   494 {

   495   QCString absName=(path ? (QCString)path+"/"+fileName : (QCString)fileName);

   496   QFileInfo fi(absName);

   497   if (fi.exists() && fi.isFile())

   498   {

   499     FILE *f=fopen(absName,"r");

   500     if (!f) config_err("Error: could not open file %s for reading\n",absName.data());

   501     return f;

   502   }

   503   return 0;

   504 }

   505 

   506 static void substEnvVarsInStrList(QStrList &sl);

   507 static void substEnvVarsInString(QCString &s);

   508 

   509 static bool isAbsolute(const char * fileName)

   510 {

   511 # ifdef _WIN32

   512   if (isalpha (fileName [0]) && fileName[1] == ':')

   513     fileName += 2;

   514 # endif

   515   char const fst = fileName [0];

   516   if (fst == '/')  {

   517     return true;

   518   }

   519 # ifdef _WIN32

   520   if (fst == '\\')

   521     return true;

   522 # endif

   523   return false;

   524 }

   525 

   526 static FILE *findFile(const char *fileName)

   527 {

   528   if(isAbsolute(fileName))

   529     return tryPath(NULL, fileName);

   530   substEnvVarsInStrList(includePathList);

   531   char *s=includePathList.first();

   532   while (s) // try each of the include paths

   533   {

   534     FILE *f = tryPath(s,fileName);

   535     if (f) return f;

   536     s=includePathList.next();

   537   } 

   538   // try cwd if includePathList fails

   539   return tryPath(".",fileName);

   540 }

   541 

   542 static void readIncludeFile(const char *incName)

   543 {

   544   if (includeDepth==MAX_INCLUDE_DEPTH) {

   545     config_err("Error: maximum include depth (%d) reached, %s is not included. Aborting...\n",

   546 	MAX_INCLUDE_DEPTH,incName);

   547     exit(1);

   548   } 

   549 

   550   QCString inc = incName;

   551   substEnvVarsInString(inc);

   552   inc = inc.stripWhiteSpace();

   553   uint incLen = inc.length();

   554   if (inc.at(0)=='"' && inc.at(incLen-1)=='"') // strip quotes

   555   {

   556     inc=inc.mid(1,incLen-2);

   557   }

   558 

   559   FILE *f;

   560 

   561   if ((f=findFile(inc))) // see if the include file can be found

   562   {

   563     // For debugging

   564 #if SHOW_INCLUDES

   565     for (i=0;i<includeStack.count();i++) msg("  ");

   566     msg("@INCLUDE = %s: parsing...\n",inc.data());

   567 #endif

   568 

   569     // store the state of the old file 

   570     ConfigFileState *fs=new ConfigFileState;

   571     fs->oldState=YY_CURRENT_BUFFER;

   572     fs->lineNr=yyLineNr;

   573     fs->fileName=yyFileName;

   574     fs->filePtr=f;

   575     // push the state on the stack

   576     includeStack.push(fs);

   577     // set the scanner to the include file

   578     yy_switch_to_buffer(yy_create_buffer(f, YY_BUF_SIZE));

   579     fs->newState=YY_CURRENT_BUFFER;

   580     yyFileName=inc;

   581     includeDepth++;

   582   } 

   583   else

   584   {

   585     config_err("Error: @INCLUDE = %s: not found!\n",inc.data());

   586     exit(1);

   587   }

   588 }

   589 

   590 

   591 %}

   592 

   593 %option nounput

   594 %option noyywrap

   595 

   596 %x      Start

   597 %x	SkipComment

   598 %x      SkipInvalid

   599 %x      GetString

   600 %x      GetBool

   601 %x      GetStrList

   602 %x      GetQuotedString

   603 %x      GetEnvVar

   604 %x      Include

   605 

   606 %%

   607 

   608 <*>\0x0d

   609 <Start,GetString,GetStrList,GetBool,SkipInvalid>"#"	 { BEGIN(SkipComment); }

   610 <Start>[a-z_A-Z][a-z_A-Z0-9]*[ \t]*"="	 { QCString cmd=yytext;

   611                                            cmd=cmd.left(cmd.length()-1).stripWhiteSpace(); 

   612 					   ConfigOption *option = config->get(cmd);

   613 					   if (option==0) // oops not known

   614 					   {

   615 					     config_err("Warning: ignoring unsupported tag `%s' at line %d, file %s\n",

   616 						 yytext,yyLineNr,yyFileName.data()); 

   617 					     BEGIN(SkipInvalid);

   618 					   }

   619 					   else // known tag

   620 					   {

   621 					     option->setEncoding(encoding);

   622 					     switch(option->kind())

   623 					     {

   624 					       case ConfigOption::O_Info:

   625 						 // shouldn't get here!

   626 					         BEGIN(SkipInvalid);

   627 						 break;

   628 					       case ConfigOption::O_List:

   629 						 l = ((ConfigList *)option)->valueRef();

   630 					         l->clear();

   631 						 elemStr="";

   632 					         BEGIN(GetStrList);

   633 					         break;

   634 					       case ConfigOption::O_Enum:

   635 						 s = ((ConfigEnum *)option)->valueRef();

   636 					         s->resize(0);

   637 					         BEGIN(GetString);

   638 					         break;

   639 					       case ConfigOption::O_String:

   640 						 s = ((ConfigString *)option)->valueRef();

   641 					         s->resize(0);

   642 					         BEGIN(GetString);

   643 					         break;

   644 					       case ConfigOption::O_Int:

   645 						 s = ((ConfigInt *)option)->valueStringRef();

   646 					         s->resize(0);

   647 					         BEGIN(GetString);

   648 					         break;

   649 					       case ConfigOption::O_Bool:

   650 						 s = ((ConfigBool *)option)->valueStringRef();

   651 					         s->resize(0);

   652 					         BEGIN(GetString);

   653 						 break;

   654 					       case ConfigOption::O_Obsolete:

   655 					         config_err("Warning: Tag `%s' at line %d of file %s has become obsolete.\n"

   656 						            "To avoid this warning please update your configuration "

   657 							    "file using \"doxygen -u\"\n", cmd.data(),yyLineNr,yyFileName.data()); 

   658 					         BEGIN(SkipInvalid);

   659 						 break;

   660 					     }

   661 					   }

   662 					}

   663 <Start>[a-z_A-Z][a-z_A-Z0-9]*[ \t]*"+="	{ QCString cmd=yytext;

   664                                           cmd=cmd.left(cmd.length()-2).stripWhiteSpace(); 

   665 					  ConfigOption *option = config->get(cmd);

   666 					  if (option==0) // oops not known

   667 					  {

   668 					    config_err("Warning: ignoring unsupported tag `%s' at line %d, file %s\n",

   669 						yytext,yyLineNr,yyFileName.data()); 

   670 					    BEGIN(SkipInvalid);

   671 					  }

   672 					  else // known tag

   673 					  {

   674 					    switch(option->kind())

   675 					    {

   676 					      case ConfigOption::O_Info:

   677 					        // shouldn't get here!

   678 					        BEGIN(SkipInvalid);

   679 						break;

   680 					      case ConfigOption::O_List:

   681 					        l = ((ConfigList *)option)->valueRef();

   682 						elemStr="";

   683 					        BEGIN(GetStrList);

   684 					        break;

   685 					      case ConfigOption::O_Enum:

   686 					      case ConfigOption::O_String:

   687 					      case ConfigOption::O_Int:

   688 					      case ConfigOption::O_Bool:

   689 					        config_err("Warning: operator += not supported for `%s'. Ignoring line at line %d, file %s\n",

   690 						    yytext,yyLineNr,yyFileName.data()); 

   691 					        BEGIN(SkipInvalid);

   692 						break;

   693 					       case ConfigOption::O_Obsolete:

   694 					         config_err("Warning: Tag `%s' at line %d of file %s has become obsolete.\n"

   695 						            "To avoid this warning please update your configuration "

   696 							    "file using \"doxygen -u\"\n", cmd.data(),yyLineNr,yyFileName.data()); 

   697 					         BEGIN(SkipInvalid);

   698 						 break;

   699 					     }

   700 					   }

   701 					}

   702 <Start>"@INCLUDE_PATH"[ \t]*"=" 	{ BEGIN(GetStrList); l=&includePathList; l->clear(); elemStr=""; }

   703   /* include a config file */

   704 <Start>"@INCLUDE"[ \t]*"="     		{ BEGIN(Include);}

   705 <Include>([^ \"\t\r\n]+)|("\""[^\n\"]+"\"") { 

   706   					  readIncludeFile(configStringRecode(yytext,encoding,"UTF-8")); 

   707   					  BEGIN(Start);

   708 					}

   709 <<EOF>>					{

   710                                           //printf("End of include file\n");

   711 					  //printf("Include stack depth=%d\n",g_includeStack.count());

   712                                           if (includeStack.isEmpty())

   713 					  {

   714 					    //printf("Terminating scanner!\n");

   715 					    yyterminate();

   716 					  }

   717 					  else

   718 					  {

   719 					    ConfigFileState *fs=includeStack.pop();

   720 					    fclose(fs->filePtr);

   721 					    YY_BUFFER_STATE oldBuf = YY_CURRENT_BUFFER;

   722 					    yy_switch_to_buffer( fs->oldState );

   723 					    yy_delete_buffer( oldBuf );

   724 					    yyLineNr=fs->lineNr;

   725 					    yyFileName=fs->fileName;

   726 					    delete fs; fs=0;

   727                                             includeDepth--;

   728 					  }

   729   					}

   730 

   731 <Start>[a-z_A-Z0-9]+			{ config_err("Warning: ignoring unknown tag `%s' at line %d, file %s\n",yytext,yyLineNr,yyFileName.data()); }

   732 <GetString,GetBool,SkipInvalid>\n	{ yyLineNr++; BEGIN(Start); }

   733 <GetStrList>\n				{ 

   734   					  yyLineNr++; 

   735 					  if (!elemStr.isEmpty())

   736 					  {

   737 					    //printf("elemStr1=`%s'\n",elemStr.data());

   738 					    l->append(elemStr);

   739 					  }

   740 					  BEGIN(Start); 

   741 					}

   742 <GetStrList>[ \t]+			{

   743   				          if (!elemStr.isEmpty())

   744 					  {

   745 					    //printf("elemStr2=`%s'\n",elemStr.data());

   746   					    l->append(elemStr);

   747 					  }

   748 					  elemStr.resize(0);

   749   					}

   750 <GetString>[^ \"\t\r\n]+		{ (*s)+=configStringRecode(yytext,encoding,"UTF-8"); 

   751                                           checkEncoding();

   752                                         }

   753 <GetString,GetStrList,SkipInvalid>"\""	{ lastState=YY_START;

   754   					  BEGIN(GetQuotedString); 

   755                                           tmpString.resize(0); 

   756 					}

   757 <GetQuotedString>"\""|"\n" 		{ 

   758                                           // we add a bogus space to signal that the string was quoted. This space will be stripped later on.

   759                                           tmpString+=" ";

   760   					  //printf("Quoted String = `%s'\n",tmpString.data());

   761   					  if (lastState==GetString)

   762 					  {

   763 					    (*s)+=configStringRecode(tmpString,encoding,"UTF-8");

   764                                             checkEncoding();

   765 					  }

   766 					  else

   767 					  {

   768 					    elemStr+=configStringRecode(tmpString,encoding,"UTF-8");

   769 					  }

   770 					  if (*yytext=='\n')

   771 					  {

   772 					    config_err("Warning: Missing end quote (\") on line %d, file %s\n",yyLineNr,yyFileName.data());

   773 					    yyLineNr++;

   774 					  }

   775 					  BEGIN(lastState);

   776   					}

   777 <GetQuotedString>"\\\""			{

   778   					  tmpString+='"';

   779   					}

   780 <GetQuotedString>.			{ tmpString+=*yytext; }

   781 <GetBool>[a-zA-Z]+			{ 

   782   					  QCString bs=yytext; 

   783   					  bs=bs.upper();

   784   					  if (bs=="YES" || bs=="1")

   785 					    *b=TRUE;

   786 					  else if (bs=="NO" || bs=="0")

   787 					    *b=FALSE;

   788 					  else 

   789 					  {

   790 					    *b=FALSE; 

   791 					    config_warn("Warning: Invalid value `%s' for "

   792 						 "boolean tag in line %d, file %s; use YES or NO\n",

   793 						 bs.data(),yyLineNr,yyFileName.data());

   794 					  }

   795 					}

   796 <GetStrList>[^ \#\"\t\r\n]+		{

   797   					  elemStr+=configStringRecode(yytext,encoding,"UTF-8");

   798   					}

   799 <SkipComment>\n				{ yyLineNr++; BEGIN(Start); }

   800 <SkipComment>\\[ \r\t]*\n		{ yyLineNr++; BEGIN(Start); }

   801 <*>\\[ \r\t]*\n				{ yyLineNr++; }

   802 <*>.					

   803 <*>\n					{ yyLineNr++ ; }

   804 

   805 %%

   806 

   807 /*@ ----------------------------------------------------------------------------

   808  */

   809 

   810 void Config::writeTemplate(QTextStream &t,bool sl,bool upd)

   811 {

   812   t << "# Doxyfile " << versionString << endl << endl;

   813   if (!sl)

   814   {

   815     t << "# This file describes the settings to be used by the documentation system\n";

   816     t << "# doxygen (www.doxygen.org) for a project\n";

   817     t << "#\n";

   818     t << "# All text after a hash (#) is considered a comment and will be ignored\n";

   819     t << "# The format is:\n";

   820     t << "#       TAG = value [value, ...]\n";

   821     t << "# For lists items can also be appended using:\n";

   822     t << "#       TAG += value [value, ...]\n";

   823     t << "# Values that contain spaces should be placed between quotes (\" \")\n";

   824   }

   825   ConfigOption *option = m_options->first();

   826   while (option)

   827   {

   828     option->writeTemplate(t,sl,upd);

   829     option = m_options->next();

   830   }

   831 }

   832 

   833 void Config::writeXML(QTextStream &t)

   834 {

   835   t << "<doxygenconfig>" << endl;

   836   bool first=TRUE;

   837   ConfigOption *option = m_options->first();

   838   while (option)

   839   {

   840     if (option->kind()==ConfigOption::O_Info)

   841     {

   842       if (!first) t << "  </group>" << endl;

   843       t << "  <group name='" << option->name() << "' "

   844 	   "docs='"        << option->docs() << "'>" << endl;

   845       first=FALSE;

   846     }

   847     else

   848     {

   849       option->writeXML(t);

   850     }

   851     option = m_options->next();

   852   }

   853   option = m_obsolete->first();

   854   while (option)

   855   {

   856     option->writeXML(t);

   857     option = m_obsolete->next();

   858   }

   859   if (!first) t << "  </group>" << endl;

   860   t << "</doxygenconfig>" << endl;

   861 }

   862 

   863 void Config::convertStrToVal()

   864 {

   865   ConfigOption *option = m_options->first();

   866   while (option)

   867   {

   868     option->convertStrToVal();

   869     option = m_options->next();

   870   }

   871 }

   872 

   873 static void substEnvVarsInString(QCString &s)

   874 {

   875   static QRegExp re("\\$\\([a-z_A-Z0-9]+\\)");

   876   if (s.isEmpty()) return;

   877   int p=0;

   878   int i,l;

   879   //printf("substEnvVarInString(%s) start\n",s.data());

   880   while ((i=re.match(s,p,&l))!=-1)

   881   {

   882     //printf("Found environment var s.mid(%d,%d)=`%s'\n",i+2,l-3,s.mid(i+2,l-3).data());

   883     QCString env=portable_getenv(s.mid(i+2,l-3));

   884     substEnvVarsInString(env); // recursively expand variables if needed.

   885     s = s.left(i)+env+s.right(s.length()-i-l);

   886     p=i+env.length(); // next time start at the end of the expanded string

   887   }

   888   s=s.stripWhiteSpace(); // to strip the bogus space that was added when an argument

   889                          // has quotes

   890   //printf("substEnvVarInString(%s) end\n",s.data());

   891 }

   892 

   893 static void substEnvVarsInStrList(QStrList &sl)

   894 {

   895   char *s = sl.first();

   896   while (s)

   897   {

   898     QCString result(s);

   899     // an argument with quotes will have an extra space at the end, so wasQuoted will be TRUE.

   900     bool wasQuoted = (result.find(' ')!=-1) || (result.find('\t')!=-1);

   901     // here we strip the quote again

   902     substEnvVarsInString(result);

   903 

   904     //printf("Result %s was quoted=%d\n",result.data(),wasQuoted);

   905 

   906     if (!wasQuoted) /* as a result of the expansion, a single string

   907 		       may have expanded into a list, which we'll

   908 		       add to sl. If the orginal string already 

   909 		       contained multiple elements no further 

   910 		       splitting is done to allow quoted items with spaces! */

   911     {

   912       int l=result.length();

   913       int i,p=0;

   914       // skip spaces

   915       // search for a "word"

   916       for (i=0;i<l;i++)

   917       {

   918 	char c=0;

   919 	// skip until start of new word

   920 	while (i<l && ((c=result.at(i))==' ' || c=='\t')) i++; 

   921 	p=i; // p marks the start index of the word

   922 	// skip until end of a word

   923 	while (i<l && ((c=result.at(i))!=' ' && c!='\t' && c!='"')) i++;

   924 	if (i<l) // not at the end of the string

   925 	{

   926 	  if (c=='"') // word within quotes

   927 	  {

   928 	    p=i+1;

   929 	    for (i++;i<l;i++)

   930 	    {

   931 	      c=result.at(i);

   932 	      if (c=='"') // end quote

   933 	      {

   934 		// replace the string in the list and go to the next item.

   935 		sl.insert(sl.at(),result.mid(p,i-p)); // insert new item before current item.

   936 		sl.next();                 // current item is now the old item

   937 		p=i+1;

   938 		break; 

   939 	      }

   940 	      else if (c=='\\') // skip escaped stuff

   941 	      {

   942 		i++;

   943 	      }

   944 	    }

   945 	  }

   946 	  else if (c==' ' || c=='\t') // separator

   947 	  {

   948 	    // replace the string in the list and go to the next item.

   949 	    sl.insert(sl.at(),result.mid(p,i-p)); // insert new item before current item.

   950 	    sl.next();                 // current item is now the old item

   951 	    p=i+1;

   952 	  }

   953 	}

   954       }

   955       if (p!=l) // add the leftover as a string

   956       {

   957 	// replace the string in the list and go to the next item.

   958 	sl.insert(sl.at(),result.right(l-p)); // insert new item before current item.

   959 	sl.next();                 // current item is now the old item

   960       }

   961     }

   962     else // just goto the next element in the list

   963     {

   964       sl.insert(sl.at(),result);

   965       sl.next();

   966     }

   967     // remove the old unexpanded string from the list

   968     int i=sl.at();

   969     sl.remove(); // current item index changes if the last element is removed.

   970     if (sl.at()==i)     // not last item

   971 	s = sl.current();

   972     else                // just removed last item

   973 	s = 0;

   974   }

   975 }

   976 

   977 void ConfigString::substEnvVars()

   978 {

   979   substEnvVarsInString(m_value);

   980 }

   981 

   982 void ConfigList::substEnvVars()

   983 {

   984   substEnvVarsInStrList(m_value);

   985 }

   986 

   987 void ConfigBool::substEnvVars()

   988 {

   989   substEnvVarsInString(m_valueString);

   990 }

   991 

   992 void ConfigInt::substEnvVars()

   993 {

   994   substEnvVarsInString(m_valueString);

   995 }

   996 

   997 void ConfigEnum::substEnvVars()

   998 {

   999   substEnvVarsInString(m_value);

  1000 }

  1001 

  1002 void Config::substituteEnvironmentVars()

  1003 {

  1004   ConfigOption *option = m_options->first();

  1005   while (option)

  1006   {

  1007     option->substEnvVars();

  1008     option = m_options->next();

  1009   }

  1010 }

  1011 

  1012 static void cleanUpPaths(QStrList &str)

  1013 {

  1014   char *sfp = str.first();

  1015   while (sfp)

  1016   {

  1017     register char *p = sfp;

  1018     if (p)

  1019     {

  1020       char c;

  1021       while ((c=*p))

  1022       {

  1023 	if (c=='\\') *p='/';

  1024 	p++;

  1025       }

  1026     }

  1027     QCString path = sfp;

  1028     if ((path.at(0)!='/' && (path.length()<=2 || path.at(1)!=':')) ||

  1029 	path.at(path.length()-1)!='/'

  1030        )

  1031     {

  1032       QFileInfo fi(path);

  1033       if (fi.exists() && fi.isDir())

  1034       {

  1035 	int i = str.at();

  1036 	str.remove();

  1037 	if (str.at()==i) // did not remove last item

  1038 	  str.insert(i,fi.absFilePath()+"/");

  1039 	else

  1040 	  str.append(fi.absFilePath()+"/");

  1041       }

  1042     }

  1043     sfp = str.next();

  1044   }

  1045 }

  1046 

  1047 void Config::check()

  1048 {

  1049   //if (!projectName.isEmpty())

  1050   //{

  1051   //  projectName[0]=toupper(projectName[0]);

  1052   //}

  1053 

  1054   QCString &warnFormat = Config_getString("WARN_FORMAT");

  1055   if (warnFormat.stripWhiteSpace().isEmpty())

  1056   {

  1057     warnFormat="$file:$line $text";

  1058   }

  1059   else

  1060   {

  1061     if (warnFormat.find("$file")==-1)

  1062     {

  1063       config_err("Warning: warning format does not contain a $file tag!\n");

  1064     }

  1065     if (warnFormat.find("$line")==-1)

  1066     {

  1067       config_err("Warning: warning format does not contain a $line tag!\n");

  1068     }

  1069     if (warnFormat.find("$text")==-1)

  1070     {

  1071       config_err("Warning: warning format foes not contain a $text tag!\n");

  1072     }

  1073   }

  1074 

  1075   QCString &manExtension = Config_getString("MAN_EXTENSION");

  1076   

  1077   // set default man page extension if non is given by the user

  1078   if (manExtension.isEmpty())

  1079   {

  1080     manExtension=".3";

  1081   }

  1082   

  1083   QCString &paperType = Config_getEnum("PAPER_TYPE");

  1084   paperType=paperType.lower().stripWhiteSpace(); 

  1085   if (paperType.isEmpty())

  1086   {

  1087     paperType = "a4wide";

  1088   }

  1089   if (paperType!="a4" && paperType!="a4wide" && paperType!="letter" && 

  1090       paperType!="legal" && paperType!="executive")

  1091   {

  1092     config_err("Error: Unknown page type specified");

  1093   }

  1094   

  1095   QCString &outputLanguage=Config_getEnum("OUTPUT_LANGUAGE");

  1096   outputLanguage=outputLanguage.stripWhiteSpace();

  1097   if (outputLanguage.isEmpty())

  1098   {

  1099     outputLanguage = "English";

  1100   }

  1101 

  1102   QCString &htmlFileExtension=Config_getString("HTML_FILE_EXTENSION");

  1103   htmlFileExtension=htmlFileExtension.stripWhiteSpace();

  1104   if (htmlFileExtension.isEmpty())

  1105   {

  1106     htmlFileExtension = ".html";

  1107   }

  1108   

  1109   // expand the relative stripFromPath values

  1110   QStrList &stripFromPath = Config_getList("STRIP_FROM_PATH");

  1111   char *sfp = stripFromPath.first();

  1112   if (sfp==0) // by default use the current path

  1113   {

  1114     stripFromPath.append(QDir::currentDirPath()+"/");

  1115   }

  1116   else

  1117   {

  1118     cleanUpPaths(stripFromPath);

  1119   }

  1120 

  1121   // expand the relative stripFromPath values

  1122   QStrList &stripFromIncPath = Config_getList("STRIP_FROM_INC_PATH");

  1123   cleanUpPaths(stripFromIncPath);

  1124   

  1125   // Test to see if HTML header is valid

  1126   QCString &headerFile = Config_getString("HTML_HEADER");

  1127   if (!headerFile.isEmpty())

  1128   {

  1129     QFileInfo fi(headerFile);

  1130     if (!fi.exists())

  1131     {

  1132       config_err("Error: tag HTML_HEADER: header file `%s' "

  1133 	  "does not exist\n",headerFile.data());

  1134       exit(1);