/******************************************************************************

 *

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

 *

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

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

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

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

 * See the GNU General Public License for more details.

 *

 */

%option never-interactive

%option prefix="configimplYY"

%{

/*

 *	includes

 */

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <ctype.h>

#include <stdarg.h>

#include <errno.h>

#include <qfileinfo.h>

#include <qdir.h>

#include <qtextstream.h>

#include <qregexp.h>

#include <qstack.h>

#include <qglobal.h>

#include "configimpl.h"

#include "version.h"

#include "portable.h"

#include "util.h"

#include "message.h"

#include "lang_cfg.h"

#include "configoptions.h"

#define YY_NO_INPUT 1

#define YY_NO_UNISTD_H 1

static const char *warning_str = "warning: ";

static const char *error_str = "error: ";

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

{

  va_list args;

  va_start(args, fmt);

  vfprintf(stderr, (QCString(error_str) + fmt).data(), args);

  va_end(args); 

}

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

{

  va_list args;

  va_start(args, fmt);

  vfprintf(stderr, (QCString(warning_str) + fmt).data(), args);

  va_end(args);

}

static QCString configStringRecode(

    const QCString &str,

    const char *fromEncoding,

    const char *toEncoding);

#define MAX_INCLUDE_DEPTH 10

#define YY_NEVER_INTERACTIVE 1

/* -----------------------------------------------------------------

 */

static QCString convertToComment(const QCString &s, const QCString &u)

{

  //printf("convertToComment(%s)=%s\n",s.data(),u.data());

  QCString result;

  if (!s.isEmpty())

  {

    QCString tmp=s.stripWhiteSpace();

    const char *p=tmp.data();

    char c;

    result+="#";

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

      result+=" ";

    while ((c=*p++))

    {

      if (c=='\n')

      {

        result+="\n#";

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

          result+=" ";

      }

      else result+=c;

    }

    result+='\n';

  }

  if (!u.isEmpty())

  {

    if (!result.isEmpty()) result+='\n';

    result+= u;

  }

  return result;

}

void ConfigOption::writeBoolValue(FTextStream &t,bool v)

{

  t << " ";

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

}

void ConfigOption::writeIntValue(FTextStream &t,int i)

{

  t << " " << i;

}

void ConfigOption::writeStringValue(FTextStream &t,QCString &s)

{

  char c;

  bool needsEscaping=FALSE;

  // convert the string back to it original encoding

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

  const char *p=se.data();

  if (p)

  {

    t << " ";

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

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

    if (needsEscaping)

    { 

      t << "\"";

      p=se.data();

      while (*p)

      {

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

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

	t << *p++;

      }

      t << "\"";

    }

    else

    {

      t << se;

    }

  }

}

void ConfigOption::writeStringList(FTextStream &t,QStrList &l)

{

  const char *p = l.first();

  bool first=TRUE;

  while (p)

  {

    QCString s=p;

    if (!first)

      t << "                        ";

    first=FALSE;

    writeStringValue(t,s);

    p = l.next();

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

  }

}

/* -----------------------------------------------------------------

 */

ConfigImpl *ConfigImpl::m_instance = 0;

void ConfigInt::convertStrToVal() 

{

  if (!m_valueString.isEmpty())

  {

    bool ok;

    int val = m_valueString.toInt(&ok;;

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

    {

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

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

    }

    else

    {

      m_value=val;

    }

  }

}

void ConfigBool::convertStrToVal()

{

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

  if (!val.isEmpty())

  {

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

    {

      m_value=TRUE;

    }

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

    {

      m_value=FALSE;

    }

    else

    {

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

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

    }

  }

}

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

{

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

  if (opt==0) 

  {

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

    exit(1);

  }

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

  {

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

    exit(1);

  }

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

}

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

{

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

  if (opt==0) 

  {

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

    exit(1);

  }

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

  {

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

    exit(1);

  }

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

}

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

{

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

  if (opt==0) 

  {

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

    exit(1);

  }

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

  {

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

    exit(1);

  }

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

}

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

{

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

  if (opt==0) 

  {

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

    exit(1);

  }

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

  {

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

    exit(1);

  }

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

}

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

{

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

  if (opt==0) 

  {

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

    exit(1);

  }

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

  {

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

    exit(1);

  }

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

}

/* ------------------------------------------ */

void ConfigInfo::writeTemplate(FTextStream &t, bool sl,bool)

{

  if (!sl)

  {

    t << "\n";

  }

  t << "#---------------------------------------------------------------------------\n";

  t << "# " << m_doc << endl;

  t << "#---------------------------------------------------------------------------\n";

}

void ConfigList::writeTemplate(FTextStream &t,bool sl,bool)

{

  if (!sl)

  {

    t << endl;

    t << convertToComment(m_doc, m_userComment);

    t << endl;

  }

  else if (!m_userComment.isEmpty())

  {

    t << convertToComment("", m_userComment);

  }

  t << m_name << m_spaces.left(MAX_OPTION_LENGTH-m_name.length()) << "=";

  writeStringList(t,m_value);

  t << "\n";

}

void ConfigEnum::writeTemplate(FTextStream &t,bool sl,bool)

{

  if (!sl)

  {

    t << endl;

    t << convertToComment(m_doc, m_userComment);

    t << endl;

  }

  else if (!m_userComment.isEmpty())

  {

    t << convertToComment("", m_userComment);

  }

  t << m_name << m_spaces.left(MAX_OPTION_LENGTH-m_name.length()) << "=";

  writeStringValue(t,m_value);

  t << "\n";

}

void ConfigString::writeTemplate(FTextStream &t,bool sl,bool)

{

  if (!sl)

  {

    t << endl;

    t << convertToComment(m_doc, m_userComment);

    t << endl;

  }

  else if (!m_userComment.isEmpty())

  {

    t << convertToComment("", m_userComment);

  }

  t << m_name << m_spaces.left(MAX_OPTION_LENGTH-m_name.length()) << "=";

  writeStringValue(t,m_value);

  t << "\n";

}

void ConfigInt::writeTemplate(FTextStream &t,bool sl,bool upd)

{

  if (!sl)

  {

    t << endl;

    t << convertToComment(m_doc, m_userComment);

    t << endl;

  }

  else if (!m_userComment.isEmpty())

  {

    t << convertToComment("", m_userComment);

  }

  t << m_name << m_spaces.left(MAX_OPTION_LENGTH-m_name.length()) << "=";

  if (upd && !m_valueString.isEmpty())

  {

    writeStringValue(t,m_valueString);

  }

  else

  {

    writeIntValue(t,m_value);

  }

  t << "\n";

}

void ConfigBool::writeTemplate(FTextStream &t,bool sl,bool upd)

{

  if (!sl)

  {

    t << endl;

    t << convertToComment(m_doc, m_userComment);

    t << endl;

  }

  else if (!m_userComment.isEmpty())

  {

    t << convertToComment("", m_userComment);

  }

  t << m_name << m_spaces.left(MAX_OPTION_LENGTH-m_name.length()) << "=";

  if (upd && !m_valueString.isEmpty())

  {

    writeStringValue(t,m_valueString);

  }

  else

  {

    writeBoolValue(t,m_value);

  }

  t << "\n";

}

void ConfigObsolete::writeTemplate(FTextStream &,bool,bool) {}

void ConfigDisabled::writeTemplate(FTextStream &,bool,bool) {}

/* -----------------------------------------------------------------

 *

 *	static variables

 */

struct ConfigFileState

{

  int lineNr;

  FILE *filePtr;

  YY_BUFFER_STATE oldState;

  YY_BUFFER_STATE newState;

  QCString fileName;

};  

static const char       *inputString;

static int	         inputPosition;

static int               yyLineNr;

static QCString          yyFileName;

static QCString          tmpString;

static QCString         *s=0;

static bool             *b=0;

static QStrList         *l=0;

static int               lastState;

static QCString          elemStr;

static QStrList          includePathList;

static QStack<ConfigFileState> includeStack;  

static int               includeDepth;

static bool              config_upd = FALSE;

static QCString          encoding;

static ConfigImpl       *config;

/* -----------------------------------------------------------------

 */

#undef	YY_INPUT

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

static int yyread(char *buf,int max_size)

{

    // no file included

    if (includeStack.isEmpty()) 

    {

        int c=0;

	if (inputString==0) return c;

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

	{

	      *buf = inputString[inputPosition++] ;

	      c++; buf++;

  	}

	return c;

    } 

    else 

    {

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

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

    }

}

static QCString configStringRecode(

    const QCString &str,

    const char *fromEncoding,

    const char *toEncoding)

{

  QCString inputEncoding = fromEncoding;

  QCString outputEncoding = toEncoding;

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

  int inputSize=str.length();

  int outputSize=inputSize*4+1;

  QCString output(outputSize);

  void *cd = portable_iconv_open(outputEncoding,inputEncoding);

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

  {

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

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

    exit(1);

  }

  size_t iLeft=(size_t)inputSize;

  size_t oLeft=(size_t)outputSize;

  char *inputPtr  = str.rawData();

  char *outputPtr = output.rawData();

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

  {

    outputSize-=(int)oLeft;

    output.resize(outputSize+1);

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

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

  }

  else

  {

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

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

    exit(1);

  }

  portable_iconv_close(cd);

  return output;

}

static void checkEncoding()

{

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

  encoding = *option->valueRef();

}

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

{

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

  QFileInfo fi(absName);

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

  {

    FILE *f=portable_fopen(absName,"r");

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

    return f;

  }

  return 0;

}

static void substEnvVarsInStrList(QStrList &sl);

static void substEnvVarsInString(QCString &s);

static FILE *findFile(const char *fileName)

{

  if (fileName==0)

  {

    return 0;

  }

  if (portable_isAbsolutePath(fileName))

  {

    return tryPath(NULL, fileName);

  }

  substEnvVarsInStrList(includePathList);

  char *s=includePathList.first();

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

  {

    FILE *f = tryPath(s,fileName);

    if (f) return f;

    s=includePathList.next();

  } 

  // try cwd if includePathList fails

  return tryPath(".",fileName);

}

static void readIncludeFile(const char *incName)

{

  if (includeDepth==MAX_INCLUDE_DEPTH) {

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

	MAX_INCLUDE_DEPTH,incName);

    exit(1);

  } 

  QCString inc = incName;

  substEnvVarsInString(inc);

  inc = inc.stripWhiteSpace();

  uint incLen = inc.length();

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

  {

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

  }

  FILE *f;

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

  {

    // For debugging

#if SHOW_INCLUDES

    for (i=0;i

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

#endif

    // store the state of the old file 

    ConfigFileState *fs=new ConfigFileState;

    fs->oldState=YY_CURRENT_BUFFER;

    fs->lineNr=yyLineNr;

    fs->fileName=yyFileName;

    fs->filePtr=f;

    // push the state on the stack

    includeStack.push(fs);

    // set the scanner to the include file

    yy_switch_to_buffer(yy_create_buffer(f, YY_BUF_SIZE));

    fs->newState=YY_CURRENT_BUFFER;

    yyFileName=inc;

    includeDepth++;

  } 

  else

  {

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

    exit(1);

  }

}

%}

%option noyywrap

%x      PreStart

%x      Start

%x	SkipComment

%x      SkipInvalid

%x      GetString

%x      GetBool

%x      GetStrList

%x      GetQuotedString

%x      GetEnvVar

%x      Include

%%

<*>\0x0d

<PreStart>"##".*"\n" { config->appendStartComment(yytext);}

<PreStart>. {

              BEGIN(Start);

              unput(*yytext);

            }

<Start,GetString,GetStrList,GetBool,SkipInvalid>"##".*"\n" { config->appendUserComment(yytext);}

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

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

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

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

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

					   {

					     config_warn("ignoring unsupported tag `%s' at line %d, file %s\n",

						 yytext,yyLineNr,yyFileName.data()); 

					     BEGIN(SkipInvalid);

					   }

					   else // known tag

					   {

                                             option->setUserComment(config->takeUserComment());

					     option->setEncoding(encoding);

					     switch(option->kind())

					     {

					       case ConfigOption::O_Info:

						 // shouldn't get here!

					         BEGIN(SkipInvalid);

						 break;

					       case ConfigOption::O_List:

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

					         l->clear();

						 elemStr="";

					         BEGIN(GetStrList);

					         break;

					       case ConfigOption::O_Enum:

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

					         s->resize(0);

					         BEGIN(GetString);

					         break;

					       case ConfigOption::O_String:

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

					         s->resize(0);

					         BEGIN(GetString);

					         break;

					       case ConfigOption::O_Int:

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

					         s->resize(0);

					         BEGIN(GetString);

					         break;

					       case ConfigOption::O_Bool:

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

					         s->resize(0);

					         BEGIN(GetString);

						 break;

					       case ConfigOption::O_Obsolete:

                                                 if (config_upd)

                                                 {

					           config_warn("Tag `%s' at line %d of file `%s' has become obsolete.\n"

						              "         This tag has been removed.\n", cmd.data(),yyLineNr,yyFileName.data());

                                                 }

                                                 else

                                                 {

					           config_warn("Tag `%s' at line %d of file `%s' has become obsolete.\n"

						              "         To avoid this warning please remove this line from your configuration "

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

                                                 }

					         BEGIN(SkipInvalid);

						 break;

					       case ConfigOption::O_Disabled:

                                                 if (config_upd)

                                                 {

					           config_warn("Tag `%s' at line %d of file `%s' belongs to an option that was not enabled at compile time.\n"

						              "         This tag has been removed.\n", cmd.data(),yyLineNr,yyFileName.data());

                                                 }

                                                 else

                                                 {

					           config_warn("Tag `%s' at line %d of file `%s' belongs to an option that was not enabled at compile time.\n"

						              "         To avoid this warning please remove this line from your configuration "

							    "file or upgrade it using \"doxygen -u\", or recompile doxygen with this feature enabled.\n", cmd.data(),yyLineNr,yyFileName.data()); 

                                                 }

					         BEGIN(SkipInvalid);

						 break;

					     }

					   }

					}

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

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

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

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

					  {

					    config_warn("ignoring unsupported tag `%s' at line %d, file %s\n",

						yytext,yyLineNr,yyFileName.data()); 

					    BEGIN(SkipInvalid);

					  }

					  else // known tag

					  {

                                            option->setUserComment(config->takeUserComment());

					    switch(option->kind())

					    {

					      case ConfigOption::O_Info:

					        // shouldn't get here!

					        BEGIN(SkipInvalid);

						break;

					      case ConfigOption::O_List:

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

						elemStr="";

					        BEGIN(GetStrList);

					        break;

					      case ConfigOption::O_Enum:

					      case ConfigOption::O_String:

					      case ConfigOption::O_Int:

					      case ConfigOption::O_Bool:

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

						    yytext,yyLineNr,yyFileName.data()); 

					        BEGIN(SkipInvalid);

						break;

					       case ConfigOption::O_Obsolete:

					         config_warn("Tag `%s' at line %d of file %s has become obsolete.\n"

						            "To avoid this warning please update your configuration "

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

					         BEGIN(SkipInvalid);

						 break;

					       case ConfigOption::O_Disabled:

					         config_warn("Tag `%s' at line %d of file %s belongs to an option that was not enabled at compile time.\n"

						            "To avoid this warning please remove this line from your configuration "

							    "file, upgrade it using \"doxygen -u\", or recompile doxygen with this feature enabled.\n", cmd.data(),yyLineNr,yyFileName.data()); 

					         BEGIN(SkipInvalid);

						 break;

					     }

					   }

					}

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

  /* include a config file */

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

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

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

  					  BEGIN(Start);

					}

