summaryrefslogtreecommitdiffstats
path: root/src/config.l
diff options
context:
space:
mode:
authormueller <mueller@afe2bf4a-e733-0410-8a33-86f594647bc7>1999-12-15 19:25:10 (GMT)
committermueller <mueller@afe2bf4a-e733-0410-8a33-86f594647bc7>1999-12-15 19:25:10 (GMT)
commit719f0a35063be88eddcc4ed8fe7a940de47ef20c (patch)
treecc1cd70cf5761ddf72ff114c0b65576c3f4c1d2a /src/config.l
parentbd30c025c4651ddda467f1af09d4c7ccab397bde (diff)
downloadDoxygen-719f0a35063be88eddcc4ed8fe7a940de47ef20c.zip
Doxygen-719f0a35063be88eddcc4ed8fe7a940de47ef20c.tar.gz
Doxygen-719f0a35063be88eddcc4ed8fe7a940de47ef20c.tar.bz2
initial version
Diffstat (limited to 'src/config.l')
-rw-r--r--src/config.l1112
1 files changed, 1112 insertions, 0 deletions
diff --git a/src/config.l b/src/config.l
new file mode 100644
index 0000000..232f531
--- /dev/null
+++ b/src/config.l
@@ -0,0 +1,1112 @@
+/******************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997-1999 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.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+
+%{
+
+/*
+ * includes
+ */
+#include <stdio.h>
+#include <iostream.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <qstring.h>
+#include <qfileinf.h>
+#include <qdir.h>
+#include <qtstream.h>
+
+#include "doxygen.h"
+#include "config.h"
+#include "message.h"
+#include "pre.h"
+#include "version.h"
+#include "language.h"
+
+#define YY_NEVER_INTERACTIVE 1
+
+/* -----------------------------------------------------------------
+ *
+ * exported variables
+ */
+
+QString projectName;
+QString projectNumber;
+QString outputDir;
+QString htmlOutputDir;
+QString latexOutputDir;
+QString manOutputDir;
+QString headerFile;
+QString footerFile;
+QString cgiName;
+QString cgiURL;
+QString docURL;
+QString binAbsPath;
+QString docAbsPath;
+QString perlPath;
+QString genTagFile;
+QString inputFilter;
+QString paperType;
+QString outputLanguage;
+QString stripFromPath;
+QStrList includePath;
+QStrList examplePath;
+QStrList inputSources;
+QStrList excludeSources;
+QStrList filePatternList;
+QStrList excludePatternList;
+QStrList tagFileList;
+QStrList extDocPathList;
+QStrList predefined;
+QStrList extraPackageList;
+bool quietFlag = FALSE;
+bool warningFlag = FALSE;
+bool recursiveFlag = FALSE;
+bool allExtFlag = FALSE;
+bool searchEngineFlag = FALSE;
+bool extractAllFlag = FALSE;
+bool extractPrivateFlag = FALSE;
+bool noIndexFlag = FALSE;
+bool hideMemberFlag = FALSE;
+bool hideClassFlag = FALSE;
+bool macroExpansionFlag = FALSE;
+bool onlyPredefinedFlag = FALSE;
+bool fullPathNameFlag = FALSE;
+bool compactLatexFlag = FALSE;
+bool internalDocsFlag = FALSE;
+bool caseSensitiveNames = FALSE;
+bool generateHtml = TRUE;
+bool generateLatex = TRUE;
+bool generateMan = TRUE;
+bool preprocessingFlag = TRUE;
+bool briefMemDescFlag = TRUE;
+bool searchIncludeFlag = TRUE;
+bool classDiagramFlag = TRUE;
+bool repeatBriefFlag = TRUE;
+bool verbatimHeaderFlag = TRUE;
+
+/* -----------------------------------------------------------------
+ *
+ * static variables
+ */
+
+static const char * inputString;
+static int inputPosition;
+static int yyLineNr;
+static QString tmpString;
+static QString * s=0;
+static bool * b=0;
+static QStrList * l=0;
+static int lastState;
+static int lastEnvState;
+static QString elemStr;
+
+/* -----------------------------------------------------------------
+ */
+#undef YY_INPUT
+#define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);
+
+static int yyread(char *buf,int max_size)
+{
+ int c=0;
+ while( c < max_size && inputString[inputPosition] )
+ {
+ *buf = inputString[inputPosition++] ;
+ c++; buf++;
+ }
+ return c;
+}
+
+%}
+
+%x Start
+%x SkipComment
+%x GetString
+%x GetBool
+%x GetStrList
+%x GetQuotedString
+%x GetEnvVar
+
+%%
+
+<*>\0x0d
+<Start,GetString,GetStrList,GetBool>"#" { BEGIN(SkipComment); }
+<Start>"PROJECT_NAME"[ \t]*"=" { BEGIN(GetString); s=&projectName; }
+<Start>"PROJECT_NUMBER"[ \t]*"=" { BEGIN(GetString); s=&projectNumber; }
+<Start>"OUTPUT_DIRECTORY"[ \t]*"=" { BEGIN(GetString); s=&outputDir; }
+<Start>"HTML_OUTPUT"[ \t]*"=" { BEGIN(GetString); s=&htmlOutputDir; }
+<Start>"MAN_OUTPUT"[ \t]*"=" { BEGIN(GetString); s=&manOutputDir; }
+<Start>"LATEX_OUTPUT"[ \t]*"=" { BEGIN(GetString); s=&latexOutputDir; }
+<Start>"HTML_HEADER"[ \t]*"=" { BEGIN(GetString); s=&headerFile; }
+<Start>"HTML_FOOTER"[ \t]*"=" { BEGIN(GetString); s=&footerFile; }
+<Start>"CGI_NAME"[ \t]*"=" { BEGIN(GetString); s=&cgiName; }
+<Start>"CGI_URL"[ \t]*"=" { BEGIN(GetString); s=&cgiURL; }
+<Start>"DOC_URL"[ \t]*"=" { BEGIN(GetString); s=&docURL; }
+<Start>"BIN_ABSPATH"[ \t]*"=" { BEGIN(GetString); s=&binAbsPath; }
+<Start>"DOC_ABSPATH"[ \t]*"=" { BEGIN(GetString); s=&docAbsPath; }
+<Start>"PERL_PATH"[ \t]*"=" { BEGIN(GetString); s=&perlPath; }
+<Start>"GENERATE_TAGFILE"[ \t]*"=" { BEGIN(GetString); s=&genTagFile; }
+<Start>"INPUT_FILTER"[ \t]*"=" { BEGIN(GetString); s=&inputFilter; }
+<Start>"PAPER_TYPE"[ \t]*"=" { BEGIN(GetString); s=&paperType; }
+<Start>"OUTPUT_LANGUAGE"[ \t]*"=" { BEGIN(GetString); s=&outputLanguage; }
+<Start>"STRIP_FROM_PATH"[ \t]*"=" { BEGIN(GetString); s=&stripFromPath; }
+<Start>"INCLUDE_PATH"[ \t]*"=" { BEGIN(GetStrList); l=&includePath; elemStr=""; }
+<Start>"EXAMPLE_PATH"[ \t]*"=" { BEGIN(GetStrList); l=&examplePath; elemStr=""; }
+<Start>"INPUT"[ \t]*"=" { BEGIN(GetStrList); l=&inputSources; elemStr=""; }
+<Start>"EXCLUDE"[ \t]*"=" { BEGIN(GetStrList); l=&excludeSources; elemStr=""; }
+<Start>"FILE_PATTERNS"[ \t]*"=" { BEGIN(GetStrList); l=&filePatternList; elemStr=""; }
+<Start>"EXCLUDE_PATTERNS"[ \t]*"=" { BEGIN(GetStrList); l=&excludePatternList; elemStr=""; }
+<Start>"TAGFILES"[ \t]*"=" { BEGIN(GetStrList); l=&tagFileList; elemStr=""; }
+<Start>"EXT_DOC_PATHS"[ \t]*"=" { BEGIN(GetStrList); l=&extDocPathList; elemStr=""; }
+<Start>"PREDEFINED"[ \t]*"=" { BEGIN(GetStrList); l=&predefined; elemStr=""; }
+<Start>"EXTRA_PACKAGES"[ \t]*"=" { BEGIN(GetStrList); l=&extraPackageList; elemStr=""; }
+<Start>"QUIET"[ \t]*"=" { BEGIN(GetBool); b=&quietFlag; }
+<Start>"WARNINGS"[ \t]*"=" { BEGIN(GetBool); b=&warningFlag; }
+<Start>"RECURSIVE"[ \t]*"=" { BEGIN(GetBool); b=&recursiveFlag; }
+<Start>"ALLEXTERNALS"[ \t]*"=" { BEGIN(GetBool); b=&allExtFlag; }
+<Start>"SEARCHENGINE"[ \t]*"=" { BEGIN(GetBool); b=&searchEngineFlag; }
+<Start>"EXTRACT_ALL"[ \t]*"=" { BEGIN(GetBool); b=&extractAllFlag; }
+<Start>"EXTRACT_PRIVATE"[ \t]*"=" { BEGIN(GetBool); b=&extractPrivateFlag; }
+<Start>"DISABLE_INDEX"[ \t]*"=" { BEGIN(GetBool); b=&noIndexFlag; }
+<Start>"GENERATE_LATEX"[ \t]*"=" { BEGIN(GetBool); b=&generateLatex; }
+<Start>"GENERATE_HTML"[ \t]*"=" { BEGIN(GetBool); b=&generateHtml; }
+<Start>"GENERATE_MAN"[ \t]*"=" { BEGIN(GetBool); b=&generateMan; }
+<Start>"ENABLE_PREPROCESSING"[ \t]*"=" { BEGIN(GetBool); b=&preprocessingFlag; }
+<Start>"MACRO_EXPANSION"[ \t]*"=" { BEGIN(GetBool); b=&macroExpansionFlag; }
+<Start>"SEARCH_INCLUDES"[ \t]*"=" { BEGIN(GetBool); b=&searchIncludeFlag; }
+<Start>"BRIEF_MEMBER_DESC"[ \t]*"=" { BEGIN(GetBool); b=&briefMemDescFlag; }
+<Start>"HIDE_UNDOC_MEMBERS"[ \t]*"=" { BEGIN(GetBool); b=&hideMemberFlag; }
+<Start>"HIDE_UNDOC_CLASSES"[ \t]*"=" { BEGIN(GetBool); b=&hideClassFlag; }
+<Start>"EXPAND_ONLY_PREDEF"[ \t]*"=" { BEGIN(GetBool); b=&onlyPredefinedFlag; }
+<Start>"FULL_PATH_NAMES"[ \t]*"=" { BEGIN(GetBool); b=&fullPathNameFlag; }
+<Start>"CLASS_DIAGRAMS"[ \t]*"=" { BEGIN(GetBool); b=&classDiagramFlag; }
+<Start>"COMPACT_LATEX"[ \t]*"=" { BEGIN(GetBool); b=&compactLatexFlag; }
+<Start>"REPEAT_BRIEF"[ \t]*"=" { BEGIN(GetBool); b=&repeatBriefFlag; }
+<Start>"INTERNAL_DOCS"[ \t]*"=" { BEGIN(GetBool); b=&internalDocsFlag; }
+<Start>"CASE_SENSE_NAMES"[ \t]*"=" { BEGIN(GetBool); b=&caseSensitiveNames; }
+<Start>"VERBATIM_HEADERS"[ \t]*"=" { BEGIN(GetBool); b=&verbatimHeaderFlag; }
+<Start>[a-z_A-Z0-9]+ { err("Warning: ignoring unknown tag `%s' at line %d\n",yytext,yyLineNr); }
+<GetString,GetBool>\n { yyLineNr++; BEGIN(Start); }
+<GetStrList>\n {
+ yyLineNr++;
+ if (elemStr.length()>0)
+ {
+ //printf("elemStr1=`%s'\n",elemStr.data());
+ l->append(elemStr);
+ }
+ BEGIN(Start);
+ }
+<GetStrList>[ \t]+ {
+ if (elemStr.length()>0)
+ {
+ //printf("elemStr2=`%s'\n",elemStr.data());
+ l->append(elemStr);
+ }
+ elemStr.resize(0);
+ }
+<GetString>[^ \"\$\t\r\n]+ { (*s)+=yytext; }
+<GetString,GetStrList>"\"" { lastState=YY_START;
+ BEGIN(GetQuotedString);
+ tmpString.resize(0);
+ }
+<GetString,GetStrList,GetQuotedString>"\$\(" {
+ //printf(">> Enter env\n");
+ lastEnvState=YY_START;
+ BEGIN(GetEnvVar);
+ }
+<GetEnvVar>[a-z_A-Z0-9]+")" {
+ yytext[yyleng-1]='\0';
+ const char *env=getenv(yytext);
+ int i;
+ int l=strlen(env);
+ //printf("env name=`%s' text=`%s'\n",yytext,env);
+ for (i=l-1;i>=0;i--) unput(env[i]);
+ BEGIN(lastEnvState);
+ }
+<GetQuotedString>"\""|"\n" {
+ //printf("Quoted String = `%s'\n",tmpString.data());
+ if (lastState==GetString)
+ (*s)+=tmpString;
+ else
+ elemStr+=tmpString;
+ if (*yytext=='\n')
+ {
+ err("Warning: Missing end quote (\") on line %d\n",yyLineNr);
+ yyLineNr++;
+ }
+ BEGIN(lastState);
+ }
+<GetQuotedString>"\\\"" {
+ tmpString+='"';
+ }
+<GetQuotedString>. { tmpString+=*yytext; }
+<GetBool>[a-zA-Z]+ {
+ QString bs=yytext;
+ bs=bs.upper();
+ if (bs=="YES")
+ *b=TRUE;
+ else if (bs=="NO")
+ *b=FALSE;
+ else
+ {
+ *b=FALSE;
+ warn("Warning: Invalid value `%s' for "
+ "boolean tag in line %d; use YES or NO\n",
+ bs.data(),yyLineNr);
+ }
+ }
+ /*
+<GetStrList>[a-z_A-Z.*:?~0-9/\\\-]+ {
+ elemStr+=yytext;
+ }
+ */
+<GetStrList>[^ \#\"\$\t\r\n]+ {
+ elemStr+=yytext;
+ }
+<SkipComment>\n { yyLineNr++; BEGIN(Start); }
+<SkipComment>\\[ \r\t]*\n { yyLineNr++; BEGIN(Start); }
+<*>\\[ \r\t]*\n { yyLineNr++; }
+<*>.
+<*>\n { yyLineNr++ ; }
+
+%%
+
+/*@ ----------------------------------------------------------------------------
+ */
+
+
+void dumpConfig()
+{
+ printf("projectName=`%s'\n",projectName.data());
+ printf("outputDir=`%s'\n", outputDir.data());
+ printf("headerFile=`%s'\n", headerFile.data());
+ printf("footerFile=`%s'\n", footerFile.data());
+ char *ip=includePath.first();
+ while (ip)
+ {
+ printf("includePath=`%s'\n",ip);
+ ip=includePath.next();
+ }
+ printf("quiet=`%d'\n", quietFlag);
+ printf("warnings=`%d'\n", warningFlag);
+ char *is=inputSources.first();
+ while (is)
+ {
+ printf("inputSources=`%s'\n",is);
+ is=inputSources.next();
+ }
+ char *fp=filePatternList.first();
+ while (fp)
+ {
+ printf("filePattern=`%s'\n",fp);
+ fp=filePatternList.next();
+ }
+ printf("recusive=`%d'\n",recursiveFlag);
+ printf("inputFilter=`%s'\n",inputFilter.data());
+ char *tf=tagFileList.first();
+ while (tf)
+ {
+ printf("tagFile=`%s'\n",tf);
+ tf=tagFileList.next();
+ }
+ printf("allExternals=`%d'\n",allExtFlag);
+ printf("searchEngine=`%d'\n",searchEngineFlag);
+ printf("cgiName=`%s'\n",cgiName.data());
+ printf("cgiURL=`%s'\n",cgiURL.data());
+ printf("docURL=`%s'\n",docURL.data());
+ printf("binAbsPath=`%s'\n",binAbsPath.data());
+ char *ed=extDocPathList.first();
+ while (ed)
+ {
+ printf("binAbsPathFile=`%s'\n",ed);
+ ed=extDocPathList.next();
+ }
+}
+
+void writeTemplateConfig(QFile *f,bool sl)
+{
+ QTextStream t(f);
+ t << "# Doxyfile " << versionString << endl;
+ if (!sl)
+ {
+ t << "# This file describes the settings to be used by doxygen for a project\n";
+ t << "#\n";
+ t << "# All text after a hash (#) is considered a comment and will be ignored\n";
+ t << "# The format is:\n";
+ t << "# TAG = value [value, ...]\n";
+ t << "# Values that contain spaces should be placed between quotes (\" \")\n";
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# General configuration options\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# The PROJECT_NAME tag is a single word (or a sequence of word surrounded\n";
+ t << "# by quotes) that should identify the project. \n";
+ t << "\n";
+ }
+ t << "PROJECT_NAME =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The PROJECT_NUMBER tag can be used to enter a project or revision number.\n" ;
+ t << "# This could be handy for archiving the generated documentation or \n";
+ t << "# if some version control system is used.\n";
+ t << "\n";
+ }
+ t << "PROJECT_NUMBER =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) \n";
+ t << "# base path where the generated documentation will be put. \n";
+ t << "# If a relative path is entered, it will be relative to the location \n";
+ t << "# where doxygen was started. If left blank the current directory will be used.\n";
+ t << "\n";
+ }
+ t << "OUTPUT_DIRECTORY =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The OUTPUT_LANGUAGE tag is used to specify the language in which all\n";
+ t << "# documentation generated by doxygen is written. Doxygen will use this\n";
+ t << "# information to generate all constant output in the proper language.\n";
+ t << "# The default language is English, other supported languages are: Dutch\n";
+ t << "\n";
+ }
+ t << "OUTPUT_LANGUAGE = English\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The QUIET tag can be used to turn on/off the messages that are generated\n";
+ t << "# by doxygen. Possible values are YES and NO. If left blank NO is used.\n";
+ t << "\n";
+ }
+ t << "QUIET = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The WARNINGS tag can be used to turn on/off the warning messages that are\n";
+ t << "# generated by doxygen. Possible values are YES and NO. If left blank\n";
+ t << "# NO is used.\n";
+ t << "\n";
+ }
+ t << "WARNINGS = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The DISABLE_INDEX tag can be used to turn on/off the condensed index at\n";
+ t << "# top of each HTML page. The value NO (the default) enables the index and\n";
+ t << "# the value YES disables it.\n";
+ t << "\n";
+ }
+ t << "DISABLE_INDEX = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the EXTRACT_ALL tag is set to YES all classes and functions will be\n";
+ t << "# included in the documentation, even if no documentation was available.\n";
+ t << "\n";
+ }
+ t << "EXTRACT_ALL = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the EXTRACT_PRIVATE tag is set to YES all private members of a class\n";
+ t << "# will be included in the documentation.\n";
+ t << "\n";
+ }
+ t << "EXTRACT_PRIVATE = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all\n";
+ t << "# undocumented members inside documented classes or files.\n";
+ t << "\n";
+ }
+ t << "HIDE_UNDOC_MEMBERS = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the HIDE_UNDOC_CLASSESS tag is set to YES, Doxygen will hide all\n";
+ t << "# undocumented classes.\n";
+ t << "\n";
+ }
+ t << "HIDE_UNDOC_CLASSES = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will\n";
+ t << "# include brief member descriptions after the members that are listed in \n";
+ t << "# the file and class documentation (similar to JavaDoc).\n";
+ t << "# Set to NO to disable this.\n";
+ t << "\n";
+ }
+ t << "BRIEF_MEMBER_DESC = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The INTERNAL_DOCS tag determines if documentation\n";
+ t << "# that is typed after a \\internal command is included. If the tag is set \n";
+ t << "# to NO (the default) then the documentation will be excluded.\n";
+ t << "# Set it to YES to include the internal documentation.\n";
+ t << "\n";
+ }
+ t << "INTERNAL_DOCS = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend\n";
+ t << "# the brief description of a member or function before the detailed description.\n";
+ t << "# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the \n";
+ t << "# brief descriptions will be completely suppressed.\n";
+ t << "\n";
+ }
+ t << "REPEAT_BRIEF = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the FULL_PATH_NAMES tag is set to YES Doxygen will prepend the full\n";
+ t << "# path before files name in the file list and in the header files. If set\n" ;
+ t << "# to NO the shortest path that makes the file name unique will be used.\n";
+ t << "\n";
+ }
+ t << "FULL_PATH_NAMES = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag\n";
+ t << "# can be used to strip a user defined part of the path. Stripping is\n" ;
+ t << "# only done if the specified string matches the left-hand part of the path.\n";
+ t << "\n";
+ }
+ t << "STRIP_FROM_PATH =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will\n";
+ t << "# generate a class diagram (in Html and LaTeX) for classes with base or\n";
+ t << "# super classes. Setting the tag to NO turns the diagrams off.\n";
+ t << "\n";
+ }
+ t << "CLASS_DIAGRAMS = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the CASE_SENSE_NAMES tag is set to NO (the default) then Doxygen\n";
+ t << "# will only generate file names in lower case letters. If set to\n";
+ t << "# YES upper case letters are also allowed. This is useful if you have\n";
+ t << "# classes or files whose names only differ in case and if your file system\n";
+ t << "# supports case sensitive file names.\n";
+ t << "\n";
+ }
+ t << "CASE_SENSE_NAMES = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the VERBATIM_HEADERS tag is set the YES (the default) then Doxygen\n";
+ t << "# will generate a verbatim copy of the header file for each class for\n";
+ t << "# which an include is specified. Set to NO to disable this.\n";
+ t << "\n";
+ }
+ t << "VERBATIM_HEADERS = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# configuration options related to the input files\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# The INPUT tag can be used to specify the files and/or directories that contain \n";
+ t << "# documented source files. You may enter file names like \"myfile.cpp\" or \n";
+ t << "# directories like \"/usr/src/myproject\". Separate the files or directories \n";
+ t << "# with spaces.\n";
+ t << "\n";
+ }
+ t << "INPUT =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the value of the INPUT tag contains directories, you can use the \n";
+ t << "# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp \n";
+ t << "# and *.h) to filter out the source-files in the directories. If left \n";
+ t << "# blank all files are included.\n";
+ t << "\n";
+ }
+ t << "FILE_PATTERNS =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The RECURSIVE tag can be used to turn specify whether or not subdirectories\n";
+ t << "# should be searched for input files as well. Possible values are YES and NO.\n";
+ t << "# If left blank NO is used.\n";
+ t << "\n";
+ }
+ t << "RECURSIVE = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The EXCLUDE tag can be used to specify files and/or directories that should\n";
+ t << "# excluded from the INPUT source files. This way you can easily exclude a \n";
+ t << "# subdirectory from a directory tree whose root is specified with the INPUT tag.\n";
+ t << "\n";
+ }
+ t << "EXCLUDE =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the value of the INPUT tag contains directories, you can use the\n";
+ t << "# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude\n";
+ t << "# certain files from those directories.\n";
+ t << "\n";
+ }
+ t << "EXCLUDE_PATTERNS =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The EXAMPLE_PATH tag can be used to specify one or more files or \n";
+ t << "# directories that contain example code fragments that are included (see \n";
+ t << "# the \\include command).\n";
+ t << "\n";
+ }
+ t << "EXAMPLE_PATH =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The INPUT_FILTER tag can be used to specify a program that doxygen should\n";
+ t << "# invoke to filter for each input file. Doxygen will invoke the filter program \n";
+ t << "# by executing (via popen()) the command <filter> <input-file>, where <filter>\n";
+ t << "# is the value of the INPUT_FILTER tag, and <input-file> is the name of an\n";
+ t << "# input file. Doxygen will then use the output that the filter program writes\n";
+ t << "# to standard output.\n";
+ t << "\n";
+ }
+ t << "INPUT_FILTER =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# configuration options related to the HTML output\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# If the GENERATE_HTML tag is set to YES (the default) Doxygen will\n";
+ t << "# generate HTML output\n";
+ t << "\n";
+ }
+ t << "GENERATE_HTML = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.\n";
+ t << "# If a relative path is entered the value of OUTPUT_DIRECTORY will be\n";
+ t << "# put in front of it. If left blank `html' will be used as the default path.\n";
+ t << "\n";
+ }
+ t << "HTML_OUTPUT =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The HTML_HEADER tag can be used to specify a personal HTML header for \n";
+ t << "# each generated HTML page. If it is left blank doxygen will generate a \n";
+ t << "# standard header.\n";
+ t << "\n";
+ }
+ t << "HTML_HEADER =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The HTML_FOOTER tag can be used to specify a personal HTML footer for \n";
+ t << "# each generated HTML page. If it is left blank doxygen will generate a \n";
+ t << "# standard footer.\n";
+ t << "\n";
+ }
+ t << "HTML_FOOTER =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# configuration options related to the LaTeX output\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will\n";
+ t << "# generate Latex output.\n";
+ t << "\n";
+ }
+ t << "GENERATE_LATEX = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.\n";
+ t << "# If a relative path is entered the value of OUTPUT_DIRECTORY will be\n";
+ t << "# put in front of it. If left blank `latex' will be used as the default path.\n";
+ t << "\n";
+ }
+ t << "LATEX_OUTPUT =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact\n";
+ t << "# LaTeX documents. This may be useful for small projects and may help to\n";
+ t << "# save some trees in general.\n";
+ t << "\n";
+ }
+ t << "COMPACT_LATEX = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The PAPER_TYPE tag can be used to set the paper type that is used\n";
+ t << "# by the printer. Possible values are: a4, a4wide, letter, legal and \n";
+ t << "# executive. If left blank a4wide will be used.\n";
+ t << "\n";
+ }
+ t << "PAPER_TYPE = a4wide\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX\n";
+ t << "# packages that should be included in the LaTeX output.\n";
+ t << "\n";
+ }
+ t << "EXTRA_PACKAGES =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# configuration options related to the man page output\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# If the GENERATE_MAN tag is set to YES (the default) Doxygen will\n";
+ t << "# generate man pages\n";
+ t << "\n";
+ }
+ t << "GENERATE_MAN = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The MAN_OUTPUT tag is used to specify where the man pages will be put.\n";
+ t << "# If a relative path is entered the value of OUTPUT_DIRECTORY will be\n";
+ t << "# put in front of it. If left blank `man' will be used as the default path.\n";
+ t << "\n";
+ }
+ t << "MAN_OUTPUT =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# Configuration options related to the preprocessor \n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will\n";
+ t << "# evaluate all C-preprocessor directives found in the sources and include\n";
+ t << "# files.\n";
+ t << "\n";
+ }
+ t << "ENABLE_PREPROCESSING = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro\n";
+ t << "# names in the source code. If set to NO (the default) only conditional \n";
+ t << "# compilation will be performed.\n";
+ t << "\n";
+ }
+ t << "MACRO_EXPANSION = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files\n";
+ t << "# in the INCLUDE_PATH (see below) will be search if a #include is found.\n";
+ t << "\n";
+ }
+ t << "SEARCH_INCLUDES = YES\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The INCLUDE_PATH tag can be used to specify one or more directories that\n";
+ t << "# contain include files that are not input files but should be processed by\n";
+ t << "# the preprocessor.\n" ;
+ t << "\n";
+ }
+ t << "INCLUDE_PATH =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The PREDEFINED tag can be used to specify one or more macro names that\n";
+ t << "# are defined before the preprocessor is started (similar to the -D option of\n";
+ t << "# gcc). The argument of the tag is a list of macros of the form: name\n";
+ t << "# or name=definition (no spaces). If the definition and the = are \n";
+ t << "# omitted =1 is assumed.\n";
+ t << "\n";
+ }
+ t << "PREDEFINED =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES\n";
+ t << "# then the macro expansion is limited to the macros specified with the\n";
+ t << "# PREDEFINED tag.\n";
+ t << "\n";
+ }
+ t << "EXPAND_ONLY_PREDEF = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# Configuration options related to external references \n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# The TAGFILES tag can be used to specify one or more tagfiles. \n";
+ t << "\n";
+ }
+ t << "TAGFILES =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# When a file name is specified after GENERATE_TAGFILE, doxygen will create\n";
+ t << "# a tag file that is based on the input files it reads.\n";
+ t << "\n";
+ }
+ t << "GENERATE_TAGFILE =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# If the ALLEXTERNALS tag is set to YES all external classes will be listed\n";
+ t << "# in the class index. If set to NO only the inherited external classes\n";
+ t << "# will be listed.\n";
+ t << "\n";
+ }
+ t << "ALLEXTERNALS = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The PERL_PATH should be the absolute path and name of the perl script\n";
+ t << "# interpreter (i.e. the result of `which perl').\n";
+ t << "\n";
+ }
+ t << "PERL_PATH = /usr/local/bin/perl\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "# Configuration options related to the search engine \n";
+ t << "#---------------------------------------------------------------------------\n";
+ t << "\n";
+ t << "# The SEARCHENGINE tag specifies whether or not a search engine should be \n";
+ t << "# used. If set to NO the values of all tags below this one will be ignored.\n";
+ t << "\n";
+ }
+ t << "SEARCHENGINE = NO\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The CGI_NAME tag should be the name of the CGI script that\n";
+ t << "# starts the search engine (doxysearch) with the correct parameters.\n";
+ t << "# A script with this name will be generated by doxygen.\n";
+ t << "\n";
+ }
+ t << "CGI_NAME = search.cgi\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The CGI_URL tag should be the absolute URL to the directory where the\n";
+ t << "# cgi binaries are located. See the documentation of your http daemon for \n";
+ t << "# details.\n";
+ t << "\n";
+ }
+ t << "CGI_URL =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The DOC_URL tag should be the absolute URL to the directory where the\n";
+ t << "# documentation is located. If left blank the absolute path to the \n";
+ t << "# documentation, with file:// prepended to it, will be used.\n";
+ t << "\n";
+ }
+ t << "DOC_URL =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The DOC_ABSPATH tag should be the absolute path to the directory where the\n";
+ t << "# documentation is located. If left blank the directory on the local machine\n";
+ t << "# will be used.\n";
+ t << "\n";
+ }
+ t << "DOC_ABSPATH =\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The BIN_ABSPATH tag must point to the directory where the doxysearch binary\n";
+ t << "# is installed.\n";
+ t << "\n";
+ }
+ t << "BIN_ABSPATH = /usr/local/bin/\n";
+ if (!sl)
+ {
+ t << "\n";
+ t << "# The EXT_DOC_PATHS tag can be used to specify one or more paths to \n";
+ t << "# documentation generated for other projects. This allows doxysearch to search\n";
+ t << "# the documentation for these projects as well.\n";
+ t << "\n";
+ }
+ t << "EXT_DOC_PATHS =\n";
+}
+
+void checkConfig()
+{
+ //if (projectName.length()>0)
+ //{
+ // projectName[0]=toupper(projectName[0]);
+ //}
+
+ paperType = paperType.lower().stripWhiteSpace();
+ if (paperType.isEmpty())
+ {
+ paperType = "a4wide";
+ }
+ if (paperType!="a4" && paperType!="a4wide" && paperType!="letter" &&
+ paperType!="legal" && paperType!="executive")
+ {
+ err("Error: Unknown page type specified");
+ }
+
+ outputLanguage=outputLanguage.stripWhiteSpace();
+ if (outputLanguage.isEmpty())
+ {
+ setTranslator("English");
+ }
+ else
+ {
+ if (!setTranslator(outputLanguage))
+ {
+ err("Error: Output language %s not supported! Using english instead.\n",
+ outputLanguage.data());
+ }
+ }
+
+ // Test to see if output directory is valid
+ if (outputDir.isEmpty())
+ outputDir=QDir::currentDirPath();
+ else
+ {
+ QDir dir(outputDir);
+ if (!dir.exists())
+ {
+ dir.setPath(QDir::currentDirPath());
+ if (!dir.mkdir(outputDir))
+ {
+ err("Error: tag OUTPUT_DIRECTORY: Output directory `%s' does not "
+ "exist and cannot be created\n",outputDir.data());
+ exit(1);
+ }
+ else if (!quietFlag)
+ {
+ err("Notice: Output directory `%s' does not exist. "
+ "I have created it for you.\n", outputDir.data());
+ }
+ dir.cd(outputDir);
+ }
+ outputDir=dir.absPath();
+ }
+
+ if (htmlOutputDir.isEmpty() && generateHtml)
+ {
+ htmlOutputDir=outputDir+"/html";
+ }
+ else if (htmlOutputDir && htmlOutputDir[0]!='/')
+ {
+ htmlOutputDir.prepend(outputDir+'/');
+ }
+ QDir htmlDir(htmlOutputDir);
+ if (!htmlDir.exists() && !htmlDir.mkdir(htmlOutputDir))
+ {
+ err("Could not create output directory %s\n",htmlOutputDir.data());
+ exit(1);
+ }
+
+ if (latexOutputDir.isEmpty() && generateLatex)
+ {
+ latexOutputDir=outputDir+"/latex";
+ }
+ else if (latexOutputDir && latexOutputDir[0]!='/')
+ {
+ latexOutputDir.prepend(outputDir+'/');
+ }
+ QDir latexDir(latexOutputDir);
+ if (!latexDir.exists() && !latexDir.mkdir(latexOutputDir))
+ {
+ err("Could not create output directory %s\n",latexOutputDir.data());
+ exit(1);
+ }
+
+ if (manOutputDir.isEmpty() && generateMan)
+ {
+ manOutputDir=outputDir+"/man";
+ }
+ else if (manOutputDir && manOutputDir[0]!='/')
+ {
+ manOutputDir.prepend(outputDir+'/');
+ }
+ QDir manDir(manOutputDir);
+ if (!manDir.exists() && !manDir.mkdir(manOutputDir))
+ {
+ err("Could not create output directory %s\n",manOutputDir.data());
+ exit(1);
+ }
+
+ // Test to see if HTML header is valid
+ if (headerFile.length()>0)
+ {
+ QFileInfo fi(headerFile);
+ if (!fi.exists())
+ {
+ err("Error: tag HTML_HEADER: header file `%s' "
+ "does not exist\n",headerFile.data());
+ exit(1);
+ }
+ }
+ // Test to see if HTML footer is valid
+ if (footerFile.length()>0)
+ {
+ QFileInfo fi(footerFile);
+ if (!fi.exists())
+ {
+ err("Error: tag HTML_FOOTER: footer file `%s' "
+ "does not exist\n",footerFile.data());
+ exit(1);
+ }
+ }
+ // check include path
+ char *s=includePath.first();
+ while (s)
+ {
+ QFileInfo fi(s);
+ if (!fi.exists()) err("Warning: tag INCLUDE_PATH: include path `%s' "
+ "does not exist\n",s);
+ addSearchDir(fi.absFilePath());
+ s=includePath.next();
+ }
+ // check input
+ if (inputSources.count()==0)
+ {
+ err("Error: tag INPUT: no input files specified after the INPUT tag.\n");
+ exit(1);
+ }
+ else
+ {
+ s=inputSources.first();
+ while (s)
+ {
+ QFileInfo fi(s);
+ if (!fi.exists())
+ {
+ err("Error: tag INPUT: input source `%s' does not exist\n",s);
+ exit(1);
+ }
+ s=inputSources.next();
+ }
+ }
+ // add default pattern if needed
+ if (filePatternList.count()==0)
+ {
+ filePatternList.append("*");
+ }
+
+ // more checks needed if and only if the search engine is enabled.
+ if (searchEngineFlag)
+ {
+ // check cgi name
+ if (cgiName.length()==0)
+ {
+ err("Error: tag CGI_NAME: no cgi script name after the CGI_NAME tag.\n");
+ exit(1);
+ }
+ // check cgi URL
+ if (cgiURL.length()==0)
+ {
+ err("Error: tag CGI_URL: no URL to cgi directory specified.\n");
+ exit(1);
+ }
+ else if (cgiURL.left(7)!="http://")
+ {
+ err("Error: tag CGI_URL: URL to cgi directory is invalid (must "
+ "start with http://).\n");
+ exit(1);
+ }
+ // check documentation URL
+ if (docURL.length()==0)
+ {
+ docURL = outputDir.copy().prepend("file://").append("html");
+ }
+ else if (docURL.left(7)!="http://" && docURL.left(7)!="file://")
+ {
+ err("Error: tag DOC_URL: URL to documentation is invalid or "
+ "not absolute.\n");
+ exit(1);
+ }
+ // check absolute documentation path
+ if (docAbsPath.length()==0)
+ {
+ docAbsPath = outputDir+"/html";
+ }
+ else if (docAbsPath && docAbsPath[0]!='/')
+ {
+ err("Error: tag DOC_ABSPATH: path is not absolute\n");
+ exit(1);
+ }
+ // check path to doxysearch
+ if (binAbsPath.length()==0)
+ {
+ err("Error: tag BIN_ABSPATH: no absolute path to doxysearch "
+ "specified.\n");
+ exit(1);
+ }
+ else
+ {
+ if (binAbsPath && binAbsPath[0]!='/')
+ {
+ err("Error: tag BIN_ABSPATH: path is not absolute "
+ "(must start with /).\n");
+ exit(1);
+ }
+ }
+ // check perl path
+ if (perlPath.length()==0)
+ {
+ perlPath="/usr/local/bin/perl";
+ }
+ QFileInfo fi(perlPath);
+ if (!fi.exists())
+ {
+ err("Error: tag PERL_PATH: perl interpreter not found at `%s'\n",
+ perlPath.data());
+ exit(1);
+ }
+ }
+}
+
+void parseConfig(const QString &s)
+{
+ inputString = s;
+ inputPosition = 0;
+ yyLineNr = 1;
+ configYYrestart( configYYin );
+ BEGIN( Start );
+ configYYlex();
+ checkConfig();
+}
+
+extern "C" { // some bogus code to keep the compiler happy
+ int configYYwrap() { return 1 ; }
+}