doxygen-1.13.0/0000755000076500000240000000000014733727244012612 5ustar dimitristaffdoxygen-1.13.0/INSTALL0000644000076500000240000000023014275261450013627 0ustar dimitristaffDOXYGEN Please read the installation section of the manual (https://www.doxygen.nl/manual/install.html) for instructions. -------- Dimitri van Heesch doxygen-1.13.0/CMakeLists.txt0000644000076500000240000002614114667123366015357 0ustar dimitristaff# vim:ts=4:sw=4:expandtab:autoindent: # # 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. # # Documents produced by Doxygen are derivative works derived from the # input used in their production; they are not affected by this license. cmake_minimum_required(VERSION 3.14) project(doxygen) option("ENABLE_CLANG_TIDY" "Enable static analysis with clang-tidy" OFF) option(build_wizard "Build the GUI frontend for doxygen." OFF) option(build_app "Example showing how to embed doxygen in an application." OFF) option(build_parse "Parses source code and dumps the dependencies between the code elements." OFF) option(build_search "Build external search tools (doxysearch and doxyindexer)" OFF) option(build_doc "Build user manual (HTML and PDF)" OFF) option(build_doc_chm "Build user manual (CHM)" OFF) if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") option(use_libc++ "Use libc++ as C++ standard library." ON) endif() option(use_libclang "Add support for libclang parsing." OFF) option(use_sys_spdlog "Use system spdlog library instead of the one bundled." OFF) option(use_sys_sqlite3 "Use system sqlite3 library instead of the one bundled." OFF) option(static_libclang "Link to a statically compiled version of LLVM/libclang." OFF) option(win_static "Link with /MT in stead of /MD on windows" OFF) option(enable_console "Enable that executables on Windows get the CONSOLE bit set for the doxywizard executable [development]" OFF) option(enable_coverage "Enable coverage reporting for gcc/clang [development]" OFF) option(enable_tracing "Enable tracing option in release builds [development]" OFF) option(enable_lex_debug "Enable debugging info for lexical scanners in release builds [development]" OFF) set(force_qt CACHE INTERNAL "Forces doxywizard to build using the specified major version, this can be Qt5 or Qt6") set_property(CACHE force_qt PROPERTY STRINGS OFF Qt6 Qt5) SET(enlarge_lex_buffers "262144" CACHE INTERNAL "Sets the lex input and read buffers to the specified size") if(enable_coverage) if ("${PROJECT_BINARY_DIR}" STREQUAL "${PROJECT_SOURCE_DIR}") message(FATAL_ERROR "Doxygen cannot be generated in-place, the build directory (${PROJECT_BINARY_DIR}) has to differ from the doxygen main directory (${PROJECT_SOURCE_DIR})\nPlease don't forget to remove the already created file 'CMakeCache.txt' and the directory 'CMakeFiles'!") endif() endif() list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake") list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/Sanitizers") set(TOP "${PROJECT_SOURCE_DIR}") include(version) message(STATUS "Using Cmake version ${CMAKE_VERSION}") if (${CMAKE_VERSION} VERSION_LESS "3.21.0") set(depfile_supported "0" CACHE INTERNAL "DEPFILE is not supported") else() set(depfile_supported "1" CACHE INTERNAL "DEPFILE is supported") endif() set(clang "0" CACHE INTERNAL "used in settings.h") set(MACOS_VERSION_MIN 10.14) if (use_libclang) set(clang "1" CACHE INTERNAL "used in settings.h") find_package(LLVM CONFIG REQUIRED) find_package(Clang CONFIG REQUIRED) endif() if (use_sys_spdlog) find_package(spdlog CONFIG REQUIRED) endif() if (use_sys_sqlite3) find_package(SQLite3 REQUIRED) endif() if (build_wizard) if (force_qt STREQUAL "Qt6") if (CMAKE_SYSTEM MATCHES "Darwin") set(MACOS_VERSION_MIN 10.15) endif() endif() endif() # use C++17 standard for compiling set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS ON) if (ENABLE_CLANG_TIDY) find_program("CLANGTIDY" "clang-tidy") if (CLANGTIDY) set(CMAKE_CXX_CLANG_TIDY clang-tidy; -header-filter=.; -checks=-*,cppcoreguidelines-special-member-functions #-checks=-*,cppcoreguidelines-missing-std-forward #-checks=-*,cppcoreguidelines-init-variables #-checks=-*,cppcoreguidelines-misleading-capture-default-by-value #-checks=-*,modernize-use-nullptr #-checks=-*,modernize-use-override #-checks=-*,modernize-use-emplace ) else() message(SEND_ERROR "clang-tidy requested but executable not found") endif() endif() # produce compile_commands.json set(CMAKE_EXPORT_COMPILE_COMMANDS ON) if (FLEX_VERSION VERSION_LESS 2.6.0) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Dregister=") if (MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALLOW_KEYWORD_MACROS=") endif() endif() if (CMAKE_SYSTEM MATCHES "Darwin") set(CMAKE_OSX_DEPLOYMENT_TARGET "${MACOS_VERSION_MIN}" CACHE STRING "Minimum OS X deployment version" FORCE) set(CMAKE_CXX_FLAGS "-Wno-deprecated-register -mmacosx-version-min=${MACOS_VERSION_MIN} ${CMAKE_CXX_FLAGS}") set(CMAKE_C_FLAGS "-Wno-deprecated-register -mmacosx-version-min=${MACOS_VERSION_MIN} ${CMAKE_C_FLAGS}") find_library(CORESERVICES_LIB CoreServices) set(EXTRA_LIBS ${CORESERVICES_LIB}) endif() if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_LIBCPP_ENABLE_ASSERTIONS=1") elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_ASSERTIONS") endif() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSQLITE_OMIT_LOAD_EXTENSION=1") if (WIN32) if (MSVC) if (NOT ICONV_DIR) if(CMAKE_SIZEOF_VOID_P EQUAL 8) list(APPEND CMAKE_PREFIX_PATH "${PROJECT_SOURCE_DIR}/deps/iconv_winbuild/include" "${PROJECT_SOURCE_DIR}/deps/iconv_winbuild/x64") elseif(CMAKE_SIZEOF_VOID_P EQUAL 4) list(APPEND CMAKE_PREFIX_PATH "${PROJECT_SOURCE_DIR}/deps/iconv_winbuild/include" "${PROJECT_SOURCE_DIR}/deps/iconv_winbuild/x86") endif() else() list(APPEND CMAKE_PREFIX_PATH ${ICONV_DIR}) endif() set(CMAKE_REQUIRED_DEFINITIONS "-DLIBICONV_STATIC") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # needed for language.cpp on 64bit add_definitions(-DLIBICONV_STATIC -D_CRT_SECURE_NO_WARNINGS) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE") endif() if (CMAKE_GENERATOR MATCHES "NMake Makefiles") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") endif() endif() if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -Wa,-mbig-obj") if (CMAKE_BUILD_TYPE STREQUAL "") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O1") endif() endif() if (WIN32 AND MSVC) # workaround for GitHub runner, see https://github.com/actions/runner-images/issues/10004 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR") endif() if (CMAKE_SYSTEM_NAME MATCHES "Windows") if ((CMAKE_GENERATOR MATCHES "MinGW Makefiles") OR (CMAKE_GENERATOR MATCHES "MSYS Makefiles") OR (CMAKE_GENERATOR MATCHES "Unix Makefiles")) set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og") if (CMAKE_BUILD_TYPE STREQUAL "") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O1") endif() endif() endif() # needed for JavaCC set(JAVA_CC_EXTRA_FLAGS "-DJAVACC_CHAR_TYPE=\"unsigned char\"") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${JAVA_CC_EXTRA_FLAGS}") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${JAVA_CC_EXTRA_FLAGS}") if(POLICY CMP0063) cmake_policy(SET CMP0063 NEW) endif() # when using mutrace comment the next 3 lines and uncomment the last 2 set(CMAKE_CXX_VISIBILITY_PRESET hidden) set(CMAKE_C_VISIBILITY_PRESET hidden) set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -rdynamic") #set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -rdynamic") if (CMAKE_GENERATOR MATCHES "Ninja") set(LEX_FLAGS ) set(YACC_FLAGS ) set(JAVACC_FLAGS ) else () set(LEX_FLAGS $(LEX_FLAGS)) set(YACC_FLAGS $(YACC_FLAGS)) set(JAVACC_FLAGS $(JAVACC_FLAGS)) endif () find_program(DOT NAMES dot) find_package(Python REQUIRED) find_package(FLEX REQUIRED) if (FLEX_VERSION VERSION_LESS 2.5.37) message(SEND_ERROR "Doxygen requires at least flex version 2.5.37 (installed: ${FLEX_VERSION})") endif() find_package(BISON REQUIRED) if (BISON_VERSION VERSION_LESS 2.7) message(SEND_ERROR "Doxygen requires at least bison version 2.7 (installed: ${BISON_VERSION})") endif() find_package(Threads) find_package(Sanitizers) if ((CMAKE_BUILD_TYPE STREQUAL "Debug") OR enable_lex_debug) set(LEX_FLAGS "${LEX_FLAGS} -d") endif() find_package(Iconv REQUIRED) include_directories(${Iconv_INCLUDE_DIRS}) #set(DOXYDOCS ${PROJECT_SOURCE_DIR}/doc CACHE INTERNAL "Path to doxygen docs") set(DOXYDOCS ${PROJECT_BINARY_DIR}/doc) set(ENV{DOXYGEN_DOCDIR} ${DOXYDOCS}) set(GENERATED_SRC "${PROJECT_BINARY_DIR}/generated_src" CACHE INTERNAL "Stores generated files") set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin) # place binaries for all build types in the same directory, so we know where to find it # when running tests or generating docs set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${EXECUTABLE_OUTPUT_PATH}) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${EXECUTABLE_OUTPUT_PATH}) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${EXECUTABLE_OUTPUT_PATH}) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${EXECUTABLE_OUTPUT_PATH}) if (win_static) set(CompilerFlags CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO) foreach(CompilerFlag ${CompilerFlags}) string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}") endforeach() endif() include(cmake/CompilerWarnings.cmake) include(cmake/Coverage.cmake) include(cmake/WindowsEncoding.cmake) add_subdirectory(deps) add_subdirectory(libversion) add_subdirectory(libxml) add_subdirectory(vhdlparser) add_subdirectory(src) if (build_doc_chm) if (WIN32) find_package(HTMLHelp REQUIRED) set(build_doc ON) else () message(WARNING "CHM documentation generation not supported for this platform, ignoring setting.") set(build_doc_chm OFF) endif () endif () # always parse doc directory to at least install man pages add_subdirectory(doc) if (build_doc) add_subdirectory(examples) endif () add_subdirectory(doc_internal) find_package(generateDS) set(update_doxmlparser_dependency "") if (GENERATEDS_FOUND) set(update_doxmlparser_dependency "update_doxmlparser_files") endif() add_subdirectory(addon) enable_testing() add_subdirectory(testing) include(cmake/packaging.cmake) # set CPACK_xxxx properties include(CPack) doxygen-1.13.0/libxml/0000755000076500000240000000000014720337256014075 5ustar dimitristaffdoxygen-1.13.0/libxml/xml.l0000644000076500000240000003475614545611070015063 0ustar dimitristaff/****************************************************************************** * * Copyright (C) 1997-2020 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. * * Documents produced by Doxygen are derivative works derived from the * input used in their production; they are not affected by this license. * */ /****************************************************************************** * Minimal flex based parser for XML ******************************************************************************/ %option never-interactive %option prefix="xmlYY" %option reentrant %option extra-type="struct xmlYY_state *" %option 8bit noyywrap %top{ #include } %{ #include #include #include #include "xml.h" #define YY_NEVER_INTERACTIVE 1 #define YY_NO_INPUT 1 #define YY_NO_UNISTD_H 1 struct xmlYY_state { std::string fileName; int lineNr = 1; const char * inputString = nullptr; //!< the code fragment as text int inputPosition = 0; //!< read offset during parsing std::string name; bool isEnd = false; bool selfClose = false; std::string data; std::string attrValue; std::string attrName; XMLHandlers::Attributes attrs; XMLHandlers handlers; int cdataContext; int commentContext; char stringChar; std::string encoding; std::vector xpath; std::function transcodeFunc; }; #if USE_STATE2STRING static const char *stateToString(int state); #endif static int yyread(yyscan_t yyscanner,char *buf,int max_size); static void initElement(yyscan_t yyscanner); static void addCharacters(yyscan_t yyscanner); static void addElement(yyscan_t yyscanner); static void addAttribute(yyscan_t yyscanner); static void countLines(yyscan_t yyscanner, const char *txt,yy_size_t len); static void reportError(yyscan_t yyscanner, const std::string &msg); static std::string processData(yyscan_t yyscanner,const char *txt,yy_size_t len); #undef YY_INPUT #define YY_INPUT(buf,result,max_size) result=yyread(yyscanner,buf,max_size); %} NL (\r\n|\r|\n) SP [ \t\r\n]+ OPEN {SP}?"<" OPENSPECIAL {SP}?""{NL}? CLOSESPECIAL "?>"{NL}? NAMESTART [:A-Za-z\200-\377_] NAMECHAR [:A-Za-z\200-\377_0-9.-] NAME {NAMESTART}{NAMECHAR}* ESC "&#"[0-9]+";"|"&#x"[0-9a-fA-F]+";" COLON ":" PCDATA [^<]+ COMMENT {OPEN}"!--" COMMENTEND "--"{CLOSE} STRING \"([^"&]|{ESC})*\"|\'([^'&]|{ESC})*\' DOCTYPE {SP}?"" %option noyywrap %s Initial %s Content %s CDataSection %s Element %s Attributes %s AttributeValue %s AttrValueStr %s Prolog %s Comment %% { {SP} { countLines(yyscanner,yytext,yyleng); } {DOCTYPE} { countLines(yyscanner,yytext,yyleng); } {OPENSPECIAL} { countLines(yyscanner,yytext,yyleng); BEGIN(Prolog); } {OPEN} { countLines(yyscanner,yytext,yyleng); initElement(yyscanner); BEGIN(Element); } {COMMENT} { yyextra->commentContext = YY_START; BEGIN(Comment); } } { {CDATA} { countLines(yyscanner,yytext,yyleng); yyextra->cdataContext = YY_START; BEGIN(CDataSection); } {PCDATA} { yyextra->data += processData(yyscanner,yytext,yyleng); } {OPEN} { countLines(yyscanner,yytext,yyleng); addCharacters(yyscanner); initElement(yyscanner); BEGIN(Element); } {COMMENT} { yyextra->commentContext = YY_START; countLines(yyscanner,yytext,yyleng); BEGIN(Comment); } } { "/" { yyextra->isEnd = true; } {NAME} { yyextra->name = yytext; BEGIN(Attributes); } {CLOSE} { addElement(yyscanner); countLines(yyscanner,yytext,yyleng); yyextra->data = ""; BEGIN(Content); } {SP} { countLines(yyscanner,yytext,yyleng); } } { "/" { yyextra->selfClose = true; } {NAME} { yyextra->attrName = yytext; } "=" { BEGIN(AttributeValue); } {CLOSE} { addElement(yyscanner); countLines(yyscanner,yytext,yyleng); yyextra->data = ""; BEGIN(Content); } {SP} { countLines(yyscanner,yytext,yyleng); } } { {SP} { countLines(yyscanner,yytext,yyleng); } ['"] { yyextra->stringChar = *yytext; yyextra->attrValue = ""; BEGIN(AttrValueStr); } . { std::string msg = std::string("Missing attribute value. Unexpected character `")+yytext+"` found"; reportError(yyscanner,msg); unput(*yytext); BEGIN(Attributes); } } { [^'"\n]+ { yyextra->attrValue += processData(yyscanner,yytext,yyleng); } ['"] { if (*yytext==yyextra->stringChar) { addAttribute(yyscanner); BEGIN(Attributes); } else { yyextra->attrValue += processData(yyscanner,yytext,yyleng); } } \n { yyextra->lineNr++; yyextra->attrValue+=' '; } } { {ENDCDATA} { BEGIN(yyextra->cdataContext); } [^]\n]+ { yyextra->data += yytext; } \n { yyextra->data += yytext; yyextra->lineNr++; } . { yyextra->data += yytext; } } { "encoding"\s*=\s*\"[^\"]*\" { std::string encoding=yytext; size_t i=encoding.find('"'); encoding=encoding.substr(i+1,yyleng-i-2); if (encoding!="UTF-8") // need to transcode to UTF-8 { yyextra->encoding=encoding; } } {CLOSESPECIAL} { countLines(yyscanner,yytext,yyleng); BEGIN(Initial); } \n { yyextra->lineNr++; } . { } } { {COMMENTEND} { countLines(yyscanner,yytext,yyleng); BEGIN(yyextra->commentContext); } [^\n-]+ { } \n { yyextra->lineNr++; } . { } } \n { yyextra->lineNr++; } . { std::string msg = "Unexpected character `"; msg+=yytext; msg+="` found"; reportError(yyscanner,msg); } %% //---------------------------------------------------------------------------------------- static int yyread(yyscan_t yyscanner,char *buf,int max_size) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; int inputPosition = yyextra->inputPosition; const char *s = yyextra->inputString + inputPosition; int c=0; while( c < max_size && *s) { *buf++ = *s++; c++; } yyextra->inputPosition += c; return c; } static void countLines(yyscan_t yyscanner, const char *txt,yy_size_t len) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; for (yy_size_t i=0;ilineNr++; } } static void initElement(yyscan_t yyscanner) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; yyextra->isEnd = false; // true => yyextra->selfClose = false; // true => yyextra->name = ""; yyextra->attrs.clear(); } static void checkAndUpdatePath(yyscan_t yyscanner) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; if (yyextra->xpath.empty()) { std::string msg = "found closing tag '"+yyextra->name+"' without matching opening tag"; reportError(yyscanner,msg); } else { std::string expectedTagName = yyextra->xpath.back(); if (expectedTagName!=yyextra->name) { std::string msg = "Found closing tag '"+yyextra->name+"' that does not match the opening tag '"+expectedTagName+"' at the same level"; reportError(yyscanner,msg); } else // matching end tag { yyextra->xpath.pop_back(); } } } static void addElement(yyscan_t yyscanner) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; if (!yyextra->isEnd) { yyextra->xpath.push_back(yyextra->name); if (yyextra->handlers.startElement) { yyextra->handlers.startElement(yyextra->name,yyextra->attrs); } if (yy_flex_debug) { fprintf(stderr,"%d: startElement(%s,attr=[",yyextra->lineNr,yyextra->name.data()); for (auto attr : yyextra->attrs) { fprintf(stderr,"%s='%s' ",attr.first.c_str(),attr.second.c_str()); } fprintf(stderr,"])\n"); } } if (yyextra->isEnd || yyextra->selfClose) { if (yy_flex_debug) { fprintf(stderr,"%d: endElement(%s)\n",yyextra->lineNr,yyextra->name.data()); } checkAndUpdatePath(yyscanner); if (yyextra->handlers.endElement) { yyextra->handlers.endElement(yyextra->name); } } } static std::string trimSpaces(const std::string &str) { const int l = static_cast(str.length()); int s=0, e=l-1; while (ss && isspace(str.at(e))) e--; return str.substr(s,1+e-s); } static void addCharacters(yyscan_t yyscanner) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; std::string data = trimSpaces(yyextra->data); if (!yyextra->encoding.empty() && !yyextra->transcodeFunc(data,yyextra->encoding.c_str())) { reportError(yyscanner,"failed to transcode string '"+data+"' from encoding '"+yyextra->encoding+"' to UTF-8"); } if (yyextra->handlers.characters) { yyextra->handlers.characters(data); } if (!data.empty()) { if (yy_flex_debug) { fprintf(stderr,"characters(%s)\n",data.c_str()); } } } static void addAttribute(yyscan_t yyscanner) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; std::string val = yyextra->attrValue; if (!yyextra->encoding.empty() && !yyextra->transcodeFunc(val,yyextra->encoding.c_str())) { reportError(yyscanner,"failed to transcode string '"+val+"' from encoding '"+yyextra->encoding+"' to UTF-8"); } yyextra->attrs.insert(std::make_pair(yyextra->attrName,val)); } static void reportError(yyscan_t yyscanner,const std::string &msg) { struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; if (yy_flex_debug) { fprintf(stderr,"%s:%d: Error '%s'\n",yyextra->fileName.c_str(),yyextra->lineNr,msg.c_str()); } if (yyextra->handlers.error) { yyextra->handlers.error(yyextra->fileName,yyextra->lineNr,msg); } } static const char *entities_enc[] = { "amp", "quot", "gt", "lt", "apos" }; static const char entities_dec[] = { '&', '"', '>', '<', '\'' }; static const int num_entities = 5; // replace character entities such as & in txt and return the string where entities // are replaced static std::string processData(yyscan_t yyscanner,const char *txt,yy_size_t len) { std::string result; result.reserve(len); for (yy_size_t i=0; ixmlYY_extra,&p->yyscanner); p->xmlYY_extra.handlers = handlers; } XMLParser::~XMLParser() { xmlYYlex_destroy(p->yyscanner); } void XMLParser::parse(const char *fileName, const char *inputStr, bool debugEnabled, std::function debugStart, std::function debugEnd, std::function transcodeFunc) { yyscan_t yyscanner = p->yyscanner; struct yyguts_t *yyg = (struct yyguts_t*)yyscanner; #ifdef FLEX_DEBUG xmlYYset_debug(debugEnabled?1:0,p->yyscanner); #endif if (inputStr==nullptr || inputStr[0]=='\0') return; // empty input debugStart(); BEGIN(Initial); yyextra->fileName = fileName; yyextra->lineNr = 1; yyextra->inputString = inputStr; yyextra->inputPosition = 0; yyextra->transcodeFunc = transcodeFunc; if (static_cast(inputStr[0])==0xEF && static_cast(inputStr[1])==0xBB && static_cast(inputStr[2])==0xBF) { yyextra->inputPosition = 3; // remove UTF-8 BOM } xmlYYrestart( 0, yyscanner ); if (yyextra->handlers.startDocument) { yyextra->handlers.startDocument(); } xmlYYlex(yyscanner); if (yyextra->handlers.endDocument) { yyextra->handlers.endDocument(); } if (!yyextra->xpath.empty()) { std::string tagName = yyextra->xpath.back(); std::string msg = "End of file reached while expecting closing tag '"+tagName+"'"; reportError(yyscanner,msg); } debugEnd(); } int XMLParser::lineNr() const { struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner; return yyextra->lineNr; } std::string XMLParser::fileName() const { struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner; return yyextra->fileName; } #if USE_STATE2STRING #include "xml.l.h" #endif doxygen-1.13.0/libxml/CMakeLists.txt0000644000076500000240000000107514545611070016632 0ustar dimitristaffinclude_directories( ${PROJECT_SOURCE_DIR}/libxml ) add_custom_command( COMMAND ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/src/scan_states.py ${PROJECT_SOURCE_DIR}/libxml/xml.l > ${GENERATED_SRC}/xml.l.h DEPENDS ${PROJECT_SOURCE_DIR}/src/scan_states.py ${PROJECT_SOURCE_DIR}/libxml/xml.l OUTPUT ${GENERATED_SRC}/xml.l.h ) set_source_files_properties(${GENERATED_SRC}/xml.l.h PROPERTIES GENERATED 1) FLEX_TARGET(xml xml.l ${GENERATED_SRC}/xml.cpp COMPILE_FLAGS "${LEX_FLAGS}") add_library(xml STATIC ${GENERATED_SRC}/xml.cpp ${GENERATED_SRC}/xml.l.h ) doxygen-1.13.0/libxml/xml.h0000644000076500000240000001025014607012174015035 0ustar dimitristaff#ifndef XML_H #define XML_H /****************************************************************************** * * Copyright (C) 1997-2021 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. * * Documents produced by Doxygen are derivative works derived from the * input used in their production; they are not affected by this license. * */ #include #include #include #include /*! @brief Event handlers that can installed by the client and called while parsing a XML document. */ class XMLHandlers { public: using Attributes = std::unordered_map; using StartDocType = void(); using EndDocType = void(); using StartElementType = void(const std::string &,const Attributes &); using EndElementType = void(const std::string &); using ErrorType = void(const std::string,int,const std::string &); using CharsType = void(const std::string &); std::function startDocument; /**< handler invoked at the start of the document */ std::function endDocument; /**< handler invoked at the end of the document */ std::function startElement; /**< handler invoked when an opening tag has been found */ std::function endElement; /**< handler invoked when a closing tag has been found */ std::function characters; /**< handler invoked when content between tags has been found */ std::function error; /**< handler invoked when the parser encounters an error */ static std::string value(const Attributes &attrib,const std::string &key) { auto it = attrib.find(key); if (it!=attrib.end()) { return it->second; } return ""; } }; class XMLLocator { public: XMLLocator() = default; XMLLocator(const XMLLocator &) = delete; XMLLocator &operator=(const XMLLocator &) = delete; XMLLocator(XMLLocator &&) = delete; XMLLocator &operator=(XMLLocator &&) = delete; virtual ~XMLLocator() = default; virtual int lineNr() const = 0; virtual std::string fileName() const = 0; }; /*! Very basic SAX style parser to parse XML documents. */ class XMLParser : public XMLLocator { public: /*! Creates an instance of the parser object. Different instances can run on different * threads without interference. * * @param handlers The event handlers passed by the client. */ XMLParser(const XMLHandlers &handlers); /*! Destructor */ ~XMLParser() override; XMLParser(const XMLParser &) = delete; XMLParser &operator=(const XMLParser &) = delete; XMLParser(XMLParser &&) = delete; XMLParser &operator=(XMLParser &&) = delete; using Transcode = bool(std::string &,const char *); /*! Parses a file gives the contents of the file as a string. * @param fileName the name of the file, used for error reporting. * @param inputString the contents of the file as a zero terminated UTF-8 string. * @param debugEnabled indicates if debugging via -d lex is enabled or not. * @param debugStart hook that is to be called before starting with parsing * @param debugEnd hook that is to be called after finishing with parsing * @param transcoder hook that is to be called when transcoding text to UTF-8 */ void parse(const char *fileName, const char *inputString, bool debugEnabled, std::function debugStart, std::function debugEnd, std::function transcoder = [](std::string&s,const char *){ return true; } ); private: int lineNr() const override; std::string fileName() const override; struct Private; std::unique_ptr p; }; #endif doxygen-1.13.0/LICENSE0000644000076500000240000004325414275261450013620 0ustar dimitristaff GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. doxygen-1.13.0/cmake/0000755000076500000240000000000014733535657013677 5ustar dimitristaffdoxygen-1.13.0/cmake/git_watcher.cmake0000644000076500000240000002007214644164135017170 0ustar dimitristaff# git_watcher.cmake # # License: MIT # Source: https://raw.githubusercontent.com/andrew-hardin/cmake-git-version-tracking/master/git_watcher.cmake # This file defines the functions and targets needed to monitor # the state of a git repo. If the state changes (e.g. a commit is made), # then a file gets reconfigured. # # The behavior of this script can be modified by defining any of these variables: # # PRE_CONFIGURE_GIT_VERSION_FILE (REQUIRED) # -- The path to the file that'll be configured. # # POST_CONFIGURE_GIT_VERSION_FILE (REQUIRED) # -- The path to the configured PRE_CONFIGURE_GIT_VERSION_FILE. # # GIT_STATE_FILE (OPTIONAL) # -- The path to the file used to store the previous build's git state. # Defaults to the current binary directory. # # GIT_WORKING_DIR (OPTIONAL) # -- The directory from which git commands will be run. # Defaults to the directory with the top level CMakeLists.txt. # # GIT_EXECUTABLE (OPTIONAL) # -- The path to the git executable. It'll automatically be set if the # user doesn't supply a path. # # Script design: # - This script was designed similar to a Python application # with a Main() function. I wanted to keep it compact to # simplify "copy + paste" usage. # # - This script is made to operate in two CMake contexts: # 1. Configure time context (when build files are created). # 2. Build time context (called via CMake -P) # If you see something odd (e.g. the NOT DEFINED clauses), # consider that it can run in one of two contexts. # Short hand for converting paths to absolute. macro(PATH_TO_ABSOLUTE var_name) get_filename_component(${var_name} "${${var_name}}" ABSOLUTE) endmacro() # Check that a required variable is set. macro(CHECK_REQUIRED_VARIABLE var_name) if(NOT DEFINED ${var_name}) message(FATAL_ERROR "The \"${var_name}\" variable must be defined.") endif() PATH_TO_ABSOLUTE(${var_name}) endmacro() # Check that an optional variable is set, or, set it to a default value. macro(CHECK_OPTIONAL_VARIABLE var_name default_value) if(NOT DEFINED ${var_name}) set(${var_name} ${default_value}) endif() PATH_TO_ABSOLUTE(${var_name}) endmacro() CHECK_REQUIRED_VARIABLE(PRE_CONFIGURE_GIT_VERSION_FILE) CHECK_REQUIRED_VARIABLE(POST_CONFIGURE_GIT_VERSION_FILE) CHECK_REQUIRED_VARIABLE(GIT_CONFIG_DIR) CHECK_OPTIONAL_VARIABLE(GIT_STATE_FILE "${GENERATED_SRC}/git_state") #CHECK_REQUIRED_VARIABLE(GIT_STATE_FILE) CHECK_OPTIONAL_VARIABLE(GIT_WORKING_DIR "${PROJECT_SOURCE_DIR}") # Check the optional git variable. # If it's not set, we'll try to find it using the CMake packaging system. if(NOT DEFINED GIT_EXECUTABLE) find_package(Git QUIET) endif() CHECK_REQUIRED_VARIABLE(GIT_EXECUTABLE) # Function: GitStateChangedAction # Description: this function is executed when the state of the git # repo changes (e.g. a commit is made). function(GitStateChangedAction _state_as_list) # Set variables by index, then configure the file w/ these variables defined. LIST(GET _state_as_list 0 GIT_RETRIEVED_STATE) LIST(GET _state_as_list 1 GIT_HEAD_SHA1) LIST(GET _state_as_list 2 GIT_IS_DIRTY) configure_file("${PRE_CONFIGURE_GIT_VERSION_FILE}" "${POST_CONFIGURE_GIT_VERSION_FILE}" @ONLY) endfunction() # Function: GetGitState # Description: gets the current state of the git repo. # Args: # _working_dir (in) string; the directory from which git commands will be executed. # _state (out) list; a collection of variables representing the state of the # repository (e.g. commit SHA). function(GetGitState _working_dir _state) # Get the hash for HEAD. set(_success "true") if(EXISTS "${GIT_CONFIG_DIR}") execute_process(COMMAND "${GIT_EXECUTABLE}" rev-parse --verify HEAD WORKING_DIRECTORY "${_working_dir}" RESULT_VARIABLE res OUTPUT_VARIABLE _hashvar ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT res EQUAL 0) set(_success "false") set(_hashvar "GIT-NOTFOUND") endif() # Get whether or not the working tree is dirty. execute_process(COMMAND "${GIT_EXECUTABLE}" status --porcelain WORKING_DIRECTORY "${_working_dir}" RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT res EQUAL 0) set(_success "false") set(_dirty "false") else() if(NOT "${out}" STREQUAL "") set(_dirty "true") else() set(_dirty "false") endif() endif() else() set(_success "false") set(_hashvar "GIT-NOTFOUND") set(_dirty "false") endif() # Return a list of our variables to the parent scope. set(${_state} ${_success} ${_hashvar} ${_dirty} PARENT_SCOPE) endfunction() # Function: CheckGit # Description: check if the git repo has changed. If so, update the state file. # Args: # _working_dir (in) string; the directory from which git commands will be ran. # _state_changed (out) bool; whether or no the state of the repo has changed. # _state (out) list; the repository state as a list (e.g. commit SHA). function(CheckGit _working_dir _state_changed _state) # Get the current state of the repo. GetGitState("${_working_dir}" state) # Set the output _state variable. # (Passing by reference in CMake is awkward...) set(${_state} ${state} PARENT_SCOPE) if(EXISTS "${POST_CONFIGURE_GIT_VERSION_FILE}") if("${PRE_CONFIGURE_GIT_VERSION_FILE}" IS_NEWER_THAN "${POST_CONFIGURE_GIT_VERSION_FILE}") file(REMOVE "${POST_CONFIGURE_GIT_VERSION_FILE}") file(REMOVE "${GIT_STATE_FILE}") set(${_state_changed} "true" PARENT_SCOPE) return() endif() else() file(REMOVE "${GIT_STATE_FILE}") set(${_state_changed} "true" PARENT_SCOPE) return() endif() # Check if the state has changed compared to the backup on disk. if(EXISTS "${GIT_STATE_FILE}") file(READ "${GIT_STATE_FILE}" OLD_HEAD_CONTENTS) if(OLD_HEAD_CONTENTS STREQUAL "${state}") # State didn't change. set(${_state_changed} "false" PARENT_SCOPE) return() endif() endif() # The state has changed. # We need to update the state file on disk. # Future builds will compare their state to this file. file(WRITE "${GIT_STATE_FILE}" "${state}") set(${_state_changed} "true" PARENT_SCOPE) endfunction() # Function: SetupGitMonitoring # Description: this function sets up custom commands that make the build system # check the state of git before every build. If the state has # changed, then a file is configured. function(SetupGitMonitoring) add_custom_target(check_git_repository ALL DEPENDS ${PRE_CONFIGURE_GIT_VERSION_FILE} BYPRODUCTS ${POST_CONFIGURE_GIT_VERSION_FILE} BYPRODUCTS ${GIT_STATE_FILE} COMMENT "Checking the git repository for changes..." COMMAND ${CMAKE_COMMAND} -D_BUILD_TIME_CHECK_GIT=TRUE -DGIT_WORKING_DIR=${GIT_WORKING_DIR} -DGIT_EXECUTABLE=${GIT_EXECUTABLE} -DGIT_STATE_FILE=${GIT_STATE_FILE} -DGIT_CONFIG_DIR=${GIT_CONFIG_DIR} -DPRE_CONFIGURE_GIT_VERSION_FILE=${PRE_CONFIGURE_GIT_VERSION_FILE} -DPOST_CONFIGURE_GIT_VERSION_FILE=${POST_CONFIGURE_GIT_VERSION_FILE} -P "${CMAKE_CURRENT_LIST_FILE}") endfunction() # Function: Main # Description: primary entry-point to the script. Functions are selected based # on whether it's configure or build time. function(Main) if(_BUILD_TIME_CHECK_GIT) # Check if the repo has changed. # If so, run the change action. CheckGit("${GIT_WORKING_DIR}" did_change state) if(did_change) GitStateChangedAction("${state}") endif() else() # >> Executes at configure time. SetupGitMonitoring() endif() endfunction() # And off we go... Main() doxygen-1.13.0/cmake/Sanitizers/0000755000076500000240000000000014545611070016013 5ustar dimitristaffdoxygen-1.13.0/cmake/Sanitizers/sanitize-helpers.cmake0000644000076500000240000001700414275261450022310 0ustar dimitristaff# The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # Helper function to get the language of a source file. function (sanitizer_lang_of_source FILE RETURN_VAR) get_filename_component(LONGEST_EXT "${FILE}" EXT) # If extension is empty return. This can happen for extensionless headers if("${LONGEST_EXT}" STREQUAL "") set(${RETURN_VAR} "" PARENT_SCOPE) return() endif() # Get shortest extension as some files can have dot in their names string(REGEX REPLACE "^.*(\\.[^.]+)$" "\\1" FILE_EXT ${LONGEST_EXT}) string(TOLOWER "${FILE_EXT}" FILE_EXT) string(SUBSTRING "${FILE_EXT}" 1 -1 FILE_EXT) get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES) foreach (LANG ${ENABLED_LANGUAGES}) list(FIND CMAKE_${LANG}_SOURCE_FILE_EXTENSIONS "${FILE_EXT}" TEMP) if (NOT ${TEMP} EQUAL -1) set(${RETURN_VAR} "${LANG}" PARENT_SCOPE) return() endif () endforeach() set(${RETURN_VAR} "" PARENT_SCOPE) endfunction () # Helper function to get compilers used by a target. function (sanitizer_target_compilers TARGET RETURN_VAR) # Check if all sources for target use the same compiler. If a target uses # e.g. C and Fortran mixed and uses different compilers (e.g. clang and # gfortran) this can trigger huge problems, because different compilers may # use different implementations for sanitizers. set(BUFFER "") get_target_property(TSOURCES ${TARGET} SOURCES) foreach (FILE ${TSOURCES}) # If expression was found, FILE is a generator-expression for an object # library. Object libraries will be ignored. string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _file ${FILE}) if ("${_file}" STREQUAL "") sanitizer_lang_of_source(${FILE} LANG) if (LANG) list(APPEND BUFFER ${CMAKE_${LANG}_COMPILER_ID}) endif () endif () endforeach () list(REMOVE_DUPLICATES BUFFER) set(${RETURN_VAR} "${BUFFER}" PARENT_SCOPE) endfunction () # Helper function to check compiler flags for language compiler. function (sanitizer_check_compiler_flag FLAG LANG VARIABLE) if (${LANG} STREQUAL "C") include(CheckCCompilerFlag) check_c_compiler_flag("${FLAG}" ${VARIABLE}) elseif (${LANG} STREQUAL "CXX") include(CheckCXXCompilerFlag) check_cxx_compiler_flag("${FLAG}" ${VARIABLE}) elseif (${LANG} STREQUAL "Fortran") # CheckFortranCompilerFlag was introduced in CMake 3.x. To be compatible # with older Cmake versions, we will check if this module is present # before we use it. Otherwise we will define Fortran coverage support as # not available. include(CheckFortranCompilerFlag OPTIONAL RESULT_VARIABLE INCLUDED) if (INCLUDED) check_fortran_compiler_flag("${FLAG}" ${VARIABLE}) elseif (NOT CMAKE_REQUIRED_QUIET) message(STATUS "Performing Test ${VARIABLE}") message(STATUS "Performing Test ${VARIABLE}" " - Failed (Check not supported)") endif () endif() endfunction () # Helper function to test compiler flags. function (sanitizer_check_compiler_flags FLAG_CANDIDATES NAME PREFIX) set(CMAKE_REQUIRED_QUIET ${${PREFIX}_FIND_QUIETLY}) get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES) foreach (LANG ${ENABLED_LANGUAGES}) # Sanitizer flags are not dependent on language, but the used compiler. # So instead of searching flags foreach language, search flags foreach # compiler used. set(COMPILER ${CMAKE_${LANG}_COMPILER_ID}) if (NOT DEFINED ${PREFIX}_${COMPILER}_FLAGS) foreach (FLAG ${FLAG_CANDIDATES}) if(NOT CMAKE_REQUIRED_QUIET) message(STATUS "Try ${COMPILER} ${NAME} flag = [${FLAG}]") endif() set(CMAKE_REQUIRED_FLAGS "${FLAG}") unset(${PREFIX}_FLAG_DETECTED CACHE) sanitizer_check_compiler_flag("${FLAG}" ${LANG} ${PREFIX}_FLAG_DETECTED) if (${PREFIX}_FLAG_DETECTED) # If compiler is a GNU compiler, search for static flag, if # SANITIZE_LINK_STATIC is enabled. if (SANITIZE_LINK_STATIC AND (${COMPILER} STREQUAL "GNU")) string(TOLOWER ${PREFIX} PREFIX_lower) sanitizer_check_compiler_flag( "-static-lib${PREFIX_lower}" ${LANG} ${PREFIX}_STATIC_FLAG_DETECTED) if (${PREFIX}_STATIC_FLAG_DETECTED) set(FLAG "-static-lib${PREFIX_lower} ${FLAG}") endif () endif () set(${PREFIX}_${COMPILER}_FLAGS "${FLAG}" CACHE STRING "${NAME} flags for ${COMPILER} compiler.") mark_as_advanced(${PREFIX}_${COMPILER}_FLAGS) break() endif () endforeach () if (NOT ${PREFIX}_FLAG_DETECTED) set(${PREFIX}_${COMPILER}_FLAGS "" CACHE STRING "${NAME} flags for ${COMPILER} compiler.") mark_as_advanced(${PREFIX}_${COMPILER}_FLAGS) message(WARNING "${NAME} is not available for ${COMPILER} " "compiler. Targets using this compiler will be " "compiled without ${NAME}.") endif () endif () endforeach () endfunction () # Helper to assign sanitizer flags for TARGET. function (sanitizer_add_flags TARGET NAME PREFIX) # Get list of compilers used by target and check, if sanitizer is available # for this target. Other compiler checks like check for conflicting # compilers will be done in add_sanitizers function. sanitizer_target_compilers(${TARGET} TARGET_COMPILER) list(LENGTH TARGET_COMPILER NUM_COMPILERS) if ("${${PREFIX}_${TARGET_COMPILER}_FLAGS}" STREQUAL "") return() endif() # Set compile- and link-flags for target. set_property(TARGET ${TARGET} APPEND_STRING PROPERTY COMPILE_FLAGS " ${${PREFIX}_${TARGET_COMPILER}_FLAGS}") set_property(TARGET ${TARGET} APPEND_STRING PROPERTY COMPILE_FLAGS " ${SanBlist_${TARGET_COMPILER}_FLAGS}") set_property(TARGET ${TARGET} APPEND_STRING PROPERTY LINK_FLAGS " ${${PREFIX}_${TARGET_COMPILER}_FLAGS}") endfunction () doxygen-1.13.0/cmake/Sanitizers/FindMSan.cmake0000644000076500000240000000436414275261450020466 0ustar dimitristaff# The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. option(SANITIZE_MEMORY "Enable MemorySanitizer for sanitized targets." Off) set(FLAG_CANDIDATES "-g -fsanitize=memory" ) include(sanitize-helpers) if (SANITIZE_MEMORY) if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux") message(WARNING "MemorySanitizer disabled for target ${TARGET} because " "MemorySanitizer is supported for Linux systems only.") set(SANITIZE_MEMORY Off CACHE BOOL "Enable MemorySanitizer for sanitized targets." FORCE) elseif (NOT ${CMAKE_SIZEOF_VOID_P} EQUAL 8) message(WARNING "MemorySanitizer disabled for target ${TARGET} because " "MemorySanitizer is supported for 64bit systems only.") set(SANITIZE_MEMORY Off CACHE BOOL "Enable MemorySanitizer for sanitized targets." FORCE) else () sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "MemorySanitizer" "MSan") endif () endif () function (add_sanitize_memory TARGET) if (NOT SANITIZE_MEMORY) return() endif () sanitizer_add_flags(${TARGET} "MemorySanitizer" "MSan") endfunction () doxygen-1.13.0/cmake/Sanitizers/asan-wrapper0000755000076500000240000000373314545611070020347 0ustar dimitristaff#!/bin/sh # The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # This script is a wrapper for AddressSanitizer. In some special cases you need # to preload AddressSanitizer to avoid error messages - e.g. if you're # preloading another library to your application. At the moment this script will # only do something, if we're running on a Linux platform. OSX might not be # affected. # Exit immediately, if platform is not Linux. if [ "$(uname)" != "Linux" ] then exec $@ fi # Get the used libasan of the application ($1). If a libasan was found, it will # be prepended to LD_PRELOAD. libasan=$(ldd $1 | grep libasan | sed "s/^[[:space:]]//" | cut -d' ' -f1) if [ -n "$libasan" ] then if [ -n "$LD_PRELOAD" ] then export LD_PRELOAD="$libasan:$LD_PRELOAD" else export LD_PRELOAD="$libasan" fi fi # Execute the application. exec $@ doxygen-1.13.0/cmake/Sanitizers/FindUBSan.cmake0000644000076500000240000000324014275261450020570 0ustar dimitristaff# The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. option(SANITIZE_UNDEFINED "Enable UndefinedBehaviorSanitizer for sanitized targets." Off) set(FLAG_CANDIDATES "-g -fsanitize=undefined" ) include(sanitize-helpers) if (SANITIZE_UNDEFINED) sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "UndefinedBehaviorSanitizer" "UBSan") endif () function (add_sanitize_undefined TARGET) if (NOT SANITIZE_UNDEFINED) return() endif () sanitizer_add_flags(${TARGET} "UndefinedBehaviorSanitizer" "UBSan") endfunction () doxygen-1.13.0/cmake/Sanitizers/FindSanitizers.cmake0000644000076500000240000000723114275261450021757 0ustar dimitristaff# The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # If any of the used compiler is a GNU compiler, add a second option to static # link against the sanitizers. option(SANITIZE_LINK_STATIC "Try to link static against sanitizers." Off) set(FIND_QUIETLY_FLAG "") if (DEFINED Sanitizers_FIND_QUIETLY) set(FIND_QUIETLY_FLAG "QUIET") endif () find_package(ASan ${FIND_QUIETLY_FLAG}) find_package(TSan ${FIND_QUIETLY_FLAG}) find_package(MSan ${FIND_QUIETLY_FLAG}) find_package(UBSan ${FIND_QUIETLY_FLAG}) function(sanitizer_add_blacklist_file FILE) if(NOT IS_ABSOLUTE ${FILE}) set(FILE "${CMAKE_CURRENT_SOURCE_DIR}/${FILE}") endif() get_filename_component(FILE "${FILE}" REALPATH) sanitizer_check_compiler_flags("-fsanitize-blacklist=${FILE}" "SanitizerBlacklist" "SanBlist") endfunction() function(add_sanitizers ...) # If no sanitizer is enabled, return immediately. if (NOT (SANITIZE_ADDRESS OR SANITIZE_MEMORY OR SANITIZE_THREAD OR SANITIZE_UNDEFINED)) return() endif () foreach (TARGET ${ARGV}) # Check if this target will be compiled by exactly one compiler. Other- # wise sanitizers can't be used and a warning should be printed once. get_target_property(TARGET_TYPE ${TARGET} TYPE) if (TARGET_TYPE STREQUAL "INTERFACE_LIBRARY") message(WARNING "Can't use any sanitizers for target ${TARGET}, " "because it is an interface library and cannot be " "compiled directly.") return() endif () sanitizer_target_compilers(${TARGET} TARGET_COMPILER) list(LENGTH TARGET_COMPILER NUM_COMPILERS) if (NUM_COMPILERS GREATER 1) message(WARNING "Can't use any sanitizers for target ${TARGET}, " "because it will be compiled by incompatible compilers. " "Target will be compiled without sanitizers.") return() # If the target is compiled by no or no known compiler, give a warning. elseif (NUM_COMPILERS EQUAL 0) message(WARNING "Sanitizers for target ${TARGET} may not be" " usable, because it uses no or an unknown compiler. " "This is a false warning for targets using only " "object lib(s) as input.") endif () # Add sanitizers for target. add_sanitize_address(${TARGET}) add_sanitize_thread(${TARGET}) add_sanitize_memory(${TARGET}) add_sanitize_undefined(${TARGET}) endforeach () endfunction(add_sanitizers) doxygen-1.13.0/cmake/Sanitizers/FindTSan.cmake0000644000076500000240000000477314275261450020501 0ustar dimitristaff# The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. option(SANITIZE_THREAD "Enable ThreadSanitizer for sanitized targets." Off) set(FLAG_CANDIDATES "-g -fsanitize=thread" ) # ThreadSanitizer is not compatible with MemorySanitizer. if (SANITIZE_THREAD AND SANITIZE_MEMORY) message(FATAL_ERROR "ThreadSanitizer is not compatible with " "MemorySanitizer.") endif () include(sanitize-helpers) if (SANITIZE_THREAD) if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") message(WARNING "ThreadSanitizer disabled for target ${TARGET} because " "ThreadSanitizer is supported for Linux systems and macOS only.") set(SANITIZE_THREAD Off CACHE BOOL "Enable ThreadSanitizer for sanitized targets." FORCE) elseif (NOT ${CMAKE_SIZEOF_VOID_P} EQUAL 8) message(WARNING "ThreadSanitizer disabled for target ${TARGET} because " "ThreadSanitizer is supported for 64bit systems only.") set(SANITIZE_THREAD Off CACHE BOOL "Enable ThreadSanitizer for sanitized targets." FORCE) else () sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "ThreadSanitizer" "TSan") endif () endif () function (add_sanitize_thread TARGET) if (NOT SANITIZE_THREAD) return() endif () sanitizer_add_flags(${TARGET} "ThreadSanitizer" "TSan") endfunction () doxygen-1.13.0/cmake/Sanitizers/FindASan.cmake0000644000076500000240000000414014275261450020442 0ustar dimitristaff# The MIT License (MIT) # # Copyright (c) # 2013 Matthew Arsenault # 2015-2016 RWTH Aachen University, Federal Republic of Germany # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. option(SANITIZE_ADDRESS "Enable AddressSanitizer for sanitized targets." Off) set(FLAG_CANDIDATES # Clang 3.2+ use this version. The no-omit-frame-pointer option is optional. "-g -fsanitize=address -fno-omit-frame-pointer" "-g -fsanitize=address" # Older deprecated flag for ASan "-g -faddress-sanitizer" ) if (SANITIZE_ADDRESS AND (SANITIZE_THREAD OR SANITIZE_MEMORY)) message(FATAL_ERROR "AddressSanitizer is not compatible with " "ThreadSanitizer or MemorySanitizer.") endif () include(sanitize-helpers) if (SANITIZE_ADDRESS) sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "AddressSanitizer" "ASan") find_program(ASan_WRAPPER "asan-wrapper" PATHS ${CMAKE_MODULE_PATH}) mark_as_advanced(ASan_WRAPPER) endif () function (add_sanitize_address TARGET) if (NOT SANITIZE_ADDRESS) return() endif () sanitizer_add_flags(${TARGET} "AddressSanitizer" "ASan") endfunction () doxygen-1.13.0/cmake/WindowsEncoding.cmake0000644000076500000240000000143114545611070017762 0ustar dimitristaffif(CMAKE_C_COMPILER_ID STREQUAL "MSVC" OR CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") include(FindPythonInterp) execute_process( COMMAND ${Python_EXECUTABLE} "${CMAKE_SOURCE_DIR}/cmake/QueryCodePage.py" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} RESULT_VARIABLE ReturnCode OUTPUT_VARIABLE CodePage ) message(STATUS "CodePage is ${CodePage}") if("${CodePage}" STREQUAL "936") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /source-charset:utf-8 /execution-charset:gbk") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /source-charset:utf-8 /execution-charset:gbk") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /utf-8") endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # /bigobj needed for language.cpp on 64bit endif() doxygen-1.13.0/cmake/QueryCodePage.py0000644000076500000240000000106414545611070016730 0ustar dimitristaffimport platform def is_windows(): return platform.system().lower() == "windows" if is_windows(): from winreg import OpenKey, QueryValueEx, HKEY_LOCAL_MACHINE, KEY_READ if __name__ == '__main__': if is_windows(): root = HKEY_LOCAL_MACHINE subkey = R'SYSTEM\CurrentControlSet\Control\Nls\CodePage' key = OpenKey(root, subkey, 0, KEY_READ) name = 'ACP' try: codepage, _ = QueryValueEx(key, name) print(codepage) except WindowsError: print('Failed to get code page') doxygen-1.13.0/cmake/doxygen_version.cmake0000644000076500000240000000647014275261450020116 0ustar dimitristaff# doxygen_version.cmake # # This file defines the functions and targets needed to monitor # doxygen VERSION file. # # The behavior of this script can be modified by defining any of these variables: # # PRE_CONFIGURE_DOXYGEN_VERSION_FILE (REQUIRED) # -- The path to the file that'll be configured. # # POST_CONFIGURE_DOXYGEN_VERSION_FILE (REQUIRED) # -- The path to the configured PRE_CONFIGURE_DOXYGEN_VERSION_FILE. # # DOXY_STATE_FILE (OPTIONAL) # -- The path to the file used to store the doxygen version information. # # This file is based on git_watcher.cmake # Short hand for converting paths to absolute. macro(PATH_TO_ABSOLUTE var_name) get_filename_component(${var_name} "${${var_name}}" ABSOLUTE) endmacro() # Check that a required variable is set. macro(CHECK_REQUIRED_VARIABLE var_name) if(NOT DEFINED ${var_name}) message(FATAL_ERROR "The \"${var_name}\" variable must be defined.") endif() PATH_TO_ABSOLUTE(${var_name}) endmacro() # Check that an optional variable is set, or, set it to a default value. macro(CHECK_OPTIONAL_VARIABLE var_name default_value) if(NOT DEFINED ${var_name}) set(${var_name} ${default_value}) endif() PATH_TO_ABSOLUTE(${var_name}) endmacro() CHECK_REQUIRED_VARIABLE(PRE_CONFIGURE_DOXYGEN_VERSION_FILE) CHECK_REQUIRED_VARIABLE(POST_CONFIGURE_DOXYGEN_VERSION_FILE) CHECK_OPTIONAL_VARIABLE(DOXY_STATE_FILE "${PROJECT_SOURCE_DIR}/VERSION") # Function: DoxygenStateChangedAction # Description: this function is executed when the # doxygen version file has changed. function(DoxygenStateChangedAction _state_as_list) # Set variables by index, then configure the file w/ these variables defined. LIST(GET _state_as_list 0 DOXYGEN_VERSION) configure_file("${PRE_CONFIGURE_DOXYGEN_VERSION_FILE}" "${POST_CONFIGURE_DOXYGEN_VERSION_FILE}" @ONLY) endfunction() # Function: SetupDoxyMonitoring # Description: this function sets up custom commands that make the build system # check the doxygen version file before every build. If it has # changed, then a file is configured. function(SetupDoxyMonitoring) add_custom_target(check_doxygen_version ALL DEPENDS ${PRE_CONFIGURE_DOXYGEN_VERSION_FILE} BYPRODUCTS ${POST_CONFIGURE_DOXYGEN_VERSION_FILE} COMMENT "Checking the doxygen version for changes..." COMMAND ${CMAKE_COMMAND} -D_BUILD_TIME_CHECK_DOXY=TRUE -DDOXY_STATE_FILE=${DOXY_STATE_FILE} -DPRE_CONFIGURE_DOXYGEN_VERSION_FILE=${PRE_CONFIGURE_DOXYGEN_VERSION_FILE} -DPOST_CONFIGURE_DOXYGEN_VERSION_FILE=${POST_CONFIGURE_DOXYGEN_VERSION_FILE} -P "${CMAKE_CURRENT_LIST_FILE}") endfunction() # Function: Main # Description: primary entry-point to the script. Functions are selected based # on whether it's configure or build time. function(Main) file(STRINGS "${DOXY_STATE_FILE}" DOXYGEN_VERSION) if(_BUILD_TIME_CHECK_DOXY) # Check if the doxygen version file has changed. # If so, run the change action. if(${DOXY_STATE_FILE} IS_NEWER_THAN ${POST_CONFIGURE_DOXYGEN_VERSION_FILE}) DoxygenStateChangedAction("${DOXYGEN_VERSION}") endif() else() # >> Executes at configure time. SetupDoxyMonitoring() DoxygenStateChangedAction("${DOXYGEN_VERSION}") endif() endfunction() # And off we go... Main() doxygen-1.13.0/cmake/FindJavacc.cmake0000644000076500000240000000164114275261450016657 0ustar dimitristafffind_program(JAVACC_EXECUTABLE NAMES javacc javaCC Javacc JavaCC javacc.bat DOC "path to the javacc executable") mark_as_advanced(JAVACC_EXECUTABLE) set(JAVACC_FOUND 0) if(JAVACC_EXECUTABLE) execute_process( COMMAND "${JAVACC_EXECUTABLE}" -version OUTPUT_VARIABLE JAVACC_TEMP_VERSION ) string(REGEX MATCH ".* ([0-9]+(\\.[0-9]+)+) .*" JAVACC_TEMP_VERSION2_UNUSED "${JAVACC_TEMP_VERSION}") if(CMAKE_MATCH_1) set(JAVACC_FOUND 1) set(JAVACC_VERSION ${CMAKE_MATCH_1}) else() string(REGEX MATCH "([0-9]+(\\.[0-9]+)+)" JAVACC_TEMP_VERSION3_UNUSED "${JAVACC_TEMP_VERSION}") if(CMAKE_MATCH_1) set(JAVACC_FOUND 1) set(JAVACC_VERSION ${CMAKE_MATCH_1}) endif() endif() endif() if(JAVACC_FOUND) message(STATUS "The javacc executable: ${JAVACC_EXECUTABLE} (found version \"${JAVACC_VERSION}\")") else() message(STATUS "The javacc executable not found, using existing files") endif() doxygen-1.13.0/cmake/SearchReplace.cmake0000644000076500000240000000034114275261450017364 0ustar dimitristaffmessage("Replacing ${search} by ${replace} in file ${src} and writing to ${dst}...") file(READ ${src} file_contents) string(REPLACE "${search}" "${replace}" file_contents ${file_contents}) file(WRITE ${dst} ${file_contents}) doxygen-1.13.0/cmake/Findxapian.cmake0000644000076500000240000000254214275261450016751 0ustar dimitristaff# Find xapian search engine library # # XAPIAN_FOUND - system has Xapian # XAPIAN_INCLUDE_DIR - the Xapian include directory # XAPIAN_LIBRARIES - the libraries needed to use Xapian # # Copyright © 2010 Harald Sitter # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if(XAPIAN_INCLUDE_DIR AND XAPIAN_LIBRARIES) # Already in cache, be silent set(xapian_FIND_QUIETLY TRUE) endif(XAPIAN_INCLUDE_DIR AND XAPIAN_LIBRARIES) FIND_PATH(XAPIAN_INCLUDE_DIR xapian/version.h) FIND_LIBRARY(XAPIAN_LIBRARIES NAMES xapian) IF(XAPIAN_INCLUDE_DIR AND XAPIAN_LIBRARIES) SET(XAPIAN_FOUND TRUE) ELSE(XAPIAN_INCLUDE_DIR AND XAPIAN_LIBRARIES) SET(XAPIAN_FOUND FALSE) ENDIF(XAPIAN_INCLUDE_DIR AND XAPIAN_LIBRARIES) IF(XAPIAN_FOUND) IF(NOT xapian_FIND_QUIETLY) MESSAGE(STATUS "Found xapian: ${XAPIAN_LIBRARIES}") ENDIF(NOT xapian_FIND_QUIETLY) ELSE(XAPIAN_FOUND) IF(xapian_FIND_REQUIRED) MESSAGE(FATAL_ERROR "Could not find xapian") ENDIF(xapian_FIND_REQUIRED) IF(NOT xapian_FIND_QUIETLY) MESSAGE(STATUS "Could not find xapian") ENDIF(NOT xapian_FIND_QUIETLY) ENDIF(XAPIAN_FOUND) # show the XAPIAN_INCLUDE_DIR and XAPIAN_LIBRARIES variables only in the advanced view MARK_AS_ADVANCED(XAPIAN_INCLUDE_DIR XAPIAN_LIBRARIES) doxygen-1.13.0/cmake/version.cmake0000644000076500000240000000022614303714154016346 0ustar dimitristafffile (STRINGS "${TOP}/VERSION" VERSION) set(ENV{VERSION} "${VERSION}") set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${TOP}/VERSION) doxygen-1.13.0/cmake/Coverage.cmake0000644000076500000240000000314514275261450016423 0ustar dimitristaffif(enable_coverage) FIND_PROGRAM( LCOV_PATH lcov ) FIND_PROGRAM( GENHTML_PATH genhtml ) set(COVERAGE_COMPILER_FLAGS -g --coverage -O0 CACHE INTERNAL "") set(COVERAGE_LINKER_FLAGS --coverage CACHE INTERNAL "") add_custom_target(coverage-clean COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --directory . --zerocounters WORKING_DIRECTORY ${PROJECT_BINARY_DIR} ) add_custom_target(coverage COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --directory . --capture --output-file cov.info COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --remove cov.info '*/c++/*' '*/_ctype.h' '*/generated_src/*' --output-file cov.info.cleaned COMMAND ${CMAKE_COMMAND} -Dsearch=${PROJECT_BINARY_DIR} -Dreplace=${PROJECT_SOURCE_DIR} -Dsrc=cov.info.cleaned -Ddst=cov.info.final -P ${PROJECT_SOURCE_DIR}/cmake/SearchReplace.cmake COMMAND ${GENHTML_PATH} --rc genhtml_branch_coverage=1 --function-coverage --branch-coverage --title "Doxygen Coverage Report" --num-spaces 2 --legend --prefix ${PROJECT_SOURCE_DIR} --demangle-cpp --output-directory cov_output cov.info.final COMMAND ${CMAKE_COMMAND} -E remove cov.info cov.info.cleaned cov.info.final WORKING_DIRECTORY ${PROJECT_BINARY_DIR} ) add_custom_command(TARGET coverage POST_BUILD COMMAND ; COMMENT "Open ./cov_output/index.html in your browser to view the coverage report" ) endif() function(set_project_coverage project_name) if(enable_coverage) target_compile_options(${project_name} PRIVATE ${COVERAGE_COMPILER_FLAGS}) endif() endfunction() doxygen-1.13.0/cmake/FindgenerateDS.cmake0000644000076500000240000000137414275261450017514 0ustar dimitristafffind_program(GENERATEDS_EXECUTABLE NAMES generateDS generateDS.py DOC "path to the generateDS executable") mark_as_advanced(GENERATEDS_EXECUTABLE) set(GENERATEDS_FOUND 0) if(GENERATEDS_EXECUTABLE) execute_process( COMMAND "${GENERATEDS_EXECUTABLE}" --version OUTPUT_VARIABLE GENERATEDS_TEMP_VERSION ) string(REGEX MATCH ".* ([0-9]+(\\.[0-9]+)+)" GENERATEDS_TEMP_VERSION_UNUSED "${GENERATEDS_TEMP_VERSION}") if(CMAKE_MATCH_1) set(GENERATEDS_FOUND 1) set(GENERATEDS_VERSION ${CMAKE_MATCH_1}) endif() endif() if(GENERATEDS_FOUND) message(STATUS "The generateDS executable: ${GENERATEDS_EXECUTABLE} (found version \"${GENERATEDS_VERSION}\")") else() message(STATUS "The generateDS executable not found, using existing files") endif() doxygen-1.13.0/cmake/ApplyEditbin.cmake0000644000076500000240000000121714275261450017252 0ustar dimitristaff# helper script for Windows to run editbin.exe on a generated executable function(apply_editbin target_name target_type) if (WIN32) find_program(EDITBIN editbin) if(EDITBIN) set(EDITBIN_FLAGS /nologo /OSVERSION:5.1) if (${target_type} STREQUAL "console") set(EDITBIN_FLAGS ${EDITBIN_FLAGS} /SUBSYSTEM:CONSOLE,6.00) elseif (${target_type} STREQUAL "windows") set(EDITBIN_FLAGS ${EDITBIN_FLAGS} /SUBSYSTEM:WINDOWS,6.00) endif() add_custom_command( TARGET ${target_name} POST_BUILD COMMAND "${EDITBIN}" ${EDITBIN_FLAGS} "$" VERBATIM) endif() endif() endfunction() doxygen-1.13.0/cmake/packaging.cmake0000644000076500000240000001420714545611070016612 0ustar dimitristaff##### set CPack properties ##### # # Good doc/tutorial/example: # - https://gitlab.kitware.com/cmake/community/-/wikis/doc/cpack/PackageGenerators # - https://www.cmake.org/cmake/help/v3.3/module/CPack.html # - https://sourceforge.net/p/klusters/klusters/ci/master/tree/CMakeLists.txt # # This cmake script should generate same packages (deb,rpm) as: # - https://mirror.debian.ikoula.com/debian/pool/main/d/doxygen # - http://archive.ubuntu.com/ubuntu/pool/main/d/doxygen (http://old-releases.ubuntu.com/ubuntu/pool/main/d/doxygen) # - https://rpmfind.net/linux/rpm2html/search.php?query=doxygen set(CPACK_STRIP_FILES ON) set(CPACK_PACKAGE_NAME ${PROJECT_NAME} ) set(CPACK_PACKAGE_VERSION ${VERSION}) set(CPACK_PACKAGE_CONTACT "Dimitri van Heesch") set(CPACK_PACKAGE_VENDOR "Dimitri van Heesch") set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Generate documentation from C, C++, Java, Python and other languages") set(CPACK_PACKAGE_DESCRIPTION "Doxygen is the de facto standard tool for generating documentation from annotated C++ sources. But many other popular programming languages are supported: C, Objective-C, C#, PHP, Java, Python, Fortran, D (some extent), and IDL (Corba, Microsoft, and UNO/OpenOffice flavors). Doxygen also supports the hardware description language VHDL. . Three usages: . 1. Generate documentation from annotated source files to various format: - On-line documentation (HTML) - Off-line reference manual (LaTeX, RTF, PostScript, hyperlinked PDF, compressed HTML, Unix man pages) . 2. Extract the code structure from undocumented source files. Also generate include dependency graphs, inheritance diagrams, and collaboration diagrams. Useful to quickly understand code organization in large source distributions. . 3. Create normal documentation (as the doxygen user manual and web-site http://doxygen.org/) . Install the doxygen-latex package to build LaTeX based documents. Install the libclang1 package to use the 'clang assisted parsing'.") set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE) set(CPACK_RESOURCE_FILE_README ${CMAKE_CURRENT_SOURCE_DIR}/README.md) # Variables specific to CPack RPM generator set(CPACK_RPM_PACKAGE_DESCRIPTION ${CPACK_PACKAGE_DESCRIPTION}) set(CPACK_RPM_PACKAGE_LICENSE "GPLv2") set(CPACK_RPM_PACKAGE_GROUP "Development/Tools") set(CPACK_RPM_PACKAGE_URL "https://doxygen.org/") set(CPACK_RPM_PACKAGE_REQUIRES "/sbin/chkconfig, /bin/mktemp, /bin/rm, /bin/mv, libstdc++ >= 2.96") set(CPACK_RPM_PACKAGE_SUGGESTS "doxygen-latex, doxygen-doc, doxygen-gui, graphviz, libclang1") # Variables specific to CPack DEB generator set(CPACK_DEBIAN_PACKAGE_DESCRIPTION ${CPACK_PACKAGE_DESCRIPTION}) set(CPACK_DEBIAN_PACKAGE_SECTION "devel") set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://doxygen.org/") set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS YES) #set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libclang1-3.6, libgcc1, libstdc++6, libxapian22") set(CPACK_DEBIAN_PACKAGE_SUGGESTS "doxygen-latex, doxygen-doc, doxygen-gui, graphviz, libclang1") set(CPACK_DEBIAN_PACKAGE_CONFLICTS "graphviz (<< 1.12)") set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Matthias Klose ") # Ubuntu Developers # Variables specific to CPack NSIS generator set(CPACK_NSIS_MUI_ICON ${CMAKE_CURRENT_SOURCE_DIR}/addon/doxywizard/doxywizard.ico) set(CPACK_NSIS_URL_INFO_ABOUT "https://doxygen.org/") set(CPACK_NSIS_PACKAGE_NAME ${PROJECT_NAME}) # Variables specific to CPack DragNDrop generator set(CPACK_DMG_FORMAT "UDBZ") # UDRO=UDIF-Read-Only, UDZO=zlib, UDBZ=bzip2 -- See hdiutil set(CPACK_DMG_VOLUME_NAME ${PROJECT_NAME}) set(CPACK_DMG_BACKGROUND_IMAGE ${CMAKE_CURRENT_SOURCE_DIR}/doc/doxygen_logo.eps) if(WIN32) set(CPACK_GENERATOR "ZIP;NSIS") elseif(APPLE) set(CPACK_GENERATOR "ZIP;DragNDrop;PackageMaker;Bundle" ) set(CPACK_SYSTEM_NAME "OSX" ) elseif(UNIX) # Determine distribution and release execute_process(COMMAND lsb_release -si OUTPUT_VARIABLE distribution OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process(COMMAND lsb_release -sc OUTPUT_VARIABLE release OUTPUT_STRIP_TRAILING_WHITESPACE) #xecute_process(COMMAND uname -i OUTPUT_VARIABLE CPACK_RPM_PACKAGE_ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process(COMMAND uname -m OUTPUT_VARIABLE CPACK_RPM_PACKAGE_ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE) if(distribution STREQUAL "Debian" OR distribution STREQUAL "Ubuntu") set(CPACK_GENERATOR "DEB") execute_process(COMMAND dpkg --print-architecture OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE) set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}) elseif(distribution MATCHES "RedHat.*") # extract the major version from RedHat full version (e.g. 6.7 --> 6) execute_process(COMMAND lsb_release -sr COMMAND sed s/[.].*// OUTPUT_VARIABLE redhat_version_major OUTPUT_STRIP_TRAILING_WHITESPACE) set(CPACK_GENERATOR "RPM") set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_RPM_PACKAGE_RELEASE}.el${redhat_version_major}.${CPACK_RPM_PACKAGE_ARCHITECTURE}) elseif(distribution MATCHES "openSUSE.*") set(CPACK_GENERATOR "RPM") set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${release}.${CPACK_RPM_PACKAGE_ARCHITECTURE}) elseif(distribution STREQUAL "Fedora") set(CPACK_GENERATOR "RPM") set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.fc${release}.${CPACK_RPM_PACKAGE_ARCHITECTURE}) elseif(distribution STREQUAL "Scientific") set(CPACK_GENERATOR "RPM") set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${release}.${CPACK_RPM_PACKAGE_ARCHITECTURE}) else() set(CPACK_GENERATOR "RPM;TGZ;STGZ") set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${release}.${CPACK_RPM_PACKAGE_ARCHITECTURE}) endif() else() # other operating system (not Windows/Apple/Unix) endif() doxygen-1.13.0/cmake/CompilerWarnings.cmake0000644000076500000240000001303414733535657020165 0ustar dimitristaff# adapted from # https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md function(set_project_warnings project_name) set(MSVC_WARNINGS #/W4 # Baseline reasonable warnings /w14242 # 'identfier': conversion from 'type1' to 'type1', possible loss # of data /w14254 # 'operator': conversion from 'type1:field_bits' to # 'type2:field_bits', possible loss of data /w14263 # 'function': member function does not override any base class # virtual member function /w14265 # 'classname': class has virtual functions, but destructor is not # virtual instances of this class may not be destructed correctly /w14287 # 'operator': unsigned/negative constant mismatch /we4289 # nonstandard extension used: 'variable': loop control variable # declared in the for-loop is used outside the for-loop scope /w14296 # 'operator': expression is always 'boolean_value' /w14311 # 'variable': pointer truncation from 'type1' to 'type2' /w14456 # declaration of 'name' hides previous local declaration /w14457 # declaration of 'name' hides function parameter /w14458 # declaration of 'name' hides class member /w14459 # declaration of 'name' hides global declaration /w14545 # expression before comma evaluates to a function which is missing # an argument list /w14546 # function call before comma missing argument list /w14547 # 'operator': operator before comma has no effect; expected # operator with side-effect /w14549 # 'operator': operator before comma has no effect; did you intend # 'operator'? /w14555 # expression has no effect; expected expression with side- effect /w14619 # pragma warning: there is no warning number 'number' /w14640 # Enable warning on thread un-safe static member initialization /w14826 # Conversion from 'type1' to 'type_2' is sign-extended. This may # cause unexpected runtime behavior. /w14905 # wide string literal cast to 'LPSTR' /w14906 # string literal cast to 'LPWSTR' /w14928 # illegal copy-initialization; more than one user-defined # conversion has been implicitly applied ) set(CLANG_WARNINGS -Wall -Wextra # reasonable and standard -Wshadow # warn the user if a variable declaration shadows one from a # parent context $<$:-Wnon-virtual-dtor> # warn the user if a class with virtual functions has a # non-virtual destructor. This helps catch hard to # track down memory errors # -Wold-style-cast # warn for c-style casts -Wcast-align # warn for potential performance problem casts -Wunused # warn on anything being unused $<$:-Woverloaded-virtual> # warn if you overload (not override) a virtual function -Wpedantic # warn if non-standard C++ is used -Wconversion # warn on type conversions that may lose data -Wnull-dereference # warn if a null dereference is detected -Wdouble-promotion # warn if float is implicit promoted to double -Wformat=2 # warn on security issues around functions that format output # (ie printf) -Wpedantic # warn if non-standard C++ is used # turn off warning caused by generated code (flex) -Wno-unused-parameter -Wno-implicit-int-conversion -Wno-sign-conversion -Wno-format-nonliteral -Wno-shorten-64-to-32 # allow comma removal for empty __VA_ARGS__ in ,##__VA_ARGS__ -Wno-gnu-zero-variadic-macro-arguments # enable to turn warnings into errors #-Werror ) set(GCC_WARNINGS -Wall -Wextra # reasonable and standard -Wshadow # warn the user if a variable declaration shadows one from a # parent context $<$:-Wnon-virtual-dtor> # warn the user if a class with virtual functions has a # non-virtual destructor. This helps catch hard to # track down memory errors # -Wold-style-cast # warn for c-style casts -Wcast-align # warn for potential performance problem casts -Wunused # warn on anything being unused $<$:-Woverloaded-virtual> # warn if you overload (not override) a virtual function -Wpedantic # warn if non-standard C++ is used #-Wconversion # warn on type conversions that may lose data #-Wnull-dereference # warn if a null dereference is detected -Wdouble-promotion # warn if float is implicit promoted to double -Wformat=2 # warn on security issues around functions that format output # (ie printf) # turn off warning caused by generated code (flex) -Wno-unused-parameter -Wno-sign-conversion -Wno-format-nonliteral # enable to turn warnings into errors #-Werror ) if(MSVC) set(PROJECT_WARNINGS ${MSVC_WARNINGS}) elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # e.g. Clang or AppleClang set(PROJECT_WARNINGS ${CLANG_WARNINGS}) elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "7.0.0") set(GCC_EXTRA_WARNINGS -Wno-implicit-fallthrough ) else() set(GCC_EXTRA_WARNINGS ) endif() set(PROJECT_WARNINGS ${GCC_WARNINGS} ${GCC_EXTRA_WARNINGS}) endif() target_compile_options(${project_name} PRIVATE ${PROJECT_WARNINGS}) endfunction() doxygen-1.13.0/doc_internal/0000755000076500000240000000000014733601612015241 5ustar dimitristaffdoxygen-1.13.0/doc_internal/doxygen.md0000644000076500000240000002363214577353402017255 0ustar dimitristaff%Doxygen Internals {#mainpage} ================= Generated on \showdate "%A, %B %-d, %Y at %-I:%M %p" Introduction ============ This page provides a high-level overview of the internals of doxygen, with links to the relevant parts of the code. This document is intended for developers who want to work on doxygen. Users of doxygen are referred to the [User Manual](https://www.doxygen.nl/manual/index.html). The generic starting point of the application is of course the main() function. Configuration options ===================== Configuration file data is stored in singleton class Config and can be accessed using wrapper macros Config_getString(), Config_getInt(), Config_getList(), Config_getEnum(), and Config_getBool() depending on the type of the option. The format of the configuration file (options and types) is defined by the file `config.xml`. As part of the build process, the python script `configgen.py` will create the files `configoptions.cpp`, `configvalues.h` and `configvalues.cpp` from this, which serves as the input for the configuration file parser that is invoked using Config::parse(). The script `configgen.py` will also create the documentation for the configuration items, creating the file `config.doc`. Gathering Input files ===================== After the configuration is known, the input files are searched using searchInputFiles() and any tag files are read using readTagFile() Parsing Input files =================== The function parseFilesSingleThreading() takes care of parsing all files (in case `NUM_PROC_THREADS!=1`, the function parseFilesMultiThreading() is used instead). These functions use the ParserManager singleton factory to create a suitable parser object for each file. Each parser implements two abstract interfaces: OutlineParserInterface en CodeParserInterface. The OutlineParserInterface is used to collect information about the symbols that can be documented but does not look into the body of functions. The CodeParserInterface is used for syntax highlighting, but also to collect the symbol references needed for cross reference relations. If the parser indicates it needs preprocessing via OutlineParserInterface::needsPreprocessing(), doxygen will call Preprocessor::processFile() on the file. A second step is to convert multiline C++-style comments into C style comments for easier processing later on. As side effect of this step also aliases (ALIASES option) are resolved. The function that performs these 2 tasks is called convertCppComments(). *Note:* Alias resolution should better be done in a separate step as it is now coupled to C/C++ code and does not work automatically for other languages! The third step is the actual language parsing and is done by calling OutlineParserInterface::parseInput() on the parser interface returned by the ParserManager. The result of parsing is a tree of Entry objects. Each Entry object roughly contains the raw data for a symbol and is later converted into a Definition object. When a parser finds a special comment block in the input, it will do a first pass parsing via CommentScanner::parseCommentBlock(). During this pass the comment block is split into multiple parts if needed. Some data that is later needed is extracted like section labels, xref items, and formulas. Also Markdown markup is processed via Markdown::process() during this pass. Resolving relations =================== The Entry objects created and filled during parsing and stored as a tree of Entry nodes, which is kept in memory. %Doxygen does a number of tree walks over the Entry nodes in the tree to build up the data structures needed to produce the output. The resulting data structures are all children of the generic base class called Definition which holds all non-specific data for a symbol definition. Definition is an abstract base class. Concrete subclasses are - ClassDef: for storing class/struct/union related data - ConceptDef: for storing C++20 concept definitions - NamespaceDef: for storing namespace related data - FileDef: for storing file related data - DirDef: for storing directory related data For doxygen specific concepts the following subclasses are available - GroupDef: for storing grouping related data - PageDef: for storing page related data Finally the data for members of classes, namespaces, and files is stored in the subclass MemberDef. This class is used for functions, variables, enums, etc, as indicated by MemberDef::memberType(). Producing tracing and debug output ================================== Within doxygen there are a number of ways to obtain debug output. Besides the invasive method of putting print statements in the code there are a number of easier ways to get debug information. For a debug build (build option `-DCMAKE_BUILD_TYPE=%Debug`) these options are always available, but for a release build some debug capabilities have to be enabled explicitly (see build options `-Denable_tracing=YES` and `-Denable_lex_debug=YES`). To enable tracing use the `-t` option. You can optionally specify a name of a trace file, if omitted `trace.txt` will be used. When running doxygen with tracing enabled, doxygen will write a lot of internal information to the trace file, which can be used (by experts) to diagnose problems. During a run of doxygen it is possible to specify the `-d` command line option with one of the following values (each option has to be preceded by `-d`): - `preprocessor`
Shows the results of the preprocessing phase, i.e. results from include files, \#define statements etc., definitions in the doxygen configuration file like: `EXPAND_ONLY_PREDEF`, `PREDEFINED` and `MACRO_EXPANSION`. - `nolineno`
In case the line numbers in the results of the preprocessing phase are not wanted they can be removed by means of this option (without `-d preprocessor` this option has no effect. - `commentcnv`
Shows the results of the comment conversion, the comment conversion does the following: - It converts multi-line C++ style comment blocks (that are aligned) to C style comment blocks (if `MULTILINE_CPP_IS_BRIEF` is set to `NO`). - It replaces aliases with their definition (see `ALIASES`) - It handles conditional sections (\\cond ... \\endcond blocks) - `commentscan`
Will print each comment block before and after the comment is interpreted by the comment scanner. - `printtree`
Give the results in pretty print way, i.e. in an XML like way with each level indented by a `"."` (dot). - `time`
Provides information of the different stages of the doxygen process. - `extcmd`
Shows which external commands are executed and which pipes are opened. - `markdown`
Will print each comment block before and after Markdown processing. - `filteroutput`
Gives the output of the output as result of the filter command (when a filter command is specified) - `cite`
Retains the temporary files as created and used for the non LaTeX output results of the generation of the bibliographical references. - `fortranfixed2free`
Shows the result of the conversion of Fortran fixed formatted files to Fortran free formatted files as done by doxygen. - `plantuml`
Shows information about the plantuml process run and the used input / output filenames, the content of the input file. - `rtf`
- Shows the original names and the anchors names (called bookmarks in RTF) where they are mapped to. - At the end of the generation of the RTF files these files are merged into one large RTF file, with this option the original files are retained. - `qhp`
- The qhp file is created with indentation for better readability (normally no indentation so the file is smaller). - When the setting `QHG_LOCATION` is pointing to the `qhelpgenerator` besides generating the `qch` file also some extra checks are done by means of the `-c` flag of the `qhelpgenerator`. - `tag`
Shows the results of reading the tag files. - `alias`
Show the results of the `ALIASES` resolving process - `entries`
Dump the tree of Entries as found by doxygen - `formula`
Don't remove the intermediate files generated by the creation of the images with the formulas. - `sections`
Show the sections as found by doxygen - `lex`
Provide output of the `lex` files used. When a lexer is started and when a lexer ends the name of the `lex` file is given so it is possible to see in which lexer the problem occurs. This makes it easier to select the file to be compiled in `lex` debug mode. - `lex:lexer`
Enables output for a specific lexer only, where `lexer` should be replaced by the name of the specific lexer. Producing output ================ TODO Documentation Topics TODO =========== - Grouping of files in Model / Parser / Generator categories - Index files based on IndexIntf - HTML navigation - HTML Help (chm) - Documentation Sets (XCode) - Qt Help (qhp) - Eclipse Help - Search index - JavaScript based - Server based - External - Citations - via bibtex - Various processing steps for a comment block - comment conversion - comment scanner - markdown processor - doc tokenizer - doc parser - doc visitors - Diagrams and Images - builtin - via Graphviz dot - via mscgen - PNG generation - Output formats: OutputGenerator, OutputList, and DocVisitor - Html: HtmlGenerator and HtmlDocVisitor - Latex: LatexGenerator and LatexDocVisitor - RTF: RTFGenerator and RTFDocVisitor - Man: ManGenerator and ManDocVisitor - XML: generateXML() and XmlDocVisitor - print: debugging via PrintDocVisitor - text: TextDocVisitor for tooltips - perlmod - i18n via Translator and language.cpp - Customizing the layout via LayoutDocManager - Parsers - C Preprocessing - const expression evaluation - C link languages - Python - Fortran - VHDL - Tag files - Marshaling to/from disk - Portability functions - Utility functions doxygen-1.13.0/doc_internal/commands_history.md0000755000076500000240000001744314545611070021161 0ustar dimitristaff\page pg_cmds Overview of introduction of special commands The following table gives an overview of the doxygen special commands and the version in which they were introduced.
New in 1.0.0
\\\\
\\#
\\$
\\&
\\@@
\\<
\\>
\\a
\\addindex
\\anchor
\\arg
\\author
\\b
\\brief
\\bug
\\c
\\class
\\code
\\date
\\def
\\defgroup
\\deprecated
\\dontinclude
\\e
\\endcode
\\endhtmlonly
\\endlatexonly
\\endlink
\\endverbatim
\\enum
\\example
\\exception
\\f$
\\f[
\\f]
\\file
\\fn
\\htmlonly
\\image
\\include
\\ingroup
\\internal
\\latexonly
\\line
\\link
\\mainpage
\\namespace
\\overload
\\page
\\par
\\param
\\ref
\\relates
\\return
\\retval
\\sa
\\section
\\skip
\\skipline
\\struct
\\subsection
\\throw
\\typedef
\\union
\\until
\\var
\\verbatim
\\verbinclude
\\version
\\warning
New in 1.1.0
\\invariant
\\post
\\pre
New in 1.1.3
\\endif
\\if
\\name
New in 1.1.4
\\hideinitializer
\\nosubgrouping
\\showinitializer
\\todo
New in 1.1.5
\\attention
\\remarks
\\since
New in 1.2.0
\\em
\\li
\\note
\\p
New in 1.2.1
\\test
New in 1.2.7
\\addtogroup
\\htmlinclude
New in 1.2.8
\\interface
\\weakgroup
New in 1.2.9.1
\\else
\\elseif
\\ifnot
New in 1.2.10
\\dotfile
\\package
New in 1.2.14
\\~
New in 1.2.17
\\copydoc
New in 1.2.18
\\n
\\subsubsection
New in 1.3.1
\\xrefitem
New in 1.3.2
\\callgraph
\\endxmlonly
\\xmlonly
New in 1.3.4
\\dot
\\enddot
\\relatesalso
New in 1.3.7
\\%
\\endmanonly
\\includelineno
\\manonly
\\property
New in 1.3.8
\\category
\\paragraph
\\private
\\privatesection
\\protected
\\protectedsection
\\protocol
\\public
\\publicsection
New in 1.3.9
\\dir
New in 1.4.0
\\cond
\\endcond
\\see
New in 1.4.2
\\subpage
New in 1.4.7
\\callergraph
New in 1.5.2
\\endmsc
\\msc
New in 1.5.3
\\details
New in 1.5.4
\\f{
\\f}
New in 1.5.5
\\headerfile
New in 1.5.6
\\copybrief
\\copydetails
\\tparam
New in 1.5.7
\\extends
\\implements
\\memberof
New in 1.6.2
\\"
New in 1.7.2
\\authors
\\endinternal
\\endrtfonly
\\mscfile
\\related
\\relatedalso
\\remark
\\returns
\\rtfonly
\\short
\\throws
New in 1.7.3
\\::
\\result
New in 1.7.5
\\cite
\\copyright
\\snippet
New in 1.8.0
\\.
\\tableofcontents
New in 1.8.3
\\vhdlflow
New in 1.8.4
\\|
\\docbookonly
\\enddocbookonly
\\endsecreflist
\\idlexcept
\\pure
\\refitem
\\secreflist
New in 1.8.6
\\diafile
\\endparblock
\\parblock
New in 1.8.7
\\\--
\\\---
\\latexinclude
New in 1.8.8
\\enduml
\\startuml
New in 1.8.10
\\hidecallergraph
\\hidecallgraph
New in 1.8.12
\\includedoc
\\snippetdoc
\\snippetlineno
New in 1.8.15
\\=
\\emoji
\\hiderefby
\\hiderefs
\\showrefby
\\showrefs
New in 1.8.18
\\docbookinclude
\\maninclude
\\rtfinclude
\\xmlinclude
doxygen-1.13.0/doc_internal/tags_history.md0000755000076500000240000004535414545611070020320 0ustar dimitristaff\page pg_tags Overview of introduction of doxygen configuration settings The following table gives an overview of the doxygen configuration settings and the version in which they were introduced or became obsolete.
New in 1.0.0
ALLEXTERNALS
ALPHABETICAL_INDEX
ALWAYS_DETAILED_SEC
BIN_ABSPATH
BRIEF_MEMBER_DESC
CASE_SENSE_NAMES
CGI_NAME
CGI_URL
CLASS_DIAGRAMS
COLS_IN_ALPHA_INDEX
COMPACT_LATEX
DISABLE_INDEX
DOC_ABSPATH
DOC_URL
ENABLE_PREPROCESSING
EXAMPLE_PATH
EXAMPLE_PATTERNS
EXCLUDE
EXCLUDE_PATTERNS
EXPAND_ONLY_PREDEF
EXT_DOC_PATHS
EXTRA_PACKAGES
EXTRACT_ALL
EXTRACT_PRIVATE
FILE_PATTERNS
FULL_PATH_NAMES
GENERATE_HTML
GENERATE_HTMLHELP
GENERATE_LATEX
GENERATE_MAN
GENERATE_TAGFILE
HIDE_UNDOC_CLASSES
HIDE_UNDOC_MEMBERS
HTML_ALIGN_MEMBERS
HTML_FOOTER
HTML_HEADER
HTML_OUTPUT
HTML_STYLESHEET
IMAGE_PATH
IMAGE_PATTERNS
INCLUDE_PATH
INHERIT_DOCS
INLINE_INFO
INLINE_SOURCES
INPUT
INPUT_FILTER
INTERNAL_DOCS
JAVADOC_AUTOBRIEF
LATEX_HEADER
LATEX_OUTPUT
MACRO_EXPANSION
MAN_EXTENSION
MAN_OUTPUT
OUTPUT_DIRECTORY
OUTPUT_LANGUAGE
PAPER_TYPE
PDF_HYPERLINKS
PERL_PATH
PREDEFINED
PROJECT_NAME
PROJECT_NUMBER
QUIET
RECURSIVE
REPEAT_BRIEF
SEARCH_INCLUDES
SEARCHENGINE
SOURCE_BROWSER
STRIP_FROM_PATH
TAB_SIZE
TAGFILES
VERBATIM_HEADERS
WARNINGS
New in 1.1.0
COLLABORATION_GRAPH
COMPACT_RTF
GENERATE_RTF
GRAPHICAL_HIERARCHY
HAVE_DOT
IGNORE_PREFIX
INCLUDE_GRAPH
RTF_HYPERLINKS
RTF_OUTPUT
New in 1.1.1
SHOW_INCLUDE_FILES
SORT_MEMBER_DOCS
STRIP_CODE_COMMENTS
New in 1.1.2
ENABLED_SECTIONS
LATEX_BATCHMODE
New in 1.1.3
CLASS_GRAPH
Obsolete in 1.1.3
IMAGE_PATTERNS
New in 1.1.4
DOT_PATH
WARN_FORMAT
WARN_IF_UNDOCUMENTED
New in 1.1.5
EXPAND_AS_DEFINED
EXTRACT_STATIC
HIDE_SCOPE_NAMES
INCLUDED_BY_GRAPH
MAX_DOT_GRAPH_HEIGHT
MAX_DOT_GRAPH_WIDTH
RTF_STYLESHEET_FILE
New in 1.2.0
INCLUDE_FILE_PATTERNS
New in 1.2.1
GENERATE_TESTLIST
GENERATE_TODOLIST
GENERATE_XML
USE_PDFLATEX
New in 1.2.2
ALIASES
DISTRIBUTE_GROUP_DOC
New in 1.2.3
ENUM_VALUES_PER_LINE
FILTER_SOURCE_FILES
GENERATE_LEGEND
WARN_LOGFILE
New in 1.2.4
GENERATE_TREEVIEW
TREEVIEW_WIDTH
New in 1.2.5
MAX_INITIALIZER_LINES
OPTIMIZE_OUTPUT_FOR_C
Obsolete in 1.2.5
GENERATE_XML
New in 1.2.6
BINARY_TOC
DOT_CLEANUP
GENERATE_BUGLIST
GENERATE_CHI
SHOW_USED_FILES
TOC_EXPAND
New in 1.2.7
RTF_EXTENSIONS_FILE
SHORT_NAMES
New in 1.2.8
MAN_LINKS
New in 1.2.9
GENERATE_XML
New in 1.2.10
DOTFILE_DIRS
TEMPLATE_RELATIONS
New in 1.2.11
SKIP_FUNCTION_MACROS
New in 1.2.12
EXAMPLE_RECURSIVE
HIDE_UNDOC_RELATIONS
REFERENCED_BY_RELATION
REFERENCES_RELATION
New in 1.2.13
EXTRACT_LOCAL_CLASSES
GENERATE_AUTOGEN_DEF
INLINE_INHERITED_MEMB
New in 1.2.14
DOT_IMAGE_FORMAT
EXCLUDE_SYMLINKS
EXTERNAL_GROUPS
HTML_FILE_EXTENSION
New in 1.2.15
LATEX_CMD_NAME
MAKEINDEX_CMD_NAME
OPTIMIZE_OUTPUT_JAVA
New in 1.2.16
DETAILS_AT_TOP
New in 1.2.17
CHM_FILE
HHC_LOCATION
MULTILINE_CPP_IS_BRIEF
New in 1.2.18
GENERATE_DEPRECATEDLIST
HIDE_FRIEND_COMPOUNDS
XML_DTD
XML_SCHEMA
New in 1.3
GENERATE_PERLMOD
HIDE_IN_BODY_DOCS
LATEX_HIDE_INDICES
MAX_DOT_GRAPH_DEPTH
PERLMOD_LATEX
PERLMOD_MAKEVAR_PREFIX
PERLMOD_PRETTY
USE_WINDOWS_ENCODING
WARN_IF_DOC_ERROR
New in 1.3.1
XML_OUTPUT
New in 1.3.2
CALL_GRAPH
UML_LOOK
New in 1.3.3
SUBGROUPING
Obsolete in 1.3.4
BIN_ABSPATH
CGI_NAME
CGI_URL
DOC_ABSPATH
DOC_URL
EXT_DOC_PATHS
New in 1.3.5
ABBREVIATE_BRIEF
XML_PROGRAMLISTING
New in 1.3.6
SORT_BRIEF_DOCS
SORT_BY_SCOPE_NAME
New in 1.3.7
CREATE_SUBDIRS
EXTRACT_LOCAL_METHODS
STRIP_FROM_INC_PATH
New in 1.3.8
FILTER_PATTERNS
New in 1.3.9
SHOW_DIRECTORIES
New in 1.4.0
DIRECTORY_GRAPH
DOT_MULTI_TARGETS
DOT_TRANSPARENT
FILE_VERSION_FILTER
GROUP_GRAPHS
WARN_NO_PARAMDOC
New in 1.4.2
SEPARATE_MEMBER_PAGES
New in 1.4.3
USE_HTAGS
New in 1.4.5
BUILTIN_STL_SUPPORT
New in 1.4.7
CALLER_GRAPH
REFERENCES_LINK_SOURCE
New in 1.5.2
CPP_CLI_SUPPORT
DOT_GRAPH_MAX_NODES
DOXYFILE_ENCODING
EXCLUDE_SYMBOLS
INPUT_ENCODING
LATEX_OUTPUT_ENCODING
MSCGEN_PATH
RTF_OUTPUT_ENCODING
Obsolete in 1.5.2
MAX_DOT_GRAPH_DEPTH
MAX_DOT_GRAPH_HEIGHT
MAX_DOT_GRAPH_WIDTH
USE_WINDOWS_ENCODING
New in 1.5.3
EXTRACT_ANON_NSPACES
HTML_DYNAMIC_SECTIONS
MAX_DOT_GRAPH_DEPTH
QT_AUTOBRIEF
New in 1.5.4
SIP_SUPPORT
TYPEDEF_HIDES_STRUCT
New in 1.5.5
DOCSET_BUNDLE_ID
DOCSET_FEEDNAME
GENERATE_DOCSET
OPTIMIZE_FOR_FORTRAN
OPTIMIZE_OUTPUT_VHDL
SORT_GROUP_NAMES
New in 1.5.6
CHM_INDEX_ENCODING
DOT_FONTNAME
DOT_FONTPATH
FORMULA_FONTSIZE
IDL_PROPERTY_SUPPORT
SHOW_FILES
SHOW_NAMESPACES
New in 1.5.7
GENERATE_INDEXLOG
GENERATE_QHP
LAYOUT_FILE
QCH_FILE
QHG_LOCATION
QHP_NAMESPACE
QHP_VIRTUAL_FOLDER
SYMBOL_CACHE_SIZE
Obsolete in 1.5.7
ALPHABETICAL_INDEX
DETAILS_AT_TOP
DOXYGEN2QTHELP_LOC
QTHELP_CONFIG
QTHELP_FILE
New in 1.5.7.1
ALPHABETICAL_INDEX
DOT_FONTSIZE
Obsolete in 1.5.7.1
GENERATE_INDEXLOG
New in 1.5.8
EXTENSION_MAPPING
QHP_CUST_FILTER_ATTRS
QHP_CUST_FILTER_NAME
QHP_SECT_FILTER_ATTRS
DETAILS_AT_TOP
Obsolete in 1.5.8
LATEX_OUTPUT_ENCODING
RTF_OUTPUT_ENCODING
New in 1.5.9
LATEX_SOURCE_CODE
Obsolete in 1.5.9
SHOW_USED_FILES
New in 1.6.0
SORT_MEMBERS_CTORS_1ST
USE_INLINE_TREES
New in 1.6.1
SHOW_USED_FILES
New in 1.6.2
ECLIPSE_DOC_ID
FORCE_LOCAL_INCLUDES
GENERATE_ECLIPSEHELP
HTML_TIMESTAMP
SERVER_BASED_SEARCH
New in 1.7.0
DOCSET_PUBLISHER_ID
DOCSET_PUBLISHER_NAME
DOT_NUM_THREADS
EXT_LINKS_IN_WINDOW
HTML_COLORSTYLE_GAMMA
HTML_COLORSTYLE_HUE
HTML_COLORSTYLE_SAT
New in 1.7.1
FORMULA_TRANSPARENT
New in 1.7.2
MATHJAX_RELPATH
MSCFILE_DIRS
USE_MATHJAX
New in 1.7.3
FILTER_SOURCE_PATTERNS
PROJECT_BRIEF
PROJECT_LOGO
STRICT_PROTO_MATCHING
New in 1.7.4
HTML_EXTRA_FILES
INLINE_GROUPED_CLASSES
LATEX_FOOTER
New in 1.7.5
CITE_BIB_FILES
INLINE_SIMPLE_STRUCTS
INTERACTIVE_SVG
LATEX_BIB_STYLE
MATHJAX_EXTENSIONS
New in 1.7.6
TCL_SUBST
New in 1.7.6.1
LOOKUP_CACHE_SIZE
New in 1.8.0
EXTRACT_PACKAGE
MARKDOWN_SUPPORT
UML_LIMIT_NUM_FIELDS
New in 1.8.1
HTML_INDEX_NUM_ENTRIES
Obsolete in 1.8.1
HTML_ALIGN_MEMBERS
SHOW_DIRECTORIES
USE_INLINE_TREES
New in 1.8.2
AUTOLINK_SUPPORT
HTML_EXTRA_STYLESHEET
New in 1.8.3
EXTERNAL_SEARCH
EXTRA_SEARCH_MAPPINGS
MATHJAX_FORMAT
SEARCHDATA_FILE
SEARCHENGINE_URL
USE_MDFILE_AS_MAINPAGE
New in 1.8.3.1
EXTERNAL_SEARCH_ID
New in 1.8.4
CLANG_ASSISTED_PARSING
CLANG_OPTIONS
DOCBOOK_OUTPUT
EXTERNAL_PAGES
GENERATE_DOCBOOK
GENERATE_SQLITE3
LATEX_EXTRA_FILES
MATHJAX_CODEFILE
SQLITE3_OUTPUT
Obsolete in 1.8.4
SYMBOL_CACHE_SIZE
New in 1.8.5
SOURCE_TOOLTIPS
New in 1.8.6
DIA_PATH
DIAFILE_DIRS
SHOW_GROUPED_MEMB_INC
New in 1.8.7
ALLOW_UNICODE_NAMES
MAN_SUBDIR
Obsolete in 1.8.7
XML_DTD
XML_SCHEMA
New in 1.8.8
DOCBOOK_PROGRAMLISTING
PLANTUML_JAR_PATH
New in 1.8.9
HIDE_COMPOUND_REFERENCE
LATEX_EXTRA_STYLESHEET
PLANTUML_INCLUDE_PATH
RTF_SOURCE_CODE
New in 1.8.10
GROUP_NESTED_COMPOUNDS
New in 1.8.11
LATEX_TIMESTAMP
WARN_AS_ERROR
New in 1.8.12
TOC_INCLUDE_HEADINGS
New in 1.8.13
PLANTUML_CFG_FILE
New in 1.8.14
CLANG_COMPILATION_DATABASE_PATH
HTML_DYNAMIC_MENUS
New in 1.8.15
CLANG_DATABASE_PATH
LATEX_EMOJI_DIRECTORY
LATEX_MAKEINDEX_CMD
OPTIMIZE_OUTPUT_SLICE
OUTPUT_TEXT_DIRECTION
XML_NS_MEMB_FILE_SCOPE
Obsolete in 1.8.15
CLANG_COMPILATION_DATABASE_PATH
New in 1.8.16
EXTRACT_PRIV_VIRTUAL
JAVADOC_BANNER
Obsolete in 1.8.16
MSCGEN_PATH
PERL_PATH
New in 1.8.17
FORMULA_MACROFILE
New in 1.8.18
HTML_FORMULA_FORMAT
Obsolete in 1.8.18
TCL_SUBST
New in 1.8.19
NUM_PROC_THREADS
SQLITE3_RECREATE_DB
New in 1.8.20
PYTHON_DOCSTRING
# Directives
New in 1.2.1
@@INCLUDE
@@INCLUDE_PATH
doxygen-1.13.0/doc_internal/releases.md0000755000076500000240000001501614733601576017405 0ustar dimitristaff\page pg_rel Overview of doxygen release dates The following table gives an overview of the doxygen releases together with the release dates.
  • Release 1.13.0   28-12-2024
  • Release 1.12.0   07-08-2024
  • Release 1.11.0   20-05-2024
  • Release 1.10.0   25-12-2023
  • Release 1.9.8    25-08-2023
  • Release 1.9.7    18-05-2023
  • Release 1.9.6    27-12-2022
  • Release 1.9.5    26-08-2022
  • Release 1.9.4    05-05-2022
  • Release 1.9.3    03-01-2022
  • Release 1.9.3    31-12-2021
  • Release 1.9.2    18-08-2021
  • Release 1.9.1    08-01-2021
  • Release 1.9.0    27-12-2020
  • Release 1.8.20   24-08-2020
  • Release 1.8.19   08-08-2020
  • Release 1.8.18   12-04-2020
  • Release 1.8.17   27-12-2019
  • Release 1.8.16   08-08-2019
  • Release 1.8.15   27-12-2018
  • Release 1.8.14   25-12-2017
  • Release 1.8.13   29-12-2016
  • Release 1.8.12   05-09-2016
  • Release 1.8.11   30-12-2015
  • Release 1.8.10   27-06-2015
  • Release 1.8.9.1  04-01-2015
  • Release 1.8.9    25-12-2014
  • Release 1.8.8    21-08-2014
  • Release 1.8.7    21-04-2014
  • Release 1.8.6    24-12-2013
  • Release 1.8.5    23-08-2013
  • Release 1.8.4    19-05-2013
  • Release 1.8.3.1  20-01-2013
  • Release 1.8.3    26-12-2012
  • Release 1.8.2    11-08-2012
  • Release 1.8.1.2  12-07-2012
  • Release 1.8.1.1  10-06-2012
  • Release 1.8.1    19-05-2012
  • Release 1.8.0    25-02-2012
  • Release 1.7.6.1  10-12-2011
  • Release 1.7.6    03-12-2011
  • Release 1.7.5.1  21-08-2011
  • Release 1.7.5    14-08-2011
  • Release 1.7.4    28-03-2011
  • Release 1.7.3    03-01-2011
  • Release 1.7.2    09-10-2010
  • Release 1.7.1    25-06-2010
  • Release 1.7.0    15-06-2010
  • Release 1.6.3    21-02-2010
  • Release 1.6.2    30-12-2009
  • Release 1.6.1    25-08-2009
  • Release 1.6.0    20-08-2009
  • Release 1.5.9    30-04-2009
  • Release 1.5.8    27-12-2008
  • Release 1.5.7.1  05-10-2008
  • Release 1.5.7    28-09-2008
  • Release 1.5.6    18-05-2008
  • Release 1.5.5    10-02-2008
  • Release 1.5.4    27-10-2007
  • Release 1.5.3    27-07-2007
  • Release 1.5.2    04-04-2007
  • Release 1.5.1    29-10-2006
  • Release 1.5.0    16-10-2006
  • Release 1.4.7    11-06-2006
  • Release 1.4.6    30-12-2005
  • Release 1.4.5    04-10-2005
  • Release 1.4.4    21-07-2005
  • Release 1.4.3    16-05-2005
  • Release 1.4.2    28-03-2005
  • Release 1.4.1    11-01-2005
  • Release 1.4.0    31-12-2004
  • Release 1.3.9.1  10-10-2004
  • Release 1.3.9    05-10-2004
  • Release 1.3.8    25-07-2004
  • Release 1.3.7    07-05-2004
  • Release 1.3.6    12-02-2004
  • Release 1.3.5    21-11-2003
  • Release 1.3.4    22-09-2003
  • Release 1.3.3    25-07-2003
  • Release 1.3.2    15-06-2003
  • Release 1.3.1    28-05-2003
  • Release 1.3      12-04-2003
  • Release 1.2.18   18-09-2002
  • Release 1.2.17   15-07-2002
  • Release 1.2.16   20-05-2002
  • Release 1.2.15   01-04-2002
  • Release 1.2.14   18-02-2002
  • Release 1.2.13.1 05-01-2002
  • Release 1.2.13   29-12-2001
  • Release 1.2.12   18-11-2001
  • Release 1.2.11.1 07-10-2001
  • Release 1.2.11   30-09-2001
  • Release 1.2.10   26-08-2001
  • Release 1.2.9.1  05-08-2001
  • Release 1.2.9    01-08-2001
  • Release 1.2.8.1  10-06-2001
  • Release 1.2.8    04-06-2001
  • Release 1.2.7    30-04-2001
  • Release 1.2.6    11-03-2001
  • Release 1.2.5    04-02-2001
  • Release 1.2.4    24-12-2000
  • Release 1.2.3    30-10-2000
  • Release 1.2.2    24-09-2000
  • Release 1.2.1    13-08-2000
  • Release 1.2.0    23-07-2000
  • Release 1.1.5    03-07-2000
  • Release 1.1.4    04-06-2000
  • Release 1.1.3    08-05-2000
  • Release 1.1.2    09-04-2000
  • Release 1.1.1    12-03-2000
  • Release 1.1.0    15-02-2000
  • Release 1.0.0    08-02-2000
doxygen-1.13.0/doc_internal/CMakeLists.txt0000644000076500000240000000605414545611070020006 0ustar dimitristaff# vim:ts=4:sw=4:expandtab:autoindent: # # Copyright (C) 1997-2022 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. # # Documents produced by Doxygen are derivative works derived from the # input used in their production; they are not affected by this license. if (doxygen_BINARY_DIR) set(DOXYGEN_EXECUTABLE ${doxygen_BINARY_DIR}/bin/doxygen) else() # when building only the doxygen_doc, from the doc/ directory, the # doxygen project variables are unknown so look for doxygen in PATH find_package(Doxygen) endif() configure_file(${CMAKE_SOURCE_DIR}/doc_internal/Doxyfile.in "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile" @ONLY) set(DOC_FILES language.tpl maintainers.txt translator.py ) file(GLOB LANG_FILES CONFIGURE_DEPENDS "${TOP}/src//translator_??.h") foreach (f ${DOC_FILES}) add_custom_command(OUTPUT ${PROJECT_BINARY_DIR}/doc_internal/${f} COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/doc/${f} ${PROJECT_BINARY_DIR}/doc_internal/ DEPENDS ${PROJECT_SOURCE_DIR}/doc/${f} ) set_source_files_properties(${PROJECT_BINARY_DIR}/doc_internal/${f} PROPERTIES GENERATED 1) endforeach() add_custom_command( COMMAND ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/doc_internal/cmds_tags.py -cmds ${CMAKE_SOURCE_DIR}/doc_internal ${CMAKE_SOURCE_DIR}/doc_internal/commands_history.md ${PROJECT_BINARY_DIR}/doc_internal/commands_history.md DEPENDS ${CMAKE_CURRENT_LIST_DIR}/cmds_tags.py ${CMAKE_SOURCE_DIR}/doc_internal/commands_history.md OUTPUT ${PROJECT_BINARY_DIR}/doc_internal/commands_history.md ) add_custom_command( COMMAND ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/doc_internal/cmds_tags.py -tags ${CMAKE_SOURCE_DIR}/doc_internal ${CMAKE_SOURCE_DIR}/doc_internal/tags_history.md ${PROJECT_BINARY_DIR}/doc_internal/tags_history.md DEPENDS ${CMAKE_CURRENT_LIST_DIR}/cmds_tags.py ${CMAKE_SOURCE_DIR}/doc_internal/tags_history.md OUTPUT ${PROJECT_BINARY_DIR}/doc_internal/tags_history.md ) add_custom_command( COMMAND ${Python_EXECUTABLE} translator.py --doc_internal ${PROJECT_SOURCE_DIR} DEPENDS ${PROJECT_SOURCE_DIR}/VERSION ${PROJECT_SOURCE_DIR}/doc/maintainers.txt ${PROJECT_SOURCE_DIR}/doc/language.tpl ${PROJECT_BINARY_DIR}/doc_internal/translator.py ${LANG_FILES} OUTPUT translator_report.md WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/doc_internal ) add_custom_target(docs_internal COMMENT "Generating HTML internal documentation." COMMAND ${CMAKE_COMMAND} -E env VERSION=${VERSION} ${DOXYGEN_EXECUTABLE} DEPENDS doxygen DEPENDS ${PROJECT_BINARY_DIR}/doc_internal/commands_history.md DEPENDS ${PROJECT_BINARY_DIR}/doc_internal/tags_history.md DEPENDS ${PROJECT_BINARY_DIR}/doc_internal/translator_report.md ) doxygen-1.13.0/doc_internal/cmds_tags.py0000644000076500000240000001305114545611070017557 0ustar dimitristaff#!/usr/bin/env python from __future__ import print_function import argparse, glob, itertools, re, shutil, os, sys import subprocess import shlex cmds_reg = re.compile(r'.refitem *cmd[a-z]* *') tags_obsolete_reg = re.compile(r"^.*option *type=.obsolete.*id='([^']*)'.*") tags_active_reg = re.compile(r"^.*option .*id='([^']*)'.*") def xopen(fname, mode='r', encoding='utf-8'): '''Unified file opening for Python 2 an Python 3. Python 2 does not have the encoding argument. Python 3 has one. ''' if sys.version_info[0] == 2: return open(fname, mode=mode) # Python 2 without encoding else: return open(fname, mode=mode, encoding=encoding) # Python 3 with encoding def xpopen(cmd, cmd1="",encoding='utf-8-sig', getStderr=False): '''Unified file pipe opening for Python 2 an Python 3. Python 2 does not have the encoding argument. Python 3 has one. and ''' if sys.version_info[0] == 2: return os.popen(cmd).read() # Python 2 without encoding else: if (getStderr): proc = subprocess.Popen(shlex.split(cmd1),stdout=subprocess.PIPE,stderr=subprocess.PIPE,encoding=encoding) # Python 3 with encoding return proc.stderr.read() else: proc = subprocess.Popen(shlex.split(cmd),stdout=subprocess.PIPE,stderr=subprocess.PIPE,encoding=encoding) # Python 3 with encoding return proc.stdout.read() def get_versions(): raw_versions = xpopen('git tag') versions = [] strip_versions = [] versions.append("Release_1_8_20") pre = "Release_" for o in shlex.split(raw_versions): if o.startswith(pre): ver = o.split('_') v = int(ver[1])*1000+int(ver[2]) if v >= 1009: strip_versions.append(v*1000+int(ver[3])) for i in sorted(set(strip_versions)): versions.append(pre + str(int((i/1000)/1000)) + "_" + str(int((i/1000) % 1000)) + "_" + str(i%1000)) versions.append("master") print(versions) return versions def get_commands(version): lst = xpopen('git show %s:doc/commands.dox'%(version)) if lst.count('\n') == 0: lst = xpopen('git show %s:doc/commands.doc'%(version)) lst_list = [] for line in lst.split('\n'): if cmds_reg.match(line): lst_list.append(re.sub(cmds_reg,'',line).replace("\\\\","\\")) elif line.startswith("\\endsecreflist"): break; return lst_list def process_commands(old_version,new_version): ver = xpopen('git show %s:VERSION'%(new_version)).rstrip() old_list = get_commands(old_version) new_list = get_commands(new_version) hits = [] for l in new_list: toadd = True for o in old_list: if l == o: toadd = False if toadd: hits.append(l) cmds = "" first = True for o in hits: if first: cmds += "
New in %s
\\%s
"%(ver,o) else: cmds += "\n
\\%s
"%(o) first = False if not first: cmds += "\n" return cmds def get_tags(version): lst = xpopen('git show %s:src/config.xml'%(version)) lst_act = [] lst_obs = [] for line in lst.split('\n'): if tags_obsolete_reg.match(line): lst_obs.append(re.sub(tags_obsolete_reg,'\\1',line)) elif tags_active_reg.match(line): lst_act.append(re.sub(tags_active_reg,'\\1',line)) return (sorted(lst_act),sorted(lst_obs)) def process_tags(old_version,new_version): ver = xpopen('git show %s:VERSION'%(new_version)).rstrip() (old_active,old_obsolete) = get_tags(old_version) (new_active,new_obsolete) = get_tags(new_version) hits_active = [] hits_obsolete = [] for l in new_active: toadd = True for o in old_active: if l == o: toadd = False if toadd: hits_active.append(l) for l in new_obsolete: toadd = True for o in old_obsolete: if l == o: toadd = False if toadd: hits_obsolete.append(l) tags= "" if len(hits_active) != 0: tags+= "
New in %s
\n"%(ver) for o in hits_active: tags+= "
%s
\n"%(o) if len(hits_obsolete) != 0: tags+= "
Obsolete in %s
\n"%(ver) for o in hits_obsolete: tags+= "
%s
\n"%(o) return tags def replace_placeholder(cmds,inp_file,outp_file): if (os.path.exists(inp_file)): with xopen(outp_file,"w") as out_file: with xopen(inp_file) as in_file: for line in in_file: if line.startswith(""): out_file.write(cmds) else: out_file.write(line) def main(): git_working_dir = sys.argv[2] inp_file = sys.argv[3] outp_file = sys.argv[4] # set the working directory (to get git information) old_working_dir = os.getcwd() os.chdir(git_working_dir) versions = get_versions() if sys.argv[1] == "-cmds": cmds = "" for i in range(1,len(versions)): cmds += process_commands(versions[i-1],versions[i]) replace_placeholder(cmds,inp_file,outp_file) elif sys.argv[1] == "-tags": tags = "" for i in range(1,len(versions)): tags += process_tags(versions[i-1],versions[i]) pass replace_placeholder(tags,inp_file,outp_file) os.chdir(old_working_dir) if __name__ == '__main__': main() doxygen-1.13.0/doc_internal/Doxyfile.in0000644000076500000240000003176414662154007017371 0ustar dimitristaff# Doxyfile 1.10.0 #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- DOXYFILE_ENCODING = UTF-8 PROJECT_NAME = Doxygen PROJECT_NUMBER = PROJECT_BRIEF = PROJECT_LOGO = PROJECT_ICON = @CMAKE_SOURCE_DIR@/templates/icon/doxygen.ico OUTPUT_DIRECTORY = @PROJECT_BINARY_DIR@/doxygen_docs CREATE_SUBDIRS = YES CREATE_SUBDIRS_LEVEL = 8 ALLOW_UNICODE_NAMES = NO OUTPUT_LANGUAGE = English BRIEF_MEMBER_DESC = YES REPEAT_BRIEF = YES ABBREVIATE_BRIEF = ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO FULL_PATH_NAMES = YES STRIP_FROM_PATH = @CMAKE_SOURCE_DIR@ STRIP_FROM_INC_PATH = @CMAKE_SOURCE_DIR@ SHORT_NAMES = NO JAVADOC_AUTOBRIEF = YES JAVADOC_BANNER = NO QT_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO PYTHON_DOCSTRING = YES INHERIT_DOCS = YES SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 8 ALIASES = OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_JAVA = NO OPTIMIZE_FOR_FORTRAN = NO OPTIMIZE_OUTPUT_VHDL = NO OPTIMIZE_OUTPUT_SLICE = NO EXTENSION_MAPPING = MARKDOWN_SUPPORT = YES TOC_INCLUDE_HEADINGS = 5 MARKDOWN_ID_STYLE = DOXYGEN AUTOLINK_SUPPORT = YES BUILTIN_STL_SUPPORT = NO CPP_CLI_SUPPORT = NO SIP_SUPPORT = NO IDL_PROPERTY_SUPPORT = YES DISTRIBUTE_GROUP_DOC = NO GROUP_NESTED_COMPOUNDS = NO SUBGROUPING = YES INLINE_GROUPED_CLASSES = NO INLINE_SIMPLE_STRUCTS = NO TYPEDEF_HIDES_STRUCT = NO LOOKUP_CACHE_SIZE = 1 NUM_PROC_THREADS = 0 TIMESTAMP = NO #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- EXTRACT_ALL = YES EXTRACT_PRIVATE = YES EXTRACT_PRIV_VIRTUAL = NO EXTRACT_PACKAGE = NO EXTRACT_STATIC = YES EXTRACT_LOCAL_CLASSES = YES EXTRACT_LOCAL_METHODS = NO EXTRACT_ANON_NSPACES = YES RESOLVE_UNNAMED_PARAMS = YES HIDE_UNDOC_MEMBERS = NO HIDE_UNDOC_CLASSES = NO HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO INTERNAL_DOCS = NO CASE_SENSE_NAMES = NO HIDE_SCOPE_NAMES = NO HIDE_COMPOUND_REFERENCE= NO SHOW_HEADERFILE = YES SHOW_INCLUDE_FILES = YES SHOW_GROUPED_MEMB_INC = NO FORCE_LOCAL_INCLUDES = NO INLINE_INFO = YES SORT_MEMBER_DOCS = YES SORT_BRIEF_DOCS = NO SORT_MEMBERS_CTORS_1ST = NO SORT_GROUP_NAMES = NO SORT_BY_SCOPE_NAME = NO STRICT_PROTO_MATCHING = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 30 SHOW_USED_FILES = YES SHOW_FILES = YES SHOW_NAMESPACES = YES FILE_VERSION_FILTER = LAYOUT_FILE = CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- QUIET = NO WARNINGS = YES WARN_IF_UNDOCUMENTED = YES WARN_IF_DOC_ERROR = YES WARN_IF_INCOMPLETE_DOC = YES WARN_NO_PARAMDOC = NO WARN_IF_UNDOC_ENUM_VAL = NO WARN_AS_ERROR = FAIL_ON_WARNINGS_PRINT WARN_FORMAT = "$file:$line: $text" WARN_LINE_FORMAT = "at line $line of file $file" WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- INPUT = @CMAKE_SOURCE_DIR@/doc_internal/doxygen.md \ @PROJECT_BINARY_DIR@/doc_internal/commands_history.md \ @CMAKE_SOURCE_DIR@/doc_internal/commands_internal.md \ @CMAKE_SOURCE_DIR@/doc_internal/releases.md \ @PROJECT_BINARY_DIR@/doc_internal/tags_history.md \ @PROJECT_BINARY_DIR@/doc_internal/translator_report.md \ @CMAKE_SOURCE_DIR@/src \ @CMAKE_SOURCE_DIR@/vhdlparser \ @CMAKE_SOURCE_DIR@/libxml INPUT_ENCODING = UTF-8 INPUT_FILE_ENCODING = FILE_PATTERNS = *.h \ *.hpp \ *.cpp \ *.l \ *.md RECURSIVE = NO EXCLUDE = EXCLUDE_SYMLINKS = NO EXCLUDE_PATTERNS = EXCLUDE_SYMBOLS = EXAMPLE_PATH = EXAMPLE_PATTERNS = EXAMPLE_RECURSIVE = NO IMAGE_PATH = INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO FILTER_SOURCE_PATTERNS = USE_MDFILE_AS_MAINPAGE = FORTRAN_COMMENT_AFTER = 72 #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- SOURCE_BROWSER = YES INLINE_SOURCES = YES STRIP_CODE_COMMENTS = NO REFERENCED_BY_RELATION = YES REFERENCES_RELATION = YES REFERENCES_LINK_SOURCE = YES SOURCE_TOOLTIPS = YES USE_HTAGS = NO VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- ALPHABETICAL_INDEX = YES IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- GENERATE_HTML = YES HTML_OUTPUT = HTML_FILE_EXTENSION = .html HTML_HEADER = HTML_FOOTER = HTML_STYLESHEET = HTML_EXTRA_STYLESHEET = @CMAKE_SOURCE_DIR@/doc_internal/doc_internal.css HTML_EXTRA_FILES = HTML_COLORSTYLE = TOGGLE HTML_COLORSTYLE_HUE = 220 HTML_COLORSTYLE_SAT = 100 HTML_COLORSTYLE_GAMMA = 80 HTML_DYNAMIC_MENUS = YES HTML_DYNAMIC_SECTIONS = YES HTML_CODE_FOLDING = YES HTML_COPY_CLIPBOARD = YES HTML_PROJECT_COOKIE = doxygen_docs_internal HTML_INDEX_NUM_ENTRIES = 100 GENERATE_DOCSET = NO DOCSET_FEEDNAME = "Doxygen docs" DOCSET_FEEDURL = DOCSET_BUNDLE_ID = org.doxygen.Doxygen DOCSET_PUBLISHER_ID = org.doxygen.Publisher DOCSET_PUBLISHER_NAME = Publisher GENERATE_HTMLHELP = NO CHM_FILE = HHC_LOCATION = GENERATE_CHI = NO CHM_INDEX_ENCODING = BINARY_TOC = NO TOC_EXPAND = NO SITEMAP_URL = GENERATE_QHP = NO QCH_FILE = QHP_NAMESPACE = org.doxygen.Project QHP_VIRTUAL_FOLDER = doc QHP_CUST_FILTER_NAME = QHP_CUST_FILTER_ATTRS = QHP_SECT_FILTER_ATTRS = QHG_LOCATION = GENERATE_ECLIPSEHELP = NO ECLIPSE_DOC_ID = org.doxygen.Project DISABLE_INDEX = NO GENERATE_TREEVIEW = YES FULL_SIDEBAR = NO ENUM_VALUES_PER_LINE = 4 TREEVIEW_WIDTH = 250 EXT_LINKS_IN_WINDOW = NO OBFUSCATE_EMAILS = YES HTML_FORMULA_FORMAT = png FORMULA_FONTSIZE = 10 FORMULA_MACROFILE = USE_MATHJAX = NO MATHJAX_VERSION = MathJax_2 MATHJAX_FORMAT = HTML-CSS MATHJAX_RELPATH = MATHJAX_EXTENSIONS = MATHJAX_CODEFILE = SEARCHENGINE = YES SERVER_BASED_SEARCH = NO EXTERNAL_SEARCH = NO SEARCHENGINE_URL = SEARCHDATA_FILE = searchdata.xml EXTERNAL_SEARCH_ID = EXTRA_SEARCH_MAPPINGS = #--------------------------------------------------------------------------- # Configuration options related to the LaTeX output #--------------------------------------------------------------------------- GENERATE_LATEX = NO LATEX_OUTPUT = LATEX_CMD_NAME = MAKEINDEX_CMD_NAME = makeindex LATEX_MAKEINDEX_CMD = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4 EXTRA_PACKAGES = LATEX_HEADER = LATEX_FOOTER = LATEX_EXTRA_STYLESHEET = LATEX_EXTRA_FILES = PDF_HYPERLINKS = YES USE_PDFLATEX = NO LATEX_BATCHMODE = NO LATEX_HIDE_INDICES = NO LATEX_BIB_STYLE = plain LATEX_EMOJI_DIRECTORY = #--------------------------------------------------------------------------- # Configuration options related to the RTF output #--------------------------------------------------------------------------- GENERATE_RTF = NO RTF_OUTPUT = COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # Configuration options related to the man page output #--------------------------------------------------------------------------- GENERATE_MAN = NO MAN_OUTPUT = MAN_EXTENSION = .3 MAN_SUBDIR = MAN_LINKS = NO #--------------------------------------------------------------------------- # Configuration options related to the XML output #--------------------------------------------------------------------------- GENERATE_XML = NO XML_OUTPUT = xml XML_PROGRAMLISTING = YES XML_NS_MEMB_FILE_SCOPE = NO #--------------------------------------------------------------------------- # Configuration options related to the DOCBOOK output #--------------------------------------------------------------------------- GENERATE_DOCBOOK = NO DOCBOOK_OUTPUT = docbook #--------------------------------------------------------------------------- # Configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # Configuration options related to Sqlite3 output #--------------------------------------------------------------------------- GENERATE_SQLITE3 = NO SQLITE3_OUTPUT = sqlite3 SQLITE3_RECREATE_DB = YES #--------------------------------------------------------------------------- # Configuration options related to the Perl module output #--------------------------------------------------------------------------- GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- ENABLE_PREPROCESSING = YES MACRO_EXPANSION = YES EXPAND_ONLY_PREDEF = YES SEARCH_INCLUDES = YES INCLUDE_PATH = @CMAKE_SOURCE_DIR@/deps/libmd5 \ @CMAKE_SOURCE_DIR@/deps/liblodepng \ @CMAKE_SOURCE_DIR@/deps/libmscgen INCLUDE_FILE_PATTERNS = PREDEFINED = DOXYGEN_ONLY EXPAND_AS_DEFINED = DOC_NODES \ DN_SEP \ DN SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration options related to external references #--------------------------------------------------------------------------- TAGFILES = GENERATE_TAGFILE = doxygen.tag ALLEXTERNALS = NO EXTERNAL_GROUPS = YES EXTERNAL_PAGES = YES #--------------------------------------------------------------------------- # Configuration options related to diagram generator tools #--------------------------------------------------------------------------- HIDE_UNDOC_RELATIONS = YES HAVE_DOT = YES DOT_NUM_THREADS = 0 DOT_COMMON_ATTR = "fontname=Helvetica,fontsize=10" DOT_EDGE_ATTR = "labelfontname=Helvetica,labelfontsize=10" DOT_NODE_ATTR = "shape=box,height=0.2,width=0.4" DOT_FONTPATH = CLASS_GRAPH = YES COLLABORATION_GRAPH = YES GROUP_GRAPHS = YES UML_LOOK = NO UML_LIMIT_NUM_FIELDS = 10 DOT_UML_DETAILS = NO DOT_WRAP_THRESHOLD = 17 TEMPLATE_RELATIONS = YES INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = YES CALL_GRAPH = NO CALLER_GRAPH = NO GRAPHICAL_HIERARCHY = YES DIRECTORY_GRAPH = YES DIR_GRAPH_MAX_DEPTH = 1 DOT_IMAGE_FORMAT = svg INTERACTIVE_SVG = YES DOT_PATH = DOTFILE_DIRS = DIA_PATH = DIAFILE_DIRS = PLANTUML_JAR_PATH = PLANTUML_CFG_FILE = PLANTUML_INCLUDE_PATH = PLANTUMLFILE_DIRS = DOT_GRAPH_MAX_NODES = 300 MAX_DOT_GRAPH_DEPTH = 0 DOT_MULTI_TARGETS = YES GENERATE_LEGEND = YES DOT_CLEANUP = NO MSCGEN_TOOL = MSCFILE_DIRS = doxygen-1.13.0/doc_internal/doc_internal.css0000755000076500000240000000137314545611070020423 0ustar dimitristaffdl.multicol { -moz-column-gap: 1em; -webkit-column-gap: 1em; column-gap: 1em; -moz-column-count: 3; -webkit-column-count: 3; column-count: 3; list-style-type: none; } ul.multicol { font-family: courier,monospace; } body { scrollbar-color: var(--scrollbar-thumb-color) var(--scrollbar-background-color); } ::-webkit-scrollbar { background-color: var(--scrollbar-background-color); height: 12px; width: 12px; } ::-webkit-scrollbar-thumb { border-radius: 6px; box-shadow: inset 0 0 12px 12px var(--scrollbar-thumb-color); border: solid 2px transparent; } ::-webkit-scrollbar-corner { background-color: var(--scrollbar-background-color); } doxygen-1.13.0/doc_internal/commands_internal.md0000755000076500000240000001374714646202364021303 0ustar dimitristaff\page pg_cmds_int Overview of introduction of internal special commands The following table gives an overview of the doxygen internal special commands and the version in which they were introduced. \secreflist \refitem cmdialias \\ialias \refitem cmdendicode \\endicode \refitem cmdendiliteral \\endiliteral \refitem cmdendiskip \\endiskip \refitem cmdendiverbatim \\endiverbatim \refitem cmdianchor \\ianchor \refitem cmdicode \\icode \refitem cmdifile \\ifile \refitem cmdiline \\iline \refitem cmdilinebr \\ilinebr \refitem cmdiliteral \\iliteral \refitem cmdiprefix \\iprefix \refitem cmdiraise \\iraise \refitem cmdiskip \\iskip \refitem cmdiverbatim \\iverbatim \endsecreflist
\section cmdialias \\ialias{name} \addindex \\ialias This command is used to prevent endless recursive expansion of aliases. For an alias `name` the command `\ialias{name}` is inserted after its expansion, and then the expanded string is reparsed, but until the `\ialias` is processed the `name` is not considered for further alias expansion. \since doxygen version 1.11.0
\section cmdianchor \\ianchor{title} anchor \addindex \\ianchor This command has a similar syntax and function as the command `\anchor`, but is internally used for the `@page` command in markdown files. Unlike `\anchor` it has an additional `title` option that is used as the link text in references to the page. \since doxygen version 1.9.7
\section cmdilinebr \\ilinebr \addindex \\ilinebr Internal doxygen command to simulate an end of line, but without advancing the line counter. In this way it is possible to have multiple commands on one line that read till the end of line. This command is internally used by doxygen and for replacement of the `^^` in `ALIASES` settings. This command sees to it that e.g. warning messages stay correct when a command is replaced internally by multiple commands. Temporarily also as `@_ilinebr` (doxygen version 1.8.14) and `\_ilinebr` (doxygen version 1.8.15 till 1.8.18) \since doxygen version 1.8.19
\section cmdifile \\ifile \ \addindex \\ifile Internal doxygen command to reset the current filename in a documentation block so that doxygen can give a better warning about the original source of a problem when a documentation block is constructed from multiple files. \since doxygen version 1.9.5
\section cmdiline \\iline \ \addindex \\iline Internal doxygen command to reset the current line counter in a documentation block so that doxygen can give a better warning about the original source of a problem when a documentation block is constructed from multiple files or blocks from one file. \since doxygen version 1.9.2
\section cmdicode \\icode['{'\'}'] \addindex \\icode This command has a similar syntax and function as the command `\code`, but is internally used for markdown fenced code blocks (i.e. \`\`\` and `~~~` type of blocks) to replace these markers. The `\code` command cannot be used as in that case the block cannot contain a `\endcode` as this would terminate the `\code` block. \since doxygen version 1.9.5
\section cmdendicode \\endicode \addindex \\endicode Ends a block of text that was started with a \ref cmdicode "\\icode" command. \since doxygen version 1.9.5
\section cmdiliteral \\iliteral['{'\'}'] \addindex \\iliteral This command is to replace the Java documentation commands `{@literal .... }` and `{@code ...}`. The text in the blocks will not be interpreted by doxygen in any way. The text in the `{@literal` will put as is text in the output. The text in the `{@code` will be replaced by a code block with class `JavaDocCode` i.e. `...`. \since doxygen version 1.9.3
\section cmdendiliteral \\endiliteral \addindex \\endiliteral Ends a block of text that was started with a \ref cmdiliteral "\\iliteral" command. \since doxygen version 1.9.3
\section cmdiverbatim \\iverbatim \addindex \\iverbatim This command has a similar function as the command `\verbatim`, but is internally used for markdown code blocks (i.e. blocks of text indented with at least 4 extra spaces compared to the previous block) and python unformatted docstrings (i.e. ''' type of blocks) to replace these markers. The `\verbatim` command cannot be used as in that case the block cannot contain a `\endverbatim` as this would terminate the `\verbatim` block. \since doxygen version 1.9.5
\section cmdiraise \\iraise \ \addindex \\iraise Internal doxygen command to increase the section level by a given `amount`. After processing `\iraise 1` for instance, a `\section s1` will be treated as a `\subsection s1`. Inserted when processing `\include{doc}` with the `raise` option. \since doxygen version 1.11.0
\section cmdiskip \\iskip \addindex \\iskip Internal doxygen command to suppress evaluation of whitespace to determine the indentation of a comment block. Evaluation will continue as normal when the matching \ref cmdendiskip "\\endiskip" command is found. Inserted when processing commands that contain literal text like `\startuml`, `\verbatim`, `` etc. \since doxygen version 1.12.0
\section cmdiprefix \\iprefix "