<<EOF>>					{

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

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

                                          if (includeStack.isEmpty())

					  {

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

					    yyterminate();

					  }

					  else

					  {

					    ConfigFileState *fs=includeStack.pop();

					    fclose(fs->filePtr);

					    YY_BUFFER_STATE oldBuf = YY_CURRENT_BUFFER;

					    yy_switch_to_buffer( fs->oldState );

					    yy_delete_buffer( oldBuf );

					    yyLineNr=fs->lineNr;

					    yyFileName=fs->fileName;

					    delete fs; fs=0;

                                            includeDepth--;

					  }

  					}

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

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

<GetStrList>\n				{ 

  					  yyLineNr++; 

					  if (!elemStr.isEmpty())

					  {

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

					    l->append(elemStr);

					  }

					  BEGIN(Start); 

					}

<GetStrList>[ \t]+			{

  				          if (!elemStr.isEmpty())

					  {

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

  					    l->append(elemStr);

					  }

					  elemStr.resize(0);

  					}

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

                                          checkEncoding();

                                        }

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

  					  BEGIN(GetQuotedString); 

                                          tmpString.resize(0); 

					}

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

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

                                          tmpString+=" ";

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

  					  if (lastState==GetString)

					  {

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

                                            checkEncoding();

					  }

					  else

					  {

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

					  }

					  if (*yytext=='\n')

					  {

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

					    yyLineNr++;

					  }

					  BEGIN(lastState);

  					}

