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

 *

 * 

 *

 * Copyright (C) 1997-2008 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.

 *

 */

%{

/*

 *	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 "config.h"

#include "version.h"

#include "portable.h"

#include "util.h"

#include "lang_cfg.h"

#include "configoptions.h"

#undef Config_getString

#undef Config_getInt

#undef Config_getList

#undef Config_getEnum

#undef Config_getBool

// use in-class definitions

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

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

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

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

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

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

{

  va_list args;

  va_start(args, fmt);

  vfprintf(stderr, fmt, args);

  va_end(args); 

}

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

{

  va_list args;

  va_start(args, fmt);

  vfprintf(stderr, fmt, 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

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

 */

QCString ConfigOption::convertToComment(const QCString &s)

{

  QCString result;

  if (s.isEmpty()) return result;

  else

  {

    QCString tmp=s.stripWhiteSpace();

    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';

  }

  return result;

}

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

{

  t << " ";

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

}

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

{

  t << " " << i;

}

void ConfigOption::writeStringValue(QTextStream &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(QTextStream &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;

  }

}

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

 */

Config *Config::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("Warning: 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);

    }

    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("Warning: 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 &Config::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 &Config::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("%d<%d>: Internal error: Requested option %s not of list type!\n",fileName,num,name);

    exit(1);

  }

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

}

QCString &Config::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 &Config::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 &Config::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 integer type!\n",fileName,num,name);

    exit(1);

  }

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

}

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

 */

void ConfigInt::writeXML(QTextStream& t)

{

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

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

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

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

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

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

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

  t << "/>" << endl;

}

void ConfigBool::writeXML(QTextStream& t)

{

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

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

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

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

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

  t << "/>" << endl;

}

void ConfigString::writeXML(QTextStream& t)

{

  QString format;

  switch (m_widgetType)

  {

    case String: format="string"; break;

    case File:   format="file";   break;

    case Dir:    format="dir";    break;

  }

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

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

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

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

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

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

  t << "/>" << endl;

}

void ConfigEnum::writeXML(QTextStream &t)

{

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

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

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

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

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

  t << ">" << endl;

  char *enumVal = m_valueRange.first();

  while (enumVal)

  {

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

    enumVal = m_valueRange.next();

  }

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

}

void ConfigList::writeXML(QTextStream &t)

{

  QString format;

  switch (m_widgetType)

  {

    case String:     format="string";  break;

    case File:       format="file";    break;

    case Dir:        format="dir";     break;

    case FileAndDir: format="filedir"; break;

  }

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

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

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

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

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

  t << ">" << endl;

  char *enumVal = m_value.first();

  while (enumVal)

  {

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

    enumVal = m_value.next();

  }

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

}

void ConfigObsolete::writeXML(QTextStream &t)

{

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

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

}

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

 *

 *	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 QCString          includeName;

static QStrList          includePathList;

static QStack<ConfigFileState> includeStack;  

static int               includeDepth;

static QCString     tabSizeString;

static QCString     maxInitLinesString;

static QCString     colsInAlphaIndexString;

static QCString     enumValuesPerLineString;

static QCString     treeViewWidthString;

static QCString     maxDotGraphWidthString;

static QCString     maxDotGraphHeightString;

static QCString     encoding;

static Config      *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();

  size_t 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=inputSize;

  size_t oLeft=outputSize;

  const char *inputPtr  = str.data();

  char       *outputPtr = output.data();

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

  {

    outputSize-=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=fopen(absName,"r");

    if (!f) config_err("Error: 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 bool isAbsolute(const char * fileName)

{

# ifdef _WIN32

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

    fileName += 2;

# endif

  char const fst = fileName [0];

  if (fst == '/')  {

    return true;

  }

# ifdef _WIN32

  if (fst == '\\')

    return true;

# endif

  return false;

}

static FILE *findFile(const char *fileName)

{

  if(isAbsolute(fileName))