<GetQuotedString>"\\\""			{

  					  tmpString+='"';

  					}

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

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

  					  QCString bs=yytext; 

  					  bs=bs.upper();

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

					    *b=TRUE;

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

					    *b=FALSE;

					  else 

					  {

					    *b=FALSE; 

					    config_warn("Invalid value `%s' for "

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

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

					  }

					}

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

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

  					}

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

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

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

<*>.					

<*>\n					{ yyLineNr++ ; }

%%

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

 */

void ConfigImpl::writeTemplate(FTextStream &t,bool sl,bool upd)

{

  /* print first lines of user comment that were at the beginning of the file, might have special meaning for editors */

  if (m_startComment)

  {

    t << takeStartComment() << endl; 

  }

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

  if (!sl)

  {

    t << convertToComment(m_header,"");

  }

  QListIterator<ConfigOption> it = iterator();

  ConfigOption *option;

  for (;(option=it.current());++it)

  {

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

  }

  /* print last lines of user comment that were at the end of the file */

  if (m_userComment)

  {

    t << "\n";

    t << takeUserComment();

  }

}

void ConfigImpl::convertStrToVal()

{

  QListIterator<ConfigOption> it = iterator();

  ConfigOption *option;

  for (;(option=it.current());++it)

  {

    option->convertStrToVal();