before_install:
- sudo apt-add-repository ppa:smspillaz/cmake-2.8.12 -y
- - sudo add-apt-repository ppa:texlive-backports/ppa -y
- sudo apt-get update -qq
install:
Doxygen's cmake configuration provides a number of options:
- build_wizard Build the GUI frontend for doxygen.
- build_app Example showing how to embed doxygen in an application.
+- build_parse Parses source code and dumps the dependencies between the code elements.
- build_xmlparser Example showing how to parse doxygen's XML output.
- build_search Build external search tools (doxysearch and doxyindexer).
- build_doc Build user manual.
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_xmlparser "Example showing how to parse doxygen's XML output." OFF)
option(build_search "Build external search tools (doxysearch and doxyindexer)" OFF)
option(build_doc "Build user manual" OFF)
if (use_sqlite3)
set(sqlite3 "1" CACHE INTERNAL "used in settings.h")
endif()
+
+set(MACOS_VERSION_MIN 10.5)
if (use_libclang)
set(clang "1" CACHE INTERNAL "used in settings.h")
- find_package(LibClang REQUIRED)
+ find_package(LLVM CONFIG REQUIRED)
+ find_package(Clang CONFIG REQUIRED)
+ if (CMAKE_SYSTEM MATCHES "Darwin")
+ set(MACOS_VERSION_MIN 10.11)
+ endif()
endif()
-if (${CMAKE_SYSTEM} MATCHES "Darwin")
- set(CMAKE_CXX_FLAGS "-Wno-deprecated-register -mmacosx-version-min=10.5 ${CMAKE_CXX_FLAGS}")
- set(CMAKE_C_FLAGS "-Wno-deprecated-register -mmacosx-version-min=10.5 ${CMAKE_C_FLAGS}")
+if (CMAKE_SYSTEM MATCHES "Darwin")
+ 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 (WIN32)
- if(NOT ICONV_DIR)
- set(ICONV_DIR "${CMAKE_SOURCE_DIR}/winbuild")
+ if (NOT CMAKE_GENERATOR MATCHES "MinGW Makefiles")
+ if (NOT ICONV_DIR)
+ set(ICONV_DIR "${CMAKE_SOURCE_DIR}/winbuild")
+ 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)
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)
endif()
-if ("${CMAKE_GENERATOR}" MATCHES "Ninja")
+if(POLICY CMP0063)
+ cmake_policy(SET CMP0063 NEW)
+endif()
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+
+if (CMAKE_GENERATOR MATCHES "Ninja")
set(LEX_FLAGS )
set(YACC_FLAGS )
-else ("${CMAKE_GENERATOR}" MATCHES "Ninja")
+else ()
set(LEX_FLAGS $(LEX_FLAGS))
set(YACC_FLAGS $(YACC_FLAGS))
-endif ("${CMAKE_GENERATOR}" MATCHES "Ninja")
+endif ()
find_program(DOT NAMES dot)
find_package(PythonInterp REQUIRED)
set(GENERATED_SRC "${CMAKE_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)
-set(CUSTOM_INCLUDE_DIR "" CACHE FILEPATH "Extra include path")
-set(CUSTOM_LINK_DIR "" CACHE FILEPATH "Extra library path")
# place binaries for all build types in the same directory, so we know where to find it
# when running tests or generating docs
# gather lang codes for translation
file(GLOB lang_files RELATIVE "${CMAKE_SOURCE_DIR}/src" "${CMAKE_SOURCE_DIR}/src/translator_??.h")
-set(lcodes "")
-foreach (_lang ${lang_files})
- string(REGEX REPLACE "translator_(.*).h" "\\1" _lang_code ${_lang})
- string(TOUPPER ${_lang_code} lang_code)
- list(APPEND lcodes "${lang_code}")
-endforeach()
if (english_only) # user only wants English
set(lcodes "ENONLY")
+else ()
+ set(lcodes "")
+ foreach (_lang ${lang_files})
+ string(REGEX REPLACE "translator_(.*).h" "\\1" _lang_code ${_lang})
+ string(TOUPPER ${_lang_code} lang_code)
+ list(APPEND lcodes "${lang_code}")
+ endforeach()
endif()
set(LANG_CODES ${lcodes} CACHE STRING "List of language codes for which translations should be compiled in")
-if (${CUSTOM_INCLUDE_DIR})
- include_directories(${CUSTOM_INCLUDE_DIR})
-endif()
-
-if (${CUSTOM_LINK_DIR})
- link_directories(${CUSTOM_LINK_DIR})
-endif()
-
if (win_static)
set(CompilerFlags
CMAKE_CXX_FLAGS
add_subdirectory(qtools)
add_subdirectory(vhdlparser)
add_subdirectory(src)
-add_subdirectory(examples)
-add_subdirectory(doc)
-add_subdirectory(addon/doxmlparser)
-add_subdirectory(addon/doxyapp)
-add_subdirectory(addon/doxysearch)
-add_subdirectory(addon/doxywizard)
+if (build_doc)
+ add_subdirectory(examples)
+ add_subdirectory(doc)
+endif ()
+
+add_subdirectory(addon)
enable_testing()
add_subdirectory(testing)
FORMULA_TRANSPARENT = YES
USE_MATHJAX = NO
MATHJAX_FORMAT = HTML-CSS
-MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_RELPATH = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/
MATHJAX_EXTENSIONS =
MATHJAX_CODEFILE =
SEARCHENGINE = YES
DOXYGEN
-Please read the installation section of the manual
+Please read the installation section of the manual
(http://www.doxygen.org/install.html) for instructions.
--------
Source Code
----------------------------------
In May 2013, Doxygen moved from
-subversion to git hosted at github
+subversion to git hosted at GitHub
* https://github.com/doxygen/doxygen
Enjoy,
--- /dev/null
+add_subdirectory(doxmlparser)
+
+if (build_app)
+ add_subdirectory(doxyapp)
+endif ()
+
+if (build_parse)
+ add_subdirectory(doxyparse)
+endif ()
+
+if (build_search)
+ add_subdirectory(doxysearch)
+endif ()
+
+if (build_wizard)
+ add_subdirectory(doxywizard)
+endif ()
-if (build_app)
-
# configvalues.h
add_custom_command(
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/src/configgen.py -maph ${CMAKE_SOURCE_DIR}/src/config.xml > ${GENERATED_SRC}/configvalues.h
)
install(TARGETS doxyapp DESTINATION bin)
-
-endif()
--- /dev/null
+# configvalues.h
+add_custom_command(
+ COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/src/configgen.py -maph ${CMAKE_SOURCE_DIR}/src/config.xml > ${GENERATED_SRC}/configvalues.h
+ DEPENDS ${CMAKE_SOURCE_DIR}/src/config.xml ${CMAKE_SOURCE_DIR}/src/configgen.py
+ OUTPUT ${GENERATED_SRC}/configvalues.h
+)
+set_source_files_properties(${GENERATED_SRC}/configvalues.h PROPERTIES GENERATED 1)
+
+find_package(Iconv)
+
+include_directories(
+ ${CMAKE_SOURCE_DIR}/src
+ ${GENERATED_SRC}
+ ${CMAKE_SOURCE_DIR}/qtools
+ ${ICONV_INCLUDE_DIR}
+ ${CLANG_INCLUDEDIR}
+)
+
+add_executable(doxyparse
+doxyparse.cpp
+)
+target_link_libraries(doxyparse
+_doxygen
+qtools
+md5
+doxycfg
+vhdlparser
+${ICONV_LIBRARIES}
+${CMAKE_THREAD_LIBS_INIT}
+${SQLITE3_LIBRARIES}
+${EXTRA_LIBS}
+${CLANG_LIBS}
+)
+
+install(TARGETS doxyparse DESTINATION bin)
--- /dev/null
+doxyparse
+=========
+
+This directory contains an "source parsing engine" based on doxyapp code.
+
+More info and source code repository: https://github.com/analizo/doxygen
+
+## build
+
+ cmake -G "Unix Makefiles" -Dbuild_parse=ON
+ make
+
+AUTHORS
+=======
+
+Antonio Terceiro <terceiro@softwarelivre.org>
+João M. Miranda <joaomm88@gmail.com>
+Joenio Costa <joenio@colivre.coop.br>
+Paulo Meirelles <paulo@softwarelivre.org>
+Vinicius Daros <vkdaros@mercurio.eclipse.ime.usp.br>
--- /dev/null
+.TH DOXYPARSE "1" "DATE" "doxyparse VERSION" "User Commands"
+.SH NAME
+doxyparse \- parse and dumps information about the code
+.SH SYNOPSIS
+.B doxyparse
+[\fIsource file\fR...]
+.SH DESCRIPTION
+Parses source code and dumps the dependencies between the code elements.
+.SH SEE ALSO
+doxygen(1), doxytag(1), doxywizard(1).
--- /dev/null
+/******************************************************************************
+ *
+ * Copyright (C) 2009-2015 by Joenio Costa.
+ *
+ * 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.
+ *
+ */
+
+/** @file
+ * @brief Code parse based on doxyapp by Dimitri van Heesch
+ *
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include "doxygen.h"
+#include "outputgen.h"
+#include "parserintf.h"
+#include "classlist.h"
+#include "config.h"
+#include "filedef.h"
+#include "util.h"
+#include "filename.h"
+#include "arguments.h"
+#include "memberlist.h"
+#include "types.h"
+#include <string>
+#include <cstdlib>
+#include <sstream>
+#include <map>
+
+class Doxyparse : public CodeOutputInterface
+{
+ public:
+ Doxyparse(FileDef *fd) : m_fd(fd) {}
+ ~Doxyparse() {}
+
+ // these are just null functions, they can be used to produce a syntax highlighted
+ // and cross-linked version of the source code, but who needs that anyway ;-)
+ void codify(const char *) {}
+ void writeCodeLink(const char *,const char *,const char *,const char *,const char *) {}
+ void startCodeLine() {}
+ void endCodeLine() {}
+ void startCodeAnchor(const char *) {}
+ void endCodeAnchor() {}
+ void startFontClass(const char *) {}
+ void endFontClass() {}
+ void writeCodeAnchor(const char *) {}
+ void writeLineNumber(const char *,const char *,const char *,int) {}
+ virtual void writeTooltip(const char *,const DocLinkInfo &,
+ const char *,const char *,const SourceLinkInfo &,
+ const SourceLinkInfo &) {}
+ void startCodeLine(bool) {}
+ void setCurrentDoc(Definition *,const char *,bool) {}
+ void addWord(const char *,bool) {}
+
+ void linkableSymbol(int l, const char *sym, Definition *symDef, Definition *context)
+ {
+ if (!symDef) {
+ // in this case we have a local or external symbol
+
+ // TODO record use of external symbols
+ // TODO must have a way to differentiate external symbols from local variables
+ }
+ }
+
+ private:
+ FileDef *m_fd;
+};
+
+static bool is_c_code = true;
+static std::map<std::string, bool> modules;
+static std::string current_module;
+
+static void findXRefSymbols(FileDef *fd)
+{
+ // get the interface to a parser that matches the file extension
+ ParserInterface *pIntf=Doxygen::parserManager->getParser(fd->getDefFileExtension());
+
+ // get the programming language from the file name
+ SrcLangExt lang = getLanguageFromFileName(fd->name());
+
+ // reset the parsers state
+ pIntf->resetCodeParserState();
+
+ // create a new backend object
+ Doxyparse *parse = new Doxyparse(fd);
+
+ // parse the source code
+ pIntf->parseCode(*parse, 0, fileToString(fd->absFilePath()), lang, FALSE, 0, fd);
+
+ // dismiss the object.
+ delete parse;
+}
+
+static bool ignoreStaticExternalCall(MemberDef *context, MemberDef *md) {
+ if (md->isStatic()) {
+ if(md->getFileDef()) {
+ if(md->getFileDef()->getOutputFileBase() == context->getFileDef()->getOutputFileBase())
+ // TODO ignore prefix of file
+ return false;
+ else
+ return true;
+ }
+ else {
+ return false;
+ }
+ }
+ else {
+ return false;
+ }
+}
+
+static void printFile(std::string file) {
+ printf("%s:\n", file.c_str());
+}
+static void printModule(std::string module) {
+ current_module = module;
+ printf(" %s:\n", module.c_str());
+}
+static void printClassInformation(std::string information) {
+ printf(" information: %s\n", information.c_str());
+}
+static void printInheritance(std::string base_class) {
+ printf(" inherits: %s\n", base_class.c_str());
+}
+static void printDefines() {
+ if (! modules[current_module]) {
+ printf(" defines:\n");
+ }
+ modules[current_module] = true;
+}
+static void printDefinition(std::string type, std::string signature, int line) {
+ printf(" - %s:\n", signature.c_str());
+ printf(" type: %s\n", type.c_str());
+ printf(" line: %d\n", line);
+}
+static void printProtection(std::string protection) {
+ printf(" protection: %s\n", protection.c_str());
+}
+static void printNumberOfLines(int lines) {
+ printf(" lines_of_code: %d\n", lines);
+}
+static void printNumberOfArguments(int arguments) {
+ printf(" parameters: %d\n", arguments);
+}
+static void printUses() {
+ printf(" uses:\n");
+}
+static void printReferenceTo(std::string type, std::string signature, std::string defined_in) {
+ printf(" - %s:\n", signature.c_str());
+ printf(" type: %s\n", type.c_str());
+ printf(" defined_in: %s\n", defined_in.c_str());
+}
+static void printNumberOfConditionalPaths(MemberDef* md) {
+ printf(" conditional_paths: %d\n", md->numberOfFlowKeyWords());
+}
+
+static int isPartOfCStruct(MemberDef * md) {
+ return is_c_code && md->getClassDef() != NULL;
+}
+
+std::string functionSignature(MemberDef* md) {
+ std::string signature = md->name().data();
+ if(md->isFunction()){
+ ArgumentList *argList = md->argumentList();
+ ArgumentListIterator iterator(*argList);
+ signature += "(";
+ Argument * argument = iterator.toFirst();
+ if(argument != NULL) {
+ signature += argument->type.data();
+ for(++iterator; (argument = iterator.current()) ;++iterator){
+ signature += std::string(",") + argument->type.data();
+ }
+ }
+ signature += ")";
+ }
+ return signature;
+}
+
+static void referenceTo(MemberDef* md) {
+ std::string type = md->memberTypeName().data();
+ std::string defined_in = "";
+ std::string signature = "";
+ if (isPartOfCStruct(md)) {
+ signature = md->getClassDef()->name().data() + std::string("::") + functionSignature(md);
+ defined_in = md->getClassDef()->getFileDef()->getOutputFileBase().data();
+ }
+ else {
+ signature = functionSignature(md);
+ if (md->getClassDef()) {
+ defined_in = md->getClassDef()->name().data();
+ }
+ else if (md->getFileDef()) {
+ defined_in = md->getFileDef()->getOutputFileBase().data();
+ }
+ }
+ printReferenceTo(type, signature, defined_in);
+}
+
+void cModule(ClassDef* cd) {
+ MemberList* ml = cd->getMemberList(MemberListType_variableMembers);
+ if (ml) {
+ MemberListIterator mli(*ml);
+ MemberDef* md;
+ for (mli.toFirst(); (md=mli.current()); ++mli) {
+ printDefinition("variable", cd->name().data() + std::string("::") + md->name().data(), md->getDefLine());
+ if (md->protection() == Public) {
+ printProtection("public");
+ }
+ }
+ }
+}
+
+void functionInformation(MemberDef* md) {
+ int size = md->getEndBodyLine() - md->getStartBodyLine() + 1;
+ printNumberOfLines(size);
+ ArgumentList *argList = md->argumentList();
+ printNumberOfArguments(argList->count());
+ printNumberOfConditionalPaths(md);
+ MemberSDict *defDict = md->getReferencesMembers();
+ if (defDict) {
+ MemberSDict::Iterator msdi(*defDict);
+ MemberDef *rmd;
+ printUses();
+ for (msdi.toFirst(); (rmd=msdi.current()); ++msdi) {
+ if (rmd->definitionType() == Definition::TypeMember && !ignoreStaticExternalCall(md, rmd)) {
+ referenceTo(rmd);
+ }
+ }
+ }
+}
+
+static void lookupSymbol(Definition *d) {
+ if (d->definitionType() == Definition::TypeMember) {
+ MemberDef *md = (MemberDef *)d;
+ std::string type = md->memberTypeName().data();
+ std::string signature = functionSignature(md);
+ printDefinition(type, signature, md->getDefLine());
+ if (md->protection() == Public) {
+ printProtection("protection public");
+ }
+ if (md->isFunction()) {
+ functionInformation(md);
+ }
+ }
+}
+
+void listMembers(MemberList *ml) {
+ if (ml) {
+ MemberListIterator mli(*ml);
+ MemberDef *md;
+ printDefines();
+ for (mli.toFirst(); (md=mli.current()); ++mli) {
+ lookupSymbol((Definition*) md);
+ }
+ }
+}
+
+void listAllMembers(ClassDef* cd) {
+ // methods
+ listMembers(cd->getMemberList(MemberListType_functionMembers));
+ // constructors
+ listMembers(cd->getMemberList(MemberListType_constructors));
+ // attributes
+ listMembers(cd->getMemberList(MemberListType_variableMembers));
+}
+
+static void classInformation(ClassDef* cd) {
+ if (is_c_code) {
+ cModule(cd);
+ } else {
+ printModule(cd->name().data());
+ BaseClassList* baseClasses = cd->baseClasses();
+ if (baseClasses) {
+ BaseClassListIterator bci(*baseClasses);
+ BaseClassDef* bcd;
+ for (bci.toFirst(); (bcd = bci.current()); ++bci) {
+ printInheritance(bcd->classDef->name().data());
+ }
+ }
+ if(cd->isAbstract()) {
+ printClassInformation("abstract class");
+ }
+ listAllMembers(cd);
+ }
+}
+
+static bool checkLanguage(std::string& filename, std::string extension) {
+ if (filename.find(extension, filename.size() - extension.size()) != std::string::npos) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+/* Detects the programming language of the project. Actually, we only care
+ * about whether it is a C project or not. */
+static void detectProgrammingLanguage(FileNameListIterator& fnli) {
+ FileName* fn;
+ for (fnli.toFirst(); (fn=fnli.current()); ++fnli) {
+ std::string filename = fn->fileName();
+ if (
+ checkLanguage(filename, ".cc") ||
+ checkLanguage(filename, ".cxx") ||
+ checkLanguage(filename, ".cpp") ||
+ checkLanguage(filename, ".java")
+ ) {
+ is_c_code = false;
+ }
+ }
+}
+
+static void listSymbols() {
+ // iterate over the input files
+ FileNameListIterator fnli(*Doxygen::inputNameList);
+ FileName *fn;
+
+ detectProgrammingLanguage(fnli);
+
+ // for each file
+ for (fnli.toFirst(); (fn=fnli.current()); ++fnli) {
+ FileNameIterator fni(*fn);
+ FileDef *fd;
+ for (; (fd=fni.current()); ++fni) {
+ printFile(fd->absFilePath().data());
+ MemberList *ml = fd->getMemberList(MemberListType_allMembersList);
+ if (ml && ml->count() > 0) {
+ printModule(fd->getOutputFileBase().data());
+ listMembers(ml);
+ }
+
+ ClassSDict *classes = fd->getClassSDict();
+ if (classes) {
+ ClassSDict::Iterator cli(*classes);
+ ClassDef *cd;
+ for (cli.toFirst(); (cd = cli.current()); ++cli) {
+ classInformation(cd);
+ }
+ }
+ }
+ }
+ // TODO print external symbols referenced
+}
+
+int main(int argc,char **argv) {
+ if (argc < 2) {
+ printf("Usage: %s [source_file | source_dir]\n",argv[0]);
+ exit(1);
+ }
+
+ // initialize data structures
+ initDoxygen();
+
+ // check and finalize the configuration
+ checkConfiguration();
+ adjustConfiguration();
+
+ // setup the non-default configuration options
+
+ // we need a place to put intermediate files
+ std::ostringstream tmpdir;
+ tmpdir << "/tmp/doxyparse-" << getpid();
+ Config_getString(OUTPUT_DIRECTORY)= tmpdir.str().c_str();
+ // enable HTML (fake) output to omit warning about missing output format
+ Config_getBool(GENERATE_HTML)=TRUE;
+ // disable latex output
+ Config_getBool(GENERATE_LATEX)=FALSE;
+ // be quiet
+ Config_getBool(QUIET)=TRUE;
+ // turn off warnings
+ Config_getBool(WARNINGS)=FALSE;
+ Config_getBool(WARN_IF_UNDOCUMENTED)=FALSE;
+ Config_getBool(WARN_IF_DOC_ERROR)=FALSE;
+ // Extract as much as possible
+ Config_getBool(EXTRACT_ALL)=TRUE;
+ Config_getBool(EXTRACT_STATIC)=TRUE;
+ Config_getBool(EXTRACT_PRIVATE)=TRUE;
+ Config_getBool(EXTRACT_LOCAL_METHODS)=TRUE;
+ // Extract source browse information, needed
+ // to make doxygen gather the cross reference info
+ Config_getBool(SOURCE_BROWSER)=TRUE;
+ // find functions call between modules
+ Config_getBool(CALL_GRAPH)=TRUE;
+ // loop recursive over input files
+ Config_getBool(RECURSIVE)=TRUE;
+ // set the input
+ Config_getList(INPUT).clear();
+ for (int i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "-") == 0) {
+ char filename[1024];
+ while (1) {
+ scanf("%s[^\n]", filename);
+ if (feof(stdin)) {
+ break;
+ }
+ Config_getList(INPUT).append(filename);
+ }
+ } else {
+ Config_getList(INPUT).append(argv[i]);
+ }
+ }
+ if (Config_getList(INPUT).isEmpty()) {
+ exit(0);
+ }
+
+ // parse the files
+ parseInput();
+
+ // iterate over the input files
+ FileNameListIterator fnli(*Doxygen::inputNameList);
+ FileName *fn;
+ // for each file with a certain name
+ for (fnli.toFirst();(fn=fnli.current());++fnli) {
+ FileNameIterator fni(*fn);
+ FileDef *fd;
+ // for each file definition
+ for (;(fd=fni.current());++fni) {
+ // get the references (linked and unlinked) found in this file
+ findXRefSymbols(fd);
+ }
+ }
+
+ // remove temporary files
+ if (!Doxygen::objDBFileName.isEmpty()) unlink(Doxygen::objDBFileName);
+ if (!Doxygen::entryDBFileName.isEmpty()) unlink(Doxygen::entryDBFileName);
+ // clean up after us
+ rmdir(Config_getString(OUTPUT_DIRECTORY));
+
+ listSymbols();
+
+ std::string cleanup_command = "rm -rf ";
+ cleanup_command += tmpdir.str();
+ system(cleanup_command.c_str());
+
+ exit(0);
+}
-if (build_search)
-
find_package(Xapian REQUIRED)
find_package(ZLIB REQUIRED)
)
install(TARGETS doxyindexer doxysearch.cgi DESTINATION bin)
-
-endif()
-if (build_wizard)
-
# search for Qt5
if (NOT force_qt4)
- find_package(Qt5Core QUIET)
+ find_package(Qt5Core QUIET CONFIG)
if (Qt5Core_FOUND)
message(STATUS "Using Qt5")
find_package(Qt5 COMPONENTS Widgets Gui Xml)
)
install(TARGETS doxywizard DESTINATION bin)
-
-endif()
+++ /dev/null
-if (NOT CLANG_ROOT)
- set(CLANG_ROOT $ENV{CLANG_ROOT})
-endif ()
-
-if (NOT LLVM_CONFIG)
- set(LLVM_CONFIG $ENV{LLVM_CONFIG})
- if (NOT LLVM_CONFIG)
- set(llvm_config_names llvm-config)
- foreach(minor RANGE 9 1)
- list(APPEND llvm_config_names "llvm-config3${minor}" "llvm-config-3.${minor}" "llvm-config-mp-3.${minor}")
- endforeach ()
- find_program(LLVM_CONFIG NAMES ${llvm_config_names})
- endif ()
-endif ()
-
-if (LLVM_CONFIG)
- message(STATUS "llvm-config found at: ${LLVM_CONFIG}")
-else ()
- message(FATAL_ERROR "Could NOT find llvm-config executable.")
-endif ()
-
-if (NOT EXISTS ${CLANG_INCLUDEDIR})
- execute_process(COMMAND ${LLVM_CONFIG} --includedir OUTPUT_VARIABLE CLANG_INCLUDEDIR OUTPUT_STRIP_TRAILING_WHITESPACE)
- if (NOT EXISTS ${CLANG_INCLUDEDIR})
- message(FATAL_ERROR "Could NOT find clang includedir. You can fix this by setting CLANG_INCLUDEDIR in your shell or as a cmake variable.")
- endif ()
-endif ()
-
-if (NOT EXISTS ${CLANG_LIBDIR})
- execute_process(COMMAND ${LLVM_CONFIG} --libdir OUTPUT_VARIABLE CLANG_LIBDIR OUTPUT_STRIP_TRAILING_WHITESPACE)
- if (NOT EXISTS ${CLANG_LIBDIR})
- message(FATAL_ERROR "Could NOT find clang libdir. You can fix this by setting CLANG_LIBDIR in your shell or as a cmake variable.")
- endif ()
-endif ()
-
-if (NOT CLANG_LIBS)
- find_library(CLANG_LIB_HACK_CMAKECACHE_DOT_TEXT_BULLSHIT NAMES clang libclang ${CLANG_ROOT}/lib ${CLANG_LIBDIR} NO_DEFAULT_PATH)
- if (NOT EXISTS ${CLANG_CLANG_LIB_HACK_CMAKECACHE_DOT_TEXT_BULLSHIT})
- find_library(CLANG_LIBS NAMES clang libclang)
- if (NOT EXISTS ${CLANG_LIBS})
- if (MSVC)
- set (CLANG_LIBS "${CLANG_LIBDIR}/libclang.lib")
- else()
- set (CLANG_LIBS "-L${CLANG_LIBDIR}" "-lclang" "-Wl,-rpath,${CLANG_LIBDIR}")
- endif()
- endif ()
- else ()
- set(CLANG_LIBS "${CLANG_LIB_HACK_CMAKECACHE_DOT_TEXT_BULLSHIT}")
- endif ()
-endif ()
-
-execute_process(COMMAND ${LLVM_CONFIG} --version OUTPUT_VARIABLE CLANG_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
-message("-- Using Clang ${CLANG_VERSION} from ${CLANG_LIBDIR} with LIBS ${CLANG_LIBS} and CXXFLAGS ${CLANG_CXXFLAGS}")
-
-
-if(${CMAKE_ARGC} GREATER 1)
- if ("${CMAKE_ARGV3}" STREQUAL "ENONLY")
- message("#define ENGLISH_ONLY")
+if(${CMAKE_ARGC} GREATER 2)
+ if ("${CMAKE_ARGV4}" STREQUAL "ENONLY")
+ file(APPEND ${CMAKE_ARGV3} " #define ENGLISH_ONLY\n")
else()
math(EXPR UPTO ${CMAKE_ARGC}-1)
- foreach(i RANGE 3 ${UPTO})
- message("#define LANG_${CMAKE_ARGV${i}}")
+ foreach(i RANGE 4 ${UPTO})
+ file(APPEND ${CMAKE_ARGV3} " #define LANG_${CMAKE_ARGV${i}}\n")
endforeach()
endif()
endif()
# Documents produced by Doxygen are derivative works derived from the
# input used in their production; they are not affected by this license.
-if (build_doc)
-
include (${TOP}/cmake/version.cmake)
string(TIMESTAMP DATE "%d-%m-%Y")
find_program(EPSTOPDF NAMES epstopdf )
find_program(PDFLATEX NAMES pdflatex )
find_program(MAKEINDEX NAMES makeindex )
+include(GNUInstallDirs)
if (doxygen_BINARY_DIR)
set(DOXYGEN_EXECUTABLE ${doxygen_BINARY_DIR}/bin/doxygen)
)
file(GLOB LANG_FILES "${TOP}/src/translator_??.h")
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/man)
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/src)
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/doc)
+file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/man
+ ${PROJECT_BINARY_DIR}/src
+ ${PROJECT_BINARY_DIR}/doc)
file(COPY ${TOP}/VERSION DESTINATION ${PROJECT_BINARY_DIR}/)
file(COPY ${TOP}/src/translator.h DESTINATION ${PROJECT_BINARY_DIR}/src/)
"${PROJECT_BINARY_DIR}/man/doxywizard.1"
"${PROJECT_BINARY_DIR}/man/doxysearch.1"
"${PROJECT_BINARY_DIR}/man/doxyindexer.1"
- DESTINATION share/man/man1
+ DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
)
install(FILES
"${PROJECT_BINARY_DIR}/html"
DESTINATION "${CMAKE_INSTALL_PREFIX}/${DOC_INSTALL_DIR}"
)
-
-endif(build_doc)
print "Toggle debugging mode for $file\n";
if (!-e "../src/${file}.l")
{
- print STDERR "Error: file ../src/${file}.l does not exist!";
+ print STDERR "Error: file ../src/${file}.l does not exist!\n";
exit 1;
}
system("touch ../src/${file}.l");
-unless (rename "src/CMakeFiles/_doxygen.dir/build.make","src/CMakefiles/_doxygen.dir/build.make.old") {
+unless (rename "src/CMakeFiles/_doxygen.dir/build.make","src/CMakeFiles/_doxygen.dir/build.make.old") {
print STDERR "Error: cannot rename src/CMakeFiles/_doxygen.dir/build.make!\n";
exit 1;
}
if (open(F,"<src/CMakeFiles/_doxygen.dir/build.make.old")) {
- unless (open(G,">src/CMakefiles/_doxygen.dir/build.make")) {
+ unless (open(G,">src/CMakeFiles/_doxygen.dir/build.make")) {
print STDERR "Error: opening file build.make for writing\n";
exit 1;
}
print "Processing build.make...\n";
while (<F>) {
- if ( s/flex \$\(LEX_FLAGS\) -P${file}YY/flex \$(LEX_FLAGS) -d -P${file}YY/ ) {
- print "Enabling debug info for $file.l\n";
- }
- elsif ( s/flex \$\(LEX_FLAGS\) -d -P${file}YY/flex \$(LEX_FLAGS) -P${file}YY/ ) {
+ if ( s/flex \$\(LEX_FLAGS\) -d(.*) ${file}.l/flex \$(LEX_FLAGS)$1 ${file}.l/ ) {
print "Disabling debug info for $file\n";
}
+ elsif ( s/flex \$\(LEX_FLAGS\)(.*) ${file}.l$/flex \$(LEX_FLAGS) -d$1 ${file}.l/ ) {
+ print "Enabling debug info for $file.l\n";
+ }
print G "$_";
}
close F;
# touch the file
$now = time;
-utime $now, $now, $file
+utime $now, $now, $file;
\endverbatim
Another way to get rules matching / debugging information
from the \c flex code is setting LEX_FLAGS with \c make (`make LEX_FLAGS=-d`).
\tableofcontents
\section log_1_8 1.8 Series
+\subsection log_1_8_14 Release 1.8.14
+\htmlonly
+<b>(release date 25-12-2017)</b>
+<a name="1.8.14"></a>
+</p>
+<ul>
+<li>Add language type attribute to programlisting tag [<a href="http://github.com/doxygen/doxygen/commit/141dbfd5a4f79c98da14a1b414c6db4e1b34618b">view</a>]
+<li>Add links behind nav entries "Namespaces" and "Files" (matching "Classes") [<a href="http://github.com/doxygen/doxygen/commit/464919adf1cdae9057ff840f40c60472b4c30bfd">view</a>]
+<li>Allow case insensitive file pattern matching based on CASE_SENSE_NAMES [<a href="http://github.com/doxygen/doxygen/commit/bd759f9a3aa4096bc8574ea45ad6b23fed830742">view</a>]
+<li>Async load of mathjax javascript [<a href="http://github.com/doxygen/doxygen/commit/340e516dbf5efd3ae21d964e92369e97b252e4ab">view</a>]
+<li>Avoid generating unused dir_* output files for non HTML output formats [<a href="http://github.com/doxygen/doxygen/commit/38987846ec0752b8deee7bab69c7890aa861af00">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=557094">557094</a> - Wrong spacing in function names with french language (latex output) [<a href="http://github.com/doxygen/doxygen/commit/9d478d2fedd091ceac8e689507676292f5455882">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=652086">652086</a> - does ALIAS work for VHDL code? [<a href="http://github.com/doxygen/doxygen/commit/05364c46f806e73cce76be37a6a31230d0468507">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=729237">729237</a> - (UnFriendlyTemplate) Spurious warning when documenting friend template [<a href="http://github.com/doxygen/doxygen/commit/2fe7bc7f1df9a2483355b0743b5e0455aaccc969">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=733705">733705</a> - parser misinterpreting fortran [<a href="http://github.com/doxygen/doxygen/commit/747fc768476aef8b8b70fdd78749702a410dcd29">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=743367">743367</a> - Duplicate attribute (target="_top" target="_top") generated in .SVG files [<a href="http://github.com/doxygen/doxygen/commit/97bfbfa6c4d4eb07ac8c60545086c3370e9683b8">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=775493">775493</a> - Usage of underscore's in parameter names [<a href="http://github.com/doxygen/doxygen/commit/c10af45c61a1f9b25c514f397ace16c94cc7c8df">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=776791">776791</a> - [1.8.13 Regression] Segfault building the breathe docs [<a href="http://github.com/doxygen/doxygen/commit/0f02761a158a5e9ddbd5801682482af8986dbc35">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=776870">776870</a> - XML Parsing Error for operator<< methods when outputing to XHTML [<a href="http://github.com/doxygen/doxygen/commit/0e8530e42b69c909ef2c26468b24dfb88cc0997f">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=776964">776964</a> - Menu does not work without Javascript [<a href="http://github.com/doxygen/doxygen/commit/1be97720b7820361e85242d08d4cac3e46570bfe">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=776988">776988</a> - Too greedy behavior of @ref const matching [<a href="http://github.com/doxygen/doxygen/commit/04001c8926fb0f37dfcf284b3637b182125bba75">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=778730">778730</a> - doxygen build fails [<a href="http://github.com/doxygen/doxygen/commit/bb5c8dd29782ecbb05a4ef9788f2507e9a156848">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=779014">779014</a> - Add "\~" command to internatioalization article [<a href="http://github.com/doxygen/doxygen/commit/e204b982eebd54bd15148a520da6608935e33e50">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=784281">784281</a> - Problem RTF output: The class list "classes" within the namespace report is wrong indicated. [<a href="http://github.com/doxygen/doxygen/commit/753c06281f6b2e9172c449157fc9f863063232e3">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=786409">786409</a> - parsing error in Fortran file with preprocessing [<a href="http://github.com/doxygen/doxygen/commit/2f5e22a4be9d237a150d04659bf6abec1349fbd9">view</a>]
+, [<a href="http://github.com/doxygen/doxygen/commit/ec12eb659d8c8e78ad4bb15d1a941ac3153a0f66">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=787952">787952</a> - Problem parsing c++ gnu::visibility [<a href="http://github.com/doxygen/doxygen/commit/d8001efd89146e04d92f5ea41ab27a7de09b6c53">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=788209">788209</a> - C++: False warning message when inheriting class from tag file [<a href="http://github.com/doxygen/doxygen/commit/aac84d5624b96d8937ff543ab8724c269b8726ab">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=789007">789007</a> - Error in markdown emphasis examples [<a href="http://github.com/doxygen/doxygen/commit/81956108f2e6e97bf4dd0f1011fcae1b5c4c4408">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=789168">789168</a> - Increasing access of inherited C++ members with 'using...' is not recognized by Doxygen [<a href="http://github.com/doxygen/doxygen/commit/9468ede259153cf79eb8d61635389744e9a2ee7d">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=790320">790320</a> - C++ parameter from lambda not recognized [<a href="http://github.com/doxygen/doxygen/commit/7b43be09e513ea6f86f9ca53ce05c94d63eada4c">view</a>]
+<li>Bug <a href="https://bugzilla.gnome.org/show_bug.cgi?id=790788">790788</a> - Doxygen not showing the public, non-static member function [<a href="http://github.com/doxygen/doxygen/commit/137b2e8dd03a98e692c2f6d813b47f19f2c64e5b">view</a>]
+<li>CMake: avoid if() around the whole contents of documentation CMakeLists.txt [<a href="http://github.com/doxygen/doxygen/commit/62e87408cb7094eeac130775e62d5b7a6f4a79c9">view</a>]
+<li>CMake: avoid if() around the whole contents of plugin CMakeLists.txt [<a href="http://github.com/doxygen/doxygen/commit/7c1c75a2c5583415d178e0e46a1a356bef9b0c84">view</a>]
+<li>CMake: let CMake handle the C++ standard setting if target_compile_features() is used [<a href="http://github.com/doxygen/doxygen/commit/ca7e60edd370949cfb2adb83ca0b532bb3fdc441">view</a>]
+<li>CMake: let file(MAKE_DIRECTORY) create all directories at once [<a href="http://github.com/doxygen/doxygen/commit/0d7be027a6fea2ac198dded58f8b55cda1bbe962">view</a>]
+<li>CMake: remove CUSTOM_(LINK|INCLUDE)_DIR [<a href="http://github.com/doxygen/doxygen/commit/28f09783b1e45a827729abaca61f963dd869381b">view</a>]
+<li>CMake: remove needless variable expansions [<a href="http://github.com/doxygen/doxygen/commit/975fb19eb07bc65ef48ddd5f26bf6be2736d0e0a">view</a>]
+<li>CMake: remove unused program searching [<a href="http://github.com/doxygen/doxygen/commit/02f726b63e2b3a2ed4c5da43c164dcaad5fcfe94">view</a>]
+<li>CMake: search for Qt5 only in config file mode [<a href="http://github.com/doxygen/doxygen/commit/ac5ca4ef86ad50232be75a65fab99302307b7795">view</a>]
+<li>CMake: use GNUInstallDirs module for man pages directory [<a href="http://github.com/doxygen/doxygen/commit/fcf5fecb64d5c194430e10cbe52482b14224d645">view</a>]
+<li>CMake: use add_test to create a test [<a href="http://github.com/doxygen/doxygen/commit/b54b843accb97105ae4afaf24136e33bfd1ea9d4">view</a>]
+<li>CMakeLists: Avoid MSVC iconv changes for MinGW builds [<a href="http://github.com/doxygen/doxygen/commit/9532e0f19532e9d76c3f1092d131af91125a2dff">view</a>]
+<li>Call endMemberItem consistently. [<a href="http://github.com/doxygen/doxygen/commit/1aafbbc97bdb643cae8be036f2b9ab569ca7f15e">view</a>]
+<li>Change navtree collapsed list icon [<a href="http://github.com/doxygen/doxygen/commit/b3869a3ed82957c1785dc955876885f8b73a020b">view</a>]
+<li>Code color of , (comma) together with only in use statement [<a href="http://github.com/doxygen/doxygen/commit/6f7264f4a16f5b1240291c6d33a0e4cc98ba30e4">view</a>]
+<li>Corrected small type [<a href="http://github.com/doxygen/doxygen/commit/4360982dbaee9b32973a95ba88290022d0643e10">view</a>]
+<li>Correction display of backtick in LaTeX [<a href="http://github.com/doxygen/doxygen/commit/beaa386ca97341e66ad673660c808993240df637">view</a>]
+<li>Correction of non reachable links and redirected links in documentation. [<a href="http://github.com/doxygen/doxygen/commit/31cf78d223e52fe078ad9b0651672aeb73926065">view</a>]
+<li>Documentation, correct referenced file [<a href="http://github.com/doxygen/doxygen/commit/c93a7c34e7efd5ae1f2c3e4d230e29a333bc237a">view</a>]
+<li>Doxygen/VHDLdocgen: [<a href="http://github.com/doxygen/doxygen/commit/77e0cf86eadbec22b81e26e083ffc831240869da">view</a>]
+<li>Encode invalid XML characters instead of skipping them. [<a href="http://github.com/doxygen/doxygen/commit/b6a7abf02652b74872b9c676fcfa545e18d9bde7">view</a>]
+<li>Expose TOC placeholder in XML output. [<a href="http://github.com/doxygen/doxygen/commit/fe760977e2cb643b94fbf21847e0c81e8a080966">view</a>]
+<li>Expose underlying enum type in the XML output. [<a href="http://github.com/doxygen/doxygen/commit/17bceb8f4580535de52d19e8cadf0d088f972bef">view</a>]
+<li>Fetch filename property from object instead of hardcoded duplicated string [<a href="http://github.com/doxygen/doxygen/commit/84fd1fecfe2de7b4f8c88e1923ef7d5958dc70b0">view</a>]
+<li>Fix C# property initializer parsing [<a href="http://github.com/doxygen/doxygen/commit/14a0bcc74a121525917aefc8c9034e283e94884b">view</a>]
+<li>Fix for regression in XML output generation after fixing bug 789168 [<a href="http://github.com/doxygen/doxygen/commit/1a1fdbed64de6ce01959b2e4d0988be823fb6bad">view</a>]
+<li>Fix https://bugzilla.gnome.org/show_bug.cgi?id=782583. [<a href="http://github.com/doxygen/doxygen/commit/c87f730fe4bc40f72ed5fa52fe032a7bdf2d549c">view</a>]
+<li>Fix minor markup issue in the documentation. [<a href="http://github.com/doxygen/doxygen/commit/b4df85466cf0447d46f311046fc5b3fe062b957f">view</a>]
+<li>Fix not initialized pointer when parser is starting on a new file. [<a href="http://github.com/doxygen/doxygen/commit/52fb4cd5bb085960476e0cd256cc81db1370839d">view</a>]
+<li>Fix typo [<a href="http://github.com/doxygen/doxygen/commit/d6e9db71645d895450993972ed41406c1cf1fc52">view</a>]
+<li>Fix: add missing newline char '\n' [<a href="http://github.com/doxygen/doxygen/commit/856a43cfe08179ebbcebe656262b0229925547c8">view</a>]
+<li>Fix: add missing semicolon ';' at end of line [<a href="http://github.com/doxygen/doxygen/commit/507880a0c7ed6029ce7ede2e85d23a9650a3f6bf">view</a>]
+<li>Fix: change 'CMakefiles' to 'CMakeFiles' (the 'F' is uppercase) [<a href="http://github.com/doxygen/doxygen/commit/bcc09aa2ba01eff458a00aff853d58ed8213a5da">view</a>]
+<li>Fix: perl script regexp to toggle flex debug information [<a href="http://github.com/doxygen/doxygen/commit/b11b19badf4ef7318512c28f448dbecd6a47a715">view</a>]
+<li>Fixed problem where automatic line breaking caused missing vertical bars in the parameter table for Latex output. [<a href="http://github.com/doxygen/doxygen/commit/5fc82b2275e202438ac61b070ac5f4be0df792d6">view</a>]
+<li>Fixes for cross platform build with new LLVM/CLANG version [<a href="http://github.com/doxygen/doxygen/commit/b0aae61c97966cb9d424b500d7ced5bdf500d8db">view</a>]
+<li>Fixup man page NAME section when page has title [<a href="http://github.com/doxygen/doxygen/commit/9d0908359363dbb43236767669c214721700acf7">view</a>]
+<li>Function declaration following a function definition incorrectly listed as calling dependencing [<a href="http://github.com/doxygen/doxygen/commit/436fc7ed1158d517dd6f6d25aa3e05568f8c3d94">view</a>]
+<li>Further cleanup of lodepng code [<a href="http://github.com/doxygen/doxygen/commit/c627108f3315144f5d9fb84d0197502b939caf7d">view</a>]
+<li>Implement "double-space line breaks" syntax in Markdown [<a href="http://github.com/doxygen/doxygen/commit/e4596c7eab90ba4d307e2c212cefeab8ac820269">view</a>]
+<li>Improve Chinese translation [<a href="http://github.com/doxygen/doxygen/commit/ded5247523ec8d47129405df3999ce391cca9e2d">view</a>]
+<li>Inline attribute got reset for functions returning an explicit struct type [<a href="http://github.com/doxygen/doxygen/commit/127a43d464790dd0312794fe7ae1d92247cd9eef">view</a>]
+<li>Isolated none-existing posix threading functions on Android [<a href="http://github.com/doxygen/doxygen/commit/4e25f081847cf2717ad561214e90d9750da5a511">view</a>]
+<li>Marks JS as freely licensed [<a href="http://github.com/doxygen/doxygen/commit/6b5617e5a4c87afd2c7f2f7b8cb03de2b6735627">view</a>]
+<li>Misc. doxy and comment typos [<a href="http://github.com/doxygen/doxygen/commit/1764f7a0f199b9f2a85f885cfd0f1804f8292c49">view</a>]
+<li>Misc. typos [<a href="http://github.com/doxygen/doxygen/commit/9fd7f3aeb4c2e78bda669bf4ef6fff1c12c062a4">view</a>]
+<li>New table features mentioned in the documentation were not enabled. [<a href="http://github.com/doxygen/doxygen/commit/c120ac4762331513305e8a19fd9b267b2d4f9e41">view</a>]
+<li>Pass strings as const references. [<a href="http://github.com/doxygen/doxygen/commit/ebf75c1fe8a0ff2cc9235155b6d63367944d6342">view</a>]
+<li>Physical newlines in ALIASES configuration tags. [<a href="http://github.com/doxygen/doxygen/commit/d6801c4c5eaeebc5e14f5d1cd7c312ad82c1dbbd">view</a>]
+<li>Propagate language information to all <programlisting> XML elements. [<a href="http://github.com/doxygen/doxygen/commit/eaf8edbac7e6a1873aa5c4ff0df063cd367351d6">view</a>]
+<li>Properly copy images for the XML output. [<a href="http://github.com/doxygen/doxygen/commit/507dd0a60dd12c61ff2088db419187efc928c010">view</a>]
+<li>Provide dot path to plantuml [<a href="http://github.com/doxygen/doxygen/commit/c24cb9a74ef0af854455047f29f9925d79ac0195">view</a>]
+<li>Provide information about enum type "strongness" in the XML output. [<a href="http://github.com/doxygen/doxygen/commit/169cad806ea795e5c425fd397aa0de54cbc0a81e">view</a>]
+<li>Provide page brief in <briefdescription> of XML output. [<a href="http://github.com/doxygen/doxygen/commit/bd2cf98e75c600e0c2f5ae95301df8745d65571a">view</a>]
+<li>Provide template parameters also for type aliases in the XML output. [<a href="http://github.com/doxygen/doxygen/commit/21f0ca0085c034a37df07c1ab690472bada0a1f1">view</a>]
+<li>Removed -Wno-deprecated flag from bison as it is not support on the bison 2.3 that ships with XCode [<a href="http://github.com/doxygen/doxygen/commit/6c288bf0e7548117aa358719aaecffedcc579590">view</a>]
+<li>Restore 'make tests' rule [<a href="http://github.com/doxygen/doxygen/commit/7ce59c9fbd5e99619a9ab0ac6177d21e6aca49c7">view</a>]
+<li>Restore Makefile in vhdlparser dir [<a href="http://github.com/doxygen/doxygen/commit/aee944fe954de993a4273fafef6b5f0c726be7f3">view</a>]
+<li>Spelling correction [<a href="http://github.com/doxygen/doxygen/commit/4cca51612a50a9016be5adbd6ccdc26c03d12b58">view</a>]
+<li>Stripped unused LodePNG code to prevent false positives for coverity [<a href="http://github.com/doxygen/doxygen/commit/64865ad3e91fffe6e50b51b29ae2a54126f80126">view</a>]
+<li>Suppresses warning for XML <see langword="..."/> [<a href="http://github.com/doxygen/doxygen/commit/a3c5958b437b5dc9de91de5f40917ec53532b60a">view</a>]
+<li>Suppression warnings about deprecated directive [<a href="http://github.com/doxygen/doxygen/commit/cd0faad90e9b6ce83fa1f7b4fb27a39357b0cae3">view</a>]
+<li>Update .travis.yml [<a href="http://github.com/doxygen/doxygen/commit/5f028fd744526148aace4c971f739c9876b6108a">view</a>]
+, [<a href="http://github.com/doxygen/doxygen/commit/b7fc8a384b091f5761159d263ec27e30c3160a50">view</a>]
+<li>Update mathjax path [<a href="http://github.com/doxygen/doxygen/commit/57e69ba26eff5eac4b31b088cd7d3dfa7532f12c">view</a>]
+<li>Updated translator_de.h to doxygen 1.8.13 [<a href="http://github.com/doxygen/doxygen/commit/a9e3d5378ffbef542045d04239482bd6fec33e15">view</a>]
+<li>Use hidden symbol visibility by default [<a href="http://github.com/doxygen/doxygen/commit/dcb3b2d0b888902a062eefd8200ea194ed1c42d6">view</a>]
+<li>Use language identifier instead of file extension for language attribute [<a href="http://github.com/doxygen/doxygen/commit/ed9acb6e1bb81a2eec334180f7b8c1bf0598b444">view</a>]
+<li>Use language in stead of lang for language name attribute [<a href="http://github.com/doxygen/doxygen/commit/4e4741221f4290412ef4a6b6bbfe9799abafaf6c">view</a>]
+<li>Update of the Brazillian translation [<a href="http://github.com/doxygen/doxygen/commit/d283dfcdcaa0837e84d7995676d436fa04e96d1f">view</a>]
+<li>[preprocessing.doc] typo amended [<a href="http://github.com/doxygen/doxygen/commit/6b67a64bd0bd1c6759294c323433dbd7d37df6ac">view</a>]
+<li>add decimal to base identifier [<a href="http://github.com/doxygen/doxygen/commit/9cbc1a04e584e83d91ff3f7501f38b0a825e1953">view</a>]
+<li>add the number of conditionals path and bugfix [<a href="http://github.com/doxygen/doxygen/commit/20af63f43e583a31dfe93f78807aa868f9b9ff14">view</a>]
+<li>build: fix the way lang_cfg.h is generated [<a href="http://github.com/doxygen/doxygen/commit/cc3a9e611c15f32ae4913a87306699db60758245">view</a> and <a href="http://github.com/doxygen/doxygen/commit/a4b6f59e0c99457ba8f4f71782e51d50b7a1057f">view</a>]
+<li>bump version number for the development version/next release [<a href="http://github.com/doxygen/doxygen/commit/0a6d8bf6f5ef3a537de6ab517d0ae9c4f5d558d0">view</a>]
+<li>const-ify [<a href="http://github.com/doxygen/doxygen/commit/5df4341210ec2374b8b7c09f5df3cd8f4ff60f65">view</a>]
+<li>dot.cpp: Fix DotGfxHierarchyTable first class node loop [<a href="http://github.com/doxygen/doxygen/commit/c7348b4483ace9b5608fbbe949eab02921eb0e70">view</a>]
+<li>fix spelling [<a href="http://github.com/doxygen/doxygen/commit/bca94d6ca30bde5f01dd17a83cfa63268c0ca664">view</a>]
+<li>fix test to support new programlisting attribute [<a href="http://github.com/doxygen/doxygen/commit/a9963fd94acd5839e818890b6a356d6b335c1f74">view</a>]
+<li>fix typo [<a href="http://github.com/doxygen/doxygen/commit/f88ebaf9f23c3151f312400d77150eeeeb8158c2">view</a>]
+<li>fixes vhdl literal bug [<a href="http://github.com/doxygen/doxygen/commit/6c387a6be9128ced0b89f6fc75946cd1a85096fb">view</a>]
+<li>line continuation characters inside comments embedded in a macro definition appeared in the output [<a href="http://github.com/doxygen/doxygen/commit/898b6044194d5967099adfadab454cd09a4f360e">view</a>]
+<li>make use of clang compilation database [<a href="http://github.com/doxygen/doxygen/commit/818aefcecf3cca986c971cd236bd7b77337db955">view</a>]
+<li>new addon doxyparse, a source parsing engine [<a href="http://github.com/doxygen/doxygen/commit/e6dcc3b6c6dd449800eeebc172c1d15367d61d74">view</a>]
+<li>sqlite3gen: add index on params [<a href="http://github.com/doxygen/doxygen/commit/3b3d1edeacde99719456b8f1616077707a5a2012">view</a>]
+<li>sqlite3gen: add missing protectedsettable column [<a href="http://github.com/doxygen/doxygen/commit/ba8e4323290da4cb6de59060c77fe02a4df694b4">view</a>]
+<li>sqlite3gen: add openDbConnection [<a href="http://github.com/doxygen/doxygen/commit/5596fcd158e7c53638324cea8ba3da31b2c32620">view</a>]
+<li>sqlite3gen: start checking operations status [<a href="http://github.com/doxygen/doxygen/commit/74cebdbbbc2c267c254ab2c337ee06250ab8424d">view</a>]
+<li>sqlite3gen: use sqlite3_exec for schema setup [<a href="http://github.com/doxygen/doxygen/commit/1ec8f0eb9169fc3f9ab82b60712a332bf60728bf">view</a>]
+<li>typos [<a href="http://github.com/doxygen/doxygen/commit/5711b54b4813a2f4ce3b858e496ac846cbda69e5">view</a>]
+<li>update compound.xsd to add language attribute [<a href="http://github.com/doxygen/doxygen/commit/0259d2a8bf9571e06873b80df96fd2ff29723dbc">view</a>]
+<li>using YAML in the output of "doxyparse" [<a href="http://github.com/doxygen/doxygen/commit/82dbb5fe863e13175eda130dcc728b102101ccda">view</a>]
+</ul>
+<p>
+\endhtmlonly
+
\subsection log_1_8_13 Release 1.8.13
\htmlonly
<b>(release date 29-12-2016)</b>
\par Example:
\include enum.h
\htmlonly
- Click <a href="examples/enum/html/class_test.html">here</a>
+ Click <a href="examples/enum/html/class_enum___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
\par Example:
\include func.h
\htmlonly
- Click <a href="examples/func/html/class_test.html">here</a>
+ Click <a href="examples/func/html/class_fn___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
\par Example:
\include overload.cpp
\htmlonly
- Click <a href="examples/overload/html/class_test.html">here</a>
+ Click <a href="examples/overload/html/class_overload___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
<hr>
\section cmdweakgroup \\weakgroup <name> [(title)]
- \addindex \\addtogroup
+ \addindex \\weakgroup
Can be used exactly like \ref cmdaddtogroup "\\addtogroup", but has
a lower priority when it comes to resolving conflicting grouping
definitions.
\par Example:
\include par.cpp
\htmlonly
- Click <a href="examples/par/html/class_test.html">here</a>
+ Click <a href="examples/par/html/class_par___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
\par Example:
\include include.cpp
- Where the example file \c example_test.cpp looks as follows:
- \include example_test.cpp
+ Where the example file \c include_test.cpp looks as follows:
+ \include include_test.cpp
\htmlonly
Click <a href="examples/include/html/example.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\note Some commands like \ref cmdcond "\\cond" and \ref cmdif "\\if" don't work with
this command due to the moment of parsing.
- \note The included documentation should not have comment signs in it as the will appear
+ \note The included documentation should not have comment signs in it as they will appear
in the documentation as well.
\sa section \ref cmdinclude "\\include".
\note Some commands like \ref cmdcond "\\cond" and \ref cmdif "\\if" don't work with
this command due to the moment of parsing.
- \note The included documentation should not have comment signs in it as the will appear
+ \note The included documentation should not have comment signs in it as they will appear
in the documentation as well.
\sa section \ref cmdsnippet "\\snippet" and \ref cmdincludedoc "\\includedoc".
\addindex \\startuml
Starts a text fragment which should contain a valid description of a
- PlantUML diagram. See http://plantuml.sourceforge.net/ for examples.
+ PlantUML diagram. See http://plantuml.com/ for examples.
The text fragment ends with \ref cmdenduml "\\enduml".
\note You need to install Java and the PlantUML's jar file,
if you want to use this command. The location of the jar file should be specified
\addindex \\\%
This command writes the \c \% character to the output. This
character has to be escaped in some cases, because it is used to
- prevent auto-linking to word that is also a documented class or struct.
+ prevent auto-linking to a word that is also a documented class or struct.
<hr>
\section cmdquot \\"
put the command `\sideeffect` (or `@sideeffect`) in the documentation, which
will result in a user-defined paragraph with heading <b>Side Effects:</b>.
-Note that you can put `\n`'s in the value part of an alias to insert newlines.
+Note that you can put `\n`'s in the value part of an alias to insert newlines
+(in the resulting output). You can put `^^` in the value part of an alias to
+insert a newline as if a physical newline was in the original file.
Also note that you can redefine existing special commands if you wish.
To tweak things like fonts or colors, margins, or other look \& feel
aspects of the HTML output in detail, you can create a different
-<a href="http://www.w3schools.com/css/default.asp">cascading style sheet</a>.
+<a href="https://www.w3schools.com/css/default.asp">cascading style sheet</a>.
You can also let doxygen use a custom header and footer for each HTML
page it generates, for instance to make the output conform to the style
used on the rest of your web site.
See <a href="https://github.com/michaeljones/breathe">the Breathe project</a> for
an example that uses doxygen XML output from Python to bridge it with the
-<a href="http://sphinx.pocoo.org/">Sphinx</a> document generator.
+<a href="http://www.sphinx-doc.org/en/stable/">Sphinx</a> document generator.
\htmlonly
\include afterdoc.h
\htmlonly
</p>
- Click <a href="examples/afterdoc/html/class_test.html">here</a>
+ Click <a href="examples/afterdoc/html/class_afterdoc___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
\include qtstyle.cpp
\htmlonly
</p>
- Click <a href="examples/qtstyle/html/class_test.html">here</a>
+ Click <a href="examples/qtstyle/html/class_q_tstyle___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
\include jdstyle.cpp
\htmlonly
</p>
- Click <a href="examples/jdstyle/html/class_test.html">here</a>
+ Click <a href="examples/jdstyle/html/class_javadoc___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
simple table. For this doxygen supports the
<a href="http://daringfireball.net/projects/markdown/syntax">Markdown</a>
syntax, including parts of the
-<a href="http://michelf.com/projects/php-markdown/extra/">Markdown Extra</a>
+<a href="https://michelf.ca/projects/php-markdown/extra/">Markdown Extra</a>
extension.
Markdown is designed to be very easy to read and write.
For programming language specific formatting doxygen has two
forms of additional markup on top of Markdown formatting.
-1. <a href="http://en.wikipedia.org/wiki/Javadoc">Javadoc</a> like markup.
+1. <a href="https://en.wikipedia.org/wiki/Javadoc">Javadoc</a> like markup.
See \ref commands for a complete overview of all commands supported by doxygen.
-2. <a href="http://en.wikipedia.org/wiki/C_Sharp_(programming_language)#XML_documentation_system">XML</a> markup
+2. <a href="https://en.wikipedia.org/wiki/C_Sharp_(programming_language)#XML_documentation_system">XML</a> markup
as specified in the C# standard. See \ref xmlcmds for the XML commands supported by doxygen.
If this is still not enough doxygen also supports a \ref htmlcmds "subset" of
-the <a href="http://en.wikipedia.org/wiki/HTML">HTML</a> markup language.
+the <a href="https://en.wikipedia.org/wiki/HTML">HTML</a> markup language.
\htmlonly
Go to the <a href="markdown.html">next</a> section or return to the
The first step is to make the search engine available via a web server.
If you use `doxysearch.cgi` this means making the
-<a href="http://en.wikipedia.org/wiki/Common_Gateway_Interface">CGI</a> binary
+<a href="https://en.wikipedia.org/wiki/Common_Gateway_Interface">CGI</a> binary
available from the web server (i.e. be able to run it from a
browser via an URL starting with http:)
\subsection extsearch_api_index Indexer input format
The search data produced by doxygen follows the
-<a href="http://wiki.apache.org/solr/UpdateXmlMessages">Solr XML index message</a>
+<a href="https://wiki.apache.org/solr/UpdateXmlMessages">Solr XML index message</a>
format.
The input for the indexer is an XML file, which consists of one `<add>` tag containing
- *text*: the documentation associated with the item. Note that only words are present, no markup.
@note Due to the potentially large size of the XML file, it is recommended to use a
-<a href="http://en.wikipedia.org/wiki/Simple_API_for_XML">SAX based parser</a> to process it.
+<a href="https://en.wikipedia.org/wiki/Simple_API_for_XML">SAX based parser</a> to process it.
\subsection extsearch_api_search_in Search URL format
When the search engine is invoked from a doxygen generated HTML page, a number of parameters are
-passed to via the <a href="http://en.wikipedia.org/wiki/Query_string">query string</a>.
+passed to via the <a href="https://en.wikipedia.org/wiki/Query_string">query string</a>.
The following fields are passed:
- *q*: the query text as entered by the user
starting with the result number 20 (`p=1`) and using callback 'dummy' (`cb=dummy`):
-@note The values are <a href="http://en.wikipedia.org/wiki/Percent-encoding">URL encoded</a> so they
+@note The values are <a href="https://en.wikipedia.org/wiki/Percent-encoding">URL encoded</a> so they
have to be decoded before they can be used.
\subsection extsearch_api_search_out Search results format
When invoking the search engine as shown in the previous subsection, it should reply with
the results. The format of the reply is
-<a href="http://en.wikipedia.org/wiki/JSONP">JSON with padding</a>, which is basically
+<a href="https://en.wikipedia.org/wiki/JSONP">JSON with padding</a>, which is basically
a javascript struct wrapped in a function call. The name of function should be the name of
the callback (as passed with the *cb* field in the query).
\section faq_why What was the reason to develop doxygen?
I once wrote a GUI widget based on the Qt library (it is still available at
-http://sourceforge.net/projects/qdbttabular/ but hasn't been updated since 2002).
+https://sourceforge.net/projects/qdbttabular/ but hasn't been updated since 2002).
Qt had nicely generated documentation (using an internal tool which
<a href="http://rant.gulbrandsen.priv.no/udoc/history">they didn't want to release</a>)
and I wrote similar docs by hand.
to bitmaps. I have used Aladdin GhostScript 8.0 for testing.
</ul>
For the HTML output there is also an alternative solution using
-<a href="http://www.mathjax.org">MathJax</a> which does not
+<a href="https://www.mathjax.org">MathJax</a> which does not
require the above tools. If you enable \ref cfg_use_mathjax "USE_MATHJAX" in
the config then the latex formulas will be copied to the HTML "as is" and a
client side javascript will parse them and turn them into (interactive) images.
\htmlonly
</p>
-Click <a href="examples/memgrp/html/class_test.html">here</a>
+Click <a href="examples/memgrp/html/class_memgrp___test.html">here</a>
for the corresponding HTML documentation that is generated by doxygen.
\endhtmlonly
\latexonly
<li>Talin for adding support for C# style comments with XML markup.
<li>Petr Prikryl for coordinating the internationalization support.
All language maintainers for providing translations into many languages.
-<li>The band <a href="http://www.porcupinetree.com">Porcupine Tree</a> for
+<li>The band <a href="http://www.porcupinetree.com/">Porcupine Tree</a> for
providing hours of great music to listen to while coding.
<li>many, many others for suggestions, patches and bug reports.
</ul>
\addindex strip
\addindex python
<li>In order to generate a \c Makefile for your platform, you need
- <a href="http://www.cmake.org/">cmake</a> version 2.8.12 or later.
+ <a href="https://cmake.org/">cmake</a> version 2.8.12 or later.
\addindex cmake
</ul>
freetype support (which requires the freetype library and header files),
otherwise the graphs will not render proper text labels.
<li>For formulas in the HTML output (when MathJax is not used)
- or in case you do not wish to use `pdflatex,
+ or in case you do not wish to use `pdflatex`,
the ghostscript interpreter is needed. You can find it at
- <a href="http://www.ghostscript.com/">www.ghostscript.com</a>.
+ <a href="https://www.ghostscript.com/">www.ghostscript.com</a>.
</ul>
Compilation is now done by performing the following steps:
\section install_src_windows Compiling from source on Windows
From version 1.8.10 onwards, build files need to be generated by cmake.
-cmake can be downloaded from http://www.cmake.org/download/
+cmake can be downloaded from https://cmake.org/download/
At the moment only the express version of Visual Studio 2013 is tested,
but other version might also work.
Alternatively, you can compile doxygen
\ref install_src_unix "the UNIX way" using
-<a href="http://en.wikipedia.org/wiki/Cygwin">Cygwin</a>
+<a href="https://en.wikipedia.org/wiki/Cygwin">Cygwin</a>
or <a href="http://www.mingw.org/">MinGW</a>.
The next step is to install modern versions of \c bison and \c flex
-(see http://sourceforge.net/projects/winflexbison. After installation and adding them to
+(see https://sourceforge.net/projects/winflexbison/. After installation and adding them to
your `path` rename `win_flex.exe` to `flex.exe` and `win_bison.exe` to `bison.exe`)
-Furthermore you have to install \c python (version 2.6 or higher, see http://www.python.org).
+Furthermore you have to install \c python (version 2.6 or higher, see https://www.python.org).
These packages are needed during the compilation process.
Download doxygen's source tarball and put it somewhere (e.g. use <code>c:\\tools</code>)
You can download Qt from <a href="http://qt-project.org/downloads">Qt Software Downloads</a>.
In order to generate PDF output or use scientific formulas you will also need to
-install <a href="http://en.wikipedia.org/wiki/LaTeX">LaTeX</a> and
-<a href="http://en.wikipedia.org/wiki/Ghostscript">Ghostscript</a>.
+install <a href="https://en.wikipedia.org/wiki/LaTeX">LaTeX</a> and
+<a href="https://en.wikipedia.org/wiki/Ghostscript">Ghostscript</a>.
For \LaTeX a number of distributions exists. Popular ones that should work with
-doxygen are <a href="http://www.miktex.org">MikTex</a>
+doxygen are <a href="https://miktex.org/">MikTex</a>
and <a href="http://www.tug.org/protext/">proTeXt</a>.
-Ghostscript can be <a href="http://sourceforge.net/projects/ghostscript/">downloaded</a>
+Ghostscript can be <a href="https://sourceforge.net/projects/ghostscript/">downloaded</a>
from Sourceforge.
After installing \LaTeX and Ghostscript you'll need to make sure the tools
latex.exe, pdflatex.exe, and gswin32c.exe are present in the search path of a
-command box. Follow <a href="http://www.computerhope.com/issues/ch000549.htm">these</a>
+command box. Follow <a href="https://www.computerhope.com/issues/ch000549.htm">these</a>
instructions if you are unsure and run the commands from a command box to verify it works.
\htmlonly
Doxygen has built-in support for multiple languages. This means that the
text fragments, generated by doxygen, can be produced in languages other
than English (the default). The output language is chosen through the
-configuration option \ref cfg_output_language "OUTPUT_LANGUAGE" in the
-configuration file (with default name and known as Doxyfile).
+configuration option \ref cfg_output_language "OUTPUT_LANGUAGE" in the
+configuration file (with default name and known as Doxyfile). To switch
+between languages inside a comment block the \ref cmdtilde "\\~" command
+can be used.
Currently (version %(doxVersion)s), %(numLangStr)s languages
are supported (sorted alphabetically):
Finally section \ref markdown_dox discusses some specifics for doxygen's
implementation of the Markdown standard.
-[markdown]: http://daringfireball.net/projects/markdown
-[mdextra]: http://michelf.com/projects/php-markdown/extra/
-[github]: http://github.github.com/github-flavored-markdown/
+[markdown]: http://daringfireball.net/projects/markdown/
+[mdextra]: https://michelf.ca/projects/php-markdown/extra/
+[github]: https://github.github.com/github-flavored-markdown/
\section markdown_std Standard Markdown
Examples:
- *single asterisks*
-
- _single underscores_
-
- **double asterisks**
-
- __double underscores__
+* *single asterisks*
+*
+* _single underscores_
+*
+* **double asterisks**
+*
+* __double underscores__
See section \ref mddox_emph_spans for more info how doxygen handles
emphasis spans slightly different than standard Markdown.
\subsection md_tables Tables
Of the features defined by "Markdown Extra" is support for
-<a href="http://michelf.com/projects/php-markdown/extra/#table">simple tables</a>:
+<a href="https://michelf.ca/projects/php-markdown/extra/#table">simple tables</a>:
A table consists of a header line, a separator line, and at least one
row line. Table columns are separated by the pipe (|) character.
\subsection md_fenced Fenced Code Blocks
Another feature defined by "Markdown Extra" is support for
-<a href="http://michelf.com/projects/php-markdown/extra/#fenced-code-blocks">
+<a href="https://michelf.ca/projects/php-markdown/extra/#fenced-code-blocks">
fenced code blocks</a>:
A fenced code block does not require indentation, and is
#define VERSION
#define CONST_STRING
- static const char * version = "1.xx";
+ static const char * version = "2.xx";
\endverbatim
Note that doxygen will now expand \e all macro definitions
searching, meaning that you could use your own indexer and search engine
of choice. To make life easier doxygen ships with an example indexer
(doxyindexer) and search engine (doxysearch.cgi) based on
- the <a href="http://xapian.org/">Xapian</a> open source search engine
+ the <a href="https://xapian.org/">Xapian</a> open source search engine
library.
To enable this search method set
\ref cfg_qhp_namespace "QHP_NAMESPACE",
\ref cfg_qhg_location "QHG_LOCATION",
\ref cfg_qhp_virtual_folder "QHP_VIRTUAL_FOLDER".
- See <a href="http://doc.qt.digia.com/qq/qq28-qthelp.html#htmlfilesandhelpprojects">this article</a>
+ See <a href="http://doc.qt.io/archives/qq/qq28-qthelp.html#htmlfilesandhelpprojects">this article</a>
for more info.
Feature wise the Qt compressed help feature is comparable with the CHM
\subsection docbook_out DocBook output
\addindex docbook
Doxygen can also generate output in the
-<a href="http://www.docbook.org/">DocBook</a> format. How to process the
+<a href="http://docbook.org/">DocBook</a> format. How to process the
DocBook output is beyond the scope of this manual.
\section step3 Step 3: Documenting the sources
-if (build_doc)
-
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/examples)
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/html/examples)
+file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/examples
+ ${PROJECT_BINARY_DIR}/html/examples)
file(GLOB EXAMPLE_FILES RELATIVE ${CMAKE_SOURCE_DIR}/examples "*")
if (DOT)
OUTPUT ${PROJECT_BINARY_DIR}/html/examples/diagrams/html/index.html ${PROJECT_BINARY_DIR}/html/examples/diagrams/latex/refman_doc.tex
)
endif(DOT)
-
-endif()
Doxygen's jquery.js script is composed of minified versions of the following
packages:
-- jquery 1.7.1: http://jquery.com/download/
+- jquery 1.7.1: http://jquery.com/download/
- jquery.ui 1.8.18: https://code.google.com/p/jquery-ui/downloads/list
modules required:
- jquery.ui.core
-# Doxyfile 1.8.4
+# Doxyfile 1.8.14
#---------------------------------------------------------------------------
# Project related configuration options
PROJECT_LOGO =
OUTPUT_DIRECTORY = ../qtools_docs
CREATE_SUBDIRS = YES
+ALLOW_UNICODE_NAMES = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
OPTIMIZE_OUTPUT_VHDL = NO
EXTENSION_MAPPING =
MARKDOWN_SUPPORT = YES
+TOC_INCLUDE_HEADINGS = 0
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
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = NO
HIDE_SCOPE_NAMES = NO
+HIDE_COMPOUND_REFERENCE= NO
SHOW_INCLUDE_FILES = YES
+SHOW_GROUPED_MEMB_INC = NO
FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
LAYOUT_FILE =
CITE_BIB_FILES =
#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
+# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
+WARN_AS_ERROR = NO
WARN_FORMAT = "$file:$line: $text "
WARN_LOGFILE =
#---------------------------------------------------------------------------
-# configuration options related to the input files
+# Configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = .
INPUT_ENCODING = UTF-8
FILTER_SOURCE_PATTERNS =
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
-# configuration options related to source browsing
+# Configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
SOURCE_TOOLTIPS = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
-CLANG_ASSISTED_PARSING = NO
-CLANG_OPTIONS =
#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
+# Configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 4
IGNORE_PREFIX = Q
#---------------------------------------------------------------------------
-# configuration options related to the HTML output
+# Configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT =
HTML_COLORSTYLE_SAT = 100
HTML_COLORSTYLE_GAMMA = 80
HTML_TIMESTAMP = YES
+HTML_DYNAMIC_MENUS = YES
HTML_DYNAMIC_SECTIONS = NO
HTML_INDEX_NUM_ENTRIES = 100
GENERATE_DOCSET = YES
GENERATE_ECLIPSEHELP = YES
ECLIPSE_DOC_ID = org.doxygen.qtools
DISABLE_INDEX = NO
-GENERATE_TREEVIEW = YES
+GENERATE_TREEVIEW = NO
ENUM_VALUES_PER_LINE = 4
TREEVIEW_WIDTH = 250
EXT_LINKS_IN_WINDOW = NO
FORMULA_TRANSPARENT = YES
USE_MATHJAX = NO
MATHJAX_FORMAT = HTML-CSS
-MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_RELPATH = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/
MATHJAX_EXTENSIONS =
MATHJAX_CODEFILE =
SEARCHENGINE = YES
EXTERNAL_SEARCH_ID =
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
+# Configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = YES
LATEX_OUTPUT =
EXTRA_PACKAGES =
LATEX_HEADER =
LATEX_FOOTER =
+LATEX_EXTRA_STYLESHEET =
LATEX_EXTRA_FILES =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_HIDE_INDICES = NO
LATEX_SOURCE_CODE = YES
LATEX_BIB_STYLE = plain
+LATEX_TIMESTAMP = NO
#---------------------------------------------------------------------------
-# configuration options related to the RTF output
+# Configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT =
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
+RTF_SOURCE_CODE = NO
#---------------------------------------------------------------------------
-# configuration options related to the man page output
+# 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
+# Configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_OUTPUT = xml
-XML_SCHEMA =
-XML_DTD =
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
-# configuration options related to the DOCBOOK output
+# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
GENERATE_DOCBOOK = NO
DOCBOOK_OUTPUT = docbook
+DOCBOOK_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
+# Configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
+# Configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
-# Configuration::additions related to external references
+# Configuration options related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE = ../qtools_docs/qtools.tag
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
+DIA_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
DOT_NUM_THREADS = 0
DOT_PATH =
DOTFILE_DIRS =
MSCFILE_DIRS =
+DIAFILE_DIRS =
+PLANTUML_JAR_PATH =
+PLANTUML_CFG_FILE =
+PLANTUML_INCLUDE_PATH =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = YES
\fn void QDataStream::setVersion( int v )
Sets the version number of the data serialization format.
- In order to accomodate for new functionality, the datastream
+ In order to accommodate for new functionality, the datastream
serialization format of some Qt classes has changed in some versions of
Qt. If you want to read data that was created by an earlier version of
Qt, or write data that can be read by a program that was compiled with
The key is used for inserting and looking up an item. QDict has
\l QString keys, which are Unicode strings. If you want to use
non-Unicode, plain 8-bit \c char* keys, use the QAsciiDict template.
- A QDict has the same performace as a QAsciiDict.
+ A QDict has the same performance as a QAsciiDict.
The dictionary has very fast insertion and lookup.
/*!
Replaces \a len characters starting at position \a index by
- \a slen units ot QChar data from \a s, and returns a reference to the string.
+ \a slen units to QChar data from \a s, and returns a reference to the string.
\sa insert(), remove()
*/
}
// For the probably_koi8_locales we have to look. the standard says
-// these are 8859-5, but almsot all Russion users uses KOI8-R and
+// these are 8859-5, but almost all Russian users uses KOI8-R and
// incorrectly set $LANG to ru_RU. We'll check tolower() to see what
// tolower() thinks ru_RU means.
void *QThreadPrivate::start(void *arg)
{
+#ifndef __ANDROID__
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+#endif
pthread_cleanup_push(QThreadPrivate::finish, arg);
QThread *thr = reinterpret_cast<QThread *>(arg);
thr->started();
+#ifndef __ANDROID__
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_testcancel();
+#endif
thr->run();
pthread_cleanup_pop(1);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
+#ifndef __ANDROID__
pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
+#endif
if (d->stackSize>0)
{
#if defined(_POSIX_THREAD_ATTR_STACKSIZE) && (_POSIX_THREAD_ATTR_STACKSIZE-0>0)
void QThread::terminate()
{
QMutexLocker locker(&d->mutex);
-
+#ifndef __ANDROID__
if (!d->thread_id) return;
int code = pthread_cancel(d->thread_id);
{
d->terminated = TRUE;
}
+#endif
}
void QThread::wait()
In addition you can search items in the list with the find() function. It exists in a const
and a non const version. It starts searching from the beginning of the list, but another
flavor of the find() function allows you to specify where searching should start.
- If you just want to know wether a certain item is at least once in the list, then you
+ If you just want to know whether a certain item is at least once in the list, then you
can use the contains() function.
Since QValueList is value based there is no need to care about deleting elements in the
of this list become invalidated. Since QValueList is highly tuned for performance
you wont see warnings if you use invalid iterators,
because it is impossible for
- an iterator to check wether it is valid or not.
+ an iterator to check whether it is valid or not.
*/
/*!
/*!
\fn const T& QValueList::operator[] ( uint i ) const
Returns a const reference to the item with index \e i in the list.
- It is up to you to check wether this item really exists. You can do that easily
- with the count() function. However this operator does not check wether \e i
+ It is up to you to check whether this item really exists. You can do that easily
+ with the count() function. However this operator does not check whether \e i
is in range and will deliver undefined results if it does not exist.
*/
/*!
\fn T& QValueList::operator[] ( uint i )
Returns a reference to the item with index \e i in the list.
- It is up to you to check wether this item really exists. You can do that easily
- with the count() function. However this operator does not check wether \e i
+ It is up to you to check whether this item really exists. You can do that easily
+ with the count() function. However this operator does not check whether \e i
is in range and will deliver undefined results if it does not exist.
In contrast to the const operator[] you may manipulate the value returned by this
operator.
QValueList is highly optimized for performance and memory usage.
On the other hand that means that you have to be a bit more careful
by what you are doing. QValueList does not know about all its iterators
- and the iterators dont even know to which list they belong. That makes
+ and the iterators don't even know to which list they belong. That makes
things fast and slim but a bit dangerous because it is up to you to make
sure that iterators you are using are still valid. QListIterator will be able
to give warnings while QValueListIterator may end up in an undefined state.
\fn QValueListIterator<T>& QValueListIterator::operator++()
Prefix ++ makes the succeeding item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the end of the list. Incrementing
+ The iterator can not check whether it reached the end of the list. Incrementing
the iterator as returned by end() causes undefined results.
*/
\fn QValueListIterator<T> QValueListIterator::operator++(int)
Postfix ++ makes the succeeding item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the end of the list. Incrementing
+ The iterator can not check whether it reached the end of the list. Incrementing
the iterator as returned by end() causes undefined results.
*/
\fn QValueListIterator<T>& QValueListIterator::operator--()
Prefix -- makes the previous item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the beginning of the list. Decrementing
+ The iterator can not check whether it reached the beginning of the list. Decrementing
the iterator as returned by begin() causes undefined results.
*/
\fn QValueListIterator<T> QValueListIterator::operator--(int)
Postfix -- makes the previous item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the beginning of the list. Decrementing
+ The iterator can not check whether it reached the beginning of the list. Decrementing
the iterator as returned by begin() causes undefined results.
*/
list. It does not allow to modify the values of the list since this would
break the const semantics.
- For more informations on QValueList iterators see QValueListIterator.
+ For more information on QValueList iterators see QValueListIterator.
\sa QValueListIterator, QValueList
*/
\fn QValueListConstIterator<T>& QValueListConstIterator::operator++()
Prefix ++ makes the succeeding item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the end of the list. Incrementing
+ The iterator can not check whether it reached the end of the list. Incrementing
the iterator as returned by end() causes undefined results.
*/
\fn QValueListConstIterator<T> QValueListConstIterator::operator++(int)
Postfix ++ makes the succeeding item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the end of the list. Incrementing
+ The iterator can not check whether it reached the end of the list. Incrementing
the iterator as returned by end() causes undefined results.
*/
\fn QValueListConstIterator<T>& QValueListConstIterator::operator--()
Prefix -- makes the previous item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the beginning of the list. Decrementing
+ The iterator can not check whether it reached the beginning of the list. Decrementing
the iterator as returned by begin() causes undefined results.
*/
\fn QValueListConstIterator<T> QValueListConstIterator::operator--(int)
Postfix -- makes the previous item current and returns
an iterator pointing to the new current item.
- The iterator can not check wether it reached the beginning of the list. Decrementing
+ The iterator can not check whether it reached the beginning of the list. Decrementing
the iterator as returned by begin() causes undefined results.
*/
code = pthread_cond_wait(&cond, &mutex);
if (code == 0 && wakeups == 0)
{
- // many vendors warn of spurios wakeups from
+ // many vendors warn of spurious wakeups from
// pthread_cond_wait(), especially after signal delivery,
// even though POSIX doesn't allow for it... sigh
continue;
// NOT REVISED
// Error strings for the XML reader
-#define XMLERR_OK "no error occured"
+#define XMLERR_OK "no error occurred"
#define XMLERR_TAGMISMATCH "tag mismatch"
#define XMLERR_UNEXPECTEDEOF "unexpected end of file"
#define XMLERR_FINISHEDPARSINGWHILENOTEOF "parsing is finished but end of file is not reached"
return msg;
}
/*!
- Returns the column number the error occured.
+ Returns the column number the error occurred.
*/
int QXmlParseException::columnNumber() const
{
return column;
}
/*!
- Returns the line number the error occured.
+ Returns the line number the error occurred.
*/
int QXmlParseException::lineNumber() const
{
return line;
}
/*!
- Returns the public identifier the error occured.
+ Returns the public identifier the error occurred.
*/
QString QXmlParseException::publicId() const
{
return pub;
}
/*!
- Returns the system identifier the error occured.
+ Returns the system identifier the error occurred.
*/
QString QXmlParseException::systemId() const
{
and looking it up among the prefixes currently declared.
First parameter is the raw XML 1.0 name to be processed. The second parameter
- is a flag wheter the name is the name of an attribute (TRUE) or not (FALSE).
+ is a flag whether the name is the name of an attribute (TRUE) or not (FALSE).
The return values will be stored in the last two parameters as follows:
<ul>
\fn bool QXmlErrorHandler::error( const QXmlParseException& exception )
A reader might use this function to report a recoverable error. A recoverable
- error corresponds to the definiton of "error" in section 1.2 of the XML 1.0
+ error corresponds to the definition of "error" in section 1.2 of the XML 1.0
specification.
The reader must continue to provide normal parsing events after invoking this
head stands on the first character after the reference.
charDataRead is set to FALSE if the reference must be parsed. The
- charachter(s) which the reference mapped to are inserted at the reference
+ character(s) which the reference mapped to are inserted at the reference
position. The head stands on the first character of the replacement).
*/
bool QXmlSimpleReader::parseReference( bool &charDataRead, EntityRecognitionContext context )
}
} else {
// "Unparsed"
- // ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
+ // ### notify for "Occurs as Attribute Value" missing (but this is no reference, anyway)
// Forbidden
d->error = XMLERR_UNPARSEDENTITYREFERENCE;
charDataRead = FALSE;
# lang_cfg.h
add_custom_command(
COMMENT "Generating ${GENERATED_SRC}/lang_cfg.h"
- COMMAND ${CMAKE_COMMAND} -P ${CMAKE_SOURCE_DIR}/cmake/lang_cfg.cmake ${LANG_CODES} 2> ${GENERATED_SRC}/lang_cfg.h
+ COMMAND ${CMAKE_COMMAND} -P ${CMAKE_SOURCE_DIR}/cmake/lang_cfg.cmake ${GENERATED_SRC}/lang_cfg.h ${LANG_CODES}
DEPENDS ${LANGUAGE_FILES}
OUTPUT ${GENERATED_SRC}/lang_cfg.h
)
FLEX_TARGET(sqlcode sqlcode.l ${GENERATED_SRC}/sqlcode.cpp COMPILE_FLAGS "${LEX_FLAGS}")
FLEX_TARGET(configimpl configimpl.l ${GENERATED_SRC}/configimpl.cpp COMPILE_FLAGS "${LEX_FLAGS}")
-BISON_TARGET(constexp constexp.y ${GENERATED_SRC}/ce_parse.cpp COMPILE_FLAGS "${YACC_FLAGS}")
+BISON_TARGET(constexp constexp.y ${GENERATED_SRC}/ce_parse.cpp COMPILE_FLAGS ${YACC_FLAGS})
add_library(doxycfg STATIC
${GENERATED_SRC}/lang_cfg.h
)
add_executable(doxygen main.cpp)
+
+if (use_libclang)
+ find_package(LLVM REQUIRED CONFIG)
+ find_package(Clang REQUIRED CONFIG)
+ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+ cmake_minimum_required(VERSION 3.1)
+ target_compile_features(_doxygen PRIVATE cxx_alignof)
+ target_compile_features(doxygen PRIVATE cxx_alignof)
+ target_compile_options(_doxygen PRIVATE -stdlib=libc++)
+ target_compile_options(doxygen PRIVATE -stdlib=libc++)
+ elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+ target_compile_options(_doxygen PRIVATE -std=c++11)
+ target_compile_options(doxygen PRIVATE -std=c++11)
+ endif()
+ include_directories(${LLVM_INCLUDE_DIRS})
+ add_definitions(${LLVM_DEFINITIONS})
+ llvm_map_components_to_libnames(llvm_libs support core option)
+ target_compile_definitions(doxygen PRIVATE ${LLVM_DEFINITIONS})
+ set(CLANG_LIBS libclang clangTooling ${llvm_libs})
+endif()
+
target_link_libraries(doxygen
_doxygen
doxycfg
)
install(TARGETS doxygen DESTINATION bin)
-
thisDir.remove(citeListFile);
thisDir.remove(doxygenBstFile);
thisDir.remove(bib2xhtmlFile);
- // we might try to remove too many files as empty files didn't get a coresponding new file
+ // we might try to remove too many files as empty files didn't get a corresponding new file
// but the remove function does not emit an error for it and we don't catch the error return
// so no problem.
for (unsigned int j = 1; j <= citeDataList.count(); j++)
#if USE_LIBCLANG
#include <clang-c/Index.h>
+#include "clang/Tooling/Tooling.h"
#include <qfileinfo.h>
#include <stdlib.h>
#include "message.h"
static bool clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
static QStrList &includePath = Config_getList(INCLUDE_PATH);
static QStrList clangOptions = Config_getList(CLANG_OPTIONS);
+ static QCString clangCompileDatabase = Config_getList(CLANG_COMPILATION_DATABASE_PATH);
if (!clangAssistedParsing) return;
//printf("ClangParser::start(%s)\n",fileName);
p->fileName = fileName;
p->index = clang_createIndex(0, 0);
p->curLine = 1;
p->curToken = 0;
- char **argv = (char**)malloc(sizeof(char*)*(4+Doxygen::inputPaths.count()+includePath.count()+clangOptions.count()));
QDictIterator<void> di(Doxygen::inputPaths);
int argc=0;
+ std::string error;
+ // load a clang compilation database (https://clang.llvm.org/docs/JSONCompilationDatabase.html)
+ // this only needs to be loaded once, and could be refactored to a higher level function
+ static std::unique_ptr<clang::tooling::CompilationDatabase> db =
+ clang::tooling::CompilationDatabase::loadFromDirectory(clangCompileDatabase.data(), error);
+ int clang_option_len = 0;
+ std::vector<clang::tooling::CompileCommand> command;
+ if (strcmp(clangCompileDatabase, "0") != 0) {
+ if (db == nullptr) {
+ // user specified a path, but DB file was not found
+ err("%s using clang compilation database path of: \"%s\"\n", error.c_str(),
+ clangCompileDatabase.data());
+ } else {
+ // check if the file we are parsing is in the DB
+ command = db->getCompileCommands(fileName);
+ if (!command.empty() ) {
+ // it's possible to have multiple entries for the same file, so use the last entry
+ clang_option_len = command[command.size()-1].CommandLine.size();
+ }
+ }
+ }
+ char **argv = (char**)malloc(sizeof(char*)*(4+Doxygen::inputPaths.count()+includePath.count()+clangOptions.count()+clang_option_len));
+ if (!command.empty() ) {
+ std::vector<std::string> options = command[command.size()-1].CommandLine;
+ // copy each compiler option used from the database. Skip the first which is compiler exe.
+ for (auto option = options.begin()+1; option != options.end(); option++) {
+ argv[argc++] = strdup(option->c_str());
+ }
+ // this extra addition to argv is accounted for as we are skipping the first entry in
+ argv[argc++]=strdup("-w"); // finally, turn off warnings.
+ } else {
// add include paths for input files
for (di.toFirst();di.current();++di,++argc)
{
// provide the input and and its dependencies as unsaved files so we can
// pass the filtered versions
argv[argc++]=strdup(fileName);
+ }
static bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);
//printf("source %s ----------\n%s\n-------------\n\n",
// fileName,p->source.data());
/* user defined member groups */
MemberGroupSDict *memberGroupSDict;
- /*! Is this an abstact class? */
+ /*! Is this an abstract class? */
bool isAbstract;
/*! Is the class part of an unnamed namespace? */
if (rootNode && !rootNode->isEmpty())
{
ol.startMemberDescription(anchor());
+
+ ol.pushGeneratorState();
+ ol.disableAll();
+ ol.enable(OutputGenerator::RTF);
+ ol.writeString("{");
+ ol.popGeneratorState();
+
ol.writeDoc(rootNode,this,0);
+
+ ol.pushGeneratorState();
+ ol.disableAll();
+ ol.enable(OutputGenerator::RTF);
+ ol.writeString("\\par}");
+ ol.popGeneratorState();
+
if (isLinkableInProject())
{
writeMoreLink(ol,anchor());
}
}
-Definition *ClassDef::findInnerCompound(const char *name)
+Definition *ClassDef::findInnerCompound(const char *name) const
{
Definition *result=0;
if (name==0) return 0;
return m_impl->isLocal;
}
-ClassSDict *ClassDef::getClassSDict()
+ClassSDict *ClassDef::getClassSDict() const
{
return m_impl->innerClasses;
}
bool isLocal() const;
/** returns the classes nested into this class */
- ClassSDict *getClassSDict();
+ ClassSDict *getClassSDict() const;
/** returns TRUE if this class has documentation */
bool hasDocumentation() const;
* available, or 0 otherwise.
* @param name The name of the nested compound
*/
- virtual Definition *findInnerCompound(const char *name);
+ virtual Definition *findInnerCompound(const char *name) const;
/** Returns the template parameter lists that form the template
* declaration of this class.
static QStack<int> g_classScopeLengthStack;
+static int g_prefixed_with_this_keyword = FALSE;
static Definition *g_searchCtx;
static bool g_collectXRefs;
bool isLocal=FALSE;
//printf("generateClassOrGlobalLink(className=%s)\n",className.data());
- if ((lcd=g_theVarContext.findVariable(className))==0) // not a local variable
+ if (!g_prefixed_with_this_keyword || (lcd=g_theVarContext.findVariable(className))==0) // not a local variable
{
Definition *d = g_currentDefinition;
//printf("d=%s g_sourceFileDef=%s\n",d?d->name().data():"<none>",g_sourceFileDef?g_sourceFileDef->name().data():"<none>");
isLocal=TRUE;
DBG_CTX((stderr,"is a local variable cd=%p!\n",cd));
}
+ g_prefixed_with_this_keyword = FALSE; // discard the "this" prefix for the next calls
+
if (cd && cd->isLinkable()) // is it a linkable class
{
DBG_CTX((stderr,"is linkable class %s\n",clName));
SCOPEPREFIX ({ID}{TEMPLIST}?{BN}*{SEP}{BN}*)+
KEYWORD_OBJC ("@public"|"@private"|"@protected"|"@class"|"@implementation"|"@interface"|"@end"|"@selector"|"@protocol"|"@optional"|"@required"|"@throw"|"@synthesize"|"@property")
KEYWORD ("asm"|"__assume"|"auto"|"class"|"const"|"delete"|"enum"|"explicit"|"extern"|"false"|"friend"|"gcnew"|"gcroot"|"set"|"get"|"inline"|"internal"|"mutable"|"namespace"|"new"|"nullptr"|"override"|"operator"|"pin_ptr"|"private"|"protected"|"public"|"raise"|"register"|"remove"|"self"|"sizeof"|"static"|"struct"|"__super"|"function"|"template"|"generic"|"this"|"true"|"typedef"|"typeid"|"typename"|"union"|"using"|"virtual"|"volatile"|"abstract"|"final"|"import"|"synchronized"|"transient"|"alignas"|"alignof"|{KEYWORD_OBJC})
-FLOWKW ("break"|"case"|"catch"|"continue"|"default"|"do"|"else"|"finally"|"for"|"foreach"|"for each"|"goto"|"if"|"return"|"switch"|"throw"|"throws"|"try"|"while"|"@try"|"@catch"|"@finally")
+FLOWKW ("break"|"catch"|"continue"|"default"|"do"|"else"|"finally"|"return"|"switch"|"throw"|"throws"|"@catch"|"@finally")
+FLOWCONDITION ("case"|"for"|"foreach"|"for each"|"goto"|"if"|"try"|"while"|"@try")
TYPEKW ("bool"|"char"|"double"|"float"|"int"|"long"|"object"|"short"|"signed"|"unsigned"|"void"|"wchar_t"|"size_t"|"boolean"|"id"|"SEL"|"string"|"nullptr")
CASTKW ("const_cast"|"dynamic_cast"|"reinterpret_cast"|"static_cast")
CHARLIT (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^' \\\n]{1,4}"'"))
g_code->codify(yytext);
if (*yytext=='{')
{
- g_curlyCount++;
if (g_searchingForBody)
{
g_searchingForBody=FALSE;
<SkipCPP>"//" {
g_code->codify(yytext);
}
-<Body,FuncCall>"}" {
- g_theVarContext.popScope();
- g_yyColNr++;
- g_code->codify(yytext);
- }
<Body,FuncCall>"{" {
g_theVarContext.pushScope();
g_insideBody=TRUE;
}
g_code->codify(yytext);
- g_curlyCount++;
if (g_insideBody)
{
g_bodyCurlyCount++;
g_name.resize(0);
BEGIN( Body );
}
-<Body,MemberCall,MemberCall2>"}" {
+<Body,FuncCall,MemberCall,MemberCall2>"}" {
g_theVarContext.popScope();
g_type.resize(0);
g_name.resize(0);
<Bases,ClassName,ClassVar,CppCliTypeModifierFollowup>{B}*"{"{B}* {
g_theVarContext.pushScope();
g_code->codify(yytext);
- g_curlyCount++;
if (YY_START==ClassVar && g_curClassName.isEmpty())
{
g_curClassName = g_name.copy();
<UsingName>\n { codifyLines(yytext); BEGIN(Body); }
<UsingName>. { codifyLines(yytext); BEGIN(Body); }
<Body,FuncCall>"$"?"this"("->"|".") { g_code->codify(yytext); // this-> for C++, this. for C#
+ g_prefixed_with_this_keyword = TRUE;
}
<Body>{KEYWORD}/([^a-z_A-Z0-9]) {
startFontClass("keyword");
g_inForEachExpression = (qstrcmp(yytext,"for each")==0 || qstrcmp(yytext, "foreach")==0);
BEGIN(FuncCall);
}
+<Body>{FLOWCONDITION}/{BN}*"(" {
+ if (g_currentMemberDef && g_currentMemberDef->isFunction())
+ {
+ g_currentMemberDef->addFlowKeyWord();
+ }
+ startFontClass("keywordflow");
+ codifyLines(yytext);
+ endFontClass();
+ g_name.resize(0);g_type.resize(0);
+ g_inForEachExpression = (strcmp(yytext,"for each")==0 || strcmp(yytext, "foreach")==0);
+ BEGIN(FuncCall);
+ }
<Body>{FLOWKW}/([^a-z_A-Z0-9]) {
startFontClass("keywordflow");
codifyLines(yytext);
g_inFunctionTryBlock=FALSE;
}
}
+<Body>{FLOWCONDITION}/([^a-z_A-Z0-9]) {
+ if (g_currentMemberDef && g_currentMemberDef->isFunction())
+ {
+ g_currentMemberDef->addFlowKeyWord();
+ }
+ startFontClass("keywordflow");
+ codifyLines(yytext);
+ endFontClass();
+ if (g_inFunctionTryBlock && (strcmp(yytext,"catch")==0 || strcmp(yytext,"finally")==0))
+ {
+ g_inFunctionTryBlock=FALSE;
+ }
+ }
<Body>{FLOWKW}/{B}* {
startFontClass("keywordflow");
codifyLines(yytext);
endFontClass();
}
+<Body>{FLOWCONDITION}/{B}* {
+ if (g_currentMemberDef && g_currentMemberDef->isFunction())
+ {
+ g_currentMemberDef->addFlowKeyWord();
+ }
+ startFontClass("keywordflow");
+ codifyLines(yytext);
+ endFontClass();
+ }
<Body>"*"{B}*")" { // end of cast?
g_code->codify(yytext);
g_theCallContext.popScope();
g_code->codify(yytext);
endFontClass();
}
+<MemberCall2,FuncCall>{FLOWCONDITION}/([^a-z_A-Z0-9]) {
+ if (g_currentMemberDef && g_currentMemberDef->isFunction())
+ {
+ g_currentMemberDef->addFlowKeyWord();
+ }
+ addParmType();
+ g_parmName=yytext;
+ startFontClass("keywordflow");
+ g_code->codify(yytext);
+ endFontClass();
+ }
<MemberCall2,FuncCall>{ID}(({B}*"<"[^\n\[\](){}<>]*">")?({B}*"::"{B}*{ID})?)* {
addParmType();
g_parmName=yytext;
g_insideBody=TRUE;
}
if (g_insideBody) g_bodyCurlyCount++;
- g_curlyCount++;
g_type.resize(0); g_name.resize(0);
BEGIN( Body );
}
}
<SkipInits>"{" {
g_code->codify(yytext);
- g_curlyCount++;
if (g_searchingForBody)
{
g_searchingForBody=FALSE;
static bool g_pythonDocString;
static int g_nestingCount;
+static bool g_vhdl; // for VHDL old style --! comment
+
static SrcLangExt g_lang;
static bool isFixedForm; // For Fortran
%%
-<Scan>[^"'!\/\n\\#-,]* { /* eat anything that is not " / , or \n */
+<Scan>[^"'!\/\n\\#,\-]* { /* eat anything that is not " / , or \n */
copyToOutput(yytext,(int)yyleng);
}
<Scan>[,] { /* eat , so we have a nice separator in long initialization lines */
}
else
{
+ g_vhdl = TRUE;
copyToOutput(yytext,(int)yyleng);
g_nestingCount=0;
g_commentStack.clear(); /* to be on the save side */
}
}
}
-<CComment>"\n"/[ \t]*[^#] { /* end of Python comment */
+ /* Python an VHDL share CComment, so special attention for ending comments is required */
+<CComment>"\n"/[ \t]*"#" {
+ if (g_lang!=SrcLangExt_VHDL)
+ {
+ REJECT;
+ }
+ else
+ {
+ if (g_vhdl) // inside --! comment
+ {
+ g_vhdl = FALSE;
+ copyToOutput(yytext,(int)yyleng);
+ BEGIN(Scan);
+ }
+ else // C-type comment
+ {
+ REJECT;
+ }
+ }
+ }
+<CComment>"\n"/[ \t]*"-" {
if (g_lang!=SrcLangExt_Python || g_pythonDocString)
{
REJECT;
copyToOutput(yytext,(int)yyleng);
BEGIN(Scan);
}
- }
-<CComment>"\n"/[ \t]*[^\-] { /* end of VHDL comment */
- if (g_lang!=SrcLangExt_VHDL)
- {
+ }
+<CComment>"\n"/[ \t]*[^ \t#\-] {
+ if (g_lang==SrcLangExt_Python)
+ {
+ if (g_pythonDocString)
+ {
+ REJECT;
+ }
+ else
+ {
+ copyToOutput(yytext,(int)yyleng);
+ BEGIN(Scan);
+ }
+ }
+ else if (g_lang==SrcLangExt_VHDL)
+ {
+ if (g_vhdl) // inside --! comment
+ {
+ g_vhdl = FALSE;
+ copyToOutput(yytext,(int)yyleng);
+ BEGIN(Scan);
+ }
+ else // C-type comment
+ {
+ REJECT;
+ }
+ }
+ else
+ {
REJECT;
- }
- else
- {
- copyToOutput(yytext,(int)yyleng);
- BEGIN(Scan);
- }
- }
+ }
+ }
/* removed for bug 674842 (bug was introduced in rev 768)
<CComment>"'" {
g_charContext = YY_START;
g_condStack.setAutoDelete(TRUE);
g_commentStack.clear();
g_commentStack.setAutoDelete(TRUE);
+ g_vhdl = FALSE;
printlex(yy_flex_debug, TRUE, __FILE__, fileName);
isFixedForm = FALSE;
static bool handleCopyDetails(const QCString &);
static bool handleParBlock(const QCString &);
static bool handleEndParBlock(const QCString &);
+static bool handleParam(const QCString &);
+static bool handleRetval(const QCString &);
typedef bool (*DocCmdFunc)(const QCString &name);
{ "line", 0, TRUE },
{ "note", 0, TRUE },
{ "par", 0, TRUE },
- { "param", 0, TRUE },
+ { "param", &handleParam, TRUE },
{ "tparam", 0, TRUE },
{ "post", 0, TRUE },
{ "pre", 0, TRUE },
{ "return", 0, TRUE },
{ "returns", 0, TRUE },
{ "exception", 0, TRUE },
- { "retval", 0, TRUE },
+ { "retval", &handleRetval, TRUE },
{ "sa", 0, TRUE },
{ "see", 0, TRUE },
{ "since", 0, TRUE },
%x XRefItemParam2
%x XRefItemParam3
%x FileDocArg1
+%x ParamArg1
%x EnumDocArg1
%x NameSpaceDocArg1
%x PackageDocArg1
BEGIN( Comment );
}
+ /* --------- handle arguments of the param command ------------ */
+<ParamArg1>{ID}/{B}*"," {
+ if (yytext[0]=='_' && Config_getBool(MARKDOWN_SUPPORT))
+ {
+ addOutput('\\');
+ }
+ addOutput(yytext);
+ }
+<ParamArg1>"," {
+ addOutput(" , ");
+ }
+<ParamArg1>{ID} {
+ if (yytext[0]=='_' && Config_getBool(MARKDOWN_SUPPORT))
+ {
+ addOutput('\\');
+ }
+ addOutput(yytext);
+ BEGIN( Comment );
+ }
+<ParamArg1>. {
+ unput(yytext[0]);
+ BEGIN( Comment );
+ }
+
/* --------- handle arguments of the file/dir/example command ------------ */
-<FileDocArg1>{DOCNL} { // no file name specfied
+<FileDocArg1>{DOCNL} { // no file name specified
if (*yytext=='\n') yyLineNr++;
addOutput('\n');
BEGIN( Comment );
return stop;
}
+static bool handleParam(const QCString &)
+{
+ // we need process param and retval arguments to escape leading underscores in case of
+ // markdown processing, see bug775493
+ addOutput("@param ");
+ BEGIN( ParamArg1 );
+ return FALSE;
+}
+
+static bool handleRetval(const QCString &)
+{
+ addOutput("@retval ");
+ BEGIN( ParamArg1 );
+ return FALSE;
+}
+
static bool handleDir(const QCString &)
{
bool stop=makeStructuralIndicator(Entry::DIRDOC_SEC);
#if 0
// check for garbage at the end of the expression
- // an expression ends with a character '\0' and token_type = delimeter
+ // an expression ends with a character '\0' and token_type = delimiter
if (m_tokenType!=DELIMITER || !m_token.isEmpty())
{
if (m_tokenType == DELIMITER)
/**
- * checks if the given char c is a delimeter
+ * checks if the given char c is a delimiter
* minus is checked apart, can be unary minus
*/
static bool isDelimiter(const char c)
return;
}
- // check for operators (delimeters)
+ // check for operators (delimiters)
if (isDelimiter(*m_e))
{
m_tokenType = DELIMITER;
This tag specifies the encoding used for all characters in the config file that
follow. The default is UTF-8 which is also the encoding used for all text before
the first occurrence of this tag. Doxygen uses \c libiconv (or the iconv built into
- \c libc) for the transcoding. See http://www.gnu.org/software/libiconv for the list of
+ \c libc) for the transcoding. See https://www.gnu.org/software/libiconv/ for the list of
possible encodings.
]]>
</docs>
will allow you to
put the command \c \\sideeffect (or \c \@sideeffect) in the documentation, which
will result in a user-defined paragraph with heading "Side Effects:".
- You can put \ref cmdn "\\n"'s in the value part of an alias to insert newlines.
+ You can put \ref cmdn "\\n"'s in the value part of an alias to insert newlines
+ (in the resulting output).
+ You can put `^^` in the value part of an alias to insert a newline as if
+ a physical newline was in the original file.
]]>
</docs>
</option>
<docs>
<![CDATA[
Set the \c SIP_SUPPORT tag to \c YES if your project consists
- of <a href="http://www.riverbankcomputing.co.uk/software/sip/intro">sip</a> sources only.
+ of <a href="https://www.riverbankcomputing.com/software/sip/intro">sip</a> sources only.
Doxygen will parse them like normal C++ but will assume all classes use public
instead of private inheritance when no explicit protection keyword is present.
]]>
</docs>
</option>
<option type='int' id='LOOKUP_CACHE_SIZE' minval='0' maxval='9' defval='0'>
- <!-- be carefull when changing these formulas as they are hard coded in the conversion script -->
+ <!-- be careful when changing these formulas as they are hard coded in the conversion script -->
<docs>
<![CDATA[
The size of the symbol lookup cache can be
The \c CITE_BIB_FILES tag can be used to specify one or more \c bib files
containing the reference definitions. This must be a list of <code>.bib</code> files. The
<code>.bib</code> extension is automatically appended if omitted. This requires the
- \c bibtex tool to be installed. See also http://en.wikipedia.org/wiki/BibTeX for
+ \c bibtex tool to be installed. See also https://en.wikipedia.org/wiki/BibTeX for
more info. For \f$\mbox{\LaTeX}\f$ the style of the bibliography can be controlled
using \ref cfg_latex_bib_style "LATEX_BIB_STYLE".
To use this feature you need \c bibtex and \c perl available in the search path.
This tag can be used to specify the character encoding of the source files that
doxygen parses. Internally doxygen uses the UTF-8 encoding.
Doxygen uses `libiconv` (or the `iconv` built into `libc`) for the transcoding.
- See <a href="http://www.gnu.org/software/libiconv">the libiconv documentation</a> for
+ See <a href="https://www.gnu.org/software/libiconv/">the libiconv documentation</a> for
the list of possible encodings.
]]>
</docs>
If the \c USE_HTAGS tag is set to \c YES then the references to source code
will point to the HTML generated by the \c htags(1) tool instead of doxygen
built-in source browser. The \c htags tool is part of GNU's global source
- tagging system (see http://www.gnu.org/software/global/global.html). You
+ tagging system (see https://www.gnu.org/software/global/global.html). You
will need version 4.8.6 or higher.
<br>
To use it do the following:
]]>
</docs>
</option>
+ <option type='string' id='CLANG_COMPILATION_DATABASE_PATH' setting='USE_LIBCLANG' defval='0'>
+ <docs>
+<![CDATA[
+ If clang assisted parsing is enabled you can provide the clang parser with the
+ path to the <a href="http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html">
+ compilation database</a> used when the files were built. This is equivalent to
+ specifying the "-p" option to a clang tool, such as clang-check. These options
+ will then be passed to the parser.
+
+ @note The availability of this option depends on whether or not doxygen
+ was generated with the `-Duse-libclang=ON` option for CMake.
+ ]]>
+ </docs>
+ </option>
</group>
<group name='Index' docs='Configuration options related to the alphabetical class index'>
<option type='bool' id='ALPHABETICAL_INDEX' defval='1'>
The \c HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
Doxygen will adjust the colors in the style sheet and background images
according to this color. Hue is specified as an angle on a colorwheel,
- see http://en.wikipedia.org/wiki/Hue for more information.
+ see https://en.wikipedia.org/wiki/Hue for more information.
For instance the value 0 represents red, 60 is yellow, 120 is green,
180 is cyan, 240 is blue, 300 purple, and 360 is red again.
]]>
]]>
</docs>
</option>
+ <option type='bool' id='HTML_DYNAMIC_MENUS' defval='1' depends='GENERATE_HTML'>
+ <docs>
+<![CDATA[
+ If the \c HTML_DYNAMIC_MENUS tag is set to \c YES then the generated HTML
+ documentation will contain a main index with vertical navigation menus that
+ are dynamically created via Javascript. If disabled, the navigation index will consists of
+ multiple levels of tabs that are statically embedded in every HTML page.
+ Disable this option to support browsers that do not have Javascript, like
+ the Qt help browser.
+]]>
+ </docs>
+ </option>
<option type='bool' id='HTML_DYNAMIC_SECTIONS' defval='0' depends='GENERATE_HTML'>
<docs>
<![CDATA[
<![CDATA[
If the \c GENERATE_DOCSET tag is set to \c YES, additional index files
will be generated that can be used as input for
- <a href="http://developer.apple.com/tools/xcode/">Apple's Xcode 3
+ <a href="https://developer.apple.com/tools/xcode/">Apple's Xcode 3
integrated development environment</a>, introduced with OSX 10.5 (Leopard).
To create a documentation set, doxygen will generate a Makefile in the
HTML output directory. Running \c make will produce the docset in that
directory and running <code>make install</code> will install the docset in
<code>~/Library/Developer/Shared/Documentation/DocSets</code>
so that Xcode will find it at startup. See
- http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for
+ https://developer.apple.com/tools/creatingdocsetswithdoxygen.html for
more information.
]]>
</docs>
<![CDATA[
The \c QHP_NAMESPACE tag specifies the namespace to use when generating
Qt Help Project output. For more information please see
- <a href="http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace">Qt Help Project / Namespace</a>.
+ <a href="http://doc.qt.io/qt-4.8/qthelpproject.html#namespace">Qt Help Project / Namespace</a>.
]]>
</docs>
</option>
<![CDATA[
The \c QHP_VIRTUAL_FOLDER tag specifies the namespace to use when
generating Qt Help Project output. For more information please see
- <a href="http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-folders">Qt Help Project / Virtual Folders</a>.
+ <a href="http://doc.qt.io/qt-4.8/qthelpproject.html#virtual-folders">Qt Help Project / Virtual Folders</a>.
]]>
</docs>
</option>
<docs>
<![CDATA[
If the \c QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom filter to add. For more information please see
- <a href="http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+ <a href="http://doc.qt.io/qt-4.8/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
]]>
</docs>
</option>
<![CDATA[
The \c QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the custom filter to add.
For more information please see
- <a href="http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+ <a href="http://doc.qt.io/qt-4.8/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
]]>
</docs>
</option>
<docs>
<![CDATA[
The \c QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's filter section matches.
- <a href="http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+ <a href="http://doc.qt.io/qt-4.8/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
]]>
</docs>
</option>
<option type='bool' id='FORMULA_TRANSPARENT' defval='1' depends='GENERATE_HTML'>
<docs>
<![CDATA[
- Use the \c FORMULA_TRANPARENT tag to determine whether or not the images
+ Use the \c FORMULA_TRANSPARENT tag to determine whether or not the images
generated for formulas are transparent PNGs. Transparent PNGs are
not supported properly for IE 6.0, but are supported on all modern browsers.
<br>Note that when changing this option you need to delete any `form_*.png` files
<docs>
<![CDATA[
Enable the \c USE_MATHJAX option to render \f$\mbox{\LaTeX}\f$ formulas using MathJax
- (see http://www.mathjax.org) which uses client side Javascript for the
+ (see https://www.mathjax.org) which uses client side Javascript for the
rendering instead of using pre-rendered bitmaps. Use this if you do not
have \f$\mbox{\LaTeX}\f$ installed or if you want to formulas look prettier in the HTML
output. When enabled you may also need to install MathJax separately and
<value name="NativeMML" desc="(i.e. MathML)"/>
<value name="SVG"/>
</option>
- <option type='string' id='MATHJAX_RELPATH' format='string' defval='http://cdn.mathjax.org/mathjax/latest' depends='USE_MATHJAX'>
+ <option type='string' id='MATHJAX_RELPATH' format='string' defval='https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/' depends='USE_MATHJAX'>
<docs>
<![CDATA[
When MathJax is enabled you need to specify the location relative to the
\c MATHJAX_RELPATH should be <code>../mathjax</code>. The default value points to
the MathJax Content Delivery Network so you can quickly see the result without
installing MathJax. However, it is strongly recommended to install a local
- copy of MathJax from http://www.mathjax.org before deployment.
+ copy of MathJax from https://www.mathjax.org before deployment.
]]>
</docs>
</option>
the search results.
<br>Doxygen ships with an example indexer (\c doxyindexer) and
search engine (<code>doxysearch.cgi</code>) which are based on the open source search
- engine library <a href="http://xapian.org/">Xapian</a>.
+ engine library <a href="https://xapian.org/">Xapian</a>.
<br>See the section \ref extsearch for details.
]]>
</docs>
is enabled.
<br>Doxygen ships with an example indexer (\c doxyindexer) and
search engine (<code>doxysearch.cgi</code>) which are based on the open source search
- engine library <a href="http://xapian.org/">Xapian</a>.
+ engine library <a href="https://xapian.org/">Xapian</a>.
See the section \ref extsearch for details.
]]>
</docs>
<![CDATA[
The \c LATEX_BIB_STYLE tag can be used to specify the style to use for the
bibliography, e.g. \c plainnat, or \c ieeetr.
- See http://en.wikipedia.org/wiki/BibTeX and \ref cmdcite "\\cite"
+ See https://en.wikipedia.org/wiki/BibTeX and \ref cmdcite "\\cite"
for more info.
]]>
</docs>
<docs>
<![CDATA[
If the \c GENERATE_AUTOGEN_DEF tag is set to \c YES, doxygen will
- generate an AutoGen Definitions (see http://autogen.sf.net) file
+ generate an AutoGen Definitions (see http://autogen.sourceforge.net/) file
that captures the structure of the code including all
documentation. Note that this feature is still experimental
and incomplete at the moment.
doc = re.sub('<a +href="([^"]*)" *>([^<]*)</a>', '\\2 (see: \\1)', doc)
# LaTeX name as formula -> LaTeX
doc = doc.replace("\\f$\\mbox{\\LaTeX}\\f$", "LaTeX")
- # Other forula's (now just 2) so explicitely mentioned.
+ # Other formula's (now just 2) so explicitly mentioned.
doc = doc.replace("\\f$2^{(16+\\mbox{LOOKUP\\_CACHE\\_SIZE})}\\f$",
"2^(16+LOOKUP_CACHE_SIZE)")
doc = doc.replace("\\f$2^{16} = 65536\\f$", "2^16=65536")
inst.addProperty("isLinkable",&DefinitionContext::isLinkable);
//%% bool isLinkableInProject: can the symbol be linked within this project?
inst.addProperty("isLinkableInProject",&DefinitionContext::isLinkableInProject);
- //%% int dynSectionId: identifier that can be used for collapsable sections
+ //%% int dynSectionId: identifier that can be used for collapsible sections
inst.addProperty("dynSectionId",&DefinitionContext::dynSectionId);
//%% string language: the programming language in which the symbol is written
inst.addProperty("language",&DefinitionContext::language);
static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
if (!ref && pdfHyperlinks)
{
- m_ts << "\\hyperlink{";
+ m_ts << "\\mbox{\\hyperlink{";
if (f) m_ts << stripPath(f);
if (f && anchor) m_ts << "_";
if (anchor) m_ts << anchor;
m_ts << "}{";
filterLatexString(m_ts,text);
- m_ts << "}";
+ m_ts << "}}";
}
else
{
REJECT;
}
}
+<CopyArgSharp>">>)" { // combined token (see bug 790320)
+ *g_copyArgValue += yytext;
+ if (g_argSharpCount>0) g_argSharpCount--;
+ else BEGIN( g_readArgContext );
+ if (g_argSharpCount>0) g_argSharpCount--;
+ else BEGIN( g_readArgContext );
+ g_argRoundCount--;
+ }
<CopyArgSharp>">>" {
if (g_argRoundCount>0)
{
actualStart,actualEnd,codeFragment)
)
{
- //printf("Adding code fragement '%s' ext='%s'\n",
+ //printf("Adding code fragment '%s' ext='%s'\n",
// codeFragment.data(),m_impl->defFileExt.data());
ParserInterface *pIntf = Doxygen::parserManager->getParser(m_impl->defFileExt);
pIntf->resetCodeParserState();
}
}
-Definition *Definition::findInnerCompound(const char *)
+Definition *Definition::findInnerCompound(const char *) const
{
return 0;
}
QList<ListItemInfo> *xrefListItems() const;
- virtual Definition *findInnerCompound(const char *name);
+ virtual Definition *findInnerCompound(const char *name) const ;
virtual Definition *getOuterScope() const;
MemberSDict *getReferencesMembers() const;
DirSDict::Iterator sdi(*Doxygen::directories);
for (sdi.toFirst();(dir=sdi.current());++sdi)
{
+ ol.pushGeneratorState();
+ if (!dir->hasDocumentation())
+ {
+ ol.disableAllBut(OutputGenerator::Html);
+ }
dir->writeDocumentation(ol);
+ ol.popGeneratorState();
}
if (Config_getBool(DIRECTORY_GRAPH))
{
static SectionDict * g_sectionDict;
static QCString g_searchUrl;
+static QCString g_includeFileName;
static QCString g_includeFileText;
static uint g_includeFileOffset;
static uint g_includeFileLength;
}
else if (!g_memberDef->hasDocumentedParams())
{
- bool allDoc=TRUE; // no paramater => all parameters are documented
+ bool allDoc=TRUE; // no parameter => all parameters are documented
if ( // member has parameters
al!=0 && // but the member has a parameter list
al->count()>0 // with at least one parameter (that is not void)
// fall through
case DontInclude:
readTextFileByName(m_file,m_text);
+ g_includeFileName = m_file;
g_includeFileText = m_text;
g_includeFileOffset = 0;
g_includeFileLength = m_text.length();
void DocIncOperator::parse()
{
+ m_includeFileName = g_includeFileName;
const char *p = g_includeFileText;
uint l = g_includeFileLength;
uint o = g_includeFileOffset;
}
}
}
+ else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langworld="..."></see>
+ {
+ doctokenizerYYsetStatePara();
+ DocLink *lnk = new DocLink(this,cref);
+ m_children.append(lnk);
+ QCString leftOver = lnk->parse(FALSE,TRUE);
+ if (!leftOver.isEmpty())
+ {
+ m_children.append(new DocWord(this,leftOver));
+ }
+ }
else
{
- warn_doc_error(g_fileName,doctokenizerYYlineno,"Missing 'cref' attribute from <see> tag.");
+ warn_doc_error(g_fileName,doctokenizerYYlineno,"Missing 'cref' or 'langword' attribute from <see> tag.");
}
}
break;
void markLast(bool v=TRUE) { m_isLast = v; }
bool isExample() const { return m_isExample; }
QCString exampleFile() const { return m_exampleFile; }
+ QCString includeFileName() const { return m_includeFileName; }
void parse();
private:
bool m_isLast;
bool m_isExample;
QCString m_exampleFile;
+ QCString m_includeFileName;
};
/** Node representing an item of a cross-referenced list */
HTMLKEYL "strong"|"center"|"table"|"caption"|"small"|"code"|"dfn"|"var"|"img"|"pre"|"sub"|"sup"|"tr"|"td"|"th"|"ol"|"ul"|"li"|"tt"|"kbd"|"em"|"hr"|"dl"|"dt"|"dd"|"br"|"i"|"a"|"b"|"p"
HTMLKEYU "STRONG"|"CENTER"|"TABLE"|"CAPTION"|"SMALL"|"CODE"|"DFN"|"VAR"|"IMG"|"PRE"|"SUB"|"SUP"|"TR"|"TD"|"TH"|"OL"|"UL"|"LI"|"TT"|"KBD"|"EM"|"HR"|"DL"|"DT"|"DD"|"BR"|"I"|"A"|"B"|"P"
HTMLKEYW {HTMLKEYL}|{HTMLKEYU}
-REFWORD2 ("#"|"::")?((({ID}{TEMPLPART}?)|{ANONNS})("."|"#"|"::"|"-"|"/"))*({ID}{TEMPLPART}?(":")?){FUNCARG2}?
-REFWORD3 ({ID}":")*{ID}":"?
-REFWORD4 (({SCOPEPRE}*"operator"{OPMASKOP2})|(("::"|"#"){SCOPEPRE}*"operator"{OPMASKOP2})){CVSPEC}?
-REFWORD {LABELID}|{REFWORD2}|{REFWORD3}|{REFWORD4}
+REFWORD2_PRE ("#"|"::")?((({ID}{TEMPLPART}?)|{ANONNS})("."|"#"|"::"|"-"|"/"))*({ID}{TEMPLPART}?(":")?)
+REFWORD2 {REFWORD2_PRE}{FUNCARG2}?
+REFWORD2_NOCV {REFWORD2_PRE}("("{FUNCPART}")")?
+REFWORD3 ({ID}":")*{ID}":"?
+REFWORD4_NOCV (({SCOPEPRE}*"operator"{OPMASKOP2})|(("::"|"#"){SCOPEPRE}*"operator"{OPMASKOP2}))
+REFWORD4 {REFWORD4_NOCV}{CVSPEC}?
+REFWORD {LABELID}|{REFWORD2}|{REFWORD3}|{REFWORD4}
+REFWORD_NOCV {LABELID}|{REFWORD2_NOCV}|{REFWORD3}|{REFWORD4_NOCV}
%option noyywrap
%option yylineno
unput(*yytext);
return 0;
}
+<St_Ref>{REFWORD_NOCV}/{BLANK}("const")[a-z_A-Z0-9] { // see bug776988
+ g_token->name=yytext;
+ return TK_WORD;
+ }
+<St_Ref>{REFWORD_NOCV}/{BLANK}("volatile")[a-z_A-Z0-9] { // see bug776988
+ g_token->name=yytext;
+ return TK_WORD;
+ }
<St_Ref>{REFWORD} { // label to refer to
g_token->name=yytext;
return TK_WORD;
//bool isXLink=FALSE;
int len = 6;
int indexS = buf.find("href=\""), indexE;
+ bool setTarget = FALSE;
if (indexS>5 && buf.find("xlink:href=\"")!=-1) // XLink href (for SVG)
{
indexS-=6;
QCString url = link.mid(marker+1);
if (!ref.isEmpty())
{
- result = externalLinkTarget() + externalRef(relPath,ref,FALSE);
+ result = externalLinkTarget();
+ if (result != "") setTarget = TRUE;
+ result += externalRef(relPath,ref,FALSE);
}
result+= href+"=\"";
result+=externalRef(relPath,ref,TRUE);
result = href+"=\"" + link + "\"";
}
}
- if (!target.isEmpty())
+ if (!target.isEmpty() && !setTarget)
{
result+=" target=\""+target+"\"";
}
}
}
-DotGfxHierarchyTable::DotGfxHierarchyTable() : m_curNodeNumber(0)
+DotGfxHierarchyTable::DotGfxHierarchyTable() : m_curNodeNumber(1)
{
m_rootNodes = new QList<DotNode>;
m_usedNodes = new QDict<DotNode>(1009);
(rootNav->parent()->section()&Entry::COMPOUND_MASK) // in a class/struct member
)
{
- //printf("Found using declaration %s at line %d of %s inside section %x\n",
- // root->name.data(),root->startLine,root->fileName.data(),
- // root->parent->section);
+ //printf("Found using declaration %s inside section %x\n",
+ // rootNav->name().data(), rootNav->parent()->section());
QCString fullName=removeRedundantWhiteSpace(rootNav->parent()->name());
fullName=stripAnonymousNamespaceScope(fullName);
fullName=stripTemplateSpecifiersFromScope(fullName);
ClassDef *bcd = getResolvedClass(cd,0,scope); // todo: file in fileScope parameter
if (bcd)
{
- //printf("found class %s\n",bcd->name().data());
+ //printf("found class %s memName=%s\n",bcd->name().data(),memName.data());
MemberNameInfoSDict *mndict=bcd->memberNameInfoSDict();
if (mndict)
{
if (root->type!="friend class" &&
root->type!="friend struct" &&
root->type!="friend union" &&
+ root->type!="friend" &&
(!Config_getBool(TYPEDEF_HIDES_STRUCT) ||
root->type.find("typedef ")==-1)
)
// This is needed before resolving the inheritance relations, since
// it would otherwise not find the inheritance relation
// for C in the example below, as B::I was already found to be unresolvable
- // (which is correct if you igore the inheritance relation between A and B).
+ // (which is correct if you ignore the inheritance relation between A and B).
//
// class A { class I {} };
// class B : public A {};
}
newValue+=value.mid(p,value.length()-p);
*s=newValue;
+ p = 0;
+ newValue = "";
+ while ((in=value.find("^^",p))!=-1)
+ {
+ newValue+=value.mid(p,in-p);
+ newValue+="\n";
+ p=in+2;
+ }
+ newValue+=value.mid(p,value.length()-p);
+ *s=newValue;
//printf("Alias %s has value %s\n",adi.currentKey().data(),s->data());
}
}
g_s.end();
g_s.begin("Searching for members imported via using declarations...\n");
- findUsingDeclImports(rootNav);
// this should be after buildTypedefList in order to properly import
// used typedefs
findUsingDeclarations(rootNav);
g_s.begin("Searching for member function documentation...\n");
findObjCMethodDefinitions(rootNav);
findMemberDocumentation(rootNav); // may introduce new members !
+ findUsingDeclImports(rootNav); // may introduce new members !
transferRelatedFunctionDocumentation();
transferFunctionDocumentation();
/******************************************************************************
*
- * Parser for syntax hightlighting and references for Fortran90 F subset
+ * Parser for syntax highlighting and references for Fortran90 F subset
*
* Copyright (C) by Anke Visser
* based on the work of Dimitri van Heesch.
* For fixed formatted code position 6 is of importance (continuation character).
* The following variables and macros keep track of the column number
* YY_USER_ACTION is always called for each scan action
- * YY_FTN_REST is used to handle end of lines and reset the column counter
+ * YY_FTN_RESET is used to handle end of lines and reset the column counter
* YY_FTN_REJECT resets the column counters when a pattern is rejected and thus rescanned.
*/
int yy_old_start = 0;
static int g_inputPosition; //!< read offset during parsing
static int g_inputLines; //!< number of line in the code fragment
static int g_yyLineNr; //!< current line number
+static int g_contLineNr; //!< current, local, line number for continuation determination
+static int *g_hasContLine = NULL; //!< signals whether or not a line has a continuation line (fixed source form)
static bool g_needsTermination;
static Definition *g_searchCtx;
static bool g_collectXRefs;
static bool g_endComment;
-// simplified way to know if this is fixed form
-// duplicate in fortranscanner.l
-static bool recognizeFixedForm(const char* contents, FortranFormat format)
-{
- int column=0;
- bool skipLine=FALSE;
-
- if (format == FortranFormat_Fixed) return TRUE;
- if (format == FortranFormat_Free) return FALSE;
- for (int i=0;;i++)
- {
- column++;
-
- switch(contents[i])
- {
- case '\n':
- column=0;
- skipLine=FALSE;
- break;
- case ' ':
- break;
- case '#':
- skipLine=TRUE;
- break;
- case '\000':
- return FALSE;
- case 'C':
- case 'c':
- case '*':
- if(column==1) return TRUE;
- if(skipLine) break;
- return FALSE;
- case '!':
- if(column>1 && column<7) return FALSE;
- skipLine=TRUE;
- break;
- default:
- if(skipLine) break;
- if(column==7) return TRUE;
- return FALSE;
- }
- }
- return FALSE;
-}
-
static void endFontClass()
{
if (g_currentFontClass)
if (getFortranDefs(memberName, currentModule, md, usedict) && md->isLinkable())
{
- //if (md->isVariable()) return FALSE; // variables aren't handled yet
+ if (md->isVariable() && (md->getLanguage()!=SrcLangExt_Fortran)) return FALSE; // Non Fortran variables aren't handled yet,
+ // see also linkifyText in util.cpp
Definition *d = md->getOuterScope()==Doxygen::globalScope ?
md->getBodyDef() : md->getOuterScope();
yy_push_state(YY_START);
BEGIN(Use);
}
+<Use>"ONLY" { // TODO: rename
+ startFontClass("keywordtype");
+ codifyLines(yytext);
+ endFontClass();
+ yy_push_state(YY_START);
+ BEGIN(UseOnly);
+ }
<Use>{ID} {
QCString tmp = yytext;
tmp = tmp.lower();
useMembers->append(tmp, useEntry);
addUse(tmp);
}
-<Use>,{BS}"ONLY" { // TODO: rename
- startFontClass("keywordtype");
- codifyLines(yytext);
- endFontClass();
- yy_push_state(YY_START);
- BEGIN(UseOnly);
- }
-<UseOnly,Import>{BS},{BS} { codifyLines(yytext); }
-<UseOnly,Import>{BS}&{BS}"\n" { codifyLines(yytext); YY_FTN_RESET}
+<Use,UseOnly,Import>{BS},{BS} { codifyLines(yytext); }
+<UseOnly,Import>{BS}&{BS}"\n" { codifyLines(yytext);
+ g_contLineNr++;
+ YY_FTN_RESET}
<UseOnly>{ID} {
QCString tmp = yytext;
tmp = tmp.lower();
}
/*-------- fortran module -----------------------------------------*/
<Start>("block"{BS}"data"|"program"|"module"|"interface")/{BS_}|({COMMA}{ACCESS_SPEC})|\n { //
- startScope();
+ startScope();
startFontClass("keyword");
codifyLines(yytext);
endFontClass();
codifyLines(yytext);
}
<Subprog,Subprogend>"\n" { codifyLines(yytext);
+ g_contLineNr++;
yy_pop_state();
YY_FTN_RESET
}
endFontClass();
}
<Declaration>{ID} { // local var
- if (g_currentMemberDef && g_currentMemberDef->isFunction() && bracketCount==0)
+ if (g_isFixedForm && yy_my_start == 1)
{
- g_code->codify(yytext);
- addLocalVar(yytext);
+ startFontClass("comment");
+ g_code->codify(yytext);
+ endFontClass();
}
- else
+ else if (g_currentMemberDef && ((g_currentMemberDef->isFunction() && (g_currentMemberDef->typeString() != QCString("subroutine"))) ||
+ g_currentMemberDef->isVariable()))
{
generateLink(*g_code, yytext);
}
+ else
+ {
+ g_code->codify(yytext);
+ addLocalVar(yytext);
+ }
}
<Declaration>{BS}("=>"|"="){BS} { // Procedure binding
BEGIN(DeclarationBinding);
g_code->codify(yytext);
}
-<Declaration,DeclarationBinding>"&" { // continuation line
+<Declaration,DeclarationBinding>"&" { // continuation line
g_code->codify(yytext);
- yy_push_state(YY_START);
- BEGIN(DeclContLine);
+ if (!g_isFixedForm)
+ {
+ yy_push_state(YY_START);
+ BEGIN(DeclContLine);
+ }
}
<DeclContLine>"\n" { // declaration not yet finished
+ g_contLineNr++;
codifyLines(yytext);
bracketCount = 0;
yy_pop_state();
YY_FTN_RESET
}
-<Declaration,DeclarationBinding>"\n" { // end declaration line
+<Declaration,DeclarationBinding>"\n" { // end declaration line (?)
if (g_endComment)
- {
- g_endComment=FALSE;
- }
- else
- {
- codifyLines(yytext);
- }
+ {
+ g_endComment=FALSE;
+ }
+ else
+ {
+ codifyLines(yytext);
+ }
bracketCount = 0;
- yy_pop_state();
+ g_contLineNr++;
+ if (!(g_hasContLine && g_hasContLine[g_contLineNr - 1]))
+ {
+ yy_pop_state();
+ }
YY_FTN_RESET
}
<Start,Declaration,DeclarationBinding>\n?{BS}"!>"|"!<" { // start comment line or comment block
if (yytext[0] == '\n')
{
+ g_contLineNr++;
yy_old_start = 0;
yy_my_start = 1;
yy_end = yyleng;
docBlock+=yytext;
}
<DocBlock>"\n"{BS}("!>"|"!<"|"!!") { // comment block (next line is also comment line)
+ g_contLineNr++;
yy_old_start = 0;
yy_my_start = 1;
yy_end = yyleng;
}
<DocBlock>"\n" { // comment block ends at the end of this line
// remove special comment (default config)
+ g_contLineNr++;
if (Config_getBool(STRIP_CODE_COMMENTS))
{
g_yyLineNr+=((QCString)docBlock).contains('\n');
endFontClass();
}
unput(*yytext);
+ g_contLineNr--;
yy_pop_state();
YY_FTN_RESET
}
/*------ preprocessor --------------------------------------------*/
<Start>"#".*\n {
if (g_isFixedForm && yy_my_start == 6) YY_FTN_REJECT;
+ g_contLineNr++;
startFontClass("preprocessor");
codifyLines(yytext);
endFontClass();
<*>"\\\""|\\\' { str+=yytext; /* ignore \" */}
<String>\n { // string with \n inside
+ g_contLineNr++;
str+=yytext;
startFontClass("stringliteral");
codifyLines(str);
{
codifyLines(yytext);
}
+ g_contLineNr++;
YY_FTN_RESET
}
<*>^{BS}"type"{BS}"=" { g_code->codify(yytext); }
void resetFortranCodeParserState() {}
+bool recognizeFixedForm(const char* contents, FortranFormat format); /* prototype, implementation in fortranscanner.l */
+const char* prepassFixedForm(const char* contents, int *hasContLine); /* prototype, implementation in fortranscanner.l */
+static void checkContLines(const char *s)
+{
+ int numLines = 0;
+ int curLine = 0;
+ int i = 0;
+ const char *p = s;
+
+ numLines = 2; // one for element 0, one in case no \n at end
+ while (*p)
+ {
+ if (*p == '\n') numLines++;
+ p++;
+ }
+
+ g_hasContLine = (int *) malloc((numLines) * sizeof(int));
+ for (i = 0; i < numLines; i++)
+ g_hasContLine[i] = 0;
+ p = prepassFixedForm(s, g_hasContLine);
+ g_hasContLine[0] = 0;
+}
+
void parseFortranCode(CodeOutputInterface &od,const char *className,const QCString &s,
bool exBlock, const char *exName,FileDef *fd,
int startLine,int endLine,bool inlineFragment,
g_inputString = s;
g_inputPosition = 0;
g_isFixedForm = recognizeFixedForm((const char*)s,format);
+ g_contLineNr = 1;
+ g_hasContLine = NULL;
+ if (g_isFixedForm)
+ {
+ checkContLines(g_inputString);
+ }
g_currentFontClass = 0;
g_needsTermination = FALSE;
g_searchCtx = searchCtx;
else
g_inputLines = g_yyLineNr + countLines() - 1;
-
g_exampleBlock = exBlock;
g_exampleName = exName;
g_sourceFileDef = fd;
delete g_sourceFileDef;
g_sourceFileDef=0;
}
+ if (g_hasContLine) free(g_hasContLine);
+ g_hasContLine = NULL;
printlex(yy_flex_debug, FALSE, __FILE__, fd ? fd->fileName().data(): NULL);
return;
}
bool nopass;
bool pass;
bool contiguous;
- bool volat; /* volatile is a reserverd name */
- bool value; /* volatile is a reserverd name */
+ bool volat; /* volatile is a reserved name */
+ bool value; /* volatile is a reserved name */
QCString passVar;
SymbolModifiers() : type(), returnName(), protection(NONE_P), direction(NONE_D),
// simplified way to know if this is fixed form
// duplicate in fortrancode.l
-static bool recognizeFixedForm(const char* contents, FortranFormat format)
+bool recognizeFixedForm(const char* contents, FortranFormat format)
{
int column=0;
bool skipLine=FALSE;
}
/* change comments and bring line continuation character to previous line */
-static const char* prepassFixedForm(const char* contents)
+/* also used to set continuation marks in case of fortran code usage, done here as it is quite complicated code */
+const char* prepassFixedForm(const char* contents, int *hasContLine)
{
int column=0;
int prevLineLength=0;
bool fullCommentLine=TRUE;
int newContentsSize = strlen(contents)+3; // \000, \n (when necessary) and one spare character (to avoid reallocation)
char* newContents = (char*)malloc(newContentsSize);
+ int curLine = 1;
for(int i=0, j=0;;i++,j++) {
if(j>=newContentsSize-3) { // check for spare characters, which may be eventually used below (by & and '! ')
else
{
prevLineLength+=column;
+ /* Even though a full comment line is not really a comment line it can be seen as one. An empty line is also seen as a comment line (small bonus) */
+ if (hasContLine)
+ {
+ hasContLine[curLine - 1] = 1;
+ }
}
fullCommentLine=TRUE;
column=0;
commented=FALSE;
newContents[j]=c;
prevQuote = thisQuote;
+ curLine++;
break;
case ' ':
case '\t':
newContents[j]=c;
break;
case '\000':
+ if (hasContLine)
+ {
+ free(newContents);
+ return NULL;
+ }
newContents[j]='\000';
newContentsSize = strlen(newContents);
if (newContents[newContentsSize - 1] != '\n')
newContents[j]=' ';
if(prevLineAmpOrExclIndex==-1) { // add & just before end of previous line
- insertCharacter(newContents, j+1, (j+1)-6-1, '&');
+ /* first line is not a continuation line in code, just in snippets etc. */
+ if (curLine != 1) insertCharacter(newContents, j+1, (j+1)-6-1, '&');
j++;
} else { // add & just before end of previous line comment
- insertCharacter(newContents, j+1, (j+1)-6-prevLineLength+prevLineAmpOrExclIndex, '&');
+ /* first line is not a continuation line in code, just in snippets etc. */
+ if (curLine != 1) insertCharacter(newContents, j+1, (j+1)-6-prevLineLength+prevLineAmpOrExclIndex, '&');
j++;
}
+ if (hasContLine) hasContLine[curLine - 1] = 1;
} else {
newContents[j]=c; // , just handle like space
}
}
}
+ if (hasContLine)
+ {
+ free(newContents);
+ return NULL;
+ }
newContentsSize = strlen(newContents);
if (newContents[newContentsSize - 1] != '\n')
{
return *this;
}
-/*! Extracts and adds passed modifier to these modifiers.*/
+/*! Extracts and adds passed modifier to these modifiers.*/
SymbolModifiers& SymbolModifiers::operator|=(QCString mdfString)
{
mdfString = mdfString.lower();
// strip direction
loc_doc = loc_doc.right(loc_doc.length()-strlen(directionParam[SymbolModifiers::IN]));
loc_doc.stripWhiteSpace();
- // in case of emty documentation or (now) just name, consider it as no documemntation
+ // in case of empty documentation or (now) just name, consider it as no documemntation
if (loc_doc.isEmpty() || (loc_doc.lower() == argName.lower()))
{
// reset current back to the part inside the routine
//printf("Input fixed form string:\n%s\n", fileBuf);
//printf("===========================\n");
- inputString = prepassFixedForm(fileBuf);
+ inputString = prepassFixedForm(fileBuf, NULL);
//printf("Resulting free form string:\n%s\n", inputString);
//printf("===========================\n");
* 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
+ * 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.
*
//----------------------------------------------------------------------------
-/*! Constructs an ftv help object.
- * The object has to be \link initialize() initialized\endlink before it can
+/*! Constructs an ftv help object.
+ * The object has to be \link initialize() initialized\endlink before it can
* be used.
*/
-FTVHelp::FTVHelp(bool TLI)
+FTVHelp::FTVHelp(bool TLI)
{
/* initial depth */
m_indentNodes = new QList<FTVNode>[MAX_INDENT];
generateTreeView();
}
-/*! Increase the level of the contents hierarchy.
+/*! Increase the level of the contents hierarchy.
* This will start a new sublist in contents file.
* \sa decContentsDepth()
*/
QList<FTVNode> *pnl = &m_indentNodes[m_indent-1];
newNode->parent = pnl->getLast();
}
-
+
}
static QCString node2URL(FTVNode *n,bool overruleFile=FALSE,bool srcLink=FALSE)
while (p) { indent++; p=p->parent; }
if (n->isDir)
{
- QCString dir = opened ? "▼" : "►";
+ QCString dir = opened ? "▼" : "▶";
t << "<span style=\"width:" << (indent*16) << "px;display:inline-block;\"> </span>"
<< "<span id=\"arr_" << generateIndentLabel(n,0) << "\" class=\"arrow\" ";
t << "onclick=\"toggleFolder('" << generateIndentLabel(n,0) << "')\"";
{
//printf("FTVHelp::generateLink(ref=%s,file=%s,anchor=%s\n",
// n->ref.data(),n->file.data(),n->anchor.data());
+ bool setTarget = FALSE;
if (n->file.isEmpty()) // no link
{
t << "<b>" << convertToHtml(n->name) << "</b>";
if (!n->ref.isEmpty()) // link to entity imported via tag file
{
t << "<a class=\"elRef\" ";
- t << externalLinkTarget() << externalRef("",n->ref,FALSE);
+ QCString result = externalLinkTarget();
+ if (result != "") setTarget = TRUE;
+ t << result << externalRef("",n->ref,FALSE);
}
else // local link
{
t << "href=\"";
t << externalRef("",n->ref,TRUE);
t << node2URL(n);
- if (m_topLevelIndex)
- t << "\" target=\"basefrm\">";
- else
- t << "\" target=\"_self\">";
+ if (!setTarget)
+ {
+ if (m_topLevelIndex)
+ t << "\" target=\"basefrm\">";
+ else
+ t << "\" target=\"_self\">";
+ }
t << convertToHtml(n->name);
t << "</a>";
if (!n->ref.isEmpty())
if (srcRef)
{
t << "<a href=\"" << srcRef->getSourceFileBase()
- << Doxygen::htmlFileExtension
+ << Doxygen::htmlFileExtension
<< "\">";
}
if (n->def && n->def->definitionType()==Definition::TypeGroup)
return substitute(varId,"-","_");
}
-static bool generateJSTree(NavIndexEntryList &navIndex,FTextStream &t,
+static bool generateJSTree(NavIndexEntryList &navIndex,FTextStream &t,
const QList<FTVNode> &nl,int level,bool &first)
{
static QCString htmlOutput = Config_getString(HTML_OUTPUT);
{
fileId+="_"+n->anchor;
}
- if (dupOfParent(n))
+ if (dupOfParent(n))
{
fileId+="_dup";
}
FTextStream tt(&f);
tt << "var " << convertFileId2Var(fileId) << " =" << endl;
generateJSTree(navIndex,tt,n->children,1,firstChild);
- tt << endl << "];";
+ tt << endl << "];";
}
t << "\"" << fileId << "\" ]";
}
if (emptySection)
t << "null ]";
else
- t << endl << indentStr << " ] ]";
+ t << endl << indentStr << " ] ]";
}
}
return found;
//tidx << "var NAVTREEINDEX =" << endl;
//tidx << "{" << endl;
FTextStream t(&f);
+ t << "/*\n@ @licstart The following is the entire license notice for the\n"
+ "JavaScript code in this file.\n\nCopyright (C) 1997-2017 by Dimitri van Heesch\n\n"
+ "This program is free software; you can redistribute it and/or modify\n"
+ "it under the terms of the GNU General Public License as published by\n"
+ "the Free Software Foundation; either version 2 of the License, or\n"
+ "(at your option) any later version.\n\n"
+ "This program is distributed in the hope that it will be useful,\n"
+ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+ " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
+ " GNU General Public License for more details.\n\n"
+ "You should have received a copy of the GNU General Public License along\n"
+ "with this program; if not, write to the Free Software Foundation, Inc.,\n"
+ "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n\n"
+ "@licend The above is the entire license notice\n"
+ "for the JavaScript code in this file\n"
+ "*/\n";
t << "var NAVTREE =" << endl;
t << "[" << endl;
t << " [ ";
bool first=TRUE;
generateJSTree(navIndex,t,nodeList,1,first);
- if (first)
+ if (first)
t << "]" << endl;
- else
+ else
t << endl << " ] ]" << endl;
t << "];" << endl << endl;
++li;
if (li.current() && elemCount<maxElemCount-1) tsidx << ","; // not last entry
tsidx << endl;
-
+
elemCount++;
if (li.current() && elemCount>=maxElemCount) // switch to new sub-index
{
tsidx << "};" << endl;
t << endl << "];" << endl;
}
- t << endl << "var SYNCONMSG = '" << theTranslator->trPanelSynchronisationTooltip(FALSE) << "';";
- t << endl << "var SYNCOFFMSG = '" << theTranslator->trPanelSynchronisationTooltip(TRUE) << "';";
+ t << endl << "var SYNCONMSG = '" << theTranslator->trPanelSynchronisationTooltip(FALSE) << "';";
+ t << endl << "var SYNCOFFMSG = '" << theTranslator->trPanelSynchronisationTooltip(TRUE) << "';";
}
ResourceMgr::instance().copyResource("navtree.js",htmlOutput);
}
if (depth>1)
{
t << "<div class=\"levels\">[";
- t << theTranslator->trDetailLevel();
+ t << theTranslator->trDetailLevel();
t << " ";
int i;
for (i=1;i<=depth;i++)
generateTreeViewImages();
generateTreeViewScripts();
}
-
//! @brief Structure defining all HTML4 entities, doxygen extensions and doxygen commands representing special symbols.
//! @details In case an entity does not exist a NULL is given for the entity. The first column contains the symbolic code
-//! for the entity, see also doxparser.h The second column contains the name of the enitity (without the starting \& and
+//! for the entity, see also doxparser.h The second column contains the name of the entity (without the starting \& and
//! ending ;)
static struct htmlEntityInfo
{
/******************************************************************************
*
- *
+ *
*
* 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
+ * 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.
*
t << " onmouseover=\"return searchBox.OnSearchSelectShow()\"\n";
t << " onmouseout=\"return searchBox.OnSearchSelectHide()\"\n";
t << " alt=\"\"/>\n";
- t << " <input type=\"text\" id=\"MSearchField\" value=\""
+ t << " <input type=\"text\" id=\"MSearchField\" value=\""
<< theTranslator->trSearch() << "\" accesskey=\"S\"\n";
t << " onfocus=\"searchBox.OnSearchFieldFocus(true)\" \n";
t << " onblur=\"searchBox.OnSearchFieldFocus(false)\" \n";
{
const char *e = p;
while (*e==' ' || *e=='\t') e++;
- if (*e=='\n')
+ if (*e=='\n')
{
p=e;
}
}
}
- if (timeStamp)
+ if (timeStamp)
{
generatedBy = theTranslator->trGeneratedAt(dateToString(TRUE), convertToHtml(Config_getString(PROJECT_NAME)));
}
- else
+ else
{
generatedBy = theTranslator->trGeneratedBy();
}
if (treeView)
{
treeViewCssJs = "<link href=\"$relpath^navtree.css\" rel=\"stylesheet\" type=\"text/css\"/>\n"
- "<script type=\"text/javascript\" src=\"$relpath^resize.js\"></script>\n"
- "<script type=\"text/javascript\" src=\"$relpath^navtreedata.js\"></script>\n"
- "<script type=\"text/javascript\" src=\"$relpath^navtree.js\"></script>\n"
- "<script type=\"text/javascript\">\n"
- " $(document).ready(initResizable);\n"
- "</script>";
+ "<script type=\"text/javascript\" src=\"$relpath^resize.js\"></script>\n"
+ "<script type=\"text/javascript\" src=\"$relpath^navtreedata.js\"></script>\n"
+ "<script type=\"text/javascript\" src=\"$relpath^navtree.js\"></script>\n"
+ "<script type=\"text/javascript\">\n"
+ "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n"
+ " $(document).ready(initResizable);\n"
+ "/* @license-end */"
+ "</script>";
}
if (searchEngine)
if (!serverBasedSearch)
{
- if (disableIndex)
+ if (disableIndex || !Config_getBool(HTML_DYNAMIC_MENUS))
{
searchCssJs += "<script type=\"text/javascript\">\n"
- " $(document).ready(function() { init_search(); });\n"
- "</script>";
+ "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n"
+ " $(document).ready(function() { init_search(); });\n"
+ "/* @license-end */\n"
+ "</script>";
}
}
else
{
- if (disableIndex)
+ if (disableIndex || !Config_getBool(HTML_DYNAMIC_MENUS))
{
searchCssJs += "<script type=\"text/javascript\">\n"
- " $(document).ready(function() {\n"
- " if ($('.searchresults').length > 0) { searchBox.DOMSearchField().focus(); }\n"
- " });\n"
- "</script>\n";
+ "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n"
+ " $(document).ready(function() {\n"
+ " if ($('.searchresults').length > 0) { searchBox.DOMSearchField().focus(); }\n"
+ " });\n"
+ " /* @license-end */\n"
+ "</script>\n";
}
// OPENSEARCH_PROVIDER {
searchCssJs += "<link rel=\"search\" href=\"" + relPath +
"search_opensearch.php?v=opensearch.xml\" "
"type=\"application/opensearchdescription+xml\" title=\"" +
- (hasProjectName ? projectName : QCString("Doxygen")) +
+ (hasProjectName ? projectName : QCString("Doxygen")) +
"\"/>";
// OPENSEARCH_PROVIDER }
}
if (mathJax)
{
- QCString path = Config_getString(MATHJAX_RELPATH);
- if (path.isEmpty() || path.left(2)=="..") // relative path
- {
- path.prepend(relPath);
- }
+ QCString path = Config_getString(MATHJAX_RELPATH);
+ if (path.isEmpty() || path.left(2)=="..") // relative path
+ {
+ path.prepend(relPath);
+ }
mathJaxJs = "<script type=\"text/x-mathjax-config\">\n"
" MathJax.Hub.Config({\n"
" extensions: [\"tex2jax.js\"";
mathJaxJs += "\n";
}
mathJaxJs += "</script>";
- mathJaxJs += "<script type=\"text/javascript\" src=\"" + path + "MathJax.js\"></script>\n";
+ mathJaxJs += "<script type=\"text/javascript\" async src=\"" + path + "MathJax.js\"></script>\n";
}
// first substitute generic keywords
result = substitute(result,"$extrastylesheet",extraCssText);
result = substitute(result,"$relpath$",relPath); //<-- obsolete: for backwards compatibility only
result = substitute(result,"$relpath^",relPath); //<-- must be last
-
+
// additional HTML only conditional blocks
result = selectBlock(result,"DISABLE_INDEX",disableIndex);
result = selectBlock(result,"GENERATE_TREEVIEW",treeView);
{
}
-HtmlCodeGenerator::HtmlCodeGenerator(FTextStream &t,const QCString &relPath)
+HtmlCodeGenerator::HtmlCodeGenerator(FTextStream &t,const QCString &relPath)
: m_col(0), m_relPath(relPath)
{
setTextStream(t);
{
static int tabSize = Config_getInt(TAB_SIZE);
if (str && m_streamSet)
- {
+ {
const char *p=str;
char c;
int spacesToNextTabStop;
c=*p++;
switch(c)
{
- case '\t': spacesToNextTabStop =
- tabSize - (m_col%tabSize);
- m_t << Doxygen::spaces.left(spacesToNextTabStop);
- m_col+=spacesToNextTabStop;
- break;
- case '\n': m_t << "\n"; m_col=0;
+ case '\t': spacesToNextTabStop =
+ tabSize - (m_col%tabSize);
+ m_t << Doxygen::spaces.left(spacesToNextTabStop);
+ m_col+=spacesToNextTabStop;
+ break;
+ case '\n': m_t << "\n"; m_col=0;
break;
case '\r': break;
- case '<': m_t << "<"; m_col++;
+ case '<': m_t << "<"; m_col++;
break;
- case '>': m_t << ">"; m_col++;
+ case '>': m_t << ">"; m_col++;
break;
- case '&': m_t << "&"; m_col++;
+ case '&': m_t << "&"; m_col++;
break;
case '\'': m_t << "'"; m_col++; // ' is not valid XHTML
break;
m_t << "\\";
m_col++;
break;
- default: p=writeUtf8Char(m_t,p-1);
- m_col++;
+ default: p=writeUtf8Char(m_t,p-1);
+ m_col++;
break;
}
}
else
m_t << "\\";
break;
- default: m_t << c;
+ default: m_t << c;
}
}
}
qsnprintf(lineAnchor,maxLineNrStr,"l%05d",l);
m_t << "<div class=\"line\">";
- m_t << "<a name=\"" << lineAnchor << "\"></a><span class=\"lineno\">";
+ m_t << "<a name=\"" << lineAnchor << "\"></a><span class=\"lineno\">";
if (filename)
{
_writeCodeLink("line",ref,filename,anchor,lineNumber,0);
{
codify(lineNumber);
}
- m_t << "</span>";
+ m_t << "</span>";
m_t << " ";
}
const char *anchor, const char *name,
const char *tooltip)
{
- if (ref)
+ if (ref)
{
m_t << "<a class=\"" << className << "Ref\" ";
m_t << externalLinkTarget() << externalRef(m_relPath,ref,FALSE);
}
-void HtmlCodeGenerator::startCodeLine(bool hasLineNumbers)
-{
+void HtmlCodeGenerator::startCodeLine(bool hasLineNumbers)
+{
if (m_streamSet)
{
if (!hasLineNumbers) m_t << "<div class=\"line\">";
- m_col=0;
+ m_col=0;
}
}
-void HtmlCodeGenerator::endCodeLine()
-{
+void HtmlCodeGenerator::endCodeLine()
+{
if (m_streamSet) m_t << "</div>";
}
-void HtmlCodeGenerator::startFontClass(const char *s)
-{
- if (m_streamSet) m_t << "<span class=\"" << s << "\">";
+void HtmlCodeGenerator::startFontClass(const char *s)
+{
+ if (m_streamSet) m_t << "<span class=\"" << s << "\">";
}
-void HtmlCodeGenerator::endFontClass()
-{
- if (m_streamSet) m_t << "</span>";
+void HtmlCodeGenerator::endFontClass()
+{
+ if (m_streamSet) m_t << "</span>";
}
-void HtmlCodeGenerator::writeCodeAnchor(const char *anchor)
-{
- if (m_streamSet) m_t << "<a name=\"" << anchor << "\"></a>";
+void HtmlCodeGenerator::writeCodeAnchor(const char *anchor)
+{
+ if (m_streamSet) m_t << "<a name=\"" << anchor << "\"></a>";
}
//--------------------------------------------------------------------------
exit(1);
}
//writeLogo(dname);
- if (!Config_getString(HTML_HEADER).isEmpty())
+ if (!Config_getString(HTML_HEADER).isEmpty())
{
g_header=fileToString(Config_getString(HTML_HEADER));
//printf("g_header='%s'\n",g_header.data());
}
- else
+ else
{
g_header = ResourceMgr::instance().getAsString("header.html");
}
- if (!Config_getString(HTML_FOOTER).isEmpty())
+ if (!Config_getString(HTML_FOOTER).isEmpty())
{
g_footer=fileToString(Config_getString(HTML_FOOTER));
//printf("g_footer='%s'\n",g_footer.data());
}
- else
+ else
{
g_footer = ResourceMgr::instance().getAsString("footer.html");
}
if (Config_getBool(USE_MATHJAX))
{
- if (!Config_getString(MATHJAX_CODEFILE).isEmpty())
+ if (!Config_getString(MATHJAX_CODEFILE).isEmpty())
{
g_mathjax_code=fileToString(Config_getString(MATHJAX_CODEFILE));
//printf("g_mathjax_code='%s'\n",g_mathjax_code.data());
createSubDirs(d);
ResourceMgr &mgr = ResourceMgr::instance();
- mgr.copyResource("tabs.css",dname);
+ if (Config_getBool(HTML_DYNAMIC_MENUS))
+ {
+ mgr.copyResourceAs("tabs.css",dname,"tabs.css");
+ }
+ else // stylesheet for the 'old' static tabs
+ {
+ mgr.copyResourceAs("fixed_tabs.css",dname,"tabs.css");
+ }
mgr.copyResource("jquery.js",dname);
if (Config_getBool(INTERACTIVE_SVG))
{
mgr.copyResource("svgpan.js",dname);
}
- if (!Config_getBool(DISABLE_INDEX))
+ if (!Config_getBool(DISABLE_INDEX) && Config_getBool(HTML_DYNAMIC_MENUS))
{
mgr.copyResource("menu.js",dname);
}
{
searchCss = mgr.getAsString("search_nomenu.css");
}
+ else if (!Config_getBool(HTML_DYNAMIC_MENUS))
+ {
+ searchCss = mgr.getAsString("search_fixedtabs.css");
+ }
else
{
searchCss = mgr.getAsString("search.css");
lastTitle=title;
relPath = relativePathToRoot(fileName);
- if (fileName.right(Doxygen::htmlFileExtension.length())!=Doxygen::htmlFileExtension)
+ if (fileName.right(Doxygen::htmlFileExtension.length())!=Doxygen::htmlFileExtension)
{
fileName+=Doxygen::htmlFileExtension;
}
m_codeGen.setTextStream(t);
m_codeGen.setRelativePath(relPath);
Doxygen::indexList->addIndexFile(fileName);
-
+
lastFile = fileName;
t << substituteHtmlKeywords(g_header,convertToHtml(filterTitle(title)),relPath);
- t << "<!-- " << theTranslator->trGeneratedBy() << " Doxygen "
+ t << "<!-- " << theTranslator->trGeneratedBy() << " Doxygen "
<< versionString << " -->" << endl;
//static bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
static bool searchEngine = Config_getBool(SEARCHENGINE);
if (searchEngine /*&& !generateTreeView*/)
{
t << "<script type=\"text/javascript\">\n";
- t << "var searchBox = new SearchBox(\"searchBox\", \""
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
+ t << "var searchBox = new SearchBox(\"searchBox\", \""
<< relPath<< "search\",false,'" << theTranslator->trSearch() << "');\n";
+ t << "/* @license-end */\n";
t << "</script>\n";
}
//generateDynamicSections(t,relPath);
if (Config_getString(HTML_STYLESHEET).isEmpty()) // write default style sheet
{
//printf("write doxygen.css\n");
- startPlainFile("doxygen.css");
-
+ startPlainFile("doxygen.css");
+
// alternative, cooler looking titles
//t << "H1 { text-align: center; border-width: thin none thin none;" << endl;
//t << " border-style : double; border-color : blue; padding-left : 1em; padding-right : 1em }" << endl;
//printf("HtmlGenerator::startIndexItem(%s,%s)\n",ref,f);
if (ref || f)
{
- if (ref)
+ if (ref)
{
t << "<a class=\"elRef\" ";
t << externalLinkTarget() << externalRef(relPath,ref,FALSE);
void HtmlGenerator::writeObjectLink(const char *ref,const char *f,
const char *anchor, const char *name)
{
- if (ref)
+ if (ref)
{
t << "<a class=\"elRef\" ";
t << externalLinkTarget() << externalRef(relPath,ref,FALSE);
t << "<a href=\"";
if (f) t << relPath << f << Doxygen::htmlFileExtension;
if (anchor) t << "#" << anchor;
- t << "\">";
+ t << "\">";
}
void HtmlGenerator::endTextLink()
if (generateTreeView) t << "target=\"top\" ";
t << "href=\"";
if (url) t << url;
- t << "\">";
+ t << "\">";
}
void HtmlGenerator::endHtmlLink()
else
t << "\\";
break;
- default: t << c;
+ default: t << c;
}
}
}
"onclick=\"return toggleVisibility(this)\" "
"class=\"dynheader closed\" "
"style=\"cursor:pointer;\">" << endl;
- t << " <img id=\"dynsection-" << sectionCount << "-trigger\" src=\""
+ t << " <img id=\"dynsection-" << sectionCount << "-trigger\" src=\""
<< relPath << "closed.png\" alt=\"+\"/> ";
}
else
}
-void HtmlGenerator::startMemberList()
-{
+void HtmlGenerator::startMemberList()
+{
DBG_HTML(t << "<!-- startMemberList -->" << endl)
}
-void HtmlGenerator::endMemberList()
-{
+void HtmlGenerator::endMemberList()
+{
DBG_HTML(t << "<!-- endMemberList -->" << endl)
}
// 0 = single column right aligned
// 1 = double column left aligned
// 2 = single column left aligned
-void HtmlGenerator::startMemberItem(const char *anchor,int annoType,const char *inheritId)
-{
+void HtmlGenerator::startMemberItem(const char *anchor,int annoType,const char *inheritId)
+{
DBG_HTML(t << "<!-- startMemberItem() -->" << endl)
if (m_emptySection)
{
}
}
-void HtmlGenerator::endMemberItem()
-{
- t << "</td></tr>";
- t << endl;
+void HtmlGenerator::endMemberItem()
+{
+ t << "</td></tr>";
+ t << endl;
}
void HtmlGenerator::startMemberTemplateParams()
}
-void HtmlGenerator::insertMemberAlign(bool templ)
-{
+void HtmlGenerator::insertMemberAlign(bool templ)
+{
DBG_HTML(t << "<!-- insertMemberAlign -->" << endl)
QCString className = templ ? "memTemplItemRight" : "memItemRight";
- t << " </td><td class=\"" << className << "\" valign=\"bottom\">";
+ t << " </td><td class=\"" << className << "\" valign=\"bottom\">";
}
-void HtmlGenerator::startMemberDescription(const char *anchor,const char *inheritId)
-{
+void HtmlGenerator::startMemberDescription(const char *anchor,const char *inheritId)
+{
DBG_HTML(t << "<!-- startMemberDescription -->" << endl)
if (m_emptySection)
{
{
t << " inherit " << inheritId;
}
- t << "\"><td class=\"mdescLeft\"> </td><td class=\"mdescRight\">";
+ t << "\"><td class=\"mdescLeft\"> </td><td class=\"mdescRight\">";
}
-void HtmlGenerator::endMemberDescription()
-{
+void HtmlGenerator::endMemberDescription()
+{
DBG_HTML(t << "<!-- endMemberDescription -->" << endl)
- t << "<br /></td></tr>" << endl;
+ t << "<br /></td></tr>" << endl;
}
void HtmlGenerator::startMemberSections()
{
DBG_HTML(t << "<!-- startMemberSections -->" << endl)
m_emptySection=TRUE; // we postpone writing <table> until we actually
- // write a row to prevent empty tables, which
+ // write a row to prevent empty tables, which
// are not valid XHTML!
}
t << "</td></tr>" << endl;
}
-void HtmlGenerator::startIndexList()
-{
- t << "<table>" << endl;
+void HtmlGenerator::startIndexList()
+{
+ t << "<table>" << endl;
}
void HtmlGenerator::endIndexList()
t << "</table>" << endl;
}
-void HtmlGenerator::startIndexKey()
-{
+void HtmlGenerator::startIndexKey()
+{
// inserted 'class = ...', 02 jan 2002, jh
- t << " <tr><td class=\"indexkey\">";
+ t << " <tr><td class=\"indexkey\">";
}
void HtmlGenerator::endIndexKey()
t << "</td>";
}
-void HtmlGenerator::startIndexValue(bool)
-{
+void HtmlGenerator::startIndexValue(bool)
+{
// inserted 'class = ...', 02 jan 2002, jh
- t << "<td class=\"indexvalue\">";
+ t << "<td class=\"indexvalue\">";
}
void HtmlGenerator::endIndexValue(const char *,bool)
}
void HtmlGenerator::startMemberDoc( const char *clName, const char *memName,
- const char *anchor, const char *title,
+ const char *anchor, const char *title,
int memCount, int memTotal, bool showInline)
{
DBG_HTML(t << "<!-- startMemberDoc -->" << endl;)
t << "\n<h2 class=\"memtitle\">"
- << "<span class=\"permalink\"><a href=\"#" << anchor << "\">◆ </a></span>"
- << title;
+ << "<span class=\"permalink\"><a href=\"#" << anchor << "\">◆ </a></span>";
+ docify(title);
if (memTotal>1)
{
t << " <span class=\"overload\">[" << memCount << "/" << memTotal <<"]</span>";
DBG_HTML(t << "<!-- startMemberDocName -->" << endl;)
t << " <table class=\"memname\">" << endl;
-
+
t << " <tr>" << endl;
t << " <td class=\"memname\">";
}
t << "</td><td></td><td colspan=\"2\">";
}
-void HtmlGenerator::endMemberDoc(bool hasArgs)
-{
+void HtmlGenerator::endMemberDoc(bool hasArgs)
+{
DBG_HTML(t << "<!-- endMemberDoc -->" << endl;)
if (!hasArgs)
{
{
}
-void HtmlGenerator::startIndent()
-{
+void HtmlGenerator::startIndent()
+{
DBG_HTML(t << "<!-- startIndent -->" << endl;)
t << "<div class=\"memdoc\">\n";
}
-void HtmlGenerator::endIndent()
-{
+void HtmlGenerator::endIndent()
+{
DBG_HTML(t << "<!-- endIndent -->" << endl;)
- t << endl << "</div>" << endl << "</div>" << endl;
+ t << endl << "</div>" << endl << "</div>" << endl;
}
void HtmlGenerator::addIndexItem(const char *,const char *)
void HtmlGenerator::endSimpleSect()
{
- t << "</dl>";
+ t << "</dl>";
}
void HtmlGenerator::startParamList(ParamListTypes,
void HtmlGenerator::endParamList()
{
- t << "</dl>";
+ t << "</dl>";
}
void HtmlGenerator::writeDoc(DocNode *n,Definition *ctx,MemberDef *)
{
HtmlDocVisitor *visitor = new HtmlDocVisitor(t,m_codeGen,ctx);
n->accept(visitor);
- delete visitor;
+ delete visitor;
}
//---------------- helpers for index generation -----------------------------
static void startQuickIndexList(FTextStream &t,bool compact,bool topLevel=TRUE)
{
- if (compact)
+ if (compact)
{
if (topLevel)
{
{
t << " <div id=\"navrow2\" class=\"tabs2\">\n";
}
- t << " <ul class=\"tablist\">\n";
+ t << " <ul class=\"tablist\">\n";
}
- else
+ else
{
t << "<ul>";
}
static void endQuickIndexList(FTextStream &t,bool compact)
{
- if (compact)
+ if (compact)
{
t << " </ul>\n";
t << " </div>\n";
}
- else
+ else
{
t << "</ul>\n";
}
bool hl,bool /*compact*/,
const QCString &relPath)
{
- t << " <li";
- if (hl)
+ t << " <li";
+ if (hl)
{
t << " class=\"current\"";
}
static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
switch (kind)
{
- case LayoutNavEntry::MainPage: return TRUE;
- case LayoutNavEntry::User: return TRUE;
- case LayoutNavEntry::UserGroup: return TRUE;
+ case LayoutNavEntry::MainPage: return TRUE;
+ case LayoutNavEntry::User: return TRUE;
+ case LayoutNavEntry::UserGroup: return TRUE;
case LayoutNavEntry::Pages: return indexedPages>0;
case LayoutNavEntry::Modules: return documentedGroups>0;
case LayoutNavEntry::Namespaces: return documentedNamespaces>0 && showNamespaces;
case LayoutNavEntry::NamespaceList: return documentedNamespaces>0 && showNamespaces;
case LayoutNavEntry::NamespaceMembers: return documentedNamespaceMembers[NMHL_All]>0;
case LayoutNavEntry::Classes: return annotatedClasses>0;
- case LayoutNavEntry::ClassList: return annotatedClasses>0;
- case LayoutNavEntry::ClassIndex: return annotatedClasses>0;
+ case LayoutNavEntry::ClassList: return annotatedClasses>0;
+ case LayoutNavEntry::ClassIndex: return annotatedClasses>0;
case LayoutNavEntry::ClassHierarchy: return hierarchyClasses>0;
case LayoutNavEntry::ClassMembers: return documentedClassMembers[CMHL_All]>0;
case LayoutNavEntry::Files: return documentedHtmlFiles>0 && showFiles;
{
QCString url = entry->url();
startQuickIndexItem(t,url,
- entry==hlEntry &&
- (entry->children().count()>0 ||
+ entry==hlEntry &&
+ (entry->children().count()>0 ||
(entry->kind()==kind && !highlightParent)
),
TRUE,relPath);
static bool searchEngine = Config_getBool(SEARCHENGINE);
static bool externalSearch = Config_getBool(EXTERNAL_SEARCH);
LayoutNavEntry *root = LayoutDocManager::instance().rootNavEntry();
-
- if (compact)
+ LayoutNavEntry::Kind kind = (LayoutNavEntry::Kind)-1;
+ LayoutNavEntry::Kind altKind = (LayoutNavEntry::Kind)-1; // fall back for the old layout file
+ bool highlightParent=FALSE;
+ switch (hli) // map HLI enums to LayoutNavEntry::Kind enums
+ {
+ case HLI_Main: kind = LayoutNavEntry::MainPage; break;
+ case HLI_Modules: kind = LayoutNavEntry::Modules; break;
+ //case HLI_Directories: kind = LayoutNavEntry::Dirs; break;
+ case HLI_Namespaces: kind = LayoutNavEntry::NamespaceList; altKind = LayoutNavEntry::Namespaces; break;
+ case HLI_Hierarchy: kind = LayoutNavEntry::ClassHierarchy; break;
+ case HLI_Classes: kind = LayoutNavEntry::ClassIndex; altKind = LayoutNavEntry::Classes; break;
+ case HLI_Annotated: kind = LayoutNavEntry::ClassList; altKind = LayoutNavEntry::Classes; break;
+ case HLI_Files: kind = LayoutNavEntry::FileList; altKind = LayoutNavEntry::Files; break;
+ case HLI_NamespaceMembers: kind = LayoutNavEntry::NamespaceMembers; break;
+ case HLI_Functions: kind = LayoutNavEntry::ClassMembers; break;
+ case HLI_Globals: kind = LayoutNavEntry::FileGlobals; break;
+ case HLI_Pages: kind = LayoutNavEntry::Pages; break;
+ case HLI_Examples: kind = LayoutNavEntry::Examples; break;
+ case HLI_UserGroup: kind = LayoutNavEntry::UserGroup; break;
+ case HLI_ClassVisible: kind = LayoutNavEntry::ClassList; altKind = LayoutNavEntry::Classes;
+ highlightParent = TRUE; break;
+ case HLI_NamespaceVisible: kind = LayoutNavEntry::NamespaceList; altKind = LayoutNavEntry::Namespaces;
+ highlightParent = TRUE; break;
+ case HLI_FileVisible: kind = LayoutNavEntry::FileList; altKind = LayoutNavEntry::Files;
+ highlightParent = TRUE; break;
+ case HLI_None: break;
+ case HLI_Search: break;
+ }
+
+ if (compact && Config_getBool(HTML_DYNAMIC_MENUS))
{
QCString searchPage;
if (externalSearch)
t << "<script type=\"text/javascript\" src=\"" << relPath << "menudata.js\"></script>" << endl;
t << "<script type=\"text/javascript\" src=\"" << relPath << "menu.js\"></script>" << endl;
t << "<script type=\"text/javascript\">" << endl;
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
t << "$(function() {" << endl;
t << " initMenu('" << relPath << "',"
<< (searchEngine?"true":"false") << ","
}
else
{
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
t << " $(document).ready(function() {\n"
<< " if ($('.searchresults').length > 0) { searchBox.DOMSearchField().focus(); }\n"
<< " });\n";
}
}
t << "});" << endl;
+ t << "/* @license-end */";
t << "</script>" << endl;
t << "<div id=\"main-nav\"></div>" << endl;
}
+ else if (compact) // && !Config_getBool(HTML_DYNAMIC_MENUS)
+ {
+ // find highlighted index item
+ LayoutNavEntry *hlEntry = root->find(kind,kind==LayoutNavEntry::UserGroup ? file : 0);
+ if (!hlEntry && altKind!=(LayoutNavEntry::Kind)-1) { hlEntry=root->find(altKind); kind=altKind; }
+ if (!hlEntry) // highlighted item not found in the index! -> just show the level 1 index...
+ {
+ highlightParent=TRUE;
+ hlEntry = root->children().getFirst();
+ if (hlEntry==0)
+ {
+ return; // argl, empty index!
+ }
+ }
+ if (kind==LayoutNavEntry::UserGroup)
+ {
+ LayoutNavEntry *e = hlEntry->children().getFirst();
+ if (e)
+ {
+ hlEntry = e;
+ }
+ }
+ renderQuickLinksAsTabs(t,relPath,hlEntry,kind,highlightParent,hli==HLI_Search);
+ }
else
{
renderQuickLinksAsTree(t,relPath,root);
if (generateTreeView)
{
result = QCString(
- "<div id=\"side-nav\" class=\"ui-resizable side-nav-resizable\">\n"
- " <div id=\"nav-tree\">\n"
- " <div id=\"nav-tree-contents\">\n"
- " <div id=\"nav-sync\" class=\"sync\"></div>\n"
- " </div>\n"
- " </div>\n"
- " <div id=\"splitbar\" style=\"-moz-user-select:none;\" \n"
- " class=\"ui-resizable-handle\">\n"
- " </div>\n"
- "</div>\n"
- "<script type=\"text/javascript\">\n"
- "$(document).ready(function(){initNavTree('") +
- QCString(name) + Doxygen::htmlFileExtension +
- QCString("','") + relpath +
- QCString("');});\n"
- "</script>\n"
- "<div id=\"doc-content\">\n");
+ "<div id=\"side-nav\" class=\"ui-resizable side-nav-resizable\">\n"
+ " <div id=\"nav-tree\">\n"
+ " <div id=\"nav-tree-contents\">\n"
+ " <div id=\"nav-sync\" class=\"sync\"></div>\n"
+ " </div>\n"
+ " </div>\n"
+ " <div id=\"splitbar\" style=\"-moz-user-select:none;\" \n"
+ " class=\"ui-resizable-handle\">\n"
+ " </div>\n"
+ "</div>\n"
+ "<script type=\"text/javascript\">\n"
+ "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n"
+ "$(document).ready(function(){initNavTree('") +
+ QCString(name) + Doxygen::htmlFileExtension +
+ QCString("','") + relpath +
+ QCString("');});\n"
+ "/* @license-end */\n"
+ "</script>\n"
+ "<div id=\"doc-content\">\n");
}
return result;
}
t << ");\n\n";
t << "$translator = array(\n";
t << " 'search_results_title' => \"" << theTranslator->trSearchResultsTitle() << "\",\n";
- t << " 'search_results' => array(\n";
- t << " 0 => \"" << theTranslator->trSearchResults(0) << "\",\n";
- t << " 1 => \"" << theTranslator->trSearchResults(1) << "\",\n";
- t << " 2 => \"" << substitute(theTranslator->trSearchResults(2), "$", "\\$") << "\",\n";
+ t << " 'search_results' => array(\n";
+ t << " 0 => \"" << theTranslator->trSearchResults(0) << "\",\n";
+ t << " 1 => \"" << theTranslator->trSearchResults(1) << "\",\n";
+ t << " 2 => \"" << substitute(theTranslator->trSearchResults(2), "$", "\\$") << "\",\n";
t << " ),\n";
t << " 'search_matches' => \"" << theTranslator->trSearchMatches() << "\",\n";
t << " 'search' => \"" << theTranslator->trSearch() << "\",\n";
FTextStream t(&f);
t << substituteHtmlKeywords(g_header,"Search","");
- t << "<!-- " << theTranslator->trGeneratedBy() << " Doxygen "
+ t << "<!-- " << theTranslator->trGeneratedBy() << " Doxygen "
<< versionString << " -->" << endl;
t << "<script type=\"text/javascript\">\n";
- t << "var searchBox = new SearchBox(\"searchBox\", \""
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
+ t << "var searchBox = new SearchBox(\"searchBox\", \""
<< "search\",false,'" << theTranslator->trSearch() << "');\n";
+ t << "/* @license-end */\n";
t << "</script>\n";
if (!Config_getBool(DISABLE_INDEX))
{
FTextStream t(&f);
t << substituteHtmlKeywords(g_header,"Search","");
- t << "<!-- " << theTranslator->trGeneratedBy() << " Doxygen "
+ t << "<!-- " << theTranslator->trGeneratedBy() << " Doxygen "
<< versionString << " -->" << endl;
t << "<script type=\"text/javascript\">\n";
- t << "var searchBox = new SearchBox(\"searchBox\", \""
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
+ t << "var searchBox = new SearchBox(\"searchBox\", \""
<< "search\",false,'" << theTranslator->trSearch() << "');\n";
+ t << "/* @license-end */\n";
t << "</script>\n";
if (!Config_getBool(DISABLE_INDEX))
{
t << "<div class=\"header\">" << endl;
}
-void HtmlGenerator::startTitleHead(const char *)
-{
+void HtmlGenerator::startTitleHead(const char *)
+{
t << " <div class=\"headertitle\">" << endl;
- startTitle();
+ startTitle();
}
-void HtmlGenerator::endTitleHead(const char *,const char *)
-{
- endTitle();
+void HtmlGenerator::endTitleHead(const char *,const char *)
+{
+ endTitle();
t << " </div>" << endl;
}
}
void HtmlGenerator::writeInheritedSectionTitle(
- const char *id, const char *ref,
+ const char *id, const char *ref,
const char *file, const char *anchor,
const char *title, const char *name)
{
classLink+=QCString("\">")+convertToHtml(name,FALSE)+"</a>";
t << "<tr class=\"inherit_header " << id << "\">"
<< "<td colspan=\"2\" onclick=\"javascript:toggleInherit('" << id << "')\">"
- << "<img src=\"" << relPath << "closed.png\" alt=\"-\"/> "
+ << "<img src=\"" << relPath << "closed.png\" alt=\"-\"/> "
<< theTranslator->trInheritedFrom(convertToHtml(title,FALSE),classLink)
<< "</td></tr>" << endl;
}
Doxygen::searchIndex->addWord(word,hiPriority);
}
}
-
/******************************************************************************
*
- *
+ *
*
* 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
+ * 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.
*
{
if (letterTabs)
{
- ol.writeString(" <div id=\"navrow4\" class=\"tabs3\">\n");
+ ol.writeString(" <div id=\"navrow4\" class=\"tabs3\">\n");
}
else
{
- ol.writeString(" <div id=\"navrow3\" class=\"tabs2\">\n");
+ ol.writeString(" <div id=\"navrow3\" class=\"tabs2\">\n");
}
- ol.writeString(" <ul class=\"tablist\">\n");
+ ol.writeString(" <ul class=\"tablist\">\n");
}
else
{
- ol.writeString(" <div class=\"qindex\">");
+ ol.writeString(" <div class=\"qindex\">");
}
}
first=FALSE;
if (fancyTabs)
{
- ol.writeString(" <li");
+ ol.writeString(" <li");
if (hl) ol.writeString(" class=\"current\"");
ol.writeString("><a ");
}
ol.writeString("<a class=\"qindex\" ");
}
}
- ol.writeString("href=\"");
+ ol.writeString("href=\"");
ol.writeString(l);
ol.writeString("\">");
if (fancyTabs)
}
//----------------------------------------------------------------------
-template<class T>
+template<class T>
void addMembersToIndex(T *def,LayoutDocManager::LayoutPart part,
const QCString &name,const QCString &anchor,
bool addToIndex=TRUE,bool preventSeparateIndex=FALSE)
bool isAnonymous = md->name().find('@')!=-1;
static bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
static bool extractStatic = Config_getBool(EXTRACT_STATIC);
- if (!isAnonymous &&
+ if (!isAnonymous &&
(!hideUndocMembers || md->hasDocumentation()) &&
(!md->isStatic() || extractStatic)
)
}
}
}
- else if (lde->kind()==LayoutDocEntry::NamespaceClasses ||
- lde->kind()==LayoutDocEntry::FileClasses ||
+ else if (lde->kind()==LayoutDocEntry::NamespaceClasses ||
+ lde->kind()==LayoutDocEntry::FileClasses ||
lde->kind()==LayoutDocEntry::ClassNestedClasses
)
{
ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());
ol.parseText(cd->displayName());
ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());
- if (cd->isReference())
- {
- ol.startTypewriter();
+ if (cd->isReference())
+ {
+ ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
//printf("Class %s at %p visited=%d\n",cd->name().data(),cd,cd->visited);
bool wasVisited=cd->visited;
cd->visited=TRUE;
- if (cd->getLanguage()==SrcLangExt_VHDL)
+ if (cd->getLanguage()==SrcLangExt_VHDL)
{
writeClassTree(ol,cd->baseClasses(),wasVisited,level+1,ftv,addToIndex);
}
- else
+ else
{
writeClassTree(ol,cd->subClasses(),wasVisited,level+1,ftv,addToIndex);
}
ol.endIndexListItem();
}
}
- if (started)
+ if (started)
{
endIndexHierarchy(ol,level);
if (addToIndex)
//printf("gd=`%s': pageDict=%d\n",gd->name().data(),gd->pageDict->count());
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
if (ftv)
{
ftv->addContentsItem(isDir,dd->shortName(),dd->getReference(),
- dd->getOutputFileBase(),0,FALSE,TRUE,dd);
+ dd->getOutputFileBase(),0,FALSE,TRUE,dd);
ftv->incContentsDepth();
}
ol.startIndexItem(dd->getReference(),dd->getOutputFileBase());
ol.parseText(dd->shortName());
ol.endIndexItem(dd->getReference(),dd->getOutputFileBase());
- if (dd->isReference())
- {
- ol.startTypewriter();
+ if (dd->isReference())
+ {
+ ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
{
writeDirTreeNode(ol,subdd,level+1,ftv,addToIndex);
}
- endIndexHierarchy(ol,level+1);
+ endIndexHierarchy(ol,level+1);
}
FileList *fileList=dd->getFiles();
doc = fileVisibleInIndex(fd,src);
QCString reference;
QCString outputBase;
- if (doc)
+ if (doc)
{
reference = fd->getReference();
outputBase = fd->getOutputFileBase();
ftv->addContentsItem(FALSE,
fd->displayName(),
reference,outputBase,
- 0,FALSE,FALSE,fd);
+ 0,FALSE,FALSE,fd);
}
}
}
- endIndexHierarchy(ol,level+1);
+ endIndexHierarchy(ol,level+1);
}
}
else if (src)
{
Doxygen::indexList->addContentsItem(
- FALSE, convertToHtml(fd->name(),TRUE), 0,
+ FALSE, convertToHtml(fd->name(),TRUE), 0,
fd->getSourceFileBase(), 0, FALSE, TRUE, fd);
}
}
{
if (ftv)
{
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
}
static bool fullPathNames = Config_getBool(FULL_PATH_NAMES);
DirDef *dd;
for (dli.toFirst();(dd=dli.current());++dli)
{
- if (dd->getOuterScope()==Doxygen::globalScope)
+ if (dd->getOuterScope()==Doxygen::globalScope)
{
writeDirTreeNode(ol,dd,0,ftv,addToIndex);
}
}
if (ftv)
{
- FileNameListIterator fnli(*Doxygen::inputNameList);
+ FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (fnli.toFirst();(fn=fnli.current());++fnli)
{
}
if (doc || src)
{
- ftv->addContentsItem(FALSE,fd->displayName(),
- reference, outputBase, 0,
+ ftv->addContentsItem(FALSE,fd->displayName(),
+ reference, outputBase, 0,
FALSE,FALSE,fd);
}
if (addToIndex)
else if (src)
{
Doxygen::indexList->addContentsItem(
- FALSE, convertToHtml(fd->name(),TRUE), 0,
+ FALSE, convertToHtml(fd->name(),TRUE), 0,
fd->getSourceFileBase(), 0, FALSE, TRUE, fd);
}
}
}
}
}
- endIndexHierarchy(ol,0);
+ endIndexHierarchy(ol,0);
if (ftv)
{
- ol.popGeneratorState();
+ ol.popGeneratorState();
}
}
started=TRUE;
}
ol.startIndexListItem();
- bool hasChildren = !cd->visited && classHasVisibleChildren(cd);
+ bool hasChildren = !cd->visited && classHasVisibleChildren(cd);
//printf("list: Has children %s: %d\n",cd->name().data(),hasChildren);
if (cd->isLinkable())
{
ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());
ol.parseText(cd->displayName());
ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());
- if (cd->isReference())
+ if (cd->isReference())
{
- ol.startTypewriter();
+ ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
}
if (ftv)
{
- ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd);
+ ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd);
}
}
else
}
if (ftv)
{
- ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0,FALSE,FALSE,cd);
+ ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0,FALSE,FALSE,cd);
}
}
- if (cd->getLanguage()==SrcLangExt_VHDL && hasChildren)
+ if (cd->getLanguage()==SrcLangExt_VHDL && hasChildren)
{
writeClassTree(ol,cd->baseClasses(),cd->visited,1,ftv,addToIndex);
cd->visited=TRUE;
initClassHierarchy(Doxygen::hiddenClasses);
if (ftv)
{
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
}
bool started=FALSE;
writeClassTreeForList(ol,Doxygen::classSDict,started,ftv,addToIndex);
writeClassTreeForList(ol,Doxygen::hiddenClasses,started,ftv,addToIndex);
- if (started)
+ if (started)
{
endIndexHierarchy(ol,0);
if (addToIndex)
}
if (ftv)
{
- ol.popGeneratorState();
+ ol.popGeneratorState();
}
}
// ---------------
// Dynamic class hierarchical index for HTML
// ---------------
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
//2.{
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"hierarchy",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"hierarchy",0,TRUE,TRUE);
}
FTVHelp* ftv = new FTVHelp(FALSE);
writeClassHierarchy(ol,ftv,addToIndex);
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.writeString(outStr);
ol.popGeneratorState();
startFile(ol,"files",0,title,HLI_Files);
startTitle(ol,0);
- //if (!Config_getString(PROJECT_NAME).isEmpty())
+ //if (!Config_getString(PROJECT_NAME).isEmpty())
//{
// title.prepend(Config_getString(PROJECT_NAME)+" ");
//}
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"files",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"files",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
if (Config_getBool(FULL_PATH_NAMES))
{
- // re-sort input files in (dir,file) output order instead of (file,dir) input order
+ // re-sort input files in (dir,file) output order instead of (file,dir) input order
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (fnli.toFirst();(fn=fnli.current());++fnli)
// ---------------
// Hierarchical file index for HTML
// ---------------
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
FTVHelp* ftv = new FTVHelp(FALSE);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
- if (cd->getLanguage()==SrcLangExt_VHDL)
+ if (cd->getLanguage()==SrcLangExt_VHDL)
{
- if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
+ if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
(VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS
)// no architecture
{
{
QCString n=cd->name();
cd->setClassName(n.data());
- }
+ }
}
- if (!globalOnly ||
- cd->getOuterScope()==0 ||
- cd->getOuterScope()==Doxygen::globalScope
- )
+ if (!globalOnly ||
+ cd->getOuterScope()==0 ||
+ cd->getOuterScope()==Doxygen::globalScope
+ )
{
int count=0;
if (cd->getClassSDict())
ClassDef *ccd;
for (;(ccd=ccit.current());++ccit)
{
- if (ccd->isLinkableInProject() && ccd->templateMaster()==0)
+ if (ccd->isLinkableInProject() && ccd->templateMaster()==0)
{
count++;
}
}
}
- if (classVisibleInIndex(cd) && cd->templateMaster()==0)
- {
+ if (classVisibleInIndex(cd) && cd->templateMaster()==0)
+ {
ftv->addContentsItem(count>0,cd->displayName(FALSE),cd->getReference(),
- cd->getOutputFileBase(),cd->anchor(),FALSE,TRUE,cd);
- if (addToIndex &&
+ cd->getOutputFileBase(),cd->anchor(),FALSE,TRUE,cd);
+ if (addToIndex &&
/*cd->partOfGroups()==0 &&*/
- (cd->getOuterScope()==0 ||
+ (cd->getOuterScope()==0 ||
cd->getOuterScope()->definitionType()!=Definition::TypeClass
)
)
NamespaceDef *nd;
for (nli.toFirst();(nd=nli.current());++nli)
{
- if (nd->localName().find('@')==-1 &&
+ if (nd->localName().find('@')==-1 &&
(!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
{
bool hasChildren = namespaceHasVisibleChild(nd,showClasses);
bool isLinkable = nd->isLinkableInProject();
- QCString ref;
- QCString file;
+ QCString ref;
+ QCString file;
if (isLinkable)
{
ref = nd->getReference();
if ((isLinkable && !showClasses) || hasChildren)
{
- ftv->addContentsItem(hasChildren,nd->localName(),ref,file,0,FALSE,TRUE,nd);
+ ftv->addContentsItem(hasChildren,nd->localName(),ref,file,0,FALSE,TRUE,nd);
if (addToIndex)
{
if (addToIndex) Doxygen::indexList->incContentsDepth();
ftv->incContentsDepth();
writeNamespaceTree(nd->getNamespaceSDict(),ftv,FALSE,showClasses,addToIndex);
- if (showClasses)
+ if (showClasses)
{
writeClassTree(nd->getClassSDict(),ftv,addToIndex,FALSE);
}
// ---------------
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
-
+
NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
NamespaceDef *nd;
for (nli.toFirst();(nd=nli.current());++nli)
// ---------------
// Hierarchical namespace index for HTML
// ---------------
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"namespaces",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"namespaces",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
FTVHelp* ftv = new FTVHelp(FALSE);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
- if (cd->isLinkableInProject() && cd->templateMaster()==0)
- {
+ if (cd->isLinkableInProject() && cd->templateMaster()==0)
+ {
if (!cd->isEmbeddedInOuterScope())
{
countPrinted++;
}
- count++;
+ count++;
}
}
*cp = countPrinted;
//LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassList);
//bool addToIndex = lne==0 || lne->visible();
- ol.startIndexList();
+ ol.startIndexList();
ClassSDict::Iterator cli(*Doxygen::classSDict);
ClassDef *cd;
-
+
for (cli.toFirst();(cd=cli.current());++cli)
{
- if (cd->getLanguage()==SrcLangExt_VHDL &&
- ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
+ if (cd->getLanguage()==SrcLangExt_VHDL &&
+ ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
(VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)
) // no architecture
{
continue;
}
-
+
ol.pushGeneratorState();
if (cd->isEmbeddedInOuterScope())
{
class AlphaIndexTableCell
{
public:
- AlphaIndexTableCell(int row,int col,uint letter,ClassDef *cd) :
- m_letter(letter), m_class(cd), m_row(row), m_col(col)
+ AlphaIndexTableCell(int row,int col,uint letter,ClassDef *cd) :
+ m_letter(letter), m_class(cd), m_row(row), m_col(col)
{ //printf("AlphaIndexTableCell(%d,%d,%c,%s)\n",row,col,letter!=0 ? letter: '-',
- // cd!=(ClassDef*)0x8 ? cd->name().data() : "<null>");
+ // cd!=(ClassDef*)0x8 ? cd->name().data() : "<null>");
}
ClassDef *classDef() const { return m_class; }
class AlphaIndexTableRowsIterator : public QListIterator<AlphaIndexTableCell>
{
public:
- AlphaIndexTableRowsIterator(const AlphaIndexTableRows &list) :
+ AlphaIndexTableRowsIterator(const AlphaIndexTableRows &list) :
QListIterator<AlphaIndexTableCell>(list) {}
};
{
if (cd->getLanguage()==SrcLangExt_VHDL && !((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS ))// no architecture
continue;
-
+
int index = getPrefixIndex(cd->className());
//printf("name=%s index=%d %d\n",cd->className().data(),index,cd->protection());
startLetter=getUtf8CodeToLower(cd->className(),index);
headerItems++;
QCString li = letterToLabel(*pLetter);
QCString ls = QString(QChar(*pLetter)).utf8();
- alphaLinks += (QCString)"<a class=\"qindex\" href=\"#letter_" +
- li + "\">" +
+ alphaLinks += (QCString)"<a class=\"qindex\" href=\"#letter_" +
+ li + "\">" +
ls + "</a>";
}
alphaLinks += "</div>\n";
{
if (cd->getLanguage()==SrcLangExt_VHDL && !((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS ))// no architecture
continue;
-
+
if (cd->isLinkableInProject() && cd->templateMaster()==0)
{
int index = getPrefixIndex(cd->className());
startLetter=getUtf8CodeToLower(cd->className(),index);
- // Do some sorting again, since the classes are sorted by name with
+ // Do some sorting again, since the classes are sorted by name with
// prefix, which should be ignored really.
if (cd->getLanguage()==SrcLangExt_VHDL)
{
ClassDef *cd = cit.current();
++cit;
tableRows->append(new AlphaIndexTableCell(row,col,0,cd));
- row++;
+ row++;
NEXT_ROW();
for (;(cd=cit.current()); ++cit)
{
//ol.nextTableRow();
ol.writeString("<tr>");
// the last column may contain less items then the others
- //int colsInRow = (i<rows-1) ? columns : itemsInLastRow;
+ //int colsInRow = (i<rows-1) ? columns : itemsInLastRow;
//printf("row [%d]\n",i);
for (j=0;j<columns;j++) // foreach table column
{
ol.writeString("\"></a>");
ol.writeString("<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">"
"<tr>"
- "<td><div class=\"ah\">  ");
+ "<td><div class=\"ah\">  ");
ol.writeString(QString(QChar(cell->letter())).utf8());
ol.writeString( "  </div>"
"</td>"
ol.writeString("</tr>\n");
}
ol.writeString("</table>\n");
-
+
ol.writeString(alphaLinks);
// release the temporary memory
QCString title = lne ? lne->title() : theTranslator->trCompoundIndex();
bool addToIndex = lne==0 || lne->visible();
- startFile(ol,"classes",0,title,HLI_Classes);
+ startFile(ol,"classes",0,title,HLI_Classes);
startTitle(ol,0);
ol.parseText(title);
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(FALSE,title,0,"classes",0,FALSE,TRUE);
+ Doxygen::indexList->addContentsItem(FALSE,title,0,"classes",0,FALSE,TRUE);
}
ol.startContents();
//printf("writeAnnotatedIndex: count=%d printed=%d\n",
// annotatedClasses,annotatedClassesPrinted);
if (annotatedClasses==0) return;
-
+
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
if (annotatedClassesPrinted==0)
QCString title = lne ? lne->title() : theTranslator->trCompoundList();
bool addToIndex = lne==0 || lne->visible();
-
+
startFile(ol,"annotated",0,title,HLI_Annotated);
startTitle(ol,0);
// ---------------
// Hierarchical class index for HTML
// ---------------
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"annotated",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"annotated",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
FTVHelp* ftv = new FTVHelp(FALSE);
ol.popGeneratorState();
// ------
-
+
endFile(ol); // contains ol.endContents()
ol.popGeneratorState();
}
QCString &prevNamespaceName);
// each index tab has its own write function
- static writeLinkForMember_t writeLinkForMemberMap[3] =
- {
- &writeClassLinkForMember,
+ static writeLinkForMember_t writeLinkForMemberMap[3] =
+ {
+ &writeClassLinkForMember,
&writeFileLinkForMember,
&writeNamespaceLinkForMember
};
for (mli.toFirst();(md=mli.current());++mli)
{
const char *sep;
- bool isFunc=!md->isObjCMethod() &&
- (md->isFunction() || md->isSlot() || md->isSignal());
+ bool isFunc=!md->isObjCMethod() &&
+ (md->isFunction() || md->isSlot() || md->isSignal());
QCString name=md->name();
int startIndex = getPrefixIndex(name);
if (QCString(name.data()+startIndex)!=prevName) // new entry
{
- if ((prevName.isEmpty() ||
- tolower(name.at(startIndex))!=tolower(prevName.at(0))) &&
+ if ((prevName.isEmpty() ||
+ tolower(name.at(startIndex))!=tolower(prevName.at(0))) &&
useSections) // new section
{
if (!firstItem) ol.endItemListItem();
static bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
ClassDef *cd=0;
-
-
- if (md->isLinkableInProject() &&
- (cd=md->getClassDef()) &&
+
+
+ if (md->isLinkableInProject() &&
+ (cd=md->getClassDef()) &&
cd->isLinkableInProject() &&
cd->templateMaster()==0)
{
QCString n = md->name();
int index = getPrefixIndex(n);
uint letter = getUtf8CodeToLower(n,index);
- if (!n.isEmpty())
+ if (!n.isEmpty())
{
bool isFriendToHide = hideFriendCompounds &&
- (QCString(md->typeString())=="friend class" ||
+ (QCString(md->typeString())=="friend class" ||
QCString(md->typeString())=="friend struct" ||
QCString(md->typeString())=="friend union");
if (!(md->isFriend() && isFriendToHide) &&
documentedNamespaceMembers[NMHL_All]++;
}
- if (md->isFunction())
+ if (md->isFunction())
{
g_namespaceIndexLetterUsed[NMHL_Functions].append(letter,md);
documentedNamespaceMembers[NMHL_Functions]++;
}
- else if (md->isVariable())
+ else if (md->isVariable())
{
g_namespaceIndexLetterUsed[NMHL_Variables].append(letter,md);
documentedNamespaceMembers[NMHL_Variables]++;
QCString n = md->name();
int index = getPrefixIndex(n);
uint letter = getUtf8CodeToLower(n,index);
- if (!n.isEmpty())
+ if (!n.isEmpty())
{
if (!md->isEnumValue() || (md->getEnumScope() && !md->getEnumScope()->isStrong()))
{
documentedFileMembers[FMHL_All]++;
}
- if (md->isFunction())
+ if (md->isFunction())
{
g_fileIndexLetterUsed[FMHL_Functions].append(letter,md);
documentedFileMembers[FMHL_Functions]++;
}
- else if (md->isVariable())
+ else if (md->isVariable())
{
g_fileIndexLetterUsed[FMHL_Variables].append(letter,md);
documentedFileMembers[FMHL_Variables]++;
QCString extension=Doxygen::htmlFileExtension;
if (!multiPage)
anchor="#index_";
- else if (first)
+ else if (first)
anchor=fullName+extension+"#index_";
- else
+ else
anchor=fullName+"_"+letterToLabel(i)+extension+"#index_";
startQuickIndexItem(ol,anchor+is,i==page,TRUE,first);
ol.writeString(ci);
{
static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
- static CmhlInfo cmhlInfo[] =
+ static CmhlInfo cmhlInfo[] =
{
CmhlInfo("functions", theTranslator->trAll()),
CmhlInfo("functions_func",
- fortranOpt ? theTranslator->trSubprograms() :
+ fortranOpt ? theTranslator->trSubprograms() :
vhdlOpt ? VhdlDocGen::trFunctionAndProc() :
theTranslator->trFunctions()),
CmhlInfo("functions_vars",theTranslator->trVariables()),
uint page = ml->letter();
QCString fileName = getCmhlInfo(hl)->fname;
if (multiPageIndex)
- {
+ {
if (!first)
{
fileName+="_"+letterToLabel(page);
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,HLI_Functions,0);
-#if 0
- startQuickIndexList(ol);
- // index item for global member list
- startQuickIndexItem(ol,
- getCmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==CMHL_All,TRUE,first);
- ol.writeString(fixSpaces(getCmhlInfo(0)->title));
- endQuickIndexItem(ol);
-
- int i;
- // index items per category member lists
- for (i=1;i<CMHL_Total;i++)
+ if (!Config_getBool(HTML_DYNAMIC_MENUS))
{
- if (documentedClassMembers[i]>0)
+ startQuickIndexList(ol);
+
+ // index item for global member list
+ startQuickIndexItem(ol,
+ getCmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==CMHL_All,TRUE,first);
+ ol.writeString(fixSpaces(getCmhlInfo(0)->title));
+ endQuickIndexItem(ol);
+
+ int i;
+ // index items per category member lists
+ for (i=1;i<CMHL_Total;i++)
{
- startQuickIndexItem(ol,getCmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
- ol.writeString(fixSpaces(getCmhlInfo(i)->title));
- //printf("multiPageIndex=%d first=%d fileName=%s file=%s title=%s\n",
- // multiPageIndex,first,fileName.data(),getCmhlInfo(i)->fname,getCmhlInfo(i)->title.data());
- endQuickIndexItem(ol);
+ if (documentedClassMembers[i]>0)
+ {
+ startQuickIndexItem(ol,getCmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
+ ol.writeString(fixSpaces(getCmhlInfo(i)->title));
+ //printf("multiPageIndex=%d first=%d fileName=%s file=%s title=%s\n",
+ // multiPageIndex,first,fileName.data(),getCmhlInfo(i)->fname,getCmhlInfo(i)->title.data());
+ endQuickIndexItem(ol);
+ }
}
- }
- endQuickIndexList(ol);
+ endQuickIndexList(ol);
- // quick alphabetical index
- if (quickIndex)
- {
- writeQuickMemberIndex(ol,g_memberIndexLetterUsed[hl],page,
- getCmhlInfo(hl)->fname,multiPageIndex);
+ // quick alphabetical index
+ if (quickIndex)
+ {
+ writeQuickMemberIndex(ol,g_memberIndexLetterUsed[hl],page,
+ getCmhlInfo(hl)->fname,multiPageIndex);
+ }
}
-#endif
}
ol.endQuickIndices();
ol.writeSplitBar(fileName);
if (documentedClassMembers[CMHL_All]>0 && addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,lne ? lne->title() : theTranslator->trCompoundMembers(),0,"functions",0);
+ Doxygen::indexList->addContentsItem(TRUE,lne ? lne->title() : theTranslator->trCompoundMembers(),0,"functions",0);
Doxygen::indexList->incContentsDepth();
}
writeClassMemberIndexFiltered(ol,CMHL_All);
//----------------------------------------------------------------------------
/** Helper class representing a file member in the navigation menu. */
-struct FmhlInfo
+struct FmhlInfo
{
FmhlInfo(const char *fn,const char *t) : fname(fn), title(t) {}
const char *fname;
{
static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
- static FmhlInfo fmhlInfo[] =
+ static FmhlInfo fmhlInfo[] =
{
FmhlInfo("globals", theTranslator->trAll()),
FmhlInfo("globals_func",
- fortranOpt ? theTranslator->trSubprograms() :
- vhdlOpt ? VhdlDocGen::trFunctionAndProc() :
+ fortranOpt ? theTranslator->trSubprograms() :
+ vhdlOpt ? VhdlDocGen::trFunctionAndProc() :
theTranslator->trFunctions()),
FmhlInfo("globals_vars",theTranslator->trVariables()),
FmhlInfo("globals_type",theTranslator->trTypedefs()),
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,HLI_Globals,0);
-#if 0
- startQuickIndexList(ol);
+ if (!Config_getBool(HTML_DYNAMIC_MENUS))
+ {
+ startQuickIndexList(ol);
- // index item for all file member lists
- startQuickIndexItem(ol,
- getFmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==FMHL_All,TRUE,first);
- ol.writeString(fixSpaces(getFmhlInfo(0)->title));
- endQuickIndexItem(ol);
+ // index item for all file member lists
+ startQuickIndexItem(ol,
+ getFmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==FMHL_All,TRUE,first);
+ ol.writeString(fixSpaces(getFmhlInfo(0)->title));
+ endQuickIndexItem(ol);
- int i;
- // index items for per category member lists
- for (i=1;i<FMHL_Total;i++)
- {
- if (documentedFileMembers[i]>0)
+ int i;
+ // index items for per category member lists
+ for (i=1;i<FMHL_Total;i++)
{
- startQuickIndexItem(ol,
- getFmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
- ol.writeString(fixSpaces(getFmhlInfo(i)->title));
- endQuickIndexItem(ol);
+ if (documentedFileMembers[i]>0)
+ {
+ startQuickIndexItem(ol,
+ getFmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
+ ol.writeString(fixSpaces(getFmhlInfo(i)->title));
+ endQuickIndexItem(ol);
+ }
}
- }
- endQuickIndexList(ol);
+ endQuickIndexList(ol);
- if (quickIndex)
- {
- writeQuickMemberIndex(ol,g_fileIndexLetterUsed[hl],page,
- getFmhlInfo(hl)->fname,multiPageIndex);
+ if (quickIndex)
+ {
+ writeQuickMemberIndex(ol,g_fileIndexLetterUsed[hl],page,
+ getFmhlInfo(hl)->fname,multiPageIndex);
+ }
}
-#endif
}
ol.endQuickIndices();
ol.writeSplitBar(fileName);
bool addToIndex = lne==0 || lne->visible();
if (documentedFileMembers[FMHL_All]>0 && addToIndex)
{
- Doxygen::indexList->addContentsItem(FALSE,lne ? lne->title() : theTranslator->trFileMembers(),0,"globals",0);
+ Doxygen::indexList->addContentsItem(FALSE,lne ? lne->title() : theTranslator->trFileMembers(),0,"globals",0);
Doxygen::indexList->incContentsDepth();
}
writeFileMemberIndexFiltered(ol,FMHL_All);
{
static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
- static NmhlInfo nmhlInfo[] =
+ static NmhlInfo nmhlInfo[] =
{
NmhlInfo("namespacemembers", theTranslator->trAll()),
NmhlInfo("namespacemembers_func",
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,HLI_NamespaceMembers,0);
-#if 0
- startQuickIndexList(ol);
+ if (!Config_getBool(HTML_DYNAMIC_MENUS))
+ {
+ startQuickIndexList(ol);
- // index item for all namespace member lists
- startQuickIndexItem(ol,
- getNmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==NMHL_All,TRUE,first);
- ol.writeString(fixSpaces(getNmhlInfo(0)->title));
- endQuickIndexItem(ol);
+ // index item for all namespace member lists
+ startQuickIndexItem(ol,
+ getNmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==NMHL_All,TRUE,first);
+ ol.writeString(fixSpaces(getNmhlInfo(0)->title));
+ endQuickIndexItem(ol);
- int i;
- // index items per category member lists
- for (i=1;i<NMHL_Total;i++)
- {
- if (documentedNamespaceMembers[i]>0)
+ int i;
+ // index items per category member lists
+ for (i=1;i<NMHL_Total;i++)
{
- startQuickIndexItem(ol,
- getNmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
- ol.writeString(fixSpaces(getNmhlInfo(i)->title));
- endQuickIndexItem(ol);
+ if (documentedNamespaceMembers[i]>0)
+ {
+ startQuickIndexItem(ol,
+ getNmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
+ ol.writeString(fixSpaces(getNmhlInfo(i)->title));
+ endQuickIndexItem(ol);
+ }
}
- }
- endQuickIndexList(ol);
+ endQuickIndexList(ol);
- if (quickIndex)
- {
- writeQuickMemberIndex(ol,g_namespaceIndexLetterUsed[hl],page,
- getNmhlInfo(hl)->fname,multiPageIndex);
+ if (quickIndex)
+ {
+ writeQuickMemberIndex(ol,g_namespaceIndexLetterUsed[hl],page,
+ getNmhlInfo(hl)->fname,multiPageIndex);
+ }
}
-#endif
}
ol.endQuickIndices();
ol.writeSplitBar(fileName);
bool addToIndex = lne==0 || lne->visible();
if (documentedNamespaceMembers[NMHL_All]>0 && addToIndex)
{
- Doxygen::indexList->addContentsItem(FALSE,lne ? lne->title() : theTranslator->trNamespaceMembers(),0,"namespacemembers",0);
+ Doxygen::indexList->addContentsItem(FALSE,lne ? lne->title() : theTranslator->trNamespaceMembers(),0,"namespacemembers",0);
Doxygen::indexList->incContentsDepth();
}
//bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"examples",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"examples",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
{
if ( pd->visibleInIndex())
{
- indexPages++;
+ indexPages++;
}
if ( pd->documentedPage())
{
ftv->addContentsItem(
hasSubPages,pageTitle,
pd->getReference(),pd->getOutputFileBase(),
- 0,hasSubPages,TRUE,pd);
+ 0,hasSubPages,TRUE,pd);
}
if (addToIndex && pd!=Doxygen::mainPage)
{
QCString imgExt = getDotImageExtension();
if (imgExt=="svg" && s!=-1 && e!=-1)
{
- legendDocs = legendDocs.left(s+8) + "[!-- SVG 0 --]\n" + legendDocs.mid(e);
+ legendDocs = legendDocs.left(s+8) + "[!-- SVG 0 --]\n" + legendDocs.mid(e);
//printf("legendDocs=%s\n",legendDocs.data());
}
FileDef fd("","graph_legend");
static void writeGroupTreeNode(OutputList &ol, GroupDef *gd, int level, FTVHelp* ftv, bool addToIndex)
{
//bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
- //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
+ //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
if (level>20)
{
warn(gd->getDefFileName(),gd->getDefLine(),
}
/* Some groups should appear twice under different parent-groups.
- * That is why we should not check if it was visited
+ * That is why we should not check if it was visited
*/
if (/*!gd->visited &&*/ (!gd->isASubGroup() || level>0) &&
gd->isVisible() &&
//printf("gd=`%s': pageDict=%d\n",gd->name().data(),gd->pageDict->count());
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(isDir,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0,isDir,TRUE);
+ Doxygen::indexList->addContentsItem(isDir,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0,isDir,TRUE);
Doxygen::indexList->incContentsDepth();
}
if (ftv)
{
ftv->addContentsItem(hasSubGroups,gd->groupTitle(),
gd->getReference(),gd->getOutputFileBase(),0,
- FALSE,FALSE,gd);
+ FALSE,FALSE,gd);
ftv->incContentsDepth();
}
-
+
//ol.writeListItem();
//ol.startTextLink(gd->getOutputFileBase(),0);
//parseText(ol,gd->groupTitle());
ol.startIndexItem(gd->getReference(),gd->getOutputFileBase());
ol.parseText(gd->groupTitle());
ol.endIndexItem(gd->getReference(),gd->getOutputFileBase());
- if (gd->isReference())
- {
- ol.startTypewriter();
+ if (gd->isReference())
+ {
+ ol.startTypewriter();
ol.docify(" [external]");
ol.endTypewriter();
}
ClassDef *cd;
for (;(cd=it.current());++it)
{
- //bool nestedClassInSameGroup =
+ //bool nestedClassInSameGroup =
// cd->getOuterScope() && cd->getOuterScope()->definitionType()==Definition::TypeClass &&
// cd->getOuterScope()->partOfGroups()!=0 && cd->getOuterScope()->partOfGroups()->contains(gd);
//printf("===== GroupClasses: %s visible=%d nestedClassInSameGroup=%d\n",cd->name().data(),cd->isVisible(),nestedClassInSameGroup);
{
writeGroupTreeNode(ol,subgd,level+1,ftv,addToIndex);
}
- endIndexHierarchy(ol,level+1);
+ endIndexHierarchy(ol,level+1);
}
}
}
ol.endIndexListItem();
-
+
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
{
if (ftv)
{
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
}
startIndexHierarchy(ol,0);
{
writeGroupTreeNode(ol,gd,0,ftv,addToIndex);
}
- endIndexHierarchy(ol,0);
+ endIndexHierarchy(ol,0);
if (ftv)
{
- ol.popGeneratorState();
+ ol.popGeneratorState();
}
}
{
static bool externalGroups = Config_getBool(EXTERNAL_GROUPS);
/* Some groups should appear twice under different parent-groups.
- * That is why we should not check if it was visited
+ * That is why we should not check if it was visited
*/
if ((!gd->isASubGroup() || level>0) &&
gd->isVisible() &&
{
if (ftv)
{
- ftv->addContentsItem(hasSubGroups,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0);
+ ftv->addContentsItem(hasSubGroups,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0);
ftv->incContentsDepth();
}
if (ftv)
static void writeGroupIndex(OutputList &ol)
{
- if (documentedGroups==0) return;
- ol.pushGeneratorState();
+ if (documentedGroups==0) return;
+ ol.pushGeneratorState();
// 1.{
ol.disable(OutputGenerator::Man);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Modules);
// interactive group index for HTML
// ---------------
// 2.{
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"modules",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"modules",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
FTVHelp* ftv = new FTVHelp(FALSE);
#if 0
static void writeDirIndex(OutputList &ol)
{
- if (documentedDirs==0) return;
- ol.pushGeneratorState();
+ if (documentedDirs==0) return;
+ ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Dirs);
QCString title = lne ? lne->title() : theTranslator->trDirectories();
if (addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,title,0,"dirs",0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,title,0,"dirs",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
ol.parseText(lne ? lne->intro() : theTranslator->trDirDescription());
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
- ol.pushGeneratorState();
+ ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.writeString(outStr);
ol.popGeneratorState();
//--------------------------------------------------------------------
ol.disableAllBut(OutputGenerator::Html);
- QCString defFileName =
+ QCString defFileName =
Doxygen::mainPage ? Doxygen::mainPage->docFile().data() : "[generated]";
int defLine =
Doxygen::mainPage ? Doxygen::mainPage->docLine() : -1;
QCString indexName="index";
ol.startFile(indexName,0,title);
-
+
if (Doxygen::mainPage)
{
if (
(!projectName.isEmpty() && mainPageHasTitle() && qstricmp(title,projectName)!=0)
) // to avoid duplicate entries in the treeview
{
- Doxygen::indexList->addContentsItem(Doxygen::mainPage->hasSubPages(),title,0,indexName,0,Doxygen::mainPage->hasSubPages(),TRUE);
+ Doxygen::indexList->addContentsItem(Doxygen::mainPage->hasSubPages(),title,0,indexName,0,Doxygen::mainPage->hasSubPages(),TRUE);
}
if (Doxygen::mainPage->hasSubPages() || Doxygen::mainPage->hasSections())
{
}
ol.startQuickIndices();
- if (!Config_getBool(DISABLE_INDEX))
+ if (!Config_getBool(DISABLE_INDEX))
{
ol.writeQuickLinks(TRUE,HLI_Main,0);
}
}
ol.startContents();
- if (Config_getBool(DISABLE_INDEX) && Doxygen::mainPage==0)
+ if (Config_getBool(DISABLE_INDEX) && Doxygen::mainPage==0)
{
ol.writeQuickLinks(FALSE,HLI_Main,0);
}
Doxygen::insideMainPage=FALSE;
}
-
+
endFile(ol);
ol.disable(OutputGenerator::Html);
-
+
//--------------------------------------------------------------------
// write LaTeX/RTF index
//--------------------------------------------------------------------
ol.startFile("refman",0,0);
ol.startIndexSection(isTitlePageStart);
- if (!Config_getString(LATEX_HEADER).isEmpty())
+ if (!Config_getString(LATEX_HEADER).isEmpty())
{
ol.disable(OutputGenerator::Latex);
}
if (!Config_getString(PROJECT_NUMBER).isEmpty())
{
- ol.startProjectNumber();
+ ol.startProjectNumber();
ol.generateDoc(defFileName,defLine,Doxygen::mainPage,0,Config_getString(PROJECT_NUMBER),FALSE,FALSE);
ol.endProjectNumber();
}
bool first=Doxygen::mainPage==0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
- if (!pd->getGroupDef() && !pd->isReference() &&
+ if (!pd->getGroupDef() && !pd->isReference() &&
(!pd->hasParentPage() || // not inside other page
(Doxygen::mainPage==pd->getOuterScope())) // or inside main page
)
{
ol.startIndexSection(isClassHierarchyIndex);
ol.parseText(/*projPrefix+*/
- (fortranOpt ? theTranslator->trCompoundIndexFortran() :
+ (fortranOpt ? theTranslator->trCompoundIndexFortran() :
vhdlOpt ? VhdlDocGen::trDesignUnitIndex() :
theTranslator->trHierarchicalIndex()
));
ol.startIndexSection(isCompoundIndex);
ol.parseText(/*projPrefix+*/
(fortranOpt ? theTranslator->trCompoundIndexFortran() :
- vhdlOpt ? VhdlDocGen::trDesignUnitIndex() :
+ vhdlOpt ? VhdlDocGen::trDesignUnitIndex() :
theTranslator->trCompoundIndex()
));
ol.endIndexSection(isCompoundIndex);
{
switch(kind)
{
- case LayoutNavEntry::MainPage:
+ case LayoutNavEntry::MainPage:
msg("Generating index page...\n");
- writeIndex(ol);
+ writeIndex(ol);
break;
- case LayoutNavEntry::Pages:
+ case LayoutNavEntry::Pages:
msg("Generating page index...\n");
writePageIndex(ol);
break;
- case LayoutNavEntry::Modules:
+ case LayoutNavEntry::Modules:
msg("Generating module index...\n");
writeGroupIndex(ol);
break;
- case LayoutNavEntry::Namespaces:
+ case LayoutNavEntry::Namespaces:
{
static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
if (showNamespaces)
{
if (documentedNamespaces>0 && addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0);
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
}
}
break;
- case LayoutNavEntry::NamespaceList:
+ case LayoutNavEntry::NamespaceList:
{
static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
if (showNamespaces)
}
}
break;
- case LayoutNavEntry::NamespaceMembers:
+ case LayoutNavEntry::NamespaceMembers:
msg("Generating namespace member index...\n");
writeNamespaceMemberIndex(ol);
break;
- case LayoutNavEntry::Classes:
+ case LayoutNavEntry::Classes:
if (annotatedClasses>0 && addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,"annotated",0);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0);
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
writeAnnotatedIndex(ol);
}
break;
- case LayoutNavEntry::ClassList:
+ case LayoutNavEntry::ClassList:
msg("Generating annotated compound index...\n");
writeAnnotatedIndex(ol);
break;
msg("Generating alphabetical compound index...\n");
writeAlphabeticalIndex(ol);
break;
- case LayoutNavEntry::ClassHierarchy:
+ case LayoutNavEntry::ClassHierarchy:
msg("Generating hierarchical class index...\n");
writeHierarchicalIndex(ol);
if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
writeGraphicalClassHierarchy(ol);
}
break;
- case LayoutNavEntry::ClassMembers:
+ case LayoutNavEntry::ClassMembers:
msg("Generating member index...\n");
writeClassMemberIndex(ol);
break;
- case LayoutNavEntry::Files:
+ case LayoutNavEntry::Files:
{
static bool showFiles = Config_getBool(SHOW_FILES);
if (showFiles)
{
if (documentedHtmlFiles>0 && addToIndex)
{
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0);
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
}
}
break;
- case LayoutNavEntry::FileList:
+ case LayoutNavEntry::FileList:
{
static bool showFiles = Config_getBool(SHOW_FILES);
if (showFiles)
}
}
break;
- case LayoutNavEntry::FileGlobals:
+ case LayoutNavEntry::FileGlobals:
msg("Generating file member index...\n");
writeFileMemberIndex(ol);
break;
- case LayoutNavEntry::Examples:
+ case LayoutNavEntry::Examples:
msg("Generating example index...\n");
writeExampleIndex(ol);
break;
- case LayoutNavEntry::User:
+ case LayoutNavEntry::User:
{
// prepend a ! or ^ marker to the URL to avoid tampering with it
QCString url = correctURL(lne->url(),"!"); // add ! to relative URL
url.prepend("^"); // prepend ^ to absolute URL
}
bool isRef = lne->baseFile().left(4)=="@ref" || lne->baseFile().left(4)=="\\ref";
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,url,0,FALSE,isRef || isRelative);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,url,0,FALSE,isRef || isRelative);
}
break;
case LayoutNavEntry::UserGroup:
{
if (url=="![none]")
{
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0,FALSE,FALSE);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0,FALSE,FALSE);
}
else
{
url.prepend("^"); // prepend ^ to absolute URL
}
bool isRef = lne->baseFile().left(4)=="@ref" || lne->baseFile().left(4)=="\\ref";
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,url,0,FALSE,isRef || isRelative);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,url,0,FALSE,isRef || isRelative);
}
}
- else
+ else
{
- Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0,TRUE,TRUE);
+ Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0,TRUE,TRUE);
}
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
{
switch(kind)
{
- case LayoutNavEntry::Namespaces:
- case LayoutNavEntry::Classes:
- case LayoutNavEntry::Files:
- case LayoutNavEntry::UserGroup:
+ case LayoutNavEntry::Namespaces:
+ case LayoutNavEntry::Classes:
+ case LayoutNavEntry::Files:
+ case LayoutNavEntry::UserGroup:
Doxygen::indexList->decContentsDepth();
break;
default:
static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
switch (kind)
{
- case LayoutNavEntry::MainPage: return TRUE;
- case LayoutNavEntry::User: return TRUE;
- case LayoutNavEntry::UserGroup: return TRUE;
+ case LayoutNavEntry::MainPage: return TRUE;
+ case LayoutNavEntry::User: return TRUE;
+ case LayoutNavEntry::UserGroup: return TRUE;
case LayoutNavEntry::Pages: return indexedPages>0;
case LayoutNavEntry::Modules: return documentedGroups>0;
case LayoutNavEntry::Namespaces: return documentedNamespaces>0 && showNamespaces;
case LayoutNavEntry::NamespaceList: return documentedNamespaces>0 && showNamespaces;
case LayoutNavEntry::NamespaceMembers: return documentedNamespaceMembers[NMHL_All]>0;
case LayoutNavEntry::Classes: return annotatedClasses>0;
- case LayoutNavEntry::ClassList: return annotatedClasses>0;
- case LayoutNavEntry::ClassIndex: return annotatedClasses>0;
+ case LayoutNavEntry::ClassList: return annotatedClasses>0;
+ case LayoutNavEntry::ClassIndex: return annotatedClasses>0;
case LayoutNavEntry::ClassHierarchy: return hierarchyClasses>0;
case LayoutNavEntry::ClassMembers: return documentedClassMembers[CMHL_All]>0;
case LayoutNavEntry::Files: return documentedHtmlFiles>0 && showFiles;
if (f.open(IO_WriteOnly))
{
FTextStream t(&f);
+ t << "/*\n@ @licstart The following is the entire license notice for the\n"
+ "JavaScript code in this file.\n\nCopyright (C) 1997-2017 by Dimitri van Heesch\n\n"
+ "This program is free software; you can redistribute it and/or modify\n"
+ "it under the terms of the GNU General Public License as published by\n"
+ "the Free Software Foundation; either version 2 of the License, or\n"
+ "(at your option) any later version.\n\n"
+ "This program is distributed in the hope that it will be useful,\n"
+ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+ " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
+ " GNU General Public License for more details.\n\n"
+ "You should have received a copy of the GNU General Public License along\n"
+ "with this program; if not, write to the Free Software Foundation, Inc.,\n"
+ "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n\n"
+ "@licend The above is the entire license notice\n"
+ "for the JavaScript code in this file\n"
+ "*/\n";
t << "var menudata={";
bool hasChildren = renderQuickLinksAsJs(t,root,TRUE);
if (hasChildren) t << "]";
writeIndexHierarchyEntries(ol,lne->children());
}
}
-
}
else
{
- if (!ref->file().isEmpty()) endLink(ref->ref(),ref->file(),ref->anchor());
+ if (!ref->file().isEmpty()) endLink(ref->ref(),ref->file(),ref->anchor(),ref->refToTable());
}
}
static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
if (pdfHyperlinks)
{
- m_t << "\\hyperlink{" << ref->file() << "_" << ref->anchor() << "}{" ;
+ m_t << "\\mbox{\\hyperlink{" << ref->file() << "_" << ref->anchor() << "}{" ;
}
}
static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
if (pdfHyperlinks)
{
- m_t << "}";
+ m_t << "}}";
}
m_t << "}{\\ref{" << ref->file() << "_" << ref->anchor() << "}}{}" << endl;
}
void LatexDocVisitor::visitPre(DocXRefItem *x)
{
+ static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
if (m_hide) return;
if (x->title().isEmpty()) return;
m_t << "\\begin{DoxyRefDesc}{";
m_t << "}" << endl;
bool anonymousEnum = x->file()=="@";
m_t << "\\item[";
- if (Config_getBool(PDF_HYPERLINKS) && !anonymousEnum)
+ if (pdfHyperlinks && !anonymousEnum)
{
- m_t << "\\hyperlink{" << stripPath(x->file()) << "_" << x->anchor() << "}{";
+ m_t << "\\mbox{\\hyperlink{" << stripPath(x->file()) << "_" << x->anchor() << "}{";
}
else
{
m_insideItem=TRUE;
filter(x->title());
m_insideItem=FALSE;
+ if (pdfHyperlinks && !anonymousEnum)
+ {
+ m_t << "}";
+ }
m_t << "}]";
}
}
else
{
- m_t << "\\hyperlink{";
+ m_t << "\\mbox{\\hyperlink{";
}
if (!file.isEmpty()) m_t << stripPath(file);
if (!file.isEmpty() && !anchor.isEmpty()) m_t << "_";
}
}
-void LatexDocVisitor::endLink(const QCString &ref,const QCString &file,const QCString &anchor)
+void LatexDocVisitor::endLink(const QCString &ref,const QCString &file,const QCString &anchor,bool refToTable)
{
m_t << "}";
static bool pdfHyperLinks = Config_getBool(PDF_HYPERLINKS);
if (!file.isEmpty() && !anchor.isEmpty()) m_t << "_";
m_t << anchor << "}";
}
+ if (ref.isEmpty() && pdfHyperLinks) // internal PDF link
+ {
+ if (!refToTable)
+ {
+ m_t << "}";
+ }
+ }
}
void LatexDocVisitor::pushEnabled()
void startLink(const QCString &ref,const QCString &file,
const QCString &anchor,bool refToTable=FALSE);
void endLink(const QCString &ref,const QCString &file,
- const QCString &anchor);
+ const QCString &anchor,bool refToTable=FALSE);
QCString escapeMakeIndexChars(const char *s);
void startDotFile(const QCString &fileName,const QCString &width,
const QCString &height, bool hasCaption);
}
if (!ref && usePDFLatex && pdfHyperlinks)
{
- m_t << "\\hyperlink{";
+ m_t << "\\mbox{\\hyperlink{";
if (f) m_t << stripPath(f);
if (f && anchor) m_t << "_";
if (anchor) m_t << anchor;
m_t << "}{";
codify(name);
- m_t << "}";
+ m_t << "}}";
}
else
{
void LatexGenerator::startTextLink(const char *f,const char *anchor)
{
- if (!disableLinks && Config_getBool(PDF_HYPERLINKS))
+ static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
+ if (!disableLinks && pdfHyperlinks)
{
- t << "\\hyperlink{";
+ t << "\\mbox{\\hyperlink{";
if (f) t << stripPath(f);
if (anchor) t << "_" << anchor;
t << "}{";
void LatexGenerator::endTextLink()
{
+ static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
+ if (!disableLinks && pdfHyperlinks)
+ {
+ t << "}";
+ }
t << "}";
}
static bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
if (!disableLinks && !ref && pdfHyperlinks)
{
- t << "\\hyperlink{";
+ t << "\\mbox{\\hyperlink{";
if (f) t << stripPath(f);
if (f && anchor) t << "_";
if (anchor) t << anchor;
t << "}{";
docify(text);
- t << "}";
+ t << "}}";
}
else
{
-They're not used in the interface, only internally in this file, so all their functions are made static.
*/
-#ifdef LODEPNG_COMPILE_ZLIB
-#ifdef LODEPNG_COMPILE_ENCODER
+//--------------------------------------------------------------------------------------------
+
+
+/*LodePNG_chunk functions: These functions need as input a large enough amount of allocated memory.*/
+
+static unsigned LodePNG_chunk_length(const unsigned char* chunk); /*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
+
+static void LodePNG_chunk_generate_crc(unsigned char* chunk); /*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
+
+/*add chunks to out buffer. It reallocs the buffer to append the data. returns error code*/
+static unsigned LodePNG_create_chunk(unsigned char** out, size_t* outlength, unsigned length, const char* type, const unsigned char* data); /*appends new chunk to out. Returns pointer to start of appended chunk, or NULL if error happened; may change memory address of out buffer*/
+
+static void LodePNG_InfoColor_init(LodePNG_InfoColor* info);
+static void LodePNG_InfoColor_cleanup(LodePNG_InfoColor* info);
+static unsigned LodePNG_InfoColor_copy(LodePNG_InfoColor* dest, const LodePNG_InfoColor* source);
+
+/*Use these functions instead of allocating palette manually*/
+static void LodePNG_InfoColor_clearPalette(LodePNG_InfoColor* info);
+
+/*additional color info*/
+static unsigned LodePNG_InfoColor_getBpp(const LodePNG_InfoColor* info); /*bits per pixel*/
+static unsigned LodePNG_InfoColor_isGreyscaleType(const LodePNG_InfoColor* info); /*is it a greyscale type? (colorType 0 or 4)*/
+static unsigned LodePNG_InfoColor_isAlphaType(const LodePNG_InfoColor* info); /*has it an alpha channel? (colorType 2 or 6)*/
+
+static void LodePNG_InfoPng_init(LodePNG_InfoPng* info);
+static void LodePNG_InfoPng_cleanup(LodePNG_InfoPng* info);
+static unsigned LodePNG_InfoPng_copy(LodePNG_InfoPng* dest, const LodePNG_InfoPng* source);
+
+static void LodePNG_InfoRaw_init(LodePNG_InfoRaw* info);
+static void LodePNG_InfoRaw_cleanup(LodePNG_InfoRaw* info);
+static unsigned LodePNG_InfoRaw_copy(LodePNG_InfoRaw* dest, const LodePNG_InfoRaw* source);
+
+/*
+LodePNG_convert: Converts from any color type to 24-bit or 32-bit (later maybe more supported). return value = LodePNG error code
+The out buffer must have (w * h * bpp + 7) / 8, where bpp is the bits per pixel of the output color type (LodePNG_InfoColor_getBpp)
+*/
+static unsigned LodePNG_convert(unsigned char* out, const unsigned char* in, LodePNG_InfoColor* infoOut, LodePNG_InfoColor* infoIn, unsigned w, unsigned h);
+
+static void LodeZlib_DeflateSettings_init(LodeZlib_DeflateSettings* settings);
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* LodeFlate & LodeZlib */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*This function reallocates the out buffer and appends the data.
+Either, *out must be NULL and *outsize must be 0, or, *out must be a valid buffer and *outsize its size in bytes.*/
+//unsigned LodeZlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DeflateSettings* settings);
+
+//--------------------------------------------------------------------------------------------
typedef struct vector /*this one is used only by the deflate compressor*/
{
{
return &((char*)p->data)[index * p->typesize];
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
-#endif /*LODEPNG_COMPILE_ZLIB*/
/* /////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_ZLIB
typedef struct uivector
{
unsigned* data;
p->size = p->allocsize = 0;
}
-#ifdef LODEPNG_COMPILE_ENCODER
static unsigned uivector_push_back(uivector* p, unsigned c) /*returns 1 if success, 0 if failure ==> nothing done*/
{
if(!uivector_resize(p, p->size + 1)) return 0;
tmp = p->allocsize; p->allocsize = q->allocsize; q->allocsize = tmp;
tmpp = p->data; p->data = q->data; q->data = tmpp;
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
-#endif /*LODEPNG_COMPILE_ZLIB*/
/* /////////////////////////////////////////////////////////////////////////// */
return 1;
}
-#ifdef LODEPNG_COMPILE_DECODER
-#ifdef LODEPNG_COMPILE_PNG
-static unsigned ucvector_resizev(ucvector* p, size_t size, unsigned char value) /*resize and give all new elements the value*/
-{
- size_t oldsize = p->size, i;
- if(!ucvector_resize(p, size)) return 0;
- for(i = oldsize; i < size; i++) p->data[i] = value;
- return 1;
-}
-#endif /*LODEPNG_COMPILE_PNG*/
-#endif /*LODEPNG_COMPILE_DECODER*/
static void ucvector_init(ucvector* p)
{
p->size = p->allocsize = 0;
}
-#ifdef LODEPNG_COMPILE_ZLIB
/*you can both convert from vector to buffer&size and vica versa*/
static void ucvector_init_buffer(ucvector* p, unsigned char* buffer, size_t size)
{
p->data = buffer;
p->allocsize = p->size = size;
}
-#endif /*LODEPNG_COMPILE_ZLIB*/
static unsigned ucvector_push_back(ucvector* p, unsigned char c) /*returns 1 if success, 0 if failure ==> nothing done*/
{
return 1;
}
-/* /////////////////////////////////////////////////////////////////////////// */
-
-#ifdef LODEPNG_COMPILE_PNG
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
-static unsigned string_resize(char** out, size_t size) /*returns 1 if success, 0 if failure ==> nothing done*/
-{
- char* data = (char*)realloc(*out, size + 1);
- if(data)
- {
- data[size] = 0; /*null termination char*/
- *out = data;
- }
- return data != 0;
-}
-
-static void string_init(char** out) /*init a {char*, size_t} pair for use as string*/
-{
- *out = NULL;
- string_resize(out, 0);
-}
-
-static void string_cleanup(char** out) /*free the above pair again*/
-{
- free(*out);
- *out = NULL;
-}
-
-static void string_set(char** out, const char* in)
-{
- size_t insize = strlen(in), i = 0;
- if(string_resize(out, insize)) for(i = 0; i < insize; i++) (*out)[i] = in[i];
-}
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-#endif /*LODEPNG_COMPILE_PNG*/
-
-#ifdef LODEPNG_COMPILE_ZLIB
-
/* ////////////////////////////////////////////////////////////////////////// */
/* / Reading and writing single bits and bytes from/to stream for Deflate / */
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_ENCODER
static void addBitToStream(size_t* bitpointer, ucvector* bitstream, unsigned char bit)
{
if((*bitpointer) % 8 == 0) ucvector_push_back(bitstream, 0); /*add a new byte at the end*/
size_t i;
for(i = 0; i < nbits; i++) addBitToStream(bitpointer, bitstream, (unsigned char)((value >> (nbits - 1 - i)) & 1));
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
-
-#ifdef LODEPNG_COMPILE_DECODER
-static unsigned char readBitFromStream(size_t* bitpointer, const unsigned char* bitstream)
-{
- unsigned char result = (unsigned char)((bitstream[(*bitpointer) >> 3] >> ((*bitpointer) & 0x7)) & 1);
- (*bitpointer)++;
- return result;
-}
-static unsigned readBitsFromStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
-{
- unsigned result = 0, i;
- for(i = 0; i < nbits; i++) result += ((unsigned)readBitFromStream(bitpointer, bitstream)) << i;
- return result;
-}
-#endif /*LODEPNG_COMPILE_DECODER*/
/* ////////////////////////////////////////////////////////////////////////// */
/* / Deflate - Huffman / */
/* /////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_ENCODER
/*terminology used for the package-merge algorithm and the coin collector's problem*/
typedef struct Coin /*a coin can be multiple coins (when they're merged)*/
{
}
}
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
typedef struct HuffmanTree
{
unsigned nodefilled = 0; /*up to which node it is filled*/
unsigned treepos = 0; /*position in the tree (1 of the numcodes columns)*/
unsigned n, i;
-
+
if(!uivector_resize(&tree->tree2d, tree->numcodes * 2)) return 9901; /*if failed return not enough memory error*/
/*convert tree1d[] to tree2d[][]. In the 2D array, a value of 32767 means uninited, a value >= numcodes is an address to another bit, a value < numcodes is a code. The 2 rows are the 2 possible bit values (0 or 1), there are as many columns as codes - 1
a good huffmann tree has N * 2 - 1 nodes, of which N - 1 are internal nodes. Here, the internal nodes are stored (what their 0 and 1 option point to). There is only memory for such good tree currently, if there are more nodes (due to too long length codes), error 55 will happen*/
else treepos = tree->tree2d.data[2 * treepos + bit] - tree->numcodes;
}
for(n = 0; n < tree->numcodes * 2; n++) if(tree->tree2d.data[n] == 32767) tree->tree2d.data[n] = 0; /*remove possible remaining 32767's*/
-
+
return 0;
}
uivector blcount;
uivector nextcode;
unsigned bits, n, error = 0;
-
+
uivector_init(&blcount);
uivector_init(&nextcode);
if(!uivector_resize(&tree->tree1d, tree->numcodes)
|| !uivector_resizev(&blcount, tree->maxbitlen + 1, 0)
|| !uivector_resizev(&nextcode, tree->maxbitlen + 1, 0))
error = 9902;
-
+
if(!error)
{
/*step 1: count number of instances of each code length*/
/*step 3: generate all the codes*/
for(n = 0; n < tree->numcodes; n++) if(tree->lengths.data[n] != 0) tree->tree1d.data[n] = nextcode.data[tree->lengths.data[n]]++;
}
-
+
uivector_cleanup(&blcount);
uivector_cleanup(&nextcode);
-
+
if(!error) return HuffmanTree_make2DTree(tree);
else return error;
}
return HuffmanTree_makeFromLengths2(tree);
}
-#ifdef LODEPNG_COMPILE_ENCODER
static unsigned HuffmanTree_fillInCoins(vector* coins, const unsigned* frequencies, unsigned numcodes, size_t sum)
{
unsigned i;
unsigned i, j;
size_t sum = 0, numpresent = 0;
unsigned error = 0;
-
+
vector prev_row; /*type Coin, the previous row of coins*/
vector coins; /*type Coin, the coins of the currently calculated row*/
-
+
tree->maxbitlen = maxbitlen;
-
+
for(i = 0; i < numcodes; i++)
{
if(frequencies[i] > 0)
sum += frequencies[i];
}
}
-
+
if(numcodes == 0) return 80; /*error: a tree of 0 symbols is not supposed to be made*/
tree->numcodes = (unsigned)numcodes; /*number of symbols*/
uivector_resize(&tree->lengths, 0);
if(!uivector_resizev(&tree->lengths, tree->numcodes, 0)) return 9905;
-
+
if(numpresent == 0) /*there are no symbols at all, in that case add one symbol of value 0 to the tree (see RFC 1951 section 3.2.7) */
{
tree->lengths.data[0] = 1;
for(i = 0; i < numcodes; i++) if(frequencies[i]) tree->lengths.data[i] = 1;
return HuffmanTree_makeFromLengths2(tree);
}
-
+
vector_init(&coins, sizeof(Coin));
vector_init(&prev_row, sizeof(Coin));
/*Package-Merge algorithm represented by coin collector's problem
For every symbol, maxbitlen coins will be created*/
-
+
/*first row, lowest denominator*/
error = HuffmanTree_fillInCoins(&coins, frequencies, tree->numcodes, sum);
if(!error)
}
}
}
-
+
if(!error)
{
/*keep the coins with lowest weight, so that they add up to the amount of symbols - 1*/
vector_resized(&coins, numpresent - 1, Coin_cleanup);
-
+
/*calculate the lengths of each symbol, as the amount of times a coin of each symbol is used*/
for(i = 0; i < coins.size; i++)
{
Coin* coin = (Coin*)vector_get(&coins, i);
for(j = 0; j < coin->symbols.size; j++) tree->lengths.data[coin->symbols.data[j]]++;
}
-
+
error = HuffmanTree_makeFromLengths2(tree);
}
vector_cleanupd(&coins, Coin_cleanup);
vector_cleanupd(&prev_row, Coin_cleanup);
-
+
return error;
}
static unsigned HuffmanTree_getCode(const HuffmanTree* tree, unsigned index) { return tree->tree1d.data[index]; }
static unsigned HuffmanTree_getLength(const HuffmanTree* tree, unsigned index) { return tree->lengths.data[index]; }
-#endif /*LODEPNG_COMPILE_ENCODER*/
/*get the tree of a deflated block with fixed tree, as specified in the deflate specification*/
static unsigned generateFixedTree(HuffmanTree* tree)
uivector bitlen;
uivector_init(&bitlen);
if(!uivector_resize(&bitlen, NUM_DEFLATE_CODE_SYMBOLS)) error = 9909;
-
+
if(!error)
{
/*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
for(i = 144; i <= 255; i++) bitlen.data[i] = 9;
for(i = 256; i <= 279; i++) bitlen.data[i] = 7;
for(i = 280; i <= 287; i++) bitlen.data[i] = 8;
-
+
error = HuffmanTree_makeFromLengths(tree, bitlen.data, NUM_DEFLATE_CODE_SYMBOLS, 15);
}
-
+
uivector_cleanup(&bitlen);
return error;
}
uivector bitlen;
uivector_init(&bitlen);
if(!uivector_resize(&bitlen, NUM_DISTANCE_SYMBOLS)) error = 9910;
-
+
/*there are 32 distance codes, but 30-31 are unused*/
if(!error)
{
return error;
}
-#ifdef LODEPNG_COMPILE_DECODER
-/*Decodes a symbol from the tree
-if decoded is true, then result contains the symbol, otherwise it contains something unspecified (because the symbol isn't fully decoded yet)
-bit is the bit that was just read from the stream
-you have to decode a full symbol (let the decode function return true) before you can try to decode another one, otherwise the state isn't reset
-return value is error.*/
-static unsigned HuffmanTree_decode(const HuffmanTree* tree, unsigned* decoded, unsigned* result, unsigned* treepos, unsigned char bit)
-{
- if((*treepos) >= tree->numcodes) return 11; /*error: it appeared outside the codetree*/
-
- (*result) = tree->tree2d.data[2 * (*treepos) + bit];
- (*decoded) = ((*result) < tree->numcodes);
-
- if(*decoded) (*treepos) = 0;
- else (*treepos) = (*result) - tree->numcodes;
-
- return 0;
-}
-
-static unsigned huffmanDecodeSymbol(unsigned int* error, const unsigned char* in, size_t* bp, const HuffmanTree* codetree, size_t inlength)
-{
- unsigned treepos = 0, decoded, ct;
- for(;;)
- {
- unsigned char bit;
- if(((*bp) & 0x07) == 0 && ((*bp) >> 3) > inlength) { *error = 10; return 0; } /*error: end of input memory reached without endcode*/
- bit = readBitFromStream(bp, in);
- *error = HuffmanTree_decode(codetree, &decoded, &ct, &treepos, bit);
- if(*error) return 0; /*stop, an error happened*/
- if(decoded) return ct;
- }
-}
-#endif /*LODEPNG_COMPILE_DECODER*/
-
-#ifdef LODEPNG_COMPILE_DECODER
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* / Inflator / */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-/*get the tree of a deflated block with fixed tree, as specified in the deflate specification*/
-static void getTreeInflateFixed(HuffmanTree* tree, HuffmanTree* treeD)
-{
- /*error checking not done, this is fixed stuff, it works, it doesn't depend on the image*/
- generateFixedTree(tree);
- generateDistanceTree(treeD);
-}
-
-/*get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree*/
-static unsigned getTreeInflateDynamic(HuffmanTree* codetree, HuffmanTree* codetreeD, HuffmanTree* codelengthcodetree,
- const unsigned char* in, size_t* bp, size_t inlength)
-{
- /*make sure that length values that aren't filled in will be 0, or a wrong tree will be generated*/
- /*C-code note: use no "return" between ctor and dtor of an uivector!*/
- unsigned error = 0;
- unsigned n, HLIT, HDIST, HCLEN, i;
- uivector bitlen;
- uivector bitlenD;
- uivector codelengthcode;
-
- if((*bp) >> 3 >= inlength - 2) { return 49; } /*the bit pointer is or will go past the memory*/
-
- HLIT = readBitsFromStream(bp, in, 5) + 257; /*number of literal/length codes + 257. Unlike the spec, the value 257 is added to it here already*/
- HDIST = readBitsFromStream(bp, in, 5) + 1; /*number of distance codes. Unlike the spec, the value 1 is added to it here already*/
- HCLEN = readBitsFromStream(bp, in, 4) + 4; /*number of code length codes. Unlike the spec, the value 4 is added to it here already*/
-
- /*read the code length codes out of 3 * (amount of code length codes) bits*/
- uivector_init(&codelengthcode);
- if(!uivector_resize(&codelengthcode, NUM_CODE_LENGTH_CODES)) error = 9911;
-
- if(!error)
- {
- for(i = 0; i < NUM_CODE_LENGTH_CODES; i++)
- {
- if(i < HCLEN) codelengthcode.data[CLCL[i]] = readBitsFromStream(bp, in, 3);
- else codelengthcode.data[CLCL[i]] = 0; /*if not, it must stay 0*/
- }
-
- error = HuffmanTree_makeFromLengths(codelengthcodetree, codelengthcode.data, codelengthcode.size, 7);
- }
-
- uivector_cleanup(&codelengthcode);
- if(error) return error;
-
- /*now we can use this tree to read the lengths for the tree that this function will return*/
- uivector_init(&bitlen);
- uivector_resizev(&bitlen, NUM_DEFLATE_CODE_SYMBOLS, 0);
- uivector_init(&bitlenD);
- uivector_resizev(&bitlenD, NUM_DISTANCE_SYMBOLS, 0);
- i = 0;
- if(!bitlen.data || !bitlenD.data) error = 9912;
- else while(i < HLIT + HDIST) /*i is the current symbol we're reading in the part that contains the code lengths of lit/len codes and dist codes*/
- {
- unsigned code = huffmanDecodeSymbol(&error, in, bp, codelengthcodetree, inlength);
- if(error) break;
-
- if(code <= 15) /*a length code*/
- {
- if(i < HLIT) bitlen.data[i] = code;
- else bitlenD.data[i - HLIT] = code;
- i++;
- }
- else if(code == 16) /*repeat previous*/
- {
- unsigned replength = 3; /*read in the 2 bits that indicate repeat length (3-6)*/
- unsigned value; /*set value to the previous code*/
-
- if((*bp) >> 3 >= inlength) { error = 50; break; } /*error, bit pointer jumps past memory*/
-
- replength += readBitsFromStream(bp, in, 2);
-
- if((i - 1) < HLIT) value = bitlen.data[i - 1];
- else value = bitlenD.data[i - HLIT - 1];
- /*repeat this value in the next lengths*/
- for(n = 0; n < replength; n++)
- {
- if(i >= HLIT + HDIST) { error = 13; break; } /*error: i is larger than the amount of codes*/
- if(i < HLIT) bitlen.data[i] = value;
- else bitlenD.data[i - HLIT] = value;
- i++;
- }
- }
- else if(code == 17) /*repeat "0" 3-10 times*/
- {
- unsigned replength = 3; /*read in the bits that indicate repeat length*/
- if((*bp) >> 3 >= inlength) { error = 50; break; } /*error, bit pointer jumps past memory*/
-
- replength += readBitsFromStream(bp, in, 3);
-
- /*repeat this value in the next lengths*/
- for(n = 0; n < replength; n++)
- {
- if(i >= HLIT + HDIST) { error = 14; break; } /*error: i is larger than the amount of codes*/
- if(i < HLIT) bitlen.data[i] = 0;
- else bitlenD.data[i - HLIT] = 0;
- i++;
- }
- }
- else if(code == 18) /*repeat "0" 11-138 times*/
- {
- unsigned replength = 11; /*read in the bits that indicate repeat length*/
- if((*bp) >> 3 >= inlength) { error = 50; break; } /*error, bit pointer jumps past memory*/
- replength += readBitsFromStream(bp, in, 7);
-
- /*repeat this value in the next lengths*/
- for(n = 0; n < replength; n++)
- {
- if(i >= HLIT + HDIST) { error = 15; break; } /*error: i is larger than the amount of codes*/
- if(i < HLIT) bitlen.data[i] = 0;
- else bitlenD.data[i - HLIT] = 0;
- i++;
- }
- }
- else { error = 16; break; } /*error: somehow an unexisting code appeared. This can never happen.*/
- }
-
- if(!error && bitlen.data[256] == 0) { error = 64; } /*the length of the end code 256 must be larger than 0*/
-
- /*now we've finally got HLIT and HDIST, so generate the code trees, and the function is done*/
- if(!error) error = HuffmanTree_makeFromLengths(codetree, &bitlen.data[0], bitlen.size, 15);
- if(!error) error = HuffmanTree_makeFromLengths(codetreeD, &bitlenD.data[0], bitlenD.size, 15);
-
- uivector_cleanup(&bitlen);
- uivector_cleanup(&bitlenD);
-
- return error;
-}
-
-/*inflate a block with dynamic of fixed Huffman tree*/
-static unsigned inflateHuffmanBlock(ucvector* out, const unsigned char* in, size_t* bp, size_t* pos, size_t inlength, unsigned btype)
-{
- unsigned endreached = 0, error = 0;
- HuffmanTree codetree; /*287, the code tree for Huffman codes*/
- HuffmanTree codetreeD; /*31, the code tree for distance codes*/
-
- HuffmanTree_init(&codetree);
- HuffmanTree_init(&codetreeD);
-
- if(btype == 1) getTreeInflateFixed(&codetree, &codetreeD);
- else if(btype == 2)
- {
- HuffmanTree codelengthcodetree; /*18, the code tree for code length codes*/
- HuffmanTree_init(&codelengthcodetree);
- error = getTreeInflateDynamic(&codetree, &codetreeD, &codelengthcodetree, in, bp, inlength);
- HuffmanTree_cleanup(&codelengthcodetree);
- }
-
- while(!endreached && !error)
- {
- unsigned code = huffmanDecodeSymbol(&error, in, bp, &codetree, inlength);
- if(error) break; /*some error happened in the above function*/
- if(code == 256) endreached = 1; /*end code*/
- else if(code <= 255) /*literal symbol*/
- {
- if((*pos) >= out->size) ucvector_resize(out, ((*pos) + 1) * 2); /*reserve more room at once*/
- if((*pos) >= out->size) { error = 9913; break; } /*not enough memory*/
- out->data[(*pos)] = (unsigned char)(code);
- (*pos)++;
- }
- else if(code >= FIRST_LENGTH_CODE_INDEX && code <= LAST_LENGTH_CODE_INDEX) /*length code*/
- {
- /*part 1: get length base*/
- size_t length = LENGTHBASE[code - FIRST_LENGTH_CODE_INDEX];
- unsigned codeD, distance, numextrabitsD;
- size_t start, forward, backward, numextrabits;
-
- /*part 2: get extra bits and add the value of that to length*/
- numextrabits = LENGTHEXTRA[code - FIRST_LENGTH_CODE_INDEX];
- if(((*bp) >> 3) >= inlength) { error = 51; break; } /*error, bit pointer will jump past memory*/
- length += readBitsFromStream(bp, in, numextrabits);
-
- /*part 3: get distance code*/
- codeD = huffmanDecodeSymbol(&error, in, bp, &codetreeD, inlength);
- if(error) break;
- if(codeD > 29) { error = 18; break; } /*error: invalid distance code (30-31 are never used)*/
- distance = DISTANCEBASE[codeD];
-
- /*part 4: get extra bits from distance*/
- numextrabitsD = DISTANCEEXTRA[codeD];
- if(((*bp) >> 3) >= inlength) { error = 51; break; } /*error, bit pointer will jump past memory*/
- distance += readBitsFromStream(bp, in, numextrabitsD);
-
- /*part 5: fill in all the out[n] values based on the length and dist*/
- start = (*pos);
- backward = start - distance;
- if((*pos) + length >= out->size) ucvector_resize(out, ((*pos) + length) * 2); /*reserve more room at once*/
- if((*pos) + length >= out->size) { error = 9914; break; } /*not enough memory*/
-
- for(forward = 0; forward < length; forward++)
- {
- out->data[(*pos)] = out->data[backward];
- (*pos)++;
- backward++;
- if(backward >= start) backward = start - distance;
- }
- }
- }
-
- HuffmanTree_cleanup(&codetree);
- HuffmanTree_cleanup(&codetreeD);
-
- return error;
-}
-
-static unsigned inflateNoCompression(ucvector* out, const unsigned char* in, size_t* bp, size_t* pos, size_t inlength)
-{
- /*go to first boundary of byte*/
- size_t p;
- unsigned LEN, NLEN, n, error = 0;
- while(((*bp) & 0x7) != 0) (*bp)++;
- p = (*bp) / 8; /*byte position*/
-
- /*read LEN (2 bytes) and NLEN (2 bytes)*/
- if(p >= inlength - 4) return 52; /*error, bit pointer will jump past memory*/
- LEN = in[p] + 256 * in[p + 1]; p += 2;
- NLEN = in[p] + 256 * in[p + 1]; p += 2;
-
- /*check if 16-bit NLEN is really the one's complement of LEN*/
- if(LEN + NLEN != 65535) return 21; /*error: NLEN is not one's complement of LEN*/
-
- if((*pos) + LEN >= out->size) { if(!ucvector_resize(out, (*pos) + LEN)) return 9915; }
-
- /*read the literal data: LEN bytes are now stored in the out buffer*/
- if(p + LEN > inlength) return 23; /*error: reading outside of in buffer*/
- for(n = 0; n < LEN; n++) out->data[(*pos)++] = in[p++];
-
- (*bp) = p * 8;
-
- return error;
-}
-
-/*inflate the deflated data (cfr. deflate spec); return value is the error*/
-unsigned LodeFlate_inflate(ucvector* out, const unsigned char* in, size_t insize, size_t inpos)
-{
- size_t bp = 0; /*bit pointer in the "in" data, current byte is bp >> 3, current bit is bp & 0x7 (from lsb to msb of the byte)*/
- unsigned BFINAL = 0;
- size_t pos = 0; /*byte position in the out buffer*/
-
- unsigned error = 0;
-
- while(!BFINAL)
- {
- unsigned BTYPE;
- if((bp >> 3) >= insize) return 52; /*error, bit pointer will jump past memory*/
- BFINAL = readBitFromStream(&bp, &in[inpos]);
- BTYPE = 1 * readBitFromStream(&bp, &in[inpos]); BTYPE += 2 * readBitFromStream(&bp, &in[inpos]);
-
- if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
- else if(BTYPE == 0) error = inflateNoCompression(out, &in[inpos], &bp, &pos, insize); /*no compression*/
- else error = inflateHuffmanBlock(out, &in[inpos], &bp, &pos, insize, BTYPE); /*compression, BTYPE 01 or 10*/
- if(error) return error;
- }
-
- if(!ucvector_resize(out, pos)) error = 9916; /*Only now we know the true size of out, resize it to that*/
-
- return error;
-}
-
-#endif /*LODEPNG_COMPILE_DECODER*/
-
-#ifdef LODEPNG_COMPILE_ENCODER
-
/* ////////////////////////////////////////////////////////////////////////// */
/* / Deflator / */
/* ////////////////////////////////////////////////////////////////////////// */
/*linear search implementation*/
/*for(size_t i = 1; i < array_size; i++) if(array[i] > value) return i - 1;
return array_size - 1;*/
-
+
/*binary search implementation (not that much faster) (precondition: array_size > 0)*/
size_t left = 1;
size_t right = array_size - 1;
unsigned extra_length = (unsigned)(length - LENGTHBASE[length_code]);
unsigned dist_code = (unsigned)searchCodeIndex(DISTANCEBASE, 30, distance);
unsigned extra_distance = (unsigned)(distance - DISTANCEBASE[dist_code]);
-
+
uivector_push_back(values, length_code + FIRST_LENGTH_CODE_INDEX);
uivector_push_back(values, extra_length);
uivector_push_back(values, dist_code);
/*using pointer instead of vector for input makes it faster when NOT using optimization when compiling; no influence if optimization is used*/
for(pos = 0; pos < size; pos++)
{
- /*Phase 1: doxygen images often have long runs of the same color, try to find them*/
+ /*Phase 1: doxygen images often have long runs of the same color, try to find them*/
const int minLength = 4; // Minimum length for a run to make sense
-
+
if(pos < size - minLength * 4)
{
size_t p, fp;
size_t current_length;
-
+
/*RGBA pixel run?*/
p = pos;
fp = pos + 4;
current_length = 0;
-
+
while(fp < size && in[p] == in[fp] && current_length < MAX_SUPPORTED_DEFLATE_LENGTH)
{
++p;
++fp;
++current_length;
}
-
+
if (current_length > (minLength - 1 ) * 4) /*worth using?*/
{
uivector_push_back(out, in[pos ]);
uivector_push_back(out, in[pos + 2]);
uivector_push_back(out, in[pos + 3]);
addLengthDistance(out, current_length, 4);
-
+
pos += current_length + 4 - 1; /*-1 for loop's pos++*/
continue;
}
-
+
/*RGB pixel run?*/
p = pos;
fp = pos + 3;
current_length = 0;
-
+
while(fp < size && in[p] == in[fp] && current_length < MAX_SUPPORTED_DEFLATE_LENGTH)
{
++p;
++fp;
++current_length;
}
-
+
if (current_length > (minLength - 1 ) * 3) /*worth using?*/
{
uivector_push_back(out, in[pos ]);
uivector_push_back(out, in[pos + 1]);
uivector_push_back(out, in[pos + 2]);
addLengthDistance(out, current_length, 3);
-
+
pos += current_length + 3 - 1; /*-1 for loop's pos++*/
continue;
}
size_t length = 0, offset = 0; /*the length and offset found for the current position*/
size_t max_offset = pos < windowSize ? pos : windowSize; /*how far back to test*/
size_t current_offset;
-
+
/**search for the longest string**/
for(current_offset = 1; current_offset < max_offset; current_offset++) /*search backwards through all possible distances (=offsets)*/
{
}
}
}
-
+
/**encode it as length/distance pair or literal value**/
if(length < 3) /*only lengths of 3 or higher are supported as length/distance pair*/
{
vector table; /*HASH_NUM_VALUES uivectors; this represents what would be an std::vector<std::vector<unsigned> > in C++*/
uivector tablepos1, tablepos2;
unsigned pos, i, error = 0;
-
+
vector_init(&table, sizeof(uivector));
if(!vector_resize(&table, HASH_NUM_VALUES)) return 9917;
for(i = 0; i < HASH_NUM_VALUES; i++)
uivector_init(&tablepos2);
if(!uivector_resizev(&tablepos1, HASH_NUM_VALUES, 0)) error = 9918;
if(!uivector_resizev(&tablepos2, HASH_NUM_VALUES, 0)) error = 9919;
-
+
if(!error)
{
for(pos = 0; pos < size; pos++)
unsigned length = 0, offset = 0; /*the length and offset found for the current position*/
unsigned max_offset = pos < windowSize ? pos : windowSize; /*how far back to test*/
unsigned tablepos;
-
+
/*/search for the longest string*/
/*first find out where in the table to start (the first value that is in the range from "pos - max_offset" to "pos")*/
unsigned hash = getHash(in, size, pos);
if(!uivector_push_back((uivector*)vector_get(&table, hash), pos)) { error = 9920; break; }
-
+
while(((uivector*)vector_get(&table, hash))->data[tablepos1.data[hash]] < pos - max_offset) tablepos1.data[hash]++; /*it now points to the first value in the table for which the index is larger than or equal to pos - max_offset*/
while(((uivector*)vector_get(&table, hash))->data[tablepos2.data[hash]] < pos) tablepos2.data[hash]++; /*it now points to the first value in the table for which the index is larger than or equal to pos*/
if(current_length == MAX_SUPPORTED_DEFLATE_LENGTH) break; /*you can jump out of this for loop once a length of max length is found (gives significant speed gain)*/
}
}
-
+
/**encode it as length/distance pair or literal value**/
if(length < 3) /*only lengths of 3 or higher are supported as length/distance pair*/
{
}
} /*end of the loop through each character of input*/
} /*end of "if(!error)"*/
-
+
/*cleanup*/
for(i = 0; i < table.size; i++)
{
static unsigned deflateNoCompression(ucvector* out, const unsigned char* data, size_t datasize)
{
/*non compressed deflate block data: 1 bit BFINAL,2 bits BTYPE,(5 bits): it jumps to start of next byte, 2 bytes LEN, 2 bytes NLEN, LEN bytes literal DATA*/
-
+
size_t i, j, numdeflateblocks = datasize / 65536 + 1;
unsigned datapos = 0;
for(i = 0; i < numdeflateblocks; i++)
{
unsigned BFINAL, BTYPE, LEN, NLEN;
unsigned char firstbyte;
-
+
BFINAL = (i == numdeflateblocks - 1);
BTYPE = 0;
-
+
firstbyte = (unsigned char)(BFINAL + ((BTYPE & 1) << 1) + ((BTYPE & 2) << 1));
ucvector_push_back(out, firstbyte);
-
+
LEN = 65535;
if(datasize - datapos < 65535) LEN = (unsigned)datasize - datapos;
NLEN = 65535 - LEN;
-
+
ucvector_push_back(out, (unsigned char)(LEN % 256));
ucvector_push_back(out, (unsigned char)(LEN / 256));
ucvector_push_back(out, (unsigned char)(NLEN % 256));
ucvector_push_back(out, data[datapos++]);
}
}
-
+
return 0;
}
unsigned length_index = val - FIRST_LENGTH_CODE_INDEX;
unsigned n_length_extra_bits = LENGTHEXTRA[length_index];
unsigned length_extra_bits = lz77_encoded->data[++i];
-
+
unsigned distance_code = lz77_encoded->data[++i];
-
+
unsigned distance_index = distance_code;
unsigned n_distance_extra_bits = DISTANCEEXTRA[distance_index];
unsigned distance_extra_bits = lz77_encoded->data[++i];
-
+
addBitsToStream(bp, out, length_extra_bits, n_length_extra_bits);
addHuffmanSymbol(bp, out, HuffmanTree_getCode(codesD, distance_code), HuffmanTree_getLength(codesD, distance_code));
addBitsToStream(bp, out, distance_extra_bits, n_distance_extra_bits);
- compressed data
- 256 (end code)
*/
-
+
unsigned error = 0;
-
+
uivector lz77_encoded;
HuffmanTree codes; /*tree for literal values and length codes*/
HuffmanTree codesD; /*tree for distance codes*/
uivector lldl;
uivector lldll; /*lit/len & dist code lengths*/
uivector clcls;
-
+
unsigned BFINAL = 1; /*make only one block... the first and final one*/
size_t numcodes, numcodesD, i, bp = 0; /*the bit pointer*/
unsigned HLIT, HDIST, HCLEN;
-
+
uivector_init(&lz77_encoded);
HuffmanTree_init(&codes);
HuffmanTree_init(&codesD);
uivector_init(&lldl);
uivector_init(&lldll);
uivector_init(&clcls);
-
+
while(!error) /*the goto-avoiding while construct: break out to go to the cleanup phase, a break at the end makes sure the while is never repeated*/
{
if(settings->useLZ77)
if(!uivector_resize(&lz77_encoded, datasize)) { error = 9923; break; }
for(i = 0; i < datasize; i++) lz77_encoded.data[i] = data[i]; /*no LZ77, but still will be Huffman compressed*/
}
-
+
if(!uivector_resizev(&frequencies, 286, 0)) { error = 9924; break; }
if(!uivector_resizev(&frequenciesD, 30, 0)) { error = 9925; break; }
for(i = 0; i < lz77_encoded.size; i++)
}
}
frequencies.data[256] = 1; /*there will be exactly 1 end code, at the end of the block*/
-
+
error = HuffmanTree_makeFromFrequencies(&codes, frequencies.data, frequencies.size, 15);
if(error) break;
error = HuffmanTree_makeFromFrequencies(&codesD, frequenciesD.data, frequenciesD.size, 15);
if(error) break;
-
+
addBitToStream(&bp, out, BFINAL);
addBitToStream(&bp, out, 0); /*first bit of BTYPE "dynamic"*/
addBitToStream(&bp, out, 1); /*second bit of BTYPE "dynamic"*/
-
+
numcodes = codes.numcodes; if(numcodes > 286) numcodes = 286;
numcodesD = codesD.numcodes; if(numcodesD > 30) numcodesD = 30;
for(i = 0; i < numcodes; i++) uivector_push_back(&lldll, HuffmanTree_getLength(&codes, (unsigned)i));
for(i = 0; i < numcodesD; i++) uivector_push_back(&lldll, HuffmanTree_getLength(&codesD, (unsigned)i));
-
+
/*make lldl smaller by using repeat codes 16 (copy length 3-6 times), 17 (3-10 zeros), 18 (11-138 zeros)*/
for(i = 0; i < (unsigned)lldll.size; i++)
{
unsigned j = 0;
while(i + j + 1 < (unsigned)lldll.size && lldll.data[i + j + 1] == lldll.data[i]) j++;
-
+
if(lldll.data[i] == 0 && j >= 2)
{
j++; /*include the first zero*/
}
else uivector_push_back(&lldl, lldll.data[i]);
}
-
+
/*generate huffmantree for the length codes of lit/len and dist codes*/
if(!uivector_resizev(&amounts, 19, 0)) { error = 9926; break; } /*16 possible lengths (0-15) and 3 repeat codes (16, 17 and 18)*/
for(i = 0; i < lldl.size; i++)
amounts.data[lldl.data[i]]++;
if(lldl.data[i] >= 16) i++; /*after a repeat code come the bits that specify the amount, those don't need to be in the amounts calculation*/
}
-
+
error = HuffmanTree_makeFromFrequencies(&codelengthcodes, amounts.data, amounts.size, 7);
if(error) break;
-
+
if(!uivector_resize(&clcls, 19)) { error = 9927; break; }
for(i = 0; i < 19; i++) clcls.data[i] = HuffmanTree_getLength(&codelengthcodes, CLCL[i]); /*lengths of code length tree is in the order as specified by deflate*/
while(clcls.data[clcls.size - 1] == 0 && clcls.size > 4)
if(!uivector_resize(&clcls, clcls.size - 1)) { error = 9928; break; } /*remove zeros at the end, but minimum size must be 4*/
}
if(error) break;
-
+
/*write the HLIT, HDIST and HCLEN values*/
HLIT = (unsigned)(numcodes - 257);
HDIST = (unsigned)(numcodesD - 1);
addBitsToStream(&bp, out, HLIT, 5);
addBitsToStream(&bp, out, HDIST, 5);
addBitsToStream(&bp, out, HCLEN, 4);
-
+
/*write the code lengths of the code length alphabet*/
for(i = 0; i < HCLEN + 4; i++) addBitsToStream(&bp, out, clcls.data[i], 3);
-
+
/*write the lengths of the lit/len AND the dist alphabet*/
for(i = 0; i < lldl.size; i++)
{
else if(lldl.data[i] == 17) addBitsToStream(&bp, out, lldl.data[++i], 3);
else if(lldl.data[i] == 18) addBitsToStream(&bp, out, lldl.data[++i], 7);
}
-
+
/*write the compressed data symbols*/
writeLZ77data(&bp, out, &lz77_encoded, &codes, &codesD);
if(HuffmanTree_getLength(&codes, 256) == 0) { error = 64; break; } /*the length of the end code 256 must be larger than 0*/
addHuffmanSymbol(&bp, out, HuffmanTree_getCode(&codes, 256), HuffmanTree_getLength(&codes, 256)); /*end code*/
-
+
break; /*end of error-while*/
}
-
+
/*cleanup*/
uivector_cleanup(&lz77_encoded);
HuffmanTree_cleanup(&codes);
uivector_cleanup(&lldl);
uivector_cleanup(&lldll);
uivector_cleanup(&clcls);
-
+
return error;
}
{
HuffmanTree codes; /*tree for literal values and length codes*/
HuffmanTree codesD; /*tree for distance codes*/
-
+
unsigned BFINAL = 1; /*make only one block... the first and final one*/
unsigned error = 0;
size_t i, bp = 0; /*the bit pointer*/
-
+
HuffmanTree_init(&codes);
HuffmanTree_init(&codesD);
-
+
generateFixedTree(&codes);
generateDistanceTree(&codesD);
-
+
addBitToStream(&bp, out, BFINAL);
addBitToStream(&bp, out, 1); /*first bit of BTYPE*/
addBitToStream(&bp, out, 0); /*second bit of BTYPE*/
-
+
if(settings->useLZ77) /*LZ77 encoded*/
{
uivector lz77_encoded;
for(i = 0; i < datasize; i++) addHuffmanSymbol(&bp, out, HuffmanTree_getCode(&codes, data[i]), HuffmanTree_getLength(&codes, data[i]));
}
if(!error) addHuffmanSymbol(&bp, out, HuffmanTree_getCode(&codes, 256), HuffmanTree_getLength(&codes, 256)); /*"end" code*/
-
+
/*cleanup*/
HuffmanTree_cleanup(&codes);
HuffmanTree_cleanup(&codesD);
-
+
return error;
}
return error;
}
-#endif /*LODEPNG_COMPILE_DECODER*/
/* ////////////////////////////////////////////////////////////////////////// */
/* / Adler32 */
{
unsigned s1 = adler & 0xffff;
unsigned s2 = (adler >> 16) & 0xffff;
-
+
while(len > 0)
{
/*at least 5550 sums can be done before the sums overflow, saving us from a lot of module divisions*/
s1 %= 65521;
s2 %= 65521;
}
-
+
return (s2 << 16) | s1;
}
/* / Reading and writing single bits and bytes from/to stream for Zlib / */
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_ENCODER
-void LodeZlib_add32bitInt(ucvector* buffer, unsigned value)
+static void LodeZlib_add32bitInt(ucvector* buffer, unsigned value)
{
ucvector_push_back(buffer, (unsigned char)((value >> 24) & 0xff));
ucvector_push_back(buffer, (unsigned char)((value >> 16) & 0xff));
ucvector_push_back(buffer, (unsigned char)((value >> 8) & 0xff));
ucvector_push_back(buffer, (unsigned char)((value ) & 0xff));
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
-
-unsigned LodeZlib_read32bitInt(const unsigned char* buffer)
-{
- return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
-}
/* ////////////////////////////////////////////////////////////////////////// */
/* / Zlib / */
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_DECODER
-
-unsigned LodeZlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DecompressSettings* settings)
-{
- unsigned error = 0;
- unsigned CM, CINFO, FDICT;
- ucvector outv;
-
- if(insize < 2) { error = 53; return error; } /*error, size of zlib data too small*/
- /*read information from zlib header*/
- if((in[0] * 256 + in[1]) % 31 != 0) { error = 24; return error; } /*error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way*/
-
- CM = in[0] & 15;
- CINFO = (in[0] >> 4) & 15;
- /*FCHECK = in[1] & 31; //FCHECK is already tested above*/
- FDICT = (in[1] >> 5) & 1;
- /*FLEVEL = (in[1] >> 6) & 3; //not really important, all it does it to give a compiler warning about unused variable, we don't care what encoding setting the encoder used*/
-
- if(CM != 8 || CINFO > 7) { error = 25; return error; } /*error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec*/
- if(FDICT != 0) { error = 26; return error; } /*error: the specification of PNG says about the zlib stream: "The additional flags shall not specify a preset dictionary."*/
-
- ucvector_init_buffer(&outv, *out, *outsize); /*ucvector-controlled version of the output buffer, for dynamic array*/
- error = LodeFlate_inflate(&outv, in, insize, 2);
- *out = outv.data;
- *outsize = outv.size;
- if(error) return error;
-
- if(!settings->ignoreAdler32)
- {
- unsigned ADLER32 = LodeZlib_read32bitInt(&in[insize - 4]);
- unsigned checksum = adler32(outv.data, (unsigned)outv.size);
- if(checksum != ADLER32) { error = 58; return error; }
- }
-
- return error;
-}
-
-#endif /*LODEPNG_COMPILE_DECODER*/
-
-#ifdef LODEPNG_COMPILE_ENCODER
-
-unsigned LodeZlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DeflateSettings* settings)
+static unsigned LodeZlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DeflateSettings* settings)
{
/*initially, *out must be NULL and outsize 0, if you just give some random *out that's pointing to a non allocated buffer, this'll crash*/
ucvector deflatedata, outv;
size_t i;
unsigned error;
-
+
unsigned ADLER32;
/*zlib data: 1 byte CMF (CM+CINFO), 1 byte FLG, deflate data, 4 byte ADLER32 checksum of the Decompressed data*/
unsigned CMF = 120; /*0b01111000: CM 8, CINFO 7. With CINFO 7, any window size up to 32768 can be used.*/
unsigned CMFFLG = 256 * CMF + FDICT * 32 + FLEVEL * 64;
unsigned FCHECK = 31 - CMFFLG % 31;
CMFFLG += FCHECK;
-
+
ucvector_init_buffer(&outv, *out, *outsize); /*ucvector-controlled version of the output buffer, for dynamic array*/
-
+
ucvector_push_back(&outv, (unsigned char)(CMFFLG / 256));
ucvector_push_back(&outv, (unsigned char)(CMFFLG % 256));
-
+
ucvector_init(&deflatedata);
error = LodeFlate_deflate(&deflatedata, in, insize, settings);
-
+
if(!error)
{
ADLER32 = adler32(in, (unsigned)insize);
ucvector_cleanup(&deflatedata);
LodeZlib_add32bitInt(&outv, ADLER32);
}
-
+
*out = outv.data;
*outsize = outv.size;
-
+
return error;
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
-
-#endif /*LODEPNG_COMPILE_ZLIB*/
-
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_ENCODER
-
void LodeZlib_DeflateSettings_init(LodeZlib_DeflateSettings* settings)
{
settings->btype = 2; /*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/
settings->windowSize = 2048; /*this is a good tradeoff between speed and compression ratio*/
}
-const LodeZlib_DeflateSettings LodeZlib_defaultDeflateSettings = {2, 1, 2048};
-
-#endif /*LODEPNG_COMPILE_ENCODER*/
-
-#ifdef LODEPNG_COMPILE_DECODER
-
-void LodeZlib_DecompressSettings_init(LodeZlib_DecompressSettings* settings)
-{
- settings->ignoreAdler32 = 0;
-}
-
-const LodeZlib_DecompressSettings LodeZlib_defaultDecompressSettings = {0};
-
-#endif /*LODEPNG_COMPILE_DECODER*/
-
/* ////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_PNG
-
/*
The two functions below (LodePNG_decompress and LodePNG_compress) directly call the
LodeZlib_decompress and LodeZlib_compress functions. The only purpose of the functions
be the size of the useful data in bytes, not the alloc size.
*/
-#ifdef LODEPNG_COMPILE_DECODER
-static unsigned LodePNG_decompress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DecompressSettings* settings)
-{
- return LodeZlib_decompress(out, outsize, in, insize, settings);
-}
-#endif /*LODEPNG_COMPILE_DECODER*/
-#ifdef LODEPNG_COMPILE_ENCODER
static unsigned LodePNG_compress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DeflateSettings* settings)
{
return LodeZlib_compress(out, outsize, in, insize, settings);
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
/* ////////////////////////////////////////////////////////////////////////// */
/* / CRC32 / */
Crc32_crc_table_computed = 1;
}
-/*Update a running CRC with the bytes buf[0..len-1]--the CRC should be
+/*Update a running CRC with the bytes buf[0..len-1]--the CRC should be
initialized to all 1's, and the transmitted value is the 1's complement of the
final running CRC (see the crc() routine below).*/
static unsigned Crc32_update_crc(const unsigned char* buf, unsigned int crc, size_t len)
return result;
}
-#ifdef LODEPNG_COMPILE_DECODER
-static void setBitOfReversedStream0(size_t* bitpointer, unsigned char* bitstream, unsigned char bit)
-{
- /*the current bit in bitstream must be 0 for this to work*/
- if(bit) bitstream[(*bitpointer) >> 3] |= (bit << (7 - ((*bitpointer) & 0x7))); /*earlier bit of huffman code is in a lesser significant bit of an earlier byte*/
- (*bitpointer)++;
-}
-#endif /*LODEPNG_COMPILE_DECODER*/
-
static void setBitOfReversedStream(size_t* bitpointer, unsigned char* bitstream, unsigned char bit)
{
/*the current bit in bitstream may be 0 or 1 for this to work*/
buffer[3] = (unsigned char)((value ) & 0xff);
}
-#ifdef LODEPNG_COMPILE_ENCODER
static void LodePNG_add32bitInt(ucvector* buffer, unsigned value)
{
ucvector_resize(buffer, buffer->size + 4);
LodePNG_set32bitInt(&buffer->data[buffer->size - 4], value);
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
/* ////////////////////////////////////////////////////////////////////////// */
/* / PNG chunks / */
/* ////////////////////////////////////////////////////////////////////////// */
-unsigned LodePNG_chunk_length(const unsigned char* chunk) /*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
+static unsigned LodePNG_chunk_length(const unsigned char* chunk) /*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
{
return LodePNG_read32bitInt(&chunk[0]);
}
-void LodePNG_chunk_type(char type[5], const unsigned char* chunk) /*puts the 4-byte type in null terminated string*/
+static void LodePNG_chunk_generate_crc(unsigned char* chunk) /*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
{
- unsigned i;
- for(i = 0; i < 4; i++) type[i] = chunk[4 + i];
- type[4] = 0; /*null termination char*/
+ unsigned length = LodePNG_chunk_length(chunk);
+ unsigned CRC = Crc32_crc(&chunk[4], length + 4);
+ LodePNG_set32bitInt(chunk + 8 + length, CRC);
}
-unsigned char LodePNG_chunk_type_equals(const unsigned char* chunk, const char* type) /*check if the type is the given type*/
-{
- if(strlen(type) != 4) return 0;
- return (chunk[4] == type[0] && chunk[5] == type[1] && chunk[6] == type[2] && chunk[7] == type[3]);
-}
-
-/*properties of PNG chunks gotten from capitalization of chunk type name, as defined by the standard*/
-unsigned char LodePNG_chunk_critical(const unsigned char* chunk) /*0: ancillary chunk, 1: it's one of the critical chunk types*/
-{
- return((chunk[4] & 32) == 0);
-}
-
-unsigned char LodePNG_chunk_private(const unsigned char* chunk) /*0: public, 1: private*/
-{
- return((chunk[6] & 32) != 0);
-}
-
-unsigned char LodePNG_chunk_safetocopy(const unsigned char* chunk) /*0: the chunk is unsafe to copy, 1: the chunk is safe to copy*/
-{
- return((chunk[7] & 32) != 0);
-}
-
-unsigned char* LodePNG_chunk_data(unsigned char* chunk) /*get pointer to the data of the chunk*/
-{
- return &chunk[8];
-}
-
-const unsigned char* LodePNG_chunk_data_const(const unsigned char* chunk) /*get pointer to the data of the chunk*/
-{
- return &chunk[8];
-}
-
-unsigned LodePNG_chunk_check_crc(const unsigned char* chunk) /*returns 0 if the crc is correct, error code if it's incorrect*/
-{
- unsigned length = LodePNG_chunk_length(chunk);
- unsigned CRC = LodePNG_read32bitInt(&chunk[length + 8]);
- unsigned checksum = Crc32_crc(&chunk[4], length + 4); /*the CRC is taken of the data and the 4 chunk type letters, not the length*/
- if(CRC != checksum) return 1;
- else return 0;
-}
-
-void LodePNG_chunk_generate_crc(unsigned char* chunk) /*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
-{
- unsigned length = LodePNG_chunk_length(chunk);
- unsigned CRC = Crc32_crc(&chunk[4], length + 4);
- LodePNG_set32bitInt(chunk + 8 + length, CRC);
-}
-
-unsigned char* LodePNG_chunk_next(unsigned char* chunk) /*don't use on IEND chunk, as there is no next chunk then*/
-{
- unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
- return &chunk[total_chunk_length];
-}
-
-const unsigned char* LodePNG_chunk_next_const(const unsigned char* chunk) /*don't use on IEND chunk, as there is no next chunk then*/
-{
- unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
- return &chunk[total_chunk_length];
-}
-
-unsigned LodePNG_append_chunk(unsigned char** out, size_t* outlength, const unsigned char* chunk) /*appends chunk that was already created, to the data. Returns error code.*/
-{
- unsigned i;
- unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
- unsigned char *chunk_start, *new_buffer;
- size_t new_length = (*outlength) + total_chunk_length;
- if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/
-
- new_buffer = (unsigned char*)realloc(*out, new_length);
- if(!new_buffer) return 9929;
- (*out) = new_buffer;
- (*outlength) = new_length;
- chunk_start = &(*out)[new_length - total_chunk_length];
-
- for(i = 0; i < total_chunk_length; i++) chunk_start[i] = chunk[i];
-
- return 0;
-}
-
-unsigned LodePNG_create_chunk(unsigned char** out, size_t* outlength, unsigned length, const char* type, const unsigned char* data) /*appends new chunk to out. Returns error code; may change memory address of out buffer*/
+static unsigned LodePNG_create_chunk(unsigned char** out, size_t* outlength, unsigned length, const char* type, const unsigned char* data) /*appends new chunk to out. Returns error code; may change memory address of out buffer*/
{
unsigned i;
unsigned char *chunk, *new_buffer;
(*out) = new_buffer;
(*outlength) = new_length;
chunk = &(*out)[(*outlength) - length - 12];
-
+
/*1: length*/
LodePNG_set32bitInt(chunk, (unsigned)length);
-
+
/*2: chunk name (4 letters)*/
chunk[4] = type[0];
chunk[5] = type[1];
chunk[6] = type[2];
chunk[7] = type[3];
-
+
/*3: the data*/
for(i = 0; i < length; i++) chunk[8 + i] = data[i];
-
+
/*4: CRC (of the chunkname characters and the data)*/
LodePNG_chunk_generate_crc(chunk);
-
+
return 0;
}
/* ////////////////////////////////////////////////////////////////////////// */
-void LodePNG_InfoColor_init(LodePNG_InfoColor* info)
+static void LodePNG_InfoColor_init(LodePNG_InfoColor* info)
{
info->key_defined = 0;
info->key_r = info->key_g = info->key_b = 0;
info->palettesize = 0;
}
-void LodePNG_InfoColor_cleanup(LodePNG_InfoColor* info)
+static void LodePNG_InfoColor_cleanup(LodePNG_InfoColor* info)
{
LodePNG_InfoColor_clearPalette(info);
}
-void LodePNG_InfoColor_clearPalette(LodePNG_InfoColor* info)
+static void LodePNG_InfoColor_clearPalette(LodePNG_InfoColor* info)
{
if(info->palette) free(info->palette);
info->palettesize = 0;
return 0;
}
-unsigned LodePNG_InfoColor_getBpp(const LodePNG_InfoColor* info) { return getBpp(info->colorType, info->bitDepth); } /*calculate bits per pixel out of colorType and bitDepth*/
-unsigned LodePNG_InfoColor_getChannels(const LodePNG_InfoColor* info) { return getNumColorChannels(info->colorType); }
-unsigned LodePNG_InfoColor_isGreyscaleType(const LodePNG_InfoColor* info) { return info->colorType == 0 || info->colorType == 4; }
-unsigned LodePNG_InfoColor_isAlphaType(const LodePNG_InfoColor* info) { return (info->colorType & 4) != 0; }
+static unsigned LodePNG_InfoColor_getBpp(const LodePNG_InfoColor* info) { return getBpp(info->colorType, info->bitDepth); } /*calculate bits per pixel out of colorType and bitDepth*/
+static unsigned LodePNG_InfoColor_isGreyscaleType(const LodePNG_InfoColor* info) { return info->colorType == 0 || info->colorType == 4; }
+static unsigned LodePNG_InfoColor_isAlphaType(const LodePNG_InfoColor* info) { return (info->colorType & 4) != 0; }
-unsigned LodePNG_InfoColor_equal(const LodePNG_InfoColor* info1, const LodePNG_InfoColor* info2)
+static unsigned LodePNG_InfoColor_equal(const LodePNG_InfoColor* info1, const LodePNG_InfoColor* info2)
{
return info1->colorType == info2->colorType
&& info1->bitDepth == info2->bitDepth; /*palette and color key not compared*/
}
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
-
-void LodePNG_UnknownChunks_init(LodePNG_UnknownChunks* chunks)
-{
- unsigned i;
- for(i = 0; i < 3; i++) chunks->data[i] = 0;
- for(i = 0; i < 3; i++) chunks->datasize[i] = 0;
-}
-
-void LodePNG_UnknownChunks_cleanup(LodePNG_UnknownChunks* chunks)
-{
- unsigned i;
- for(i = 0; i < 3; i++) free(chunks->data[i]);
-}
-
-unsigned LodePNG_UnknownChunks_copy(LodePNG_UnknownChunks* dest, const LodePNG_UnknownChunks* src)
-{
- unsigned i;
-
- LodePNG_UnknownChunks_cleanup(dest);
-
- for(i = 0; i < 3; i++)
- {
- size_t j;
- dest->datasize[i] = src->datasize[i];
- dest->data[i] = (unsigned char*)malloc(src->datasize[i]);
- if(!dest->data[i] && dest->datasize[i]) return 9932;
- for(j = 0; j < src->datasize[i]; j++) dest->data[i][j] = src->data[i][j];
- }
-
- return 0;
-}
-
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
-
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
-
-void LodePNG_Text_init(LodePNG_Text* text)
-{
- text->num = 0;
- text->keys = NULL;
- text->strings = NULL;
-}
-
-void LodePNG_Text_cleanup(LodePNG_Text* text)
-{
- LodePNG_Text_clear(text);
-}
-
-unsigned LodePNG_Text_copy(LodePNG_Text* dest, const LodePNG_Text* source)
-{
- size_t i = 0;
- dest->keys = 0;
- dest->strings = 0;
- dest->num = 0;
- for(i = 0; i < source->num; i++)
- {
- unsigned error = LodePNG_Text_add(dest, source->keys[i], source->strings[i]);
- if(error) return error;
- }
- return 0;
-}
-
-void LodePNG_Text_clear(LodePNG_Text* text)
-{
- size_t i;
- for(i = 0; i < text->num; i++)
- {
- string_cleanup(&text->keys[i]);
- string_cleanup(&text->strings[i]);
- }
- free(text->keys);
- free(text->strings);
-}
-
-unsigned LodePNG_Text_add(LodePNG_Text* text, const char* key, const char* str)
-{
- char** new_keys = (char**)(realloc(text->keys, sizeof(char*) * (text->num + 1)));
- char** new_strings = (char**)(realloc(text->strings, sizeof(char*) * (text->num + 1)));
- if(!new_keys || !new_strings)
- {
- free(new_keys);
- free(new_strings);
- return 9933;
- }
-
- text->num++;
- text->keys = new_keys;
- text->strings = new_strings;
-
- string_init(&text->keys[text->num - 1]);
- string_set(&text->keys[text->num - 1], key);
-
- string_init(&text->strings[text->num - 1]);
- string_set(&text->strings[text->num - 1], str);
-
- return 0;
-}
-
-/******************************************************************************/
-
-void LodePNG_IText_init(LodePNG_IText* text)
-{
- text->num = 0;
- text->keys = NULL;
- text->langtags = NULL;
- text->transkeys = NULL;
- text->strings = NULL;
-}
-
-void LodePNG_IText_cleanup(LodePNG_IText* text)
-{
- LodePNG_IText_clear(text);
-}
-
-unsigned LodePNG_IText_copy(LodePNG_IText* dest, const LodePNG_IText* source)
-{
- size_t i = 0;
- dest->keys = 0;
- dest->langtags = 0;
- dest->transkeys = 0;
- dest->strings = 0;
- dest->num = 0;
- for(i = 0; i < source->num; i++)
- {
- unsigned error = LodePNG_IText_add(dest, source->keys[i], source->langtags[i], source->transkeys[i], source->strings[i]);
- if(error) return error;
- }
- return 0;
-}
-
-void LodePNG_IText_clear(LodePNG_IText* text)
-{
- size_t i;
- for(i = 0; i < text->num; i++)
- {
- string_cleanup(&text->keys[i]);
- string_cleanup(&text->langtags[i]);
- string_cleanup(&text->transkeys[i]);
- string_cleanup(&text->strings[i]);
- }
- free(text->keys);
- free(text->langtags);
- free(text->transkeys);
- free(text->strings);
-}
-unsigned LodePNG_IText_add(LodePNG_IText* text, const char* key, const char* langtag, const char* transkey, const char* str)
-{
- char** new_keys = (char**)(realloc(text->keys, sizeof(char*) * (text->num + 1)));
- char** new_langtags = (char**)(realloc(text->langtags, sizeof(char*) * (text->num + 1)));
- char** new_transkeys = (char**)(realloc(text->transkeys, sizeof(char*) * (text->num + 1)));
- char** new_strings = (char**)(realloc(text->strings, sizeof(char*) * (text->num + 1)));
- if(!new_keys || !new_langtags || !new_transkeys || !new_strings)
- {
- free(new_keys);
- free(new_langtags);
- free(new_transkeys);
- free(new_strings);
- return 9934;
- }
-
- text->num++;
- text->keys = new_keys;
- text->langtags = new_langtags;
- text->transkeys = new_transkeys;
- text->strings = new_strings;
-
- string_init(&text->keys[text->num - 1]);
- string_set(&text->keys[text->num - 1], key);
-
- string_init(&text->langtags[text->num - 1]);
- string_set(&text->langtags[text->num - 1], langtag);
-
- string_init(&text->transkeys[text->num - 1]);
- string_set(&text->transkeys[text->num - 1], transkey);
-
- string_init(&text->strings[text->num - 1]);
- string_set(&text->strings[text->num - 1], str);
-
- return 0;
-}
-
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-
-void LodePNG_InfoPng_init(LodePNG_InfoPng* info)
+static void LodePNG_InfoPng_init(LodePNG_InfoPng* info)
{
info->width = info->height = 0;
LodePNG_InfoColor_init(&info->color);
info->interlaceMethod = 0;
info->compressionMethod = 0;
info->filterMethod = 0;
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- info->background_defined = 0;
- info->background_r = info->background_g = info->background_b = 0;
-
- LodePNG_Text_init(&info->text);
- LodePNG_IText_init(&info->itext);
-
- info->time_defined = 0;
- info->phys_defined = 0;
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- LodePNG_UnknownChunks_init(&info->unknown_chunks);
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
}
-void LodePNG_InfoPng_cleanup(LodePNG_InfoPng* info)
+static void LodePNG_InfoPng_cleanup(LodePNG_InfoPng* info)
{
LodePNG_InfoColor_cleanup(&info->color);
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- LodePNG_Text_cleanup(&info->text);
- LodePNG_IText_cleanup(&info->itext);
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- LodePNG_UnknownChunks_cleanup(&info->unknown_chunks);
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
}
-unsigned LodePNG_InfoPng_copy(LodePNG_InfoPng* dest, const LodePNG_InfoPng* source)
+static unsigned LodePNG_InfoPng_copy(LodePNG_InfoPng* dest, const LodePNG_InfoPng* source)
{
unsigned error = 0;
LodePNG_InfoPng_cleanup(dest);
*dest = *source;
LodePNG_InfoColor_init(&dest->color);
error = LodePNG_InfoColor_copy(&dest->color, &source->color); if(error) return error;
-
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- error = LodePNG_Text_copy(&dest->text, &source->text); if(error) return error;
- error = LodePNG_IText_copy(&dest->itext, &source->itext); if(error) return error;
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- LodePNG_UnknownChunks_init(&dest->unknown_chunks);
- error = LodePNG_UnknownChunks_copy(&dest->unknown_chunks, &source->unknown_chunks); if(error) return error;
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
return error;
}
-void LodePNG_InfoPng_swap(LodePNG_InfoPng* a, LodePNG_InfoPng* b)
-{
- LodePNG_InfoPng temp = *a;
- *a = *b;
- *b = temp;
-}
-
-unsigned LodePNG_InfoColor_copy(LodePNG_InfoColor* dest, const LodePNG_InfoColor* source)
+static unsigned LodePNG_InfoColor_copy(LodePNG_InfoColor* dest, const LodePNG_InfoColor* source)
{
size_t i;
LodePNG_InfoColor_cleanup(dest);
return 0;
}
-void LodePNG_InfoRaw_init(LodePNG_InfoRaw* info)
+static void LodePNG_InfoRaw_init(LodePNG_InfoRaw* info)
{
LodePNG_InfoColor_init(&info->color);
}
-void LodePNG_InfoRaw_cleanup(LodePNG_InfoRaw* info)
+static void LodePNG_InfoRaw_cleanup(LodePNG_InfoRaw* info)
{
LodePNG_InfoColor_cleanup(&info->color);
}
-unsigned LodePNG_InfoRaw_copy(LodePNG_InfoRaw* dest, const LodePNG_InfoRaw* source)
+static unsigned LodePNG_InfoRaw_copy(LodePNG_InfoRaw* dest, const LodePNG_InfoRaw* source)
{
unsigned error = 0;
LodePNG_InfoRaw_cleanup(dest);
the out buffer must have (w * h * bpp + 7) / 8 bytes, where bpp is the bits per pixel of the output color type (LodePNG_InfoColor_getBpp)
for < 8 bpp images, there may _not_ be padding bits at the end of scanlines.
*/
-unsigned LodePNG_convert(unsigned char* out, const unsigned char* in, LodePNG_InfoColor* infoOut, LodePNG_InfoColor* infoIn, unsigned w, unsigned h)
+static unsigned LodePNG_convert(unsigned char* out, const unsigned char* in, LodePNG_InfoColor* infoOut, LodePNG_InfoColor* infoIn, unsigned w, unsigned h)
{
const size_t numpixels = w * h; /*amount of pixels*/
const unsigned OUT_BYTES = LodePNG_InfoColor_getBpp(infoOut) / 8; /*bytes per pixel in the output image*/
const unsigned OUT_ALPHA = LodePNG_InfoColor_isAlphaType(infoOut); /*use 8-bit alpha channel*/
size_t i, c, bp = 0; /*bitpointer, used by less-than-8-bit color types*/
-
+
/*cases where in and out already have the same format*/
if(LodePNG_InfoColor_equal(infoIn, infoOut))
{
for(i = 0; i < numpixels; i++)
{
if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
- out[OUT_BYTES * i] = in[i];
- if(OUT_ALPHA && infoIn->key_defined && in[i] == infoIn->key_r) out[OUT_BYTES * i + 1] = 0;
- }
- break;
- case 4: /*greyscale with alpha*/
- for(i = 0; i < numpixels; i++)
- {
- out[OUT_BYTES * i + 0] = in[2 * i + 0];
- if(OUT_ALPHA) out[OUT_BYTES * i + 1] = in[2 * i + 1];
- }
- break;
- default: return 31;
- }
- }
- else if(infoIn->bitDepth == 16)
- {
- switch(infoIn->colorType)
- {
- case 0: /*greyscale color*/
- for(i = 0; i < numpixels; i++)
- {
- if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
- out[OUT_BYTES * i] = in[2 * i];
- if(OUT_ALPHA && infoIn->key_defined && 256U * in[i] + in[i + 1] == infoIn->key_r) out[OUT_BYTES * i + 1] = 0;
- }
- break;
- case 4: /*greyscale with alpha*/
- for(i = 0; i < numpixels; i++)
- {
- out[OUT_BYTES * i] = in[4 * i]; /*most significant byte*/
- if(OUT_ALPHA) out[OUT_BYTES * i + 1] = in[4 * i + 2]; /*most significant byte*/
- }
- break;
- default: return 31;
- }
- }
- else /*infoIn->bitDepth is less than 8 bit per channel*/
- {
- if(infoIn->colorType != 0) return 31; /*colorType 0 is the only greyscale type with < 8 bits per channel*/
- for(i = 0; i < numpixels; i++)
- {
- unsigned value = readBitsFromReversedStream(&bp, in, infoIn->bitDepth);
- if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
- if(OUT_ALPHA && infoIn->key_defined && value && ((1U << infoIn->bitDepth) - 1U) == infoIn->key_r && ((1U << infoIn->bitDepth) - 1U)) out[OUT_BYTES * i + 1] = 0;
- value = (value * 255) / ((1 << infoIn->bitDepth) - 1); /*scale value from 0 to 255*/
- out[OUT_BYTES * i] = (unsigned char)(value);
- }
- }
- }
- else return 59;
-
- return 0;
-}
-
-/*Path predictor, used by PNG filter type 4*/
-static int paethPredictor(int a, int b, int c)
-{
- int p = a + b - c;
- int pa = p > a ? p - a : a - p;
- int pb = p > b ? p - b : b - p;
- int pc = p > c ? p - c : c - p;
-
- if(pa <= pb && pa <= pc) return a;
- else if(pb <= pc) return b;
- else return c;
-}
-
-/*shared values used by multiple Adam7 related functions*/
-
-static const unsigned ADAM7_IX[7] = { 0, 4, 0, 2, 0, 1, 0 }; /*x start values*/
-static const unsigned ADAM7_IY[7] = { 0, 0, 4, 0, 2, 0, 1 }; /*y start values*/
-static const unsigned ADAM7_DX[7] = { 8, 8, 4, 4, 2, 2, 1 }; /*x delta values*/
-static const unsigned ADAM7_DY[7] = { 8, 8, 8, 4, 4, 2, 2 }; /*y delta values*/
-
-static void Adam7_getpassvalues(unsigned passw[7], unsigned passh[7], size_t filter_passstart[8], size_t padded_passstart[8], size_t passstart[8], unsigned w, unsigned h, unsigned bpp)
-{
- /*the passstart values have 8 values: the 8th one actually indicates the byte after the end of the 7th (= last) pass*/
- unsigned i;
-
- /*calculate width and height in pixels of each pass*/
- for(i = 0; i < 7; i++)
- {
- passw[i] = (w + ADAM7_DX[i] - ADAM7_IX[i] - 1) / ADAM7_DX[i];
- passh[i] = (h + ADAM7_DY[i] - ADAM7_IY[i] - 1) / ADAM7_DY[i];
- if(passw[i] == 0) passh[i] = 0;
- if(passh[i] == 0) passw[i] = 0;
- }
-
- filter_passstart[0] = padded_passstart[0] = passstart[0] = 0;
- for(i = 0; i < 7; i++)
- {
- filter_passstart[i + 1] = filter_passstart[i] + ((passw[i] && passh[i]) ? passh[i] * (1 + (passw[i] * bpp + 7) / 8) : 0); /*if passw[i] is 0, it's 0 bytes, not 1 (no filtertype-byte)*/
- padded_passstart[i + 1] = padded_passstart[i] + passh[i] * ((passw[i] * bpp + 7) / 8); /*bits padded if needed to fill full byte at end of each scanline*/
- passstart[i + 1] = passstart[i] + (passh[i] * passw[i] * bpp + 7) / 8; /*only padded at end of reduced image*/
- }
-}
-
-#ifdef LODEPNG_COMPILE_DECODER
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* / PNG Decoder / */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-/*read the information from the header and store it in the LodePNG_Info. return value is error*/
-void LodePNG_inspect(LodePNG_Decoder* decoder, const unsigned char* in, size_t inlength)
-{
- if(inlength == 0 || in == 0) { decoder->error = 48; return; } /*the given data is empty*/
- if(inlength < 29) { decoder->error = 27; return; } /*error: the data length is smaller than the length of the header*/
-
- /*when decoding a new PNG image, make sure all parameters created after previous decoding are reset*/
- LodePNG_InfoPng_cleanup(&decoder->infoPng);
- LodePNG_InfoPng_init(&decoder->infoPng);
- decoder->error = 0;
-
- if(in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) { decoder->error = 28; return; } /*error: the first 8 bytes are not the correct PNG signature*/
- if(in[12] != 'I' || in[13] != 'H' || in[14] != 'D' || in[15] != 'R') { decoder->error = 29; return; } /*error: it doesn't start with a IHDR chunk!*/
-
- /*read the values given in the header*/
- decoder->infoPng.width = LodePNG_read32bitInt(&in[16]);
- decoder->infoPng.height = LodePNG_read32bitInt(&in[20]);
- decoder->infoPng.color.bitDepth = in[24];
- decoder->infoPng.color.colorType = in[25];
- decoder->infoPng.compressionMethod = in[26];
- decoder->infoPng.filterMethod = in[27];
- decoder->infoPng.interlaceMethod = in[28];
-
- if(!decoder->settings.ignoreCrc)
- {
- unsigned CRC = LodePNG_read32bitInt(&in[29]);
- unsigned checksum = Crc32_crc(&in[12], 17);
- if(CRC != checksum) { decoder->error = 57; return; }
- }
-
- if(decoder->infoPng.compressionMethod != 0) { decoder->error = 32; return; } /*error: only compression method 0 is allowed in the specification*/
- if(decoder->infoPng.filterMethod != 0) { decoder->error = 33; return; } /*error: only filter method 0 is allowed in the specification*/
- if(decoder->infoPng.interlaceMethod > 1) { decoder->error = 34; return; } /*error: only interlace methods 0 and 1 exist in the specification*/
-
- decoder->error = checkColorValidity(decoder->infoPng.color.colorType, decoder->infoPng.color.bitDepth);
-}
-
-static unsigned unfilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon, size_t bytewidth, unsigned char filterType, size_t length)
-{
- /*
- For PNG filter method 0
- unfilter a PNG image scanline by scanline. when the pixels are smaller than 1 byte, the filter works byte per byte (bytewidth = 1)
- precon is the previous unfiltered scanline, recon the result, scanline the current one
- the incoming scanlines do NOT include the filtertype byte, that one is given in the parameter filterType instead
- recon and scanline MAY be the same memory address! precon must be disjoint.
- */
-
- size_t i;
- switch(filterType)
- {
- case 0:
- for(i = 0; i < length; i++) recon[i] = scanline[i];
- break;
- case 1:
- for(i = 0; i < bytewidth; i++) recon[i] = scanline[i];
- for(i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth];
- break;
- case 2:
- if(precon) for(i = 0; i < length; i++) recon[i] = scanline[i] + precon[i];
- else for(i = 0; i < length; i++) recon[i] = scanline[i];
- break;
- case 3:
- if(precon)
- {
- for(i = 0; i < bytewidth; i++) recon[i] = scanline[i] + precon[i] / 2;
- for(i = bytewidth; i < length; i++) recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) / 2);
- }
- else
- {
- for(i = 0; i < bytewidth; i++) recon[i] = scanline[i];
- for(i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth] / 2;
- }
- break;
- case 4:
- if(precon)
- {
- for(i = 0; i < bytewidth; i++) recon[i] = (unsigned char)(scanline[i] + paethPredictor(0, precon[i], 0));
- for(i = bytewidth; i < length; i++) recon[i] = (unsigned char)(scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth]));
- }
- else
- {
- for(i = 0; i < bytewidth; i++) recon[i] = scanline[i];
- for(i = bytewidth; i < length; i++) recon[i] = (unsigned char)(scanline[i] + paethPredictor(recon[i - bytewidth], 0, 0));
- }
- break;
- default: return 36; /*error: unexisting filter type given*/
- }
- return 0;
-}
-
-static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
-{
- /*
- For PNG filter method 0
- this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 it's called 7 times)
- out must have enough bytes allocated already, in must have the scanlines + 1 filtertype byte per scanline
- w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel
- in and out are allowed to be the same memory address!
- */
-
- unsigned y;
- unsigned char* prevline = 0;
-
- size_t bytewidth = (bpp + 7) / 8; /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
- size_t linebytes = (w * bpp + 7) / 8;
-
- for(y = 0; y < h; y++)
- {
- size_t outindex = linebytes * y;
- size_t inindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
- unsigned char filterType = in[inindex];
-
- unsigned error = unfilterScanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, filterType, linebytes);
- if(error) return error;
-
- prevline = &out[outindex];
- }
-
- return 0;
-}
-
-static void Adam7_deinterlace(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
-{
- /*Note: this function works on image buffers WITHOUT padding bits at end of scanlines with non-multiple-of-8 bit amounts, only between reduced images is padding
- out must be big enough AND must be 0 everywhere if bpp < 8 in the current implementation (because that's likely a little bit faster)*/
- unsigned passw[7], passh[7]; size_t filter_passstart[8], padded_passstart[8], passstart[8];
- unsigned i;
-
- Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
-
- if(bpp >= 8)
- {
- for(i = 0; i < 7; i++)
- {
- unsigned x, y, b;
- size_t bytewidth = bpp / 8;
- for(y = 0; y < passh[i]; y++)
- for(x = 0; x < passw[i]; x++)
- {
- size_t pixelinstart = passstart[i] + (y * passw[i] + x) * bytewidth;
- size_t pixeloutstart = ((ADAM7_IY[i] + y * ADAM7_DY[i]) * w + ADAM7_IX[i] + x * ADAM7_DX[i]) * bytewidth;
- for(b = 0; b < bytewidth; b++)
- {
- out[pixeloutstart + b] = in[pixelinstart + b];
- }
- }
- }
- }
- else /*bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers*/
- {
- for(i = 0; i < 7; i++)
- {
- unsigned x, y, b;
- unsigned ilinebits = bpp * passw[i];
- unsigned olinebits = bpp * w;
- size_t obp, ibp; /*bit pointers (for out and in buffer)*/
- for(y = 0; y < passh[i]; y++)
- for(x = 0; x < passw[i]; x++)
- {
- ibp = (8 * passstart[i]) + (y * ilinebits + x * bpp);
- obp = (ADAM7_IY[i] + y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + x * ADAM7_DX[i]) * bpp;
- for(b = 0; b < bpp; b++)
- {
- unsigned char bit = readBitFromReversedStream(&ibp, in);
- setBitOfReversedStream0(&obp, out, bit); /*note that this function assumes the out buffer is completely 0, use setBitOfReversedStream otherwise*/
- }
- }
- }
- }
-}
-
-static void removePaddingBits(unsigned char* out, const unsigned char* in, size_t olinebits, size_t ilinebits, unsigned h)
-{
- /*
- After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers for the Adam7 code, the color convert code and the output to the user.
- in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits
- also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7
- only useful if (ilinebits - olinebits) is a value in the range 1..7
- */
- unsigned y;
- size_t diff = ilinebits - olinebits;
- size_t obp = 0, ibp = 0; /*bit pointers*/
- for(y = 0; y < h; y++)
- {
- size_t x;
- for(x = 0; x < olinebits; x++)
- {
- unsigned char bit = readBitFromReversedStream(&ibp, in);
- setBitOfReversedStream(&obp, out, bit);
- }
- ibp += diff;
- }
-}
-
-/*out must be buffer big enough to contain full image, and in must contain the full decompressed data from the IDAT chunks*/
-static unsigned postProcessScanlines(unsigned char* out, unsigned char* in, const LodePNG_InfoPng* infoPng) /*return value is error*/
-{
- /*
- This function converts the filtered-padded-interlaced data into pure 2D image buffer with the PNG's colortype. Steps:
- *) if no Adam7: 1) unfilter 2) remove padding bits (= possible extra bits per scanline if bpp < 8)
- *) if adam7: 1) 7x unfilter 2) 7x remove padding bits 3) Adam7_deinterlace
- NOTE: the in buffer will be overwritten with intermediate data!
- */
- unsigned bpp = LodePNG_InfoColor_getBpp(&infoPng->color);
- unsigned w = infoPng->width;
- unsigned h = infoPng->height;
- unsigned error = 0;
- if(bpp == 0) return 31; /*error: invalid colortype*/
-
- if(infoPng->interlaceMethod == 0)
- {
- if(bpp < 8 && w * bpp != ((w * bpp + 7) / 8) * 8)
- {
- error = unfilter(in, in, w, h, bpp);
- if(error) return error;
- removePaddingBits(out, in, w * bpp, ((w * bpp + 7) / 8) * 8, h);
- }
- else error = unfilter(out, in, w, h, bpp); /*we can immediately filter into the out buffer, no other steps needed*/
- }
- else /*interlaceMethod is 1 (Adam7)*/
- {
- unsigned passw[7], passh[7]; size_t filter_passstart[8], padded_passstart[8], passstart[8];
- unsigned i;
-
- Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
-
- for(i = 0; i < 7; i++)
- {
- error = unfilter(&in[padded_passstart[i]], &in[filter_passstart[i]], passw[i], passh[i], bpp);
- if(error) return error;
- if(bpp < 8) /*TODO: possible efficiency improvement: if in this reduced image the bits fit nicely in 1 scanline, move bytes instead of bits or move not at all*/
- {
- /*remove padding bits in scanlines; after this there still may be padding bits between the different reduced images: each reduced image still starts nicely at a byte*/
- removePaddingBits(&in[passstart[i]], &in[padded_passstart[i]], passw[i] * bpp, ((passw[i] * bpp + 7) / 8) * 8, passh[i]);
- }
- }
-
- Adam7_deinterlace(out, in, w, h, bpp);
- }
-
- return error;
-}
-
-/*read a PNG, the result will be in the same color type as the PNG (hence "generic")*/
-static void decodeGeneric(LodePNG_Decoder* decoder, unsigned char** out, size_t* outsize, const unsigned char* in, size_t size)
-{
- unsigned char IEND = 0;
- const unsigned char* chunk;
- size_t i;
- ucvector idat; /*the data from idat chunks*/
-
- /*for unknown chunk order*/
- unsigned unknown = 0;
- unsigned critical_pos = 1; /*1 = after IHDR, 2 = after PLTE, 3 = after IDAT*/
-
- /*provide some proper output values if error will happen*/
- *out = 0;
- *outsize = 0;
-
- if(size == 0 || in == 0) { decoder->error = 48; return; } /*the given data is empty*/
-
- LodePNG_inspect(decoder, in, size); /*reads header and resets other parameters in decoder->infoPng*/
- if(decoder->error) return;
-
- ucvector_init(&idat);
-
- chunk = &in[33]; /*first byte of the first chunk after the header*/
-
- while(!IEND) /*loop through the chunks, ignoring unknown chunks and stopping at IEND chunk. IDAT data is put at the start of the in buffer*/
- {
- unsigned chunkLength;
- const unsigned char* data; /*the data in the chunk*/
-
- if((size_t)((chunk - in) + 12) > size || chunk < in) { decoder->error = 30; break; } /*error: size of the in buffer too small to contain next chunk*/
- chunkLength = LodePNG_chunk_length(chunk); /*length of the data of the chunk, excluding the length bytes, chunk type and CRC bytes*/
- if(chunkLength > 2147483647) { decoder->error = 63; break; }
- if((size_t)((chunk - in) + chunkLength + 12) > size || (chunk + chunkLength + 12) < in) { decoder->error = 35; break; } /*error: size of the in buffer too small to contain next chunk*/
- data = LodePNG_chunk_data_const(chunk);
-
- /*IDAT chunk, containing compressed image data*/
- if(LodePNG_chunk_type_equals(chunk, "IDAT"))
- {
- size_t oldsize = idat.size;
- if(!ucvector_resize(&idat, oldsize + chunkLength)) { decoder->error = 9936; break; }
- for(i = 0; i < chunkLength; i++) idat.data[oldsize + i] = data[i];
- critical_pos = 3;
- }
- /*IEND chunk*/
- else if(LodePNG_chunk_type_equals(chunk, "IEND"))
- {
- IEND = 1;
- }
- /*palette chunk (PLTE)*/
- else if(LodePNG_chunk_type_equals(chunk, "PLTE"))
- {
- unsigned pos = 0;
- if(decoder->infoPng.color.palette) free(decoder->infoPng.color.palette);
- decoder->infoPng.color.palettesize = chunkLength / 3;
- decoder->infoPng.color.palette = (unsigned char*)malloc(4 * decoder->infoPng.color.palettesize);
- if(!decoder->infoPng.color.palette && decoder->infoPng.color.palettesize) { decoder->error = 9937; break; }
- if(!decoder->infoPng.color.palette) decoder->infoPng.color.palettesize = 0; /*malloc failed...*/
- if(decoder->infoPng.color.palettesize > 256) { decoder->error = 38; break; } /*error: palette too big*/
- for(i = 0; i < decoder->infoPng.color.palettesize; i++)
- {
- decoder->infoPng.color.palette[4 * i + 0] = data[pos++]; /*R*/
- decoder->infoPng.color.palette[4 * i + 1] = data[pos++]; /*G*/
- decoder->infoPng.color.palette[4 * i + 2] = data[pos++]; /*B*/
- decoder->infoPng.color.palette[4 * i + 3] = 255; /*alpha*/
- }
- critical_pos = 2;
- }
- /*palette transparency chunk (tRNS)*/
- else if(LodePNG_chunk_type_equals(chunk, "tRNS"))
- {
- if(decoder->infoPng.color.colorType == 3)
- {
- if(chunkLength > decoder->infoPng.color.palettesize) { decoder->error = 39; break; } /*error: more alpha values given than there are palette entries*/
- for(i = 0; i < chunkLength; i++) decoder->infoPng.color.palette[4 * i + 3] = data[i];
- }
- else if(decoder->infoPng.color.colorType == 0)
- {
- if(chunkLength != 2) { decoder->error = 40; break; } /*error: this chunk must be 2 bytes for greyscale image*/
- decoder->infoPng.color.key_defined = 1;
- decoder->infoPng.color.key_r = decoder->infoPng.color.key_g = decoder->infoPng.color.key_b = 256 * data[0] + data[1];
- }
- else if(decoder->infoPng.color.colorType == 2)
- {
- if(chunkLength != 6) { decoder->error = 41; break; } /*error: this chunk must be 6 bytes for RGB image*/
- decoder->infoPng.color.key_defined = 1;
- decoder->infoPng.color.key_r = 256 * data[0] + data[1];
- decoder->infoPng.color.key_g = 256 * data[2] + data[3];
- decoder->infoPng.color.key_b = 256 * data[4] + data[5];
- }
- else { decoder->error = 42; break; } /*error: tRNS chunk not allowed for other color models*/
- }
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- /*background color chunk (bKGD)*/
- else if(LodePNG_chunk_type_equals(chunk, "bKGD"))
- {
- if(decoder->infoPng.color.colorType == 3)
- {
- if(chunkLength != 1) { decoder->error = 43; break; } /*error: this chunk must be 1 byte for indexed color image*/
- decoder->infoPng.background_defined = 1;
- decoder->infoPng.background_r = decoder->infoPng.background_g = decoder->infoPng.background_g = data[0];
- }
- else if(decoder->infoPng.color.colorType == 0 || decoder->infoPng.color.colorType == 4)
- {
- if(chunkLength != 2) { decoder->error = 44; break; } /*error: this chunk must be 2 bytes for greyscale image*/
- decoder->infoPng.background_defined = 1;
- decoder->infoPng.background_r = decoder->infoPng.background_g = decoder->infoPng.background_b = 256 * data[0] + data[1];
- }
- else if(decoder->infoPng.color.colorType == 2 || decoder->infoPng.color.colorType == 6)
- {
- if(chunkLength != 6) { decoder->error = 45; break; } /*error: this chunk must be 6 bytes for greyscale image*/
- decoder->infoPng.background_defined = 1;
- decoder->infoPng.background_r = 256 * data[0] + data[1];
- decoder->infoPng.background_g = 256 * data[2] + data[3];
- decoder->infoPng.background_b = 256 * data[4] + data[5];
- }
- }
- /*text chunk (tEXt)*/
- else if(LodePNG_chunk_type_equals(chunk, "tEXt"))
- {
- if(decoder->settings.readTextChunks)
- {
- char *key = 0, *str = 0;
-
- while(!decoder->error) /*not really a while loop, only used to break on error*/
- {
- unsigned length, string2_begin;
-
- for(length = 0; length < chunkLength && data[length] != 0; length++) ;
- if(length + 1 >= chunkLength) { decoder->error = 75; break; }
- key = (char*)malloc(length + 1);
- if(!key) { decoder->error = 9938; break; }
- key[length] = 0;
- for(i = 0; i < length; i++) key[i] = data[i];
-
- string2_begin = length + 1;
- if(string2_begin > chunkLength) { decoder->error = 75; break; }
- length = chunkLength - string2_begin;
- str = (char*)malloc(length + 1);
- if(!str) { decoder->error = 9939; break; }
- str[length] = 0;
- for(i = 0; i < length; i++) str[i] = data[string2_begin + i];
-
- decoder->error = LodePNG_Text_add(&decoder->infoPng.text, key, str);
-
- break;
- }
-
- free(key);
- free(str);
- }
- }
- /*compressed text chunk (zTXt)*/
- else if(LodePNG_chunk_type_equals(chunk, "zTXt"))
- {
- if(decoder->settings.readTextChunks)
- {
- unsigned length, string2_begin;
- char *key = 0;
- ucvector decoded;
-
- ucvector_init(&decoded);
-
- while(!decoder->error) /*not really a while loop, only used to break on error*/
- {
- for(length = 0; length < chunkLength && data[length] != 0; length++) ;
- if(length + 2 >= chunkLength) { decoder->error = 75; break; }
- key = (char*)malloc(length + 1);
- if(!key) { decoder->error = 9940; break; }
- key[length] = 0;
- for(i = 0; i < length; i++) key[i] = data[i];
-
- if(data[length + 1] != 0) { decoder->error = 72; break; } /*the 0 byte indicating compression must be 0*/
-
- string2_begin = length + 2;
- if(string2_begin > chunkLength) { decoder->error = 75; break; }
- length = chunkLength - string2_begin;
- decoder->error = LodePNG_decompress(&decoded.data, &decoded.size, (unsigned char*)(&data[string2_begin]), length, &decoder->settings.zlibsettings);
- if(decoder->error) break;
- ucvector_push_back(&decoded, 0);
-
- decoder->error = LodePNG_Text_add(&decoder->infoPng.text, key, (char*)decoded.data);
-
- break;
- }
-
- free(key);
- ucvector_cleanup(&decoded);
- if(decoder->error) break;
+ out[OUT_BYTES * i] = in[i];
+ if(OUT_ALPHA && infoIn->key_defined && in[i] == infoIn->key_r) out[OUT_BYTES * i + 1] = 0;
+ }
+ break;
+ case 4: /*greyscale with alpha*/
+ for(i = 0; i < numpixels; i++)
+ {
+ out[OUT_BYTES * i + 0] = in[2 * i + 0];
+ if(OUT_ALPHA) out[OUT_BYTES * i + 1] = in[2 * i + 1];
+ }
+ break;
+ default: return 31;
}
}
- /*international text chunk (iTXt)*/
- else if(LodePNG_chunk_type_equals(chunk, "iTXt"))
+ else if(infoIn->bitDepth == 16)
{
- if(decoder->settings.readTextChunks)
+ switch(infoIn->colorType)
{
- unsigned length, begin, compressed;
- char *key = 0, *langtag = 0, *transkey = 0;
- ucvector decoded;
- ucvector_init(&decoded);
-
- while(!decoder->error) /*not really a while loop, only used to break on error*/
- {
- if(chunkLength < 5) { decoder->error = 76; break; }
- for(length = 0; length < chunkLength && data[length] != 0; length++) ;
- if(length + 2 >= chunkLength) { decoder->error = 75; break; }
- key = (char*)malloc(length + 1);
- if(!key) { decoder->error = 9941; break; }
- key[length] = 0;
- for(i = 0; i < length; i++) key[i] = data[i];
-
- compressed = data[length + 1];
- if(data[length + 2] != 0) { decoder->error = 72; break; } /*the 0 byte indicating compression must be 0*/
-
- begin = length + 3;
- length = 0;
- for(i = begin; i < chunkLength && data[i] != 0; i++) length++;
- if(begin + length + 1 >= chunkLength) { decoder->error = 75; break; }
- langtag = (char*)malloc(length + 1);
- if(!langtag) { decoder->error = 9942; break; }
- langtag[length] = 0;
- for(i = 0; i < length; i++) langtag[i] = data[begin + i];
-
- begin += length + 1;
- length = 0;
- for(i = begin; i < chunkLength && data[i] != 0; i++) length++;
- if(begin + length + 1 >= chunkLength) { decoder->error = 75; break; }
- transkey = (char*)malloc(length + 1);
- if(!transkey) { decoder->error = 9943; break; }
- transkey[length] = 0;
- for(i = 0; i < length; i++) transkey[i] = data[begin + i];
-
- begin += length + 1;
- if(begin > chunkLength) { decoder->error = 75; break; }
- length = chunkLength - begin;
-
- if(compressed)
+ case 0: /*greyscale color*/
+ for(i = 0; i < numpixels; i++)
{
- decoder->error = LodePNG_decompress(&decoded.data, &decoded.size, (unsigned char*)(&data[begin]), length, &decoder->settings.zlibsettings);
- if(decoder->error) break;
- ucvector_push_back(&decoded, 0);
+ if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
+ out[OUT_BYTES * i] = in[2 * i];
+ if(OUT_ALPHA && infoIn->key_defined && 256U * in[i] + in[i + 1] == infoIn->key_r) out[OUT_BYTES * i + 1] = 0;
}
- else
+ break;
+ case 4: /*greyscale with alpha*/
+ for(i = 0; i < numpixels; i++)
{
- if(!ucvector_resize(&decoded, length + 1)) { decoder->error = 9944; break; }
- decoded.data[length] = 0;
- for(i = 0; i < length; i++) decoded.data[i] = data[begin + i];
+ out[OUT_BYTES * i] = in[4 * i]; /*most significant byte*/
+ if(OUT_ALPHA) out[OUT_BYTES * i + 1] = in[4 * i + 2]; /*most significant byte*/
}
-
- decoder->error = LodePNG_IText_add(&decoder->infoPng.itext, key, langtag, transkey, (char*)decoded.data);
-
- break;
- }
-
- free(key);
- free(langtag);
- free(transkey);
- ucvector_cleanup(&decoded);
- if(decoder->error) break;
+ break;
+ default: return 31;
}
}
- else if(LodePNG_chunk_type_equals(chunk, "tIME"))
- {
- if(chunkLength != 7) { decoder->error = 73; break; }
- decoder->infoPng.time_defined = 1;
- decoder->infoPng.time.year = 256 * data[0] + data[+ 1];
- decoder->infoPng.time.month = data[2];
- decoder->infoPng.time.day = data[3];
- decoder->infoPng.time.hour = data[4];
- decoder->infoPng.time.minute = data[5];
- decoder->infoPng.time.second = data[6];
- }
- else if(LodePNG_chunk_type_equals(chunk, "pHYs"))
- {
- if(chunkLength != 9) { decoder->error = 74; break; }
- decoder->infoPng.phys_defined = 1;
- decoder->infoPng.phys_x = 16777216 * data[0] + 65536 * data[1] + 256 * data[2] + data[3];
- decoder->infoPng.phys_y = 16777216 * data[4] + 65536 * data[5] + 256 * data[6] + data[7];
- decoder->infoPng.phys_unit = data[8];
- }
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
- else /*it's not an implemented chunk type, so ignore it: skip over the data*/
+ else /*infoIn->bitDepth is less than 8 bit per channel*/
{
- if(LodePNG_chunk_critical(chunk)) { decoder->error = 69; break; } /*error: unknown critical chunk (5th bit of first byte of chunk type is 0)*/
- unknown = 1;
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- if(decoder->settings.rememberUnknownChunks)
+ if(infoIn->colorType != 0) return 31; /*colorType 0 is the only greyscale type with < 8 bits per channel*/
+ for(i = 0; i < numpixels; i++)
{
- LodePNG_UnknownChunks* unknown = &decoder->infoPng.unknown_chunks;
- decoder->error = LodePNG_append_chunk(&unknown->data[critical_pos - 1], &unknown->datasize[critical_pos - 1], chunk);
- if(decoder->error) break;
+ unsigned value = readBitsFromReversedStream(&bp, in, infoIn->bitDepth);
+ if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
+ if(OUT_ALPHA && infoIn->key_defined && value && ((1U << infoIn->bitDepth) - 1U) == infoIn->key_r && ((1U << infoIn->bitDepth) - 1U)) out[OUT_BYTES * i + 1] = 0;
+ value = (value * 255) / ((1 << infoIn->bitDepth) - 1); /*scale value from 0 to 255*/
+ out[OUT_BYTES * i] = (unsigned char)(value);
}
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
- }
-
- if(!decoder->settings.ignoreCrc && !unknown) /*check CRC if wanted, only on known chunk types*/
- {
- if(LodePNG_chunk_check_crc(chunk)) { decoder->error = 57; break; }
- }
-
- if(!IEND) chunk = LodePNG_chunk_next_const(chunk);
- }
-
- if(!decoder->error)
- {
- ucvector scanlines;
- ucvector_init(&scanlines);
- if(!ucvector_resize(&scanlines, ((decoder->infoPng.width * (decoder->infoPng.height * LodePNG_InfoColor_getBpp(&decoder->infoPng.color) + 7)) / 8) + decoder->infoPng.height)) decoder->error = 9945; /*maximum final image length is already reserved in the vector's length - this is not really necessary*/
- if(!decoder->error) decoder->error = LodePNG_decompress(&scanlines.data, &scanlines.size, idat.data, idat.size, &decoder->settings.zlibsettings); /*decompress with the Zlib decompressor*/
-
- if(!decoder->error)
- {
- ucvector outv;
- ucvector_init(&outv);
- if(!ucvector_resizev(&outv, (decoder->infoPng.height * decoder->infoPng.width * LodePNG_InfoColor_getBpp(&decoder->infoPng.color) + 7) / 8, 0)) decoder->error = 9946;
- if(!decoder->error) decoder->error = postProcessScanlines(outv.data, scanlines.data, &decoder->infoPng);
- *out = outv.data;
- *outsize = outv.size;
}
- ucvector_cleanup(&scanlines);
}
-
- ucvector_cleanup(&idat);
-}
-
-void LodePNG_decode(LodePNG_Decoder* decoder, unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize)
-{
- *out = 0;
- *outsize = 0;
- decodeGeneric(decoder, out, outsize, in, insize);
- if(decoder->error) return;
- if(!decoder->settings.color_convert || LodePNG_InfoColor_equal(&decoder->infoRaw.color, &decoder->infoPng.color))
- {
- /*same color type, no copying or converting of data needed*/
- /*store the infoPng color settings on the infoRaw so that the infoRaw still reflects what colorType
- the raw image has to the end user*/
- if(!decoder->settings.color_convert)
- {
- decoder->error = LodePNG_InfoColor_copy(&decoder->infoRaw.color, &decoder->infoPng.color);
- if(decoder->error) return;
- }
- }
- else
- {
- /*color conversion needed; sort of copy of the data*/
- unsigned char* data = *out;
-
- /*TODO: check if this works according to the statement in the documentation: "The converter can convert from greyscale input color type, to 8-bit greyscale or greyscale with alpha"*/
- if(!(decoder->infoRaw.color.colorType == 2 || decoder->infoRaw.color.colorType == 6) && !(decoder->infoRaw.color.bitDepth == 8)) { decoder->error = 56; return; }
+ else return 59;
- *outsize = (decoder->infoPng.width * decoder->infoPng.height * LodePNG_InfoColor_getBpp(&decoder->infoRaw.color) + 7) / 8;
- *out = (unsigned char*)malloc(*outsize);
- if(!(*out))
- {
- decoder->error = 9947;
- *outsize = 0;
- }
- else decoder->error = LodePNG_convert(*out, data, &decoder->infoRaw.color, &decoder->infoPng.color, decoder->infoPng.width, decoder->infoPng.height);
- free(data);
- }
+ return 0;
}
-unsigned LodePNG_decode32(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize)
+/*Path predictor, used by PNG filter type 4*/
+static int paethPredictor(int a, int b, int c)
{
- unsigned error;
- size_t dummy_size;
- LodePNG_Decoder decoder;
- LodePNG_Decoder_init(&decoder);
- LodePNG_decode(&decoder, out, &dummy_size, in, insize);
- error = decoder.error;
- *w = decoder.infoPng.width;
- *h = decoder.infoPng.height;
- LodePNG_Decoder_cleanup(&decoder);
- return error;
-}
+ int p = a + b - c;
+ int pa = p > a ? p - a : a - p;
+ int pb = p > b ? p - b : b - p;
+ int pc = p > c ? p - c : c - p;
-#ifdef LODEPNG_COMPILE_DISK
-unsigned LodePNG_decode32f(unsigned char** out, unsigned* w, unsigned* h, const char* filename)
-{
- unsigned char* buffer;
- size_t buffersize;
- unsigned error;
- error = LodePNG_loadFile(&buffer, &buffersize, filename);
- if(!error) error = LodePNG_decode32(out, w, h, buffer, buffersize);
- free(buffer);
- return error;
+ if(pa <= pb && pa <= pc) return a;
+ else if(pb <= pc) return b;
+ else return c;
}
-#endif /*LODEPNG_COMPILE_DISK*/
-void LodePNG_DecodeSettings_init(LodePNG_DecodeSettings* settings)
-{
- settings->color_convert = 1;
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- settings->readTextChunks = 1;
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
- settings->ignoreCrc = 0;
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- settings->rememberUnknownChunks = 0;
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
- LodeZlib_DecompressSettings_init(&settings->zlibsettings);
-}
+/*shared values used by multiple Adam7 related functions*/
-void LodePNG_Decoder_init(LodePNG_Decoder* decoder)
-{
- LodePNG_DecodeSettings_init(&decoder->settings);
- LodePNG_InfoRaw_init(&decoder->infoRaw);
- LodePNG_InfoPng_init(&decoder->infoPng);
- decoder->error = 1;
-}
+static const unsigned ADAM7_IX[7] = { 0, 4, 0, 2, 0, 1, 0 }; /*x start values*/
+static const unsigned ADAM7_IY[7] = { 0, 0, 4, 0, 2, 0, 1 }; /*y start values*/
+static const unsigned ADAM7_DX[7] = { 8, 8, 4, 4, 2, 2, 1 }; /*x delta values*/
+static const unsigned ADAM7_DY[7] = { 8, 8, 8, 4, 4, 2, 2 }; /*y delta values*/
-void LodePNG_Decoder_cleanup(LodePNG_Decoder* decoder)
+static void Adam7_getpassvalues(unsigned passw[7], unsigned passh[7], size_t filter_passstart[8], size_t padded_passstart[8], size_t passstart[8], unsigned w, unsigned h, unsigned bpp)
{
- LodePNG_InfoRaw_cleanup(&decoder->infoRaw);
- LodePNG_InfoPng_cleanup(&decoder->infoPng);
-}
+ /*the passstart values have 8 values: the 8th one actually indicates the byte after the end of the 7th (= last) pass*/
+ unsigned i;
-void LodePNG_Decoder_copy(LodePNG_Decoder* dest, const LodePNG_Decoder* source)
-{
- LodePNG_Decoder_cleanup(dest);
- *dest = *source;
- LodePNG_InfoRaw_init(&dest->infoRaw);
- LodePNG_InfoPng_init(&dest->infoPng);
- dest->error = LodePNG_InfoRaw_copy(&dest->infoRaw, &source->infoRaw); if(dest->error) return;
- dest->error = LodePNG_InfoPng_copy(&dest->infoPng, &source->infoPng); if(dest->error) return;
-}
+ /*calculate width and height in pixels of each pass*/
+ for(i = 0; i < 7; i++)
+ {
+ passw[i] = (w + ADAM7_DX[i] - ADAM7_IX[i] - 1) / ADAM7_DX[i];
+ passh[i] = (h + ADAM7_DY[i] - ADAM7_IY[i] - 1) / ADAM7_DY[i];
+ if(passw[i] == 0) passh[i] = 0;
+ if(passh[i] == 0) passw[i] = 0;
+ }
-#endif /*LODEPNG_COMPILE_DECODER*/
+ filter_passstart[0] = padded_passstart[0] = passstart[0] = 0;
+ for(i = 0; i < 7; i++)
+ {
+ filter_passstart[i + 1] = filter_passstart[i] + ((passw[i] && passh[i]) ? passh[i] * (1 + (passw[i] * bpp + 7) / 8) : 0); /*if passw[i] is 0, it's 0 bytes, not 1 (no filtertype-byte)*/
+ padded_passstart[i + 1] = padded_passstart[i] + passh[i] * ((passw[i] * bpp + 7) / 8); /*bits padded if needed to fill full byte at end of each scanline*/
+ passstart[i + 1] = passstart[i] + (passh[i] * passw[i] * bpp + 7) / 8; /*only padded at end of reduced image*/
+ }
+}
-#ifdef LODEPNG_COMPILE_ENCODER
/* ////////////////////////////////////////////////////////////////////////// */
/* / PNG Encoder / */
unsigned error = 0;
ucvector header;
ucvector_init(&header);
-
+
LodePNG_add32bitInt(&header, w); /*width*/
LodePNG_add32bitInt(&header, h); /*height*/
ucvector_push_back(&header, (unsigned char)bitDepth); /*bit depth*/
ucvector_push_back(&header, 0); /*compression method*/
ucvector_push_back(&header, 0); /*filter method*/
ucvector_push_back(&header, interlaceMethod); /*interlace method*/
-
+
error = addChunk(out, "IHDR", header.data, header.size);
ucvector_cleanup(&header);
-
+
return error;
}
for(i = 0; i < info->palettesize * 4; i++) if(i % 4 != 3) ucvector_push_back(&PLTE, info->palette[i]); /*add all channels except alpha channel*/
error = addChunk(out, "PLTE", PLTE.data, PLTE.size);
ucvector_cleanup(&PLTE);
-
+
return error;
}
ucvector_push_back(&tRNS, (unsigned char)(info->key_b % 256));
}
}
-
+
error = addChunk(out, "tRNS", tRNS.data, tRNS.size);
ucvector_cleanup(&tRNS);
-
+
return error;
}
{
ucvector zlibdata;
unsigned error = 0;
-
+
/*compress with the Zlib compressor*/
ucvector_init(&zlibdata);
error = LodePNG_compress(&zlibdata.data, &zlibdata.size, data, datasize, zlibsettings);
if(!error) error = addChunk(out, "IDAT", zlibdata.data, zlibdata.size);
ucvector_cleanup(&zlibdata);
-
+
return error;
}
return error;
}
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
-
-static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring) /*add text chunk*/
-{
- unsigned error = 0;
- size_t i;
- ucvector text;
- ucvector_init(&text);
- for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&text, (unsigned char)keyword[i]);
- ucvector_push_back(&text, 0);
- for(i = 0; textstring[i] != 0; i++) ucvector_push_back(&text, (unsigned char)textstring[i]);
- error = addChunk(out, "tEXt", text.data, text.size);
- ucvector_cleanup(&text);
-
- return error;
-}
-
-static unsigned addChunk_zTXt(ucvector* out, const char* keyword, const char* textstring, LodeZlib_DeflateSettings* zlibsettings)
-{
- unsigned error = 0;
- ucvector data, compressed;
- size_t i, textsize = strlen(textstring);
-
- ucvector_init(&data);
- ucvector_init(&compressed);
- for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&data, (unsigned char)keyword[i]);
- ucvector_push_back(&data, 0); /* 0 termination char*/
- ucvector_push_back(&data, 0); /*compression method: 0*/
-
- error = LodePNG_compress(&compressed.data, &compressed.size, (unsigned char*)textstring, textsize, zlibsettings);
- if(!error)
- {
- for(i = 0; i < compressed.size; i++) ucvector_push_back(&data, compressed.data[i]);
- error = addChunk(out, "zTXt", data.data, data.size);
- }
-
- ucvector_cleanup(&compressed);
- ucvector_cleanup(&data);
- return error;
-}
-
-static unsigned addChunk_iTXt(ucvector* out, unsigned compressed, const char* keyword, const char* langtag, const char* transkey, const char* textstring, LodeZlib_DeflateSettings* zlibsettings)
-{
- unsigned error = 0;
- ucvector data, compressed_data;
- size_t i, textsize = strlen(textstring);
-
- ucvector_init(&data);
-
- for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&data, (unsigned char)keyword[i]);
- ucvector_push_back(&data, 0); /*null termination char*/
- ucvector_push_back(&data, compressed ? 1 : 0); /*compression flag*/
- ucvector_push_back(&data, 0); /*compression method*/
- for(i = 0; langtag[i] != 0; i++) ucvector_push_back(&data, (unsigned char)langtag[i]);
- ucvector_push_back(&data, 0); /*null termination char*/
- for(i = 0; transkey[i] != 0; i++) ucvector_push_back(&data, (unsigned char)transkey[i]);
- ucvector_push_back(&data, 0); /*null termination char*/
-
- if(compressed)
- {
- ucvector_init(&compressed_data);
- error = LodePNG_compress(&compressed_data.data, &compressed_data.size, (unsigned char*)textstring, textsize, zlibsettings);
- if(!error)
- {
- for(i = 0; i < compressed_data.size; i++) ucvector_push_back(&data, compressed_data.data[i]);
- for(i = 0; textstring[i] != 0; i++) ucvector_push_back(&data, (unsigned char)textstring[i]);
- }
- }
- else /*not compressed*/
- {
- for(i = 0; textstring[i] != 0; i++) ucvector_push_back(&data, (unsigned char)textstring[i]);
- }
-
- if(!error) error = addChunk(out, "iTXt", data.data, data.size);
- ucvector_cleanup(&data);
- return error;
-}
-
-static unsigned addChunk_bKGD(ucvector* out, const LodePNG_InfoPng* info)
-{
- unsigned error = 0;
- ucvector bKGD;
- ucvector_init(&bKGD);
- if(info->color.colorType == 0 || info->color.colorType == 4)
- {
- ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
- ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
- }
- else if(info->color.colorType == 2 || info->color.colorType == 6)
- {
- ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
- ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
- ucvector_push_back(&bKGD, (unsigned char)(info->background_g / 256));
- ucvector_push_back(&bKGD, (unsigned char)(info->background_g % 256));
- ucvector_push_back(&bKGD, (unsigned char)(info->background_b / 256));
- ucvector_push_back(&bKGD, (unsigned char)(info->background_b % 256));
- }
- else if(info->color.colorType == 3)
- {
- ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256)); /*palette index*/
- }
-
- error = addChunk(out, "bKGD", bKGD.data, bKGD.size);
- ucvector_cleanup(&bKGD);
-
- return error;
-}
-
-static unsigned addChunk_tIME(ucvector* out, const LodePNG_Time* time)
-{
- unsigned error = 0;
- unsigned char* data = (unsigned char*)malloc(7);
- if(!data) return 9948;
- data[0] = (unsigned char)(time->year / 256);
- data[1] = (unsigned char)(time->year % 256);
- data[2] = time->month;
- data[3] = time->day;
- data[4] = time->hour;
- data[5] = time->minute;
- data[6] = time->second;
- error = addChunk(out, "tIME", data, 7);
- free(data);
- return error;
-}
-
-static unsigned addChunk_pHYs(ucvector* out, const LodePNG_InfoPng* info)
-{
- unsigned error = 0;
- ucvector data;
- ucvector_init(&data);
-
- LodePNG_add32bitInt(&data, info->phys_x);
- LodePNG_add32bitInt(&data, info->phys_y);
- ucvector_push_back(&data, info->phys_unit);
-
- error = addChunk(out, "pHYs", data.data, data.size);
- ucvector_cleanup(&data);
-
- return error;
-}
-
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-
static void filterScanline(unsigned char* out, const unsigned char* scanline, const unsigned char* prevline, size_t length, size_t bytewidth, unsigned char filterType)
{
size_t i;
/*
For PNG filter method 0
out must be a buffer with as size: h + (w * h * bpp + 7) / 8, because there are the scanlines with 1 extra byte per scanline
-
+
There is a nice heuristic described here: http://www.cs.toronto.edu/~cosmin/pngtech/optipng.html. It says:
* If the image type is Palette, or the bit depth is smaller than 8, then do not filter the image (i.e. use fixed filtering, with the filter None).
* (The other case) If the image type is Grayscale or RGB (with or without Alpha), and the bit depth is not smaller than 8, then use adaptive filtering heuristic as follows: independently for each row, apply all five filters and select the filter that produces the smallest sum of absolute values per row.
-
+
Here the above method is used mostly. Note though that it appears to be better to use the adaptive filtering on the plasma 8-bit palette example, but that image isn't the best reference for palette images in general.
*/
-
+
unsigned bpp = LodePNG_InfoColor_getBpp(info);
size_t linebytes = (w * bpp + 7) / 8; /*the width of a scanline in bytes, not including the filter type*/
size_t bytewidth = (bpp + 7) / 8; /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
unsigned x, y;
unsigned heuristic;
unsigned error = 0;
-
+
if(bpp == 0) return 31; /*invalid color type*/
-
+
/*choose heuristic as described above*/
if(info->colorType == 3 || info->bitDepth < 8) heuristic = 0;
else heuristic = 1;
-
+
if(heuristic == 0) /*None filtertype for everything*/
{
for(y = 0; y < h; y++)
ucvector attempt[5]; /*five filtering attempts, one for each filter type*/
size_t smallest = 0;
unsigned type, bestType = 0;
-
+
for(type = 0; type < 5; type++) ucvector_init(&attempt[type]);
for(type = 0; type < 5; type++)
{
if(!ucvector_resize(&attempt[type], linebytes)) { error = 9949; break; }
}
-
+
if(!error)
{
for(y = 0; y < h; y++)
for(type = 0; type < 5; type++)
{
filterScanline(attempt[type].data, &in[y * linebytes], prevline, linebytes, bytewidth, type);
-
+
/*calculate the sum of the result*/
sum[type] = 0;
for(x = 0; x < attempt[type].size; x+=3) sum[type] += attempt[type].data[x]; /*note that not all pixels are checked to speed this up while still having probably the best choice*/
-
+
/*check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/
if(type == 0 || sum[type] < smallest)
{
smallest = sum[type];
}
}
-
+
prevline = &in[y * linebytes];
-
+
/*now fill the out values*/
out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/
for(x = 0; x < linebytes; x++) out[y * (linebytes + 1) + 1 + x] = attempt[bestType].data[x];
}
}
-
- for(type = 0; type < 5; type++) ucvector_cleanup(&attempt[type]);
- }
- #if 0 /*deflate the scanline with a fixed tree after every filter attempt to see which one deflates best. This is slow, and _does not work as expected_: the heuristic gives smaller result!*/
- else if(heuristic == 2) /*adaptive filtering by using deflate*/
- {
- size_t size[5];
- ucvector attempt[5]; /*five filtering attempts, one for each filter type*/
- size_t smallest;
- unsigned type = 0, bestType = 0;
- unsigned char* dummy;
- LodeZlib_DeflateSettings deflatesettings = LodeZlib_defaultDeflateSettings;
- deflatesettings.btype = 1; /*use fixed tree on the attempts so that the tree is not adapted to the filtertype on purpose, to simulate the true case where the tree is the same for the whole image*/
- for(type = 0; type < 5; type++) { ucvector_init(&attempt[type]); ucvector_resize(&attempt[type], linebytes); }
- for(y = 0; y < h; y++) /*try the 5 filter types*/
- {
- for(type = 0; type < 5; type++)
- {
- filterScanline(attempt[type].data, &in[y * linebytes], prevline, linebytes, bytewidth, type);
- size[type] = 0; dummy = 0;
- LodePNG_compress(&dummy, &size[type], attempt[type].data, attempt[type].size, &deflatesettings);
- free(dummy);
- /*check if this is smallest size (or if type == 0 it's the first case so always store the values)*/
- if(type == 0 || size[type] < smallest) { bestType = type; smallest = size[type]; }
- }
- prevline = &in[y * linebytes];
- out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/
- for(x = 0; x < linebytes; x++) out[y * (linebytes + 1) + 1 + x] = attempt[bestType].data[x];
- }
+
for(type = 0; type < 5; type++) ucvector_cleanup(&attempt[type]);
}
- #endif
-
+
return error;
}
unsigned i;
Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
-
+
if(bpp >= 8)
{
for(i = 0; i < 7; i++)
unsigned w = infoPng->width;
unsigned h = infoPng->height;
unsigned error = 0;
-
+
if(infoPng->interlaceMethod == 0)
{
*outsize = h + (h * ((w * bpp + 7) / 8)); /*image size plus an extra byte per scanline + possible padding bits*/
{
unsigned char* adam7 = (unsigned char*)malloc((h * w * bpp + 7) / 8);
if(!adam7 && ((h * w * bpp + 7) / 8)) error = 9952; /*malloc failed*/
-
+
while(!error) /*not a real while loop, used to break out to cleanup to avoid a goto*/
{
unsigned passw[7], passh[7]; size_t filter_passstart[8], padded_passstart[8], passstart[8];
unsigned i;
-
+
Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
-
+
*outsize = filter_passstart[7]; /*image size plus an extra byte per scanline + possible padding bits*/
*out = (unsigned char*)malloc(*outsize);
if(!(*out) && (*outsize)) { error = 9953; break; }
-
+
Adam7_interlace(adam7, in, w, h, bpp);
-
+
for(i = 0; i < 7; i++)
{
if(bpp < 8)
addPaddingBits(&padded.data[padded_passstart[i]], &adam7[passstart[i]], ((passw[i] * bpp + 7) / 8) * 8, passw[i] * bpp, passh[i]);
error = filter(&(*out)[filter_passstart[i]], &padded.data[padded_passstart[i]], passw[i], passh[i], &infoPng->color);
}
-
+
ucvector_cleanup(&padded);
}
else
error = filter(&(*out)[filter_passstart[i]], &adam7[padded_passstart[i]], passw[i], passh[i], &infoPng->color);
}
}
-
+
break;
}
free(adam7);
}
-
+
return error;
}
return 0; /*color type that isn't supported by this function yet, so assume there is transparency to be safe*/
}
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
-static unsigned addUnknownChunks(ucvector* out, unsigned char* data, size_t datasize)
-{
- unsigned char* inchunk = data;
- while((size_t)(inchunk - data) < datasize)
- {
- unsigned error = LodePNG_append_chunk(&out->data, &out->size, inchunk);
- if(error) return error; /*error: not enough memory*/
- out->allocsize = out->size; /*fix the allocsize again*/
- inchunk = LodePNG_chunk_next(inchunk);
- }
- return 0;
-}
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
-
void LodePNG_encode(LodePNG_Encoder* encoder, unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h)
{
LodePNG_InfoPng info;
ucvector outv;
unsigned char* data = 0; /*uncompressed version of the IDAT chunk data*/
size_t datasize = 0;
-
+
/*provide some proper output values if error will happen*/
*out = 0;
*outsize = 0;
encoder->error = 0;
-
+
info = encoder->infoPng; /*UNSAFE copy to avoid having to cleanup! but we will only change primitive parameters, and not invoke the cleanup function nor touch the palette's buffer so we use it safely*/
info.width = w;
info.height = h;
-
+
if(encoder->settings.autoLeaveOutAlphaChannel && isFullyOpaque(image, w, h, &encoder->infoRaw.color))
{
/*go to a color type without alpha channel*/
if(info.color.colorType == 6) info.color.colorType = 2;
else if(info.color.colorType == 4) info.color.colorType = 0;
}
-
+
if(encoder->settings.zlibsettings.windowSize > 32768) { encoder->error = 60; return; } /*error: windowsize larger than allowed*/
if(encoder->settings.zlibsettings.btype > 2) { encoder->error = 61; return; } /*error: unexisting btype*/
if(encoder->infoPng.interlaceMethod > 1) { encoder->error = 71; return; } /*error: unexisting interlace mode*/
if((encoder->error = checkColorValidity(info.color.colorType, info.color.bitDepth))) return; /*error: unexisting color type given*/
if((encoder->error = checkColorValidity(encoder->infoRaw.color.colorType, encoder->infoRaw.color.bitDepth))) return; /*error: unexisting color type given*/
-
+
if(!LodePNG_InfoColor_equal(&encoder->infoRaw.color, &info.color))
{
unsigned char* converted;
size_t size = (w * h * LodePNG_InfoColor_getBpp(&info.color) + 7) / 8;
-
+
if((info.color.colorType != 6 && info.color.colorType != 2) || (info.color.bitDepth != 8)) { encoder->error = 59; return; } /*for the output image, only these types are supported*/
converted = (unsigned char*)malloc(size);
if(!converted && size) encoder->error = 9955; /*error: malloc failed*/
free(converted);
}
else preProcessScanlines(&data, &datasize, image, &info);/*filter(data.data, image, w, h, LodePNG_InfoColor_getBpp(&info.color));*/
-
+
ucvector_init(&outv);
while(!encoder->error) /*not really a while loop, this is only used to break out if an error happens to avoid goto's to do the ucvector cleanup*/
{
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- size_t i;
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
/*write signature and chunks*/
writeSignature(&outv);
/*IHDR*/
addChunk_IHDR(&outv, w, h, info.color.bitDepth, info.color.colorType, info.interlaceMethod);
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- /*unknown chunks between IHDR and PLTE*/
- if(info.unknown_chunks.data[0]) { encoder->error = addUnknownChunks(&outv, info.unknown_chunks.data[0], info.unknown_chunks.datasize[0]); if(encoder->error) break; }
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
/*PLTE*/
if(info.color.colorType == 3)
{
/*tRNS*/
if(info.color.colorType == 3 && !isPaletteFullyOpaque(info.color.palette, info.color.palettesize)) addChunk_tRNS(&outv, &info.color);
if((info.color.colorType == 0 || info.color.colorType == 2) && info.color.key_defined) addChunk_tRNS(&outv, &info.color);
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- /*bKGD (must come between PLTE and the IDAt chunks*/
- if(info.background_defined) addChunk_bKGD(&outv, &info);
- /*pHYs (must come before the IDAT chunks)*/
- if(info.phys_defined) addChunk_pHYs(&outv, &info);
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- /*unknown chunks between PLTE and IDAT*/
- if(info.unknown_chunks.data[1]) { encoder->error = addUnknownChunks(&outv, info.unknown_chunks.data[1], info.unknown_chunks.datasize[1]); if(encoder->error) break; }
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
/*IDAT (multiple IDAT chunks must be consecutive)*/
encoder->error = addChunk_IDAT(&outv, data, datasize, &encoder->settings.zlibsettings);
if(encoder->error) break;
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- /*tIME*/
- if(info.time_defined) addChunk_tIME(&outv, &info.time);
- /*tEXt and/or zTXt*/
- for(i = 0; i < info.text.num; i++)
- {
- if(strlen(info.text.keys[i]) > 79) { encoder->error = 66; break; }
- if(strlen(info.text.keys[i]) < 1) { encoder->error = 67; break; }
- if(encoder->settings.text_compression)
- addChunk_zTXt(&outv, info.text.keys[i], info.text.strings[i], &encoder->settings.zlibsettings);
- else
- addChunk_tEXt(&outv, info.text.keys[i], info.text.strings[i]);
- }
- /*LodePNG version id in text chunk*/
- if(encoder->settings.add_id)
- {
- unsigned alread_added_id_text = 0;
- for(i = 0; i < info.text.num; i++)
- if(!strcmp(info.text.keys[i], "LodePNG")) { alread_added_id_text = 1; break; }
- if(alread_added_id_text == 0)
- addChunk_tEXt(&outv, "LodePNG", VERSION_STRING); /*it's shorter as tEXt than as zTXt chunk*/
- }
- /*iTXt*/
- for(i = 0; i < info.itext.num; i++)
- {
- if(strlen(info.itext.keys[i]) > 79) { encoder->error = 66; break; }
- if(strlen(info.itext.keys[i]) < 1) { encoder->error = 67; break; }
- addChunk_iTXt(&outv, encoder->settings.text_compression,
- info.itext.keys[i], info.itext.langtags[i], info.itext.transkeys[i], info.itext.strings[i],
- &encoder->settings.zlibsettings);
- }
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- /*unknown chunks between IDAT and IEND*/
- if(info.unknown_chunks.data[2]) { encoder->error = addUnknownChunks(&outv, info.unknown_chunks.data[2], info.unknown_chunks.datasize[2]); if(encoder->error) break; }
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
/*IEND*/
addChunk_IEND(&outv);
-
+
break; /*this isn't really a while loop; no error happened so break out now!*/
}
-
+
free(data);
/*instead of cleaning the vector up, give it to the output*/
*out = outv.data;
*outsize = outv.size;
}
-unsigned LodePNG_encode32(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h)
-{
- unsigned error;
- LodePNG_Encoder encoder;
- LodePNG_Encoder_init(&encoder);
- LodePNG_encode(&encoder, out, outsize, image, w, h);
- error = encoder.error;
- LodePNG_Encoder_cleanup(&encoder);
- return error;
-}
-
-#ifdef LODEPNG_COMPILE_DISK
-unsigned LodePNG_encode32f(const char* filename, const unsigned char* image, unsigned w, unsigned h)
-{
- unsigned char* buffer;
- size_t buffersize;
- unsigned error = LodePNG_encode32(&buffer, &buffersize, image, w, h);
- LodePNG_saveFile(buffer, buffersize, filename);
- free(buffer);
- return error;
-}
-#endif /*LODEPNG_COMPILE_DISK*/
-
void LodePNG_EncodeSettings_init(LodePNG_EncodeSettings* settings)
{
LodeZlib_DeflateSettings_init(&settings->zlibsettings);
settings->autoLeaveOutAlphaChannel = 1;
settings->force_palette = 0;
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- settings->add_id = 1;
- settings->text_compression = 0;
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}
void LodePNG_Encoder_init(LodePNG_Encoder* encoder)
dest->error = LodePNG_InfoRaw_copy(&dest->infoRaw, &source->infoRaw); if(dest->error) return;
}
-#endif /*LODEPNG_COMPILE_ENCODER*/
-
-#endif /*LODEPNG_COMPILE_PNG*/
-
/* ////////////////////////////////////////////////////////////////////////// */
/* / File IO / */
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_DISK
-
-unsigned LodePNG_loadFile(unsigned char** out, size_t* outsize, const char* filename) /*designed for loading files from hard disk in a dynamically allocated buffer*/
-{
- FILE* file;
- long size;
-
- /*provide some proper output values if error will happen*/
- *out = 0;
- *outsize = 0;
-
- file = portable_fopen(filename, "rb");
- if(!file) return 78;
-
- /*get filesize:*/
- fseek(file , 0 , SEEK_END);
- size = ftell(file);
- rewind(file);
-
- /*read contents of the file into the vector*/
- if (size>0)
- {
- *outsize = 0;
- *out = (unsigned char*)malloc((size_t)size);
- if(size && (*out)) (*outsize) = fread(*out, 1, (size_t)size, file);
- }
-
- fclose(file);
- if(!(*out) && size) return 80; /*the above malloc failed*/
- return 0;
-}
-
/*write given buffer to the file, overwriting the file, it doesn't append to it.*/
unsigned LodePNG_saveFile(const unsigned char* buffer, size_t buffersize, const char* filename)
{
return 0;
}
-#endif /*LODEPNG_COMPILE_DISK*/
-
distribution.
*/
+/** Minified version of LodePNG, with only the encoder code */
+
#ifndef LODEPNG_H
#define LODEPNG_H
#include <string.h>
/* ////////////////////////////////////////////////////////////////////////// */
-/* Code Sections */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-/*The following defines can be commented disable code sections. Gives potential faster compile and smaller binary.*/
-
-#define LODEPNG_COMPILE_ZLIB /*deflate&zlib encoder and deflate&zlib decoder*/
-#define LODEPNG_COMPILE_PNG /*png encoder and png decoder*/
-//#define LODEPNG_COMPILE_DECODER /*deflate&zlib decoder and png decoder*/
-#define LODEPNG_COMPILE_ENCODER /*deflate&zlib encoder and png encoder*/
-#define LODEPNG_COMPILE_DISK /*the optional built in harddisk file loading and saving functions*/
-//#define LODEPNG_COMPILE_ANCILLARY_CHUNKS /*any code or struct datamember related to chunks other than IHDR, IDAT, PLTE, tRNS, IEND*/
-//#define LODEPNG_COMPILE_UNKNOWN_CHUNKS /*handling of unknown chunks*/
-
-/* ////////////////////////////////////////////////////////////////////////// */
/* LodeFlate & LodeZlib Setting structs */
/* ////////////////////////////////////////////////////////////////////////// */
-#ifdef LODEPNG_COMPILE_DECODER
-typedef struct LodeZlib_DecompressSettings
-{
- unsigned ignoreAdler32;
-} LodeZlib_DecompressSettings;
-
-extern const LodeZlib_DecompressSettings LodeZlib_defaultDecompressSettings;
-void LodeZlib_DecompressSettings_init(LodeZlib_DecompressSettings* settings);
-#endif /*LODEPNG_COMPILE_DECODER*/
-#ifdef LODEPNG_COMPILE_ENCODER
typedef struct LodeZlib_DeflateSettings /*deflate = compress*/
{
/*LZ77 related settings*/
unsigned windowSize; /*the maximum is 32768*/
} LodeZlib_DeflateSettings;
-extern const LodeZlib_DeflateSettings LodeZlib_defaultDeflateSettings;
-void LodeZlib_DeflateSettings_init(LodeZlib_DeflateSettings* settings);
-#endif /*LODEPNG_COMPILE_ENCODER*/
-
-#ifdef LODEPNG_COMPILE_ZLIB
-/* ////////////////////////////////////////////////////////////////////////// */
-/* LodeFlate & LodeZlib */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-#ifdef LODEPNG_COMPILE_DECODER
-/*This function reallocates the out buffer and appends the data.
-Either, *out must be NULL and *outsize must be 0, or, *out must be a valid buffer and *outsize its size in bytes.*/
-unsigned LodeZlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DecompressSettings* settings);
-#endif /*LODEPNG_COMPILE_DECODER*/
-
-#ifdef LODEPNG_COMPILE_ENCODER
-/*This function reallocates the out buffer and appends the data.
-Either, *out must be NULL and *outsize must be 0, or, *out must be a valid buffer and *outsize its size in bytes.*/
-unsigned LodeZlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize, const LodeZlib_DeflateSettings* settings);
-#endif /*LODEPNG_COMPILE_ENCODER*/
-#endif /*LODEPNG_COMPILE_ZLIB*/
-
-#ifdef LODEPNG_COMPILE_PNG
/* ////////////////////////////////////////////////////////////////////////// */
/* LodePNG */
/* ////////////////////////////////////////////////////////////////////////// */
-/*LodePNG_chunk functions: These functions need as input a large enough amount of allocated memory.*/
-
-unsigned LodePNG_chunk_length(const unsigned char* chunk); /*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
-
-void LodePNG_chunk_type(char type[5], const unsigned char* chunk); /*puts the 4-byte type in null terminated string*/
-unsigned char LodePNG_chunk_type_equals(const unsigned char* chunk, const char* type); /*check if the type is the given type*/
-
-/*properties of PNG chunks gotten from capitalization of chunk type name, as defined by the standard*/
-unsigned char LodePNG_chunk_critical(const unsigned char* chunk); /*0: ancillary chunk, 1: it's one of the critical chunk types*/
-unsigned char LodePNG_chunk_private(const unsigned char* chunk); /*0: public, 1: private*/
-unsigned char LodePNG_chunk_safetocopy(const unsigned char* chunk); /*0: the chunk is unsafe to copy, 1: the chunk is safe to copy*/
-
-unsigned char* LodePNG_chunk_data(unsigned char* chunk); /*get pointer to the data of the chunk*/
-const unsigned char* LodePNG_chunk_data_const(const unsigned char* chunk); /*get pointer to the data of the chunk*/
-
-unsigned LodePNG_chunk_check_crc(const unsigned char* chunk); /*returns 0 if the crc is correct, 1 if it's incorrect*/
-void LodePNG_chunk_generate_crc(unsigned char* chunk); /*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
-
-/*iterate to next chunks.*/
-unsigned char* LodePNG_chunk_next(unsigned char* chunk);
-const unsigned char* LodePNG_chunk_next_const(const unsigned char* chunk);
-
-/*add chunks to out buffer. It reallocs the buffer to append the data. returns error code*/
-unsigned LodePNG_append_chunk(unsigned char** out, size_t* outlength, const unsigned char* chunk); /*appends chunk that was already created, to the data. Returns pointer to start of appended chunk, or NULL if error happened*/
-unsigned LodePNG_create_chunk(unsigned char** out, size_t* outlength, unsigned length, const char* type, const unsigned char* data); /*appends new chunk to out. Returns pointer to start of appended chunk, or NULL if error happened; may change memory address of out buffer*/
-
typedef struct LodePNG_InfoColor /*info about the color type of an image*/
{
/*header (IHDR)*/
/*palette (PLTE)*/
unsigned char* palette; /*palette in RGBARGBA... order*/
size_t palettesize; /*palette size in number of colors (amount of bytes is 4 * palettesize)*/
-
+
/*transparent color key (tRNS)*/
unsigned key_defined; /*is a transparent color key given?*/
unsigned key_r; /*red component of color key*/
unsigned key_b; /*blue component of color key*/
} LodePNG_InfoColor;
-void LodePNG_InfoColor_init(LodePNG_InfoColor* info);
-void LodePNG_InfoColor_cleanup(LodePNG_InfoColor* info);
-unsigned LodePNG_InfoColor_copy(LodePNG_InfoColor* dest, const LodePNG_InfoColor* source);
-
-/*Use these functions instead of allocating palette manually*/
-void LodePNG_InfoColor_clearPalette(LodePNG_InfoColor* info);
-unsigned LodePNG_InfoColor_addPalette(LodePNG_InfoColor* info, unsigned char r, unsigned char g, unsigned char b, unsigned char a); /*add 1 color to the palette*/
-
-/*additional color info*/
-unsigned LodePNG_InfoColor_getBpp(const LodePNG_InfoColor* info); /*bits per pixel*/
-unsigned LodePNG_InfoColor_getChannels(const LodePNG_InfoColor* info); /*amount of channels*/
-unsigned LodePNG_InfoColor_isGreyscaleType(const LodePNG_InfoColor* info); /*is it a greyscale type? (colorType 0 or 4)*/
-unsigned LodePNG_InfoColor_isAlphaType(const LodePNG_InfoColor* info); /*has it an alpha channel? (colorType 2 or 6)*/
-
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
-typedef struct LodePNG_Time /*LodePNG's encoder does not generate the current time. To make it add a time chunk the correct time has to be provided*/
-{
- unsigned year; /*2 bytes*/
- unsigned char month; /*1-12*/
- unsigned char day; /*1-31*/
- unsigned char hour; /*0-23*/
- unsigned char minute; /*0-59*/
- unsigned char second; /*0-60 (to allow for leap seconds)*/
-} LodePNG_Time;
-
-typedef struct LodePNG_Text /*non-international text*/
-{
- size_t num;
- char** keys; /*the keyword of a text chunk (e.g. "Comment")*/
- char** strings; /*the actual text*/
-} LodePNG_Text;
-
-void LodePNG_Text_init(LodePNG_Text* text);
-void LodePNG_Text_cleanup(LodePNG_Text* text);
-unsigned LodePNG_Text_copy(LodePNG_Text* dest, const LodePNG_Text* source);
-
-/*Use these functions instead of allocating the char**s manually*/
-void LodePNG_Text_clear(LodePNG_Text* text);
-unsigned LodePNG_Text_add(LodePNG_Text* text, const char* key, const char* str); /*push back both texts at once*/
-
-
-typedef struct LodePNG_IText /*international text*/
-{
- size_t num;
- char** keys; /*the English keyword of the text chunk (e.g. "Comment")*/
- char** langtags; /*the language tag for this text's international language, ISO/IEC 646 string, e.g. ISO 639 language tag*/
- char** transkeys; /*keyword translated to the international language - UTF-8 string*/
- char** strings; /*the actual international text - UTF-8 string*/
-} LodePNG_IText;
-
-void LodePNG_IText_init(LodePNG_IText* text);
-void LodePNG_IText_cleanup(LodePNG_IText* text);
-unsigned LodePNG_IText_copy(LodePNG_IText* dest, const LodePNG_IText* source);
-
-/*Use these functions instead of allocating the char**s manually*/
-void LodePNG_IText_clear(LodePNG_IText* text);
-unsigned LodePNG_IText_add(LodePNG_IText* text, const char* key, const char* langtag, const char* transkey, const char* str); /*push back the 4 texts of 1 chunk at once*/
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
-typedef struct LodePNG_UnknownChunks /*unknown chunks read from the PNG, or extra chunks the user wants to have added in the encoded PNG*/
-{
- /*There are 3 buffers, one for each position in the PNG where unknown chunks can appear
- each buffer contains all unknown chunks for that position consecutively
- The 3 buffers are the unknown chunks between certain critical chunks:
- 0: IHDR-PLTE, 1: PLTE-IDAT, 2: IDAT-IEND*/
- unsigned char* data[3];
- size_t datasize[3]; /*size in bytes of the unknown chunks, given for protection*/
-
-} LodePNG_UnknownChunks;
-
-void LodePNG_UnknownChunks_init(LodePNG_UnknownChunks* chunks);
-void LodePNG_UnknownChunks_cleanup(LodePNG_UnknownChunks* chunks);
-unsigned LodePNG_UnknownChunks_copy(LodePNG_UnknownChunks* dest, const LodePNG_UnknownChunks* src);
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
-
typedef struct LodePNG_InfoPng /*information about the PNG image, except pixels and sometimes except width and height*/
{
/*header (IHDR), palette (PLTE) and transparency (tRNS)*/
unsigned filterMethod; /*filter method of the original file*/
unsigned interlaceMethod; /*interlace method of the original file*/
LodePNG_InfoColor color; /*color type and bits, palette, transparency*/
-
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
-
- /*suggested background color (bKGD)*/
- unsigned background_defined; /*is a suggested background color given?*/
- unsigned background_r; /*red component of suggested background color*/
- unsigned background_g; /*green component of suggested background color*/
- unsigned background_b; /*blue component of suggested background color*/
-
- /*non-international text chunks (tEXt and zTXt)*/
- LodePNG_Text text;
-
- /*international text chunks (iTXt)*/
- LodePNG_IText itext;
-
- /*time chunk (tIME)*/
- unsigned char time_defined; /*if 0, no tIME chunk was or will be generated in the PNG image*/
- LodePNG_Time time;
-
- /*phys chunk (pHYs)*/
- unsigned phys_defined; /*is pHYs chunk defined?*/
- unsigned phys_x;
- unsigned phys_y;
- unsigned char phys_unit; /*may be 0 (unknown unit) or 1 (metre)*/
-
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- /*unknown chunks*/
- LodePNG_UnknownChunks unknown_chunks;
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
-
} LodePNG_InfoPng;
-void LodePNG_InfoPng_init(LodePNG_InfoPng* info);
-void LodePNG_InfoPng_cleanup(LodePNG_InfoPng* info);
-unsigned LodePNG_InfoPng_copy(LodePNG_InfoPng* dest, const LodePNG_InfoPng* source);
-
typedef struct LodePNG_InfoRaw /*contains user-chosen information about the raw image data, which is independent of the PNG image*/
{
LodePNG_InfoColor color;
} LodePNG_InfoRaw;
-void LodePNG_InfoRaw_init(LodePNG_InfoRaw* info);
-void LodePNG_InfoRaw_cleanup(LodePNG_InfoRaw* info);
-unsigned LodePNG_InfoRaw_copy(LodePNG_InfoRaw* dest, const LodePNG_InfoRaw* source);
-
-/*
-LodePNG_convert: Converts from any color type to 24-bit or 32-bit (later maybe more supported). return value = LodePNG error code
-The out buffer must have (w * h * bpp + 7) / 8, where bpp is the bits per pixel of the output color type (LodePNG_InfoColor_getBpp)
-*/
-unsigned LodePNG_convert(unsigned char* out, const unsigned char* in, LodePNG_InfoColor* infoOut, LodePNG_InfoColor* infoIn, unsigned w, unsigned h);
-
-#ifdef LODEPNG_COMPILE_DECODER
-
-typedef struct LodePNG_DecodeSettings
-{
- LodeZlib_DecompressSettings zlibsettings; /*in here is the setting to ignore Adler32 checksums*/
-
- unsigned ignoreCrc; /*ignore CRC checksums*/
- unsigned color_convert; /*whether to convert the PNG to the color type you want. Default: yes*/
-
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- unsigned readTextChunks; /*if false but rememberUnknownChunks is true, they're stored in the unknown chunks*/
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
-
-#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
- unsigned rememberUnknownChunks; /*store all bytes from unknown chunks in the InfoPng (off by default, useful for a png editor)*/
-#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
-} LodePNG_DecodeSettings;
-
-void LodePNG_DecodeSettings_init(LodePNG_DecodeSettings* settings);
-
-typedef struct LodePNG_Decoder
-{
- LodePNG_DecodeSettings settings;
- LodePNG_InfoRaw infoRaw;
- LodePNG_InfoPng infoPng; /*info of the PNG image obtained after decoding*/
- unsigned error;
-} LodePNG_Decoder;
-
-void LodePNG_Decoder_init(LodePNG_Decoder* decoder);
-void LodePNG_Decoder_cleanup(LodePNG_Decoder* decoder);
-void LodePNG_Decoder_copy(LodePNG_Decoder* dest, const LodePNG_Decoder* source);
-
-/*decoding functions*/
-/*This function allocates the out buffer and stores the size in *outsize.*/
-void LodePNG_decode(LodePNG_Decoder* decoder, unsigned char** out, size_t* outsize, const unsigned char* in, size_t insize);
-unsigned LodePNG_decode32(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize); /*return value is error*/
-#ifdef LODEPNG_COMPILE_DISK
-unsigned LodePNG_decode32f(unsigned char** out, unsigned* w, unsigned* h, const char* filename);
-#endif /*LODEPNG_COMPILE_DISK*/
-void LodePNG_inspect(LodePNG_Decoder* decoder, const unsigned char* in, size_t size); /*read the png header*/
-
-#endif /*LODEPNG_COMPILE_DECODER*/
-
-#ifdef LODEPNG_COMPILE_ENCODER
+unsigned LodePNG_InfoColor_addPalette(LodePNG_InfoColor* info, unsigned char r, unsigned char g, unsigned char b, unsigned char a); /*add 1 color to the palette*/
typedef struct LodePNG_EncodeSettings
{
LodeZlib_DeflateSettings zlibsettings; /*settings for the zlib encoder, such as window size, ...*/
-
+
unsigned autoLeaveOutAlphaChannel; /*automatically use color type without alpha instead of given one, if given image is opaque*/
unsigned force_palette; /*force creating a PLTE chunk if colortype is 2 or 6 (= a suggested palette). If colortype is 3, PLTE is _always_ created.*/
-#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
- unsigned add_id; /*add LodePNG version as text chunk*/
- unsigned text_compression; /*encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks*/
-#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
} LodePNG_EncodeSettings;
void LodePNG_EncodeSettings_init(LodePNG_EncodeSettings* settings);
/*This function allocates the out buffer and stores the size in *outsize.*/
void LodePNG_encode(LodePNG_Encoder* encoder, unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h);
-unsigned LodePNG_encode32(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h); /*return value is error*/
-#ifdef LODEPNG_COMPILE_DISK
-unsigned LodePNG_encode32f(const char* filename, const unsigned char* image, unsigned w, unsigned h);
-#endif /*LODEPNG_COMPILE_DISK*/
-#endif /*LODEPNG_COMPILE_ENCODER*/
-#endif /*LODEPNG_COMPILE_PNG*/
-#ifdef LODEPNG_COMPILE_DISK
/*free functions allowing to load and save a file from/to harddisk*/
/*This function allocates the out buffer and stores the size in *outsize.*/
-unsigned LodePNG_loadFile(unsigned char** out, size_t* outsize, const char* filename);
+//unsigned LodePNG_loadFile(unsigned char** out, size_t* outsize, const char* filename);
unsigned LodePNG_saveFile(const unsigned char* buffer, size_t buffersize, const char* filename);
-#endif /*LODEPNG_COMPILE_DISK*/
-
-
-/*
-TODO:
-[ ] test if there are no memory leaks or security exploits - done a lot but needs to be checked often
-[ ] LZ77 encoder more like the one described in zlib - to make sure it's patentfree
-[ ] converting color to 16-bit types
-[ ] read all public PNG chunk types (but never let the color profile and gamma ones ever touch RGB values, that is very annoying for textures as well as images in a browser)
-[ ] make sure encoder generates no chunks with size > (2^31)-1
-[ ] partial decoding (stream processing)
-[ ] let the "isFullyOpaque" function check color keys and transparent palettes too
-[ ] better name for the variables "codes", "codesD", "codelengthcodes", "clcl" and "lldl"
-[ ] check compatibility with vareous compilers - done but needs to be redone for every newer version
-[ ] don't stop decoding on errors like 69, 57, 58 (make warnings that the decoder stores in the error at the very end? and make some errors just let it stop with this one chunk but still do the next ones)
-[ ] make option to choose if the raw image with non multiple of 8 bits per scanline should have padding bits or not, if people like storing raw images that way
-*/
#endif
-/*
-LodePNG Documentation
----------------------
-
-0. table of contents
---------------------
-
- 1. about
- 1.1. supported features
- 1.2. features not supported
- 2. C and C++ version
- 3. A note about security!
- 4. simple functions
- 4.1 C Simple Functions
- 4.2 C++ Simple Functions
- 5. decoder
- 6. encoder
- 7. color conversions
- 8. info values
- 9. error values
- 10. file IO
- 11. chunks and PNG editing
- 12. compiler support
- 13. examples
- 13.1. decoder example
- 13.2. encoder example
- 14. LodeZlib
- 15. changes
- 16. contact information
-
-
-1. about
---------
-
-PNG is a file format to store raster images losslessly with good compression,
-supporting different color types. It can be implemented in a patent-free way.
-
-LodePNG is a PNG codec according to the Portable Network Graphics (PNG)
-Specification (Second Edition) - W3C Recommendation 10 November 2003.
-
-The specifications used are:
-
-*) Portable Network Graphics (PNG) Specification (Second Edition):
- http://www.w3.org/TR/2003/REC-PNG-20031110
-*) RFC 1950 ZLIB Compressed Data Format version 3.3:
- http://www.gzip.org/zlib/rfc-zlib.html
-*) RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3:
- http://www.gzip.org/zlib/rfc-deflate.html
-
-The most recent version of LodePNG can currently be found at
-http://members.gamedev.net/lode/projects/LodePNG/
-
-LodePNG works both in C (ISO C90) and C++, with a C++ wrapper that adds
-extra functionality.
-
-LodePNG exists out of two files:
--lodepng.h: the header file for both C and C++
--lodepng.c(pp): give it the name lodepng.c or lodepng.cpp depending on your usage
-
-If you want to start using LodePNG right away without reading this doc, get the
-files lodepng_examples.c or lodepng_examples.cpp to see how to use it in code,
-or check the (smaller) examples in chapter 13 here.
-
-LodePNG is simple but only supports the basic requirements. To achieve
-simplicity, the following design choices were made: There are no dependencies
-on any external library. To decode PNGs, there's a Decoder struct or class that
-can convert any PNG file data into an RGBA image buffer with a single function
-call. To encode PNGs, there's an Encoder struct or class that can convert image
-data into PNG file data with a single function call. To read and write files,
-there are simple functions to convert the files to/from buffers in memory.
-
-This all makes LodePNG suitable for loading textures in games, demoscene
-productions, saving a screenshot, images in programs that require them for simple
-usage, ... It's less suitable for full fledged image editors, loading PNGs
-over network (it requires all the image data to be available before decoding can
-begin), life-critical systems, ...
-LodePNG has a standards conformant decoder and encoder, and supports the ability
-to make a somewhat conformant editor.
-
-1.1. supported features
------------------------
-
-The following features are supported by the decoder:
-
-*) decoding of PNGs with any color type, bit depth and interlace mode, to a 24- or 32-bit color raw image, or the same color type as the PNG
-*) encoding of PNGs, from any raw image to 24- or 32-bit color, or the same color type as the raw image
-*) Adam7 interlace and deinterlace for any color type
-*) loading the image from harddisk or decoding it from a buffer from other sources than harddisk
-*) support for alpha channels, including RGBA color model, translucent palettes and color keying
-*) zlib decompression (inflate)
-*) zlib compression (deflate)
-*) CRC32 and ADLER32 checksums
-*) handling of unknown chunks, allowing making a PNG editor that stores custom and unknown chunks.
-*) the following chunks are supported (generated/interpreted) by both encoder and decoder:
- IHDR: header information
- PLTE: color palette
- IDAT: pixel data
- IEND: the final chunk
- tRNS: transparency for palettized images
- tEXt: textual information
- zTXt: compressed textual information
- iTXt: international textual information
- bKGD: suggested background color
- pHYs: physical dimensions
- tIME: modification time
-
-1.2. features not supported
----------------------------
-
-The following features are _not_ supported:
-
-*) some features needed to make a conformant PNG-Editor might be still missing.
-*) partial loading/stream processing. All data must be available and is processed in one call.
-*) The following public chunks are not supported but treated as unknown chunks by LodePNG
- cHRM, gAMA, iCCP, sRGB, sBIT, hIST, sPLT
-
-
-2. C and C++ version
---------------------
-
-The C version uses buffers allocated with alloc instead that you need to free()
-yourself. On top of that, you need to use init and cleanup functions for each
-struct whenever using a struct from the C version to avoid exploits and memory leaks.
-
-The C++ version has constructors and destructors that take care of these things,
-and uses std::vectors in the interface for storing data.
-
-Both the C and the C++ version are contained in this file! The C++ code depends on
-the C code, the C code works on its own.
-
-These files work without modification for both C and C++ compilers because all the
-additional C++ code is in "#ifdef __cplusplus" blocks that make C-compilers ignore
-it, and the C code is made to compile both with strict ISO C90 and C++.
-
-To use the C++ version, you need to rename the source file to lodepng.cpp (instead
-of lodepng.c), and compile it with a C++ compiler.
-
-To use the C version, you need to rename the source file to lodepng.c (instead
-of lodepng.cpp), and compile it with a C compiler.
-
-
-3. A note about security!
--------------------------
-
-Despite being used already and having received bug fixes whenever bugs were reported,
-LodePNG may still contain possible exploits.
-
-If you discover a possible exploit, please let me know, and it will be eliminated.
-
-When using LodePNG, care has to be taken with the C version of LodePNG, as well as the C-style
-structs when working with C++. The following conventions are used for all C-style structs:
-
--if a struct has a corresponding init function, always call the init function when making a new one, to avoid exploits
--if a struct has a corresponding cleanup function, call it before the struct disappears to avoid memory leaks
--if a struct has a corresponding copy function, use the copy function instead of "=". The destination must be inited already!
-
-
-4. "Simple" Functions
----------------------
-
-For the most simple usage cases of loading and saving a PNG image, there
-are some simple functions that do everything in 1 call (instead of you
-having to instantiate a struct or class).
-
-The simple versions always use 32-bit RGBA color for the raw image, but
-still support loading arbitrary-colortype PNG images.
-
-The later sections of this manual are devoted to the complex versions, where
-you can use other color types and conversions.
-
-4.1 C Simple Functions
-----------------------
-
-The C simple functions have a "32" or "32f" in their name, and don't take a struct as
-parameter, unlike the non-simple ones (see more down in the documentation).
-
-unsigned LodePNG_decode32(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize);
-
-Load PNG from given buffer.
-As input, give an unsigned char* buffer gotten by loading the .png file and its size.
-As output, you get a dynamically allocated buffer of large enough size, and the width and height of the image.
-The buffer's size is w * h * 4. The image is in RGBA format.
-The return value is the error (0 if ok).
-You need to do free(out) after usage to clean up the memory.
-
-unsigned LodePNG_decode32f(unsigned char** out, unsigned* w, unsigned* h, const char* filename);
-
-Load PNG from disk, from file with given name.
-Same as decode32, except you give a filename instead of an input buffer.
-
-unsigned LodePNG_encode32(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h);
-
-Encode PNG into buffer.
-As input, give a image buffer of size w * h * 4, in RGBA format.
-As output, you get a dynamically allocated buffer and its size, which is a PNG file that can
-directly be saved in this form to the harddisk.
-The return value is the error (0 if ok).
-You need to do free(out) after usage to clean up the memory.
-
-unsigned LodePNG_encode32f(const char* filename, const unsigned char* image, unsigned w, unsigned h);
-
-Encode PNG into file on disk with given name.
-If the file exists, it's overwritten without warning!
-Same parameters as encode2, except the result is stored in a file instead of a dynamic buffer.
-
-4.2 C++ Simple Functions
-------------------------
-
-For decoding a PNG there are:
-
-unsigned LodePNG::decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const unsigned char* in, unsigned size);
-unsigned LodePNG::decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const std::vector<unsigned char>& in);
-unsigned LodePNG::decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const std::string& filename);
-
-These store the pixel data as 32-bit RGBA color in the out vector, and the width
-and height of the image in w and h.
-The 3 functions each have a different input type: The first as unsigned char
-buffer, the second as std::vector buffer, and the third allows you to give the
-filename in case you want to load the PNG from disk instead of from a buffer.
-The return value is the error (0 if ok).
-
-For encoding a PNG there are:
-
-unsigned LodePNG::encode(std::vector<unsigned char>& out, const unsigned char* in, unsigned w, unsigned h);
-unsigned LodePNG::encode(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, unsigned w, unsigned h);
-unsigned LodePNG::encode(const std::string& filename, const std::vector<unsigned char>& in, unsigned w, unsigned h);
-unsigned LodePNG::encode(const std::string& filename, const unsigned char* in, unsigned w, unsigned h);
-
-Specify the width and height of the input image with w and h.
-You can choose to get the output in an std::vector or stored in a file, and
-the input can come from an std::vector or an unsigned char* buffer. The input
-buffer must be in RGBA format and the size must be w * h * 4 bytes.
-
-The first two functions append to the out buffer, they don't clear it, clear it
-first before encoding into a buffer that you expect to only contain this result.
-
-On the other hand, the functions that encode to a file will completely overwrite
-the original file without warning if it exists.
-
-The return value is the error (0 if ok).
-
-5. Decoder
-----------
-
-This is about the LodePNG_Decoder struct in the C version, and the
-LodePNG::Decoder class in the C++ version. The C++ version inherits
-from the C struct and adds functions in the interface.
-
-The Decoder class can be used to convert a PNG image to a raw image.
-
-Usage:
-
--in C++:
- declare a LodePNG::Decoder
- call its decode member function with the parameters described below
-
--in C more needs to be done due to the lack of constructors and destructors:
- declare a LodePNG_Decoder struct
- call LodePNG_Decoder_init with the struct as parameter
- call LodePNG_Decode with the parameters described below
- after usage, call LodePNG_Decoder_cleanup with the struct as parameter
- after usage, free() the out buffer with image data that was created by the decode function
-
-The other parameters of the decode function are:
-*) out: this buffer will be filled with the raw image pixels
-*) in: pointer to the PNG image data or std::vector with the data
-*) size: the size of the PNG image data (not needed for std::vector version)
-
-After decoding you need to read the width and height of the image from the
-decoder, see further down in this manual to see how.
-
-There's also an optional function "inspect". It has the same parameters as decode except
-the "out" parameter. This function will read only the header chunk of the PNG
-image, and store the information from it in the LodePNG_InfoPng (see below).
-This allows knowing information about the image without decoding it. Only the
-header (IHDR) information is read by this, not text chunks, not the palette, ...
-
-During the decoding it's possible that an error can happen, for example if the
-PNG image was corrupted. To check if an error happened during the last decoding,
-check the value error, which is a member of the decoder struct.
-In the C++ version, use hasError() and getError() of the Decoder.
-The error codes are explained in another section.
-
-Now about colors and settings...
-
-The Decoder contains 3 components:
-*) LodePNG_InfoPng: it stores information about the PNG (the input) in an LodePNG_InfoPng struct, don't modify this one yourself
-*) Settings: you can specify a few other settings for the decoder to use
-*) LodePNG_InfoRaw: here you can say what type of raw image (the output) you want to get
-
-Some of the parameters described below may be inside the sub-struct "LodePNG_InfoColor color".
-In the C and C++ version, when using Info structs outside of the decoder or encoder, you need to use their
-init and cleanup functions, but normally you use the ones in the decoder that are already handled
-in the init and cleanup functions of the decoder itself.
-
-=LodePNG_InfoPng=
-
-This contains information such as the original color type of the PNG image, text
-comments, suggested background color, etc... More details about the LodePNG_InfoPng struct
-are in another section.
-
-Because the dimensions of the image are important, there are shortcuts to get them in the
-C++ version: use decoder.getWidth() and decoder.getHeight().
-In the C version, use decoder.infoPng.width and decoder.infoPng.height.
-
-=LodePNG_InfoRaw=
-
-In the LodePNG_InfoRaw struct of the Decoder, you can specify which color type you want
-the resulting raw image to be. If this is different from the colorType of the
-PNG, then the decoder will automatically convert the result to your LodePNG_InfoRaw
-settings. Currently the following options are supported to convert to:
--colorType 6, bitDepth 8: 32-bit RGBA
--colorType 2, bitDepth 8: 24-bit RGB
--other color types if it's exactly the same as that in the PNG image
-
-Palette of LodePNG_InfoRaw isn't used by the Decoder, when converting from palette color
-to palette color, the values of the pixels are left untouched so that the colors
-will change if the palette is different. Color key of LodePNG_InfoRaw is not used by the
-Decoder. If setting color_convert is false then LodePNG_InfoRaw is completely ignored,
-but it will be modified to match the color type of the PNG so will be overwritten.
-
-By default, 32-bit color is used for the result.
-
-=Settings=
-
-The Settings can be used to ignore the errors created by invalid CRC and Adler32
-chunks, and to disable the decoding of tEXt chunks.
-
-There's also a setting color_convert, true by default. If false, no conversion
-is done, the resulting data will be as it was in the PNG (after decompression)
-and you'll have to puzzle the colors of the pixels together yourself using the
-color type information in the LodePNG_InfoPng.
-
-
-6. Encoder
-----------
-
-This is about the LodePNG_Encoder struct in the C version, and the
-LodePNG::Encoder class in the C++ version.
-
-The Encoder class can be used to convert raw image data into a PNG image.
-
-The PNG part of the encoder is working good, the zlib compression part is
-becoming quite fine but not as good as the official zlib yet, because it's not
-as fast and doesn't provide an as high compression ratio.
-
-Usage:
-
--in C++:
- declare a LodePNG::Encoder
- call its encode member function with the parameters described below
-
--in C more needs to be done due to the lack of constructors and destructors:
- declare a LodePNG_Encoder struct
- call LodePNG_Encoder_init with the struct as parameter
- call LodePNG_Encode with the parameters described below
- after usage, call LodePNG_Encoder_cleanup with the struct as parameter
- after usage, free() the out buffer with PNG data that was created by the encode function
-
-The raw image given to the encoder is an unsigned char* buffer. You also have to
-specify the width and height of the raw image. The result is stored in a given
-buffer. These buffers can be unsigned char* pointers, std::vectors or dynamically
-allocated unsigned char* buffers that you have to free() yourself, depending on
-which you use.
-
-The parameters of the encode function are:
-*) out: in this buffer the PNG file data will be stored (it will be appended)
-*) in: vector of or pointer to a buffer containing the raw image
-*) w and h: the width and height of the raw image in pixels
-
-Make sure that the in buffer you provide, is big enough to contain w * h pixels
-of the color type specified by the LodePNG_InfoRaw.
-
-In the C version, you need to free() the out buffer after usage to avoid memory leaks.
-In the C version, you need to use the LodePNG_Encoder_init function before using the decoder,
-and the LodePNG_Encoder_cleanup function after using it.
-In the C++ version, you don't need to do this since RAII takes care of it.
-
-The encoder generates some errors but not for everything, because, unlike when
-decoding a PNG, when encoding one there aren't so much parameters of the input
-that can be corrupted. It's the responsibility of the user to make sure that all
-preconditions are satesfied, such as giving a correct window size, giving an
-existing btype, making sure the given buffer is large enough to contain an image
-with the given width and height and colortype, ... The encoder can generate
-some errors, see the section with the explanations of errors for those.
-
-Like the Decoder, the Encoder has 3 components:
-*) LodePNG_InfoRaw: here you say what color type of the raw image (the input) has
-*) Settings: you can specify a few settings for the encoder to use
-*) LodePNG_InfoPng: the same LodePNG_InfoPng struct as created by the Decoder. For the encoder,
-with this you specify how you want the PNG (the output) to be.
-
-Some of the parameters described below may be inside the sub-struct "LodePNG_InfoColor color".
-In the C and C++ version, when using Info structs outside of the decoder or encoder, you need to use their
-init and cleanup functions, but normally you use the ones in the encoder that are already handled
-in the init and cleanup functions of the decoder itself.
-
-=LodePNG_InfoPng=
-
-The Decoder class stores information about the PNG image in an LodePNG_InfoPng object. With
-the Encoder you can do the opposite: you give it an LodePNG_InfoPng object, and it'll try
-to match the LodePNG_InfoPng you give as close as possible in the PNG it encodes. For
-example in the LodePNG_InfoPng you can specify the color type you want to use, possible
-tEXt chunks you want the PNG to contain, etc... For an explanation of all the
-values in LodePNG_InfoPng see a further section. Not all PNG color types are supported
-by the Encoder.
-
-Note that the encoder will only TRY to match the LodePNG_InfoPng struct you give.
-Some things are ignored by the encoder. The width and height of LodePNG_InfoPng are
-ignored as well, because instead the width and height of the raw image you give
-in the input are used. In fact the encoder currently uses only the following
-settings from it:
--colorType: the ones it supports
--text chunks, that you can add to the LodePNG_InfoPng with "addText"
--the color key, if applicable for the given color type
--the palette, if you encode to a PNG with colorType 3
--the background color: it'll add a bKGD chunk to the PNG if one is given
--the interlaceMethod: None (0) or Adam7 (1)
-
-When encoding to a PNG with colorType 3, the encoder will generate a PLTE chunk.
-If the palette contains any colors for which the alpha channel is not 255 (so
-there are translucent colors in the palette), it'll add a tRNS chunk.
-
-=LodePNG_InfoRaw=
-
-You specify the color type of the raw image that you give to the input here,
-including a possible transparent color key and palette you happen to be using in
-your raw image data.
-
-By default, 32-bit color is assumed, meaning your input has to be in RGBA
-format with 4 bytes (unsigned chars) per pixel.
-
-=Settings=
-
-The following settings are supported (some are in sub-structs):
-*) autoLeaveOutAlphaChannel: when this option is enabled, when you specify a PNG
-color type with alpha channel (not to be confused with the color type of the raw
-image you specify!!), but the encoder detects that all pixels of the given image
-are opaque, then it'll automatically use the corresponding type without alpha
-channel, resulting in a smaller PNG image.
-*) btype: the block type for LZ77. 0 = uncompressed, 1 = fixed huffman tree, 2 = dynamic huffman tree (best compression)
-*) useLZ77: whether or not to use LZ77 for compressed block types
-*) windowSize: the window size used by the LZ77 encoder (1 - 32768)
-*) force_palette: if colorType is 2 or 6, you can make the encoder write a PLTE
- chunk if force_palette is true. This can used as suggested palette to convert
- to by viewers that don't support more than 256 colors (if those still exist)
-*) add_id: add text chunk "Encoder: LodePNG <version>" to the image.
-*) text_compression: default 0. If 1, it'll store texts as zTXt instead of tEXt chunks.
- zTXt chunks use zlib compression on the text. This gives a smaller result on
- large texts but a larger result on small texts (such as a single program name).
- It's all tEXt or all zTXt though, there's no separate setting per text yet.
-
-
-7. color conversions
---------------------
-
-For trickier usage of LodePNG, you need to understand about PNG color types and
-about how and when LodePNG uses the settings in LodePNG_InfoPng, LodePNG_InfoRaw and Settings.
-
-=PNG color types=
-
-A PNG image can have many color types, ranging from 1-bit color to 64-bit color,
-as well as palettized color modes. After the zlib decompression and unfiltering
-in the PNG image is done, the raw pixel data will have that color type and thus
-a certain amount of bits per pixel. If you want the output raw image after
-decoding to have another color type, a conversion is done by LodePNG.
-
-The PNG specification mentions the following color types:
-
-0: greyscale, bit depths 1, 2, 4, 8, 16
-2: RGB, bit depths 8 and 16
-3: palette, bit depths 1, 2, 4 and 8
-4: greyscale with alpha, bit depths 8 and 16
-6: RGBA, bit depths 8 and 16
-
-Bit depth is the amount of bits per color channel.
-
-=Default Behaviour of LodePNG=
-
-By default, the Decoder will convert the data from the PNG to 32-bit RGBA color,
-no matter what color type the PNG has, so that the result can be used directly
-as a texture in OpenGL etc... without worries about what color type the original
-image has.
-
-The Encoder assumes by default that the raw input you give it is a 32-bit RGBA
-buffer and will store the PNG as either 32 bit or 24 bit depending on whether
-or not any translucent pixels were detected in it.
-
-To get the default behaviour, don't change the values of LodePNG_InfoRaw and LodePNG_InfoPng of
-the encoder, and don't change the values of LodePNG_InfoRaw of the decoder.
-
-=Color Conversions=
-
-As explained in the sections about the Encoder and Decoder, you can specify
-color types and bit depths in LodePNG_InfoPng and LodePNG_InfoRaw, to change the default behaviour
-explained above. (for the Decoder you can only specify the LodePNG_InfoRaw, because the
-LodePNG_InfoPng contains what the PNG file has).
-
-To avoid some confusion:
--the Decoder converts from PNG to raw image
--the Encoder converts from raw image to PNG
--the color type and bit depth in LodePNG_InfoRaw, are those of the raw image
--the color type and bit depth in LodePNG_InfoPng, are those of the PNG
--if the color type of the LodePNG_InfoRaw and PNG image aren't the same, a conversion
-between the color types is done if the color types are supported
-
-Supported color types:
--It's possible to load PNGs from any colortype and to save PNGs of any colorType.
--Both encoder and decoder use the same converter. So both encoder and decoder
-suport the same color types at the input and the output. So the decoder supports
-any type of PNG image and can convert it to certain types of raw image, while the
-encoder supports any type of raw data but only certain color types for the output PNG.
--The converter can convert from _any_ input color type, to 24-bit RGB or 32-bit RGBA
--The converter can convert from greyscale input color type, to 8-bit greyscale or greyscale with alpha
--If both color types are the same, conversion from anything to anything is possible
--Color types that are invalid according to the PNG specification are not allowed
--When converting from a type with alpha channel to one without, the alpha channel information is discarded
--When converting from a type without alpha channel to one with, the result will be opaque except pixels that have the same color as the color key of the input if one was given
--When converting from 16-bit bitDepth to 8-bit bitDepth, the 16-bit precision information is lost, only the most significant byte is kept
--Converting from color to greyscale is not supported on purpose: choosing what kind of color to greyscale conversion to do is not a decision a PNG codec should make
--Converting from/to a palette type, only keeps the indices, it ignores the colors defined in the palette
-
-No conversion needed...:
--If the color type of the PNG image and raw image are the same, then no
-conversion is done, and all color types are supported.
--In the encoder, you can make it save a PNG with any color by giving the
-LodePNG_InfoRaw and LodePNG_InfoPng the same color type.
--In the decoder, you can make it store the pixel data in the same color type
-as the PNG has, by setting the color_convert setting to false. Settings in
-infoRaw are then ignored.
-
-The function LodePNG_convert does this, which is available in the interface but
-normally isn't needed since the encoder and decoder already call it.
-
-=More Notes=
-
-In the PNG file format, if a less than 8-bit per pixel color type is used and the scanlines
-have a bit amount that isn't a multiple of 8, then padding bits are used so that each
-scanline starts at a fresh byte.
-However: The input image you give to the encoder, and the output image you get from the decoder
-will NOT have these padding bits in that case, e.g. in the case of a 1-bit image with a width
-of 7 pixels, the first pixel of the second scanline will the the 8th bit of the first byte,
-not the first bit of a new byte.
-
-8. info values
---------------
-
-Both the encoder and decoder use a variable of type LodePNG_InfoPng and LodePNG_InfoRaw, which
-both also contain a LodePNG_InfoColor. Here's a list of each of the values stored in them:
-
-*) info from the PNG header (IHDR chunk):
-
-width: width of the image in pixels
-height: height of the image in pixels
-colorType: color type of the original PNG file
-bitDepth: bits per sample
-compressionMethod: compression method of the original file. Always 0.
-filterMethod: filter method of the original file. Always 0.
-interlaceMethod: interlace method of the original file. 0 is no interlace, 1 is adam7 interlace.
-
-Note: width and height are only used as information of a decoded PNG image. When encoding one, you don't have
-to specify width and height in an LodePNG_Info struct, but you give them as parameters of the encode function.
-The rest of the LodePNG_Info struct IS used by the encoder though!
-
-*) palette:
-
-This is a dynamically allocated unsigned char array with the colors of the palette. The value palettesize
-indicates the amount of colors in the palette. The allocated size of the buffer is 4 * palettesize bytes,
-because there are 4 values per color: R, G, B and A. Even if less color channels are used, the palette
-is always in RGBA format, in the order RGBARGBARGBA.....
-
-When encoding a PNG, to store your colors in the palette of the LodePNG_InfoRaw, first use
-LodePNG_InfoColor_clearPalette, then for each color use LodePNG_InfoColor_addPalette.
-In the C++ version the Encoder class also has the above functions available directly in its interface.
-
-Note that the palette information from the tRNS chunk is also already included in this palette vector.
-
-If you encode an image with palette, don't forget that you have to set the alpha channels (A) of the palette
-too, set them to 255 for an opaque palette. If you leave them at zero, the image will be encoded as
-fully invisible. This both for the palette in the infoRaw and the infoPng if the png is to have a palette.
-
-*) transparent color key
-
-key_defined: is a transparent color key given?
-key_r: red/greyscale component of color key
-key_g: green component of color key
-key_b: blue component of color key
-
-For greyscale PNGs, r, g and b will all 3 be set to the same.
-
-This color is 8-bit for 8-bit PNGs, 16-bit for 16-bit per channel PNGs.
-
-*) suggested background color
-
-background_defined: is a suggested background color given?
-background_r: red component of sugg. background color
-background_g: green component of sugg. background color
-background_b: blue component of sugg. background color
-
-This color is 8-bit for 8-bit PNGs, 16-bit for 16-bit PNGs
-
-For greyscale PNGs, r, g and b will all 3 be set to the same. When encoding
-the encoder writes the red one away.
-For palette PNGs: When decoding, the RGB value will be stored, no a palette
-index. But when encoding, specify the index of the palette in background_r,
-the other two are then ignored.
-
-The decoder pretty much ignores this background color, after all if you make a
-PNG translucent normally you intend it to be used against any background, on
-websites, as translucent textures in games, ... But you can get the color this
-way if needed.
-
-*) text and itext
-
-Non-international text:
-
--text.keys: a char** buffer containing the keywords (see below)
--text.strings: a char** buffer containing the texts (see below)
--text.num: the amount of texts in the above char** buffers (there may be more texts in itext)
--LodePNG_InfoText_clearText: use this to clear the texts again after you filled them in
--LodePNG_InfoText_addText: this function is used to push back a keyword and text
-
-International text: This is stored in separate arrays! The sum text.num and itext.num is the real amount of texts.
-
--itext.keys: keyword in English
--itext.langtags: ISO 639 letter code for the language
--itext.transkeys: keyword in this language
--itext.strings: the text in this language, in UTF-8
--itext.num: the amount of international texts in this PNG
--LodePNG_InfoIText_clearText: use this to clear the itexts again after you filled them in
--LodePNG_InfoIText_addText: this function is used to push back all 4 parts of an itext
-
-Don't allocate these text buffers yourself. Use the init/cleanup functions
-correctly and use addText and clearText.
-
-In the C++ version the Encoder class also has the above functions available directly in its interface.
-The char** buffers are used like the argv parameter of a main() function, and (i)text.num takes the role
-of argc.
-
-In a text, there must be as much keys as strings because they always form pairs. In an itext,
-there must always be as much keys, langtags, transkeys and strings.
-
-They keyword of text chunks gives a short description what the actual text
-represents. There are a few standard standard keywords recognised
-by many programs: Title, Author, Description, Copyright, Creation Time,
-Software, Disclaimer, Warning, Source, Comment. It's allowed to use other keys.
-
-The keyword is minimum 1 character and maximum 79 characters long. It's
-discouraged to use a single line length longer than 79 characters for texts.
-
-*) additional color info
-
-These functions are available with longer names in the C version, and directly
-in the Decoder's interface in the C++ version.
-
-getBpp(): bits per pixel of the PNG image
-getChannels(): amount of color channels of the PNG image
-isGreyscaleType(): its color type 0 or 4
-isAlphaType(): its color type 2 or 6
-
-These values are calculated out of color type and bit depth of InfoColor.
-
-The difference between bits per pixel and bit depth is that bit depth is the
-number of bits per color channel, while a pixel can have multiple channels.
-
-*) pHYs chunk (image dimensions)
-
-phys_defined: if 0, there is no pHYs chunk and the values are undefined, if 1 else there is one
-phys_x: pixels per unit in x direction
-phys_y: pixels per unit in y direction
-phys_unit: the unit, 0 is no unit (x and y only give the ratio), 1 is metre
-
-*) tIME chunk (modification time)
-
-time_defined: if 0, there is no tIME chunk and the values are undefined, if 1 there is one
-time: this struct contains year as a 2-byte number (0-65535), month, day, hour, minute,
-second as 1-byte numbers that must be in the correct range
-
-Note: to make the encoder add a time chunk, set time_defined to 1 and fill in
-the correct values in all the time parameters, LodePNG will not fill the current
-time in these values itself, all it does is copy them over into the chunk bytes.
-
-
-9. error values
----------------
-
-The meanings of the LodePNG error values:
-
-*) 0: no error, everything went ok
-*) 1: the Encoder/Decoder has done nothing yet, so error checking makes no sense yet
-*) 10: while huffman decoding: end of input memory reached without endcode
-*) 11: while huffman decoding: error in code tree made it jump outside of tree
-*) 13: problem while processing dynamic deflate block
-*) 14: problem while processing dynamic deflate block
-*) 15: problem while processing dynamic deflate block
-*) 16: unexisting code while processing dynamic deflate block
-*) 17: while inflating: end of out buffer memory reached
-*) 18: while inflating: invalid distance code
-*) 19: while inflating: end of out buffer memory reached
-*) 20: invalid deflate block BTYPE encountered while decoding
-*) 21: NLEN is not ones complement of LEN in a deflate block
-*) 22: while inflating: end of out buffer memory reached.
- This can happen if the inflated deflate data is longer than the amount of bytes required to fill up
- all the pixels of the image, given the color depth and image dimensions. Something that doesn't
- happen in a normal, well encoded, PNG image.
-*) 23: while inflating: end of in buffer memory reached
-*) 24: invalid FCHECK in zlib header
-*) 25: invalid compression method in zlib header
-*) 26: FDICT encountered in zlib header while it's not used for PNG
-*) 27: PNG file is smaller than a PNG header
-*) 28: incorrect PNG signature (the first 8 bytes of the PNG file)
- Maybe it's not a PNG, or a PNG file that got corrupted so that the header indicates the corruption.
-*) 29: first chunk is not the header chunk
-*) 30: chunk length too large, chunk broken off at end of file
-*) 31: illegal PNG color type or bpp
-*) 32: illegal PNG compression method
-*) 33: illegal PNG filter method
-*) 34: illegal PNG interlace method
-*) 35: chunk length of a chunk is too large or the chunk too small
-*) 36: illegal PNG filter type encountered
-*) 37: illegal bit depth for this color type given
-*) 38: the palette is too big (more than 256 colors)
-*) 39: more palette alpha values given in tRNS, than there are colors in the palette
-*) 40: tRNS chunk has wrong size for greyscale image
-*) 41: tRNS chunk has wrong size for RGB image
-*) 42: tRNS chunk appeared while it was not allowed for this color type
-*) 43: bKGD chunk has wrong size for palette image
-*) 44: bKGD chunk has wrong size for greyscale image
-*) 45: bKGD chunk has wrong size for RGB image
-*) 46: value encountered in indexed image is larger than the palette size (bitdepth == 8). Is the palette too small?
-*) 47: value encountered in indexed image is larger than the palette size (bitdepth < 8). Is the palette too small?
-*) 48: the input data is empty. Maybe a PNG file you tried to load doesn't exist or is in the wrong path.
-*) 49: jumped past memory while generating dynamic huffman tree
-*) 50: jumped past memory while generating dynamic huffman tree
-*) 51: jumped past memory while inflating huffman block
-*) 52: jumped past memory while inflating
-*) 53: size of zlib data too small
-*) 55: jumped past tree while generating huffman tree, this could be when the
- tree will have more leaves than symbols after generating it out of the
- given lengths. They call this an oversubscribed dynamic bit lengths tree in zlib.
-*) 56: given output image colorType or bitDepth not supported for color conversion
-*) 57: invalid CRC encountered (checking CRC can be disabled)
-*) 58: invalid ADLER32 encountered (checking ADLER32 can be disabled)
-*) 59: conversion to unexisting or unsupported color type or bit depth requested by encoder or decoder
-*) 60: invalid window size given in the settings of the encoder (must be 0-32768)
-*) 61: invalid BTYPE given in the settings of the encoder (only 0, 1 and 2 are allowed)
-*) 62: conversion from non-greyscale color to greyscale color requested by encoder or decoder. LodePNG
- leaves the choice of RGB to greyscale conversion formula to the user.
-*) 63: length of a chunk too long, max allowed for PNG is 2147483647 bytes per chunk (2^31-1)
-*) 64: the length of the "end" symbol 256 in the Huffman tree is 0, resulting in the inability of a deflated
- block to ever contain an end code. It must be at least 1.
-*) 66: the length of a text chunk keyword given to the encoder is longer than the maximum 79 bytes.
-*) 67: the length of a text chunk keyword given to the encoder is smaller than the minimum 1 byte.
-*) 68: tried to encode a PLTE chunk with a palette that has less than 1 or more than 256 colors
-*) 69: unknown chunk type with "critical" flag encountered by the decoder
-*) 71: unexisting interlace mode given to encoder (must be 0 or 1)
-*) 72: while decoding, unexisting compression method encountering in zTXt or iTXt chunk (it must be 0)
-*) 73: invalid tIME chunk size
-*) 74: invalid pHYs chunk size
-*) 75: no null termination char found while decoding any kind of text chunk, or wrong length
-*) 76: iTXt chunk too short to contain required bytes
-*) 77: integer overflow in buffer size happened somewhere
-*) 78: file doesn't exist or couldn't be opened for reading
-*) 79: file couldn't be opened for writing
-*) 80: tried creating a tree for 0 symbols
-*) 9900-9999: out of memory while allocating chunk of memory somewhere
-
-
-10. file IO
------------
-
-For cases where you want to load the PNG image from a file, you can use your own
-file loading code, or the file loading and saving functions provided with
-LodePNG. These use the same unsigned char format used by the Decoder and Encoder.
-
-The loadFile function fills the given buffer up with the file from harddisk
-with the given name.
-
-The saveFile function saves the contents of the given buffer to the file
-with given name. Warning: this overwrites the contents that were previously in
-the file if it already existed, without warning.
-
-Note that you don't have to decode a PNG image from a file, you can as well
-retrieve the buffer another way in your code, because the decode function takes
-a buffer as parameter, not a filename.
-
-Both C and C++ versions of the loadFile and saveFile functions are available.
-For the C version of loadFile, you need to free() the buffer after use. The
-C++ versions use std::vectors so they clean themselves automatically.
-
-
-11. chunks and PNG editing
---------------------------
-
-If you want to add extra chunks to a PNG you encode, or use LodePNG for a PNG
-editor that should follow the rules about handling of unknown chunks, or if you
-program is able to read other types of chunks than the ones handled by LodePNG,
-then that's possible with the chunk functions of LodePNG.
-
-A PNG chunk has the following layout:
-
-4 bytes length
-4 bytes type name
-length bytes data
-4 bytes CRC
-
-
-11.1 iterating through chunks
------------------------------
-
-If you have a buffer containing the PNG image data, then the first chunk (the
-IHDR chunk) starts at byte number 8 of that buffer. The first 8 bytes are the
-signature of the PNG and are not part of a chunk. But if you start at byte 8
-then you have a chunk, and can check the following things of it.
-
-NOTE: none of these functions check for memory buffer boundaries. To avoid
-exploits, always make sure the buffer contains all the data of the chunks.
-When using LodePNG_chunk_next, make sure the returned value is within the
-allocated memory.
-
-unsigned LodePNG_chunk_length(const unsigned char* chunk):
-
-Get the length of the chunk's data. The total chunk length is this length + 12.
-
-void LodePNG_chunk_type(char type[5], const unsigned char* chunk):
-unsigned char LodePNG_chunk_type_equals(const unsigned char* chunk, const char* type):
-
-Get the type of the chunk or compare if it's a certain type
-
-unsigned char LodePNG_chunk_critical(const unsigned char* chunk):
-unsigned char LodePNG_chunk_private(const unsigned char* chunk):
-unsigned char LodePNG_chunk_safetocopy(const unsigned char* chunk):
-
-Check if the chunk is critical in the PNG standard (only IHDR, PLTE, IDAT and IEND are).
-Check if the chunk is private (public chunks are part of the standard, private ones not).
-Check if the chunk is safe to copy. If it's not, then, when modifying data in a critical
-chunk, unsafe to copy chunks of the old image may NOT be saved in the new one if your
-program doesn't handle that type of unknown chunk.
-
-unsigned char* LodePNG_chunk_data(unsigned char* chunk):
-const unsigned char* LodePNG_chunk_data_const(const unsigned char* chunk):
-
-Get a pointer to the start of the data of the chunk.
-
-unsigned LodePNG_chunk_check_crc(const unsigned char* chunk):
-void LodePNG_chunk_generate_crc(unsigned char* chunk):
-
-Check if the crc is correct or generate a correct one.
-
-unsigned char* LodePNG_chunk_next(unsigned char* chunk):
-const unsigned char* LodePNG_chunk_next_const(const unsigned char* chunk):
-
-Iterate to the next chunk. This works if you have a buffer with consecutive chunks. Note that these
-functions do no boundary checking of the allocated data whatsoever, so make sure there is enough
-data available in the buffer to be able to go to the next chunk.
-
-unsigned LodePNG_append_chunk(unsigned char** out, size_t* outlength, const unsigned char* chunk):
-unsigned LodePNG_create_chunk(unsigned char** out, size_t* outlength, unsigned length, const char* type, const unsigned char* data):
-
-These functions are used to create new chunks that are appended to the data in *out that has
-length *outlength. The append function appends an existing chunk to the new data. The create
-function creates a new chunk with the given parameters and appends it. Type is the 4-letter
-name of the chunk.
-
-
-11.2 chunks in infoPng
-----------------------
-
-The LodePNG_InfoPng struct contains a struct LodePNG_UnknownChunks in it. This
-struct has 3 buffers (each with size) to contain 3 types of unknown chunks:
-the ones that come before the PLTE chunk, the ones that come between the PLTE
-and the IDAT chunks, and the ones that come after the IDAT chunks.
-It's necessary to make the distionction between these 3 cases because the PNG
-standard forces to keep the ordering of unknown chunks compared to the critical
-chunks, but does not force any other ordering rules.
-
-infoPng.unknown_chunks.data[0] is the chunks before PLTE
-infoPng.unknown_chunks.data[1] is the chunks after PLTE, before IDAT
-infoPng.unknown_chunks.data[2] is the chunks after IDAT
-
-The chunks in these 3 buffers can be iterated through and read by using the same
-way described in the previous subchapter.
-
-When using the decoder to decode a PNG, you can make it store all unknown chunks
-if you set the option settings.rememberUnknownChunks to 1. By default, this option
-is off and is 0.
-
-The encoder will always encode unknown chunks that are stored in the infoPng. If
-you need it to add a particular chunk that isn't known by LodePNG, you can use
-LodePNG_append_chunk or LodePNG_create_chunk to the chunk data in
-infoPng.unknown_chunks.data[x].
-
-Chunks that are known by LodePNG should not be added in that way. E.g. to make
-LodePNG add a bKGD chunk, set background_defined to true and add the correct
-parameters there and LodePNG will generate the chunk.
-
-
-12. compiler support
---------------------
-
-No libraries other than the current standard C library are needed to compile
-LodePNG. For the C++ version, only the standard C++ library is needed on top.
-Add the files lodepng.c(pp) and lodepng.h to your project, include
-lodepng.h where needed, and your program can read/write PNG files.
-
-Use optimization! For both the encoder and decoder, compiling with the best
-optimizations makes a large difference.
-
-Make sure that LodePNG is compiled with the same compiler of the same version
-and with the same settings as the rest of the program, or the interfaces with
-std::vectors and std::strings in C++ can be incompatible resulting in bad things.
-
-CHAR_BITS must be 8 or higher, because LodePNG uses unsigned chars for octets.
-
-*) gcc and g++
-
-LodePNG is developed in gcc so this compiler is natively supported. It gives no
-warnings with compiler options "-Wall -Wextra -pedantic -ansi", with gcc and g++
-version 4.2.2 on Linux.
-
-*) Mingw and Bloodshed DevC++
-
-The Mingw compiler (a port of gcc) used by Bloodshed DevC++ for Windows is fully
-supported by LodePNG.
-
-*) Visual Studio 2005 and Visual C++ 2005 Express Edition
-
-Versions 20070604 up to 20080107 have been tested on VS2005 and work. There are no
-warnings, except two warnings about 'fopen' being deprecated. 'fopen' is a function
-required by the C standard, so this warning is the fault of VS2005, it's nice of
-them to enforce secure code, however the multiplatform LodePNG can't follow their
-non-standard extensions. LodePNG is fully ISO C90 compliant.
-
-If you're using LodePNG in VS2005 and don't want to see the deprecated warnings,
-put this on top of lodepng.h before the inclusions: #define _CRT_SECURE_NO_DEPRECATE
-
-*) Visual Studio 6.0
-
-The C++ version of LodePNG was not supported by Visual Studio 6.0 because Visual
-Studio 6.0 doesn't follow the C++ standard and implements it incorrectly.
-The current C version of LodePNG has not been tested in VS6 but may work now.
-
-*) Comeau C/C++
-
-Vesion 20070107 compiles without problems on the Comeau C/C++ Online Test Drive
-at http://www.comeaucomputing.com/tryitout in both C90 and C++ mode.
-
-*) Compilers on Macintosh
-
-I'd love to support Macintosh but don't have one available to test it on.
-If it doesn't work with your compiler, maybe it can be gotten to work with the
-gcc compiler for Macintosh. Someone reported that it doesn't work well at all
-for Macintosh. All information on attempts to get it to work on Mac is welcome.
-
-*) Other Compilers
-
-If you encounter problems on other compilers, I'm happy to help out make LodePNG
-support the compiler if it supports the ISO C90 and C++ standard well enough. If
-the required modification to support the compiler requires using non standard or
-lesser C/C++ code or headers, I won't support it.
-
-
-13. examples
-------------
-
-This decoder and encoder example show the most basic usage of LodePNG (using the
-classes, not the simple functions, which would be trivial)
-
-More complex examples can be found in:
--lodepng_examples.c: 9 different examples in C, such as showing the image with SDL, ...
--lodepng_examples.cpp: the exact same examples in C++ using the C++ wrapper of LodePNG
-
-
-13.1. decoder C++ example
--------------------------
-
-////////////////////////////////////////////////////////////////////////////////
-#include "lodepng.h"
-#include <iostream>
-
-int main(int argc, char *argv[])
-{
- const char* filename = argc > 1 ? argv[1] : "test.png";
-
- //load and decode
- std::vector<unsigned char> buffer, image;
- LodePNG::loadFile(buffer, filename); //load the image file with given filename
- LodePNG::Decoder decoder;
- decoder.decode(image, buffer.size() ? &buffer[0] : 0, (unsigned)buffer.size()); //decode the png
-
- //if there's an error, display it
- if(decoder.hasError()) std::cout << "error: " << decoder.getError() << std::endl;
-
- //the pixels are now in the vector "image", use it as texture, draw it, ...
-}
-
-//alternative version using the "simple" function
-int main(int argc, char *argv[])
-{
- const char* filename = argc > 1 ? argv[1] : "test.png";
-
- //load and decode
- std::vector<unsigned char> image;
- unsigned w, h;
- unsigned error = LodePNG::decode(image, w, h, filename);
-
- //if there's an error, display it
- if(error != 0) std::cout << "error: " << error << std::endl;
-
- //the pixels are now in the vector "image", use it as texture, draw it, ...
-}
-////////////////////////////////////////////////////////////////////////////////
-
-
-13.2 encoder C++ example
-------------------------
-
-////////////////////////////////////////////////////////////////////////////////
-#include "lodepng.h"
-#include <iostream>
-
-int main(int argc, char *argv[])
-{
- //check if user gave a filename
- if(argc <= 1)
- {
- std::cout << "please provide a filename to save to\n";
- return 0;
- }
-
- //generate some image
- std::vector<unsigned char> image;
- image.resize(512 * 512 * 4);
- for(unsigned y = 0; y < 512; y++)
- for(unsigned x = 0; x < 512; x++)
- {
- image[4 * 512 * y + 4 * x + 0] = 255 * !(x & y);
- image[4 * 512 * y + 4 * x + 1] = x ^ y;
- image[4 * 512 * y + 4 * x + 2] = x | y;
- image[4 * 512 * y + 4 * x + 3] = 255;
- }
-
- //encode and save
- std::vector<unsigned char> buffer;
- LodePNG::Encoder encoder;
- encoder.encode(buffer, image, 512, 512);
- LodePNG::saveFile(buffer, argv[1]);
-
- //the same as the 4 lines of code above, but in 1 call:
- //LodePNG::encode(argv[1], image, 512, 512);
-}
-////////////////////////////////////////////////////////////////////////////////
-
-
-13.3 Decoder C example
-----------------------
-
-This example loads the PNG in 1 function call
-
-#include "lodepng.h"
-
-int main(int argc, char *argv[])
-{
- unsigned error;
- unsigned char* image;
- size_t w, h;
-
- if(argc <= 1) return 0;
-
- error = LodePNG_decode3(&image, &w, &h, filename);
-
- free(image);
-}
-
-
-14. LodeZlib
-------------
-
-Also available in the interface is LodeZlib. Both C and C++ versions of these
-functions are available. The interface is similar to that of the "simple" PNG
-encoding and decoding functions.
-
-LodeZlib can be used to zlib compress and decompress a buffer. It cannot be
-used to create gzip files however. Also, it only supports the part of zlib
-that is required for PNG, it does not support compression and decompression
-with dictionaries.
-
-
-15. changes
------------
-
-The version number of LodePNG is the date of the change given in the format
-yyyymmdd.
-
-Some changes aren't backwards compatible. Those are indicated with a (!)
-symbol.
-
-*) 02 sep 2008: fixed bug where it could create empty tree that linux apps could
- read by ignoring the problem but windows apps couldn't.
-*) 06 jun 2008: added more error checks for out of memory cases.
-*) 26 apr 2008: added a few more checks here and there to ensure more safety.
-*) 06 mar 2008: crash with encoding of strings fixed
-*) 02 feb 2008: support for international text chunks added (iTXt)
-*) 23 jan 2008: small cleanups, and #defines to divide code in sections
-*) 20 jan 2008: support for unknown chunks allowing using LodePNG for an editor.
-*) 18 jan 2008: support for tIME and pHYs chunks added to encoder and decoder.
-*) 17 jan 2008: ability to encode and decode compressed zTXt chunks added
- Also vareous fixes, such as in the deflate and the padding bits code.
-*) 13 jan 2008: Added ability to encode Adam7-interlaced images. Improved
- filtering code of encoder.
-*) 07 jan 2008: (!) changed LodePNG to use ISO C90 instead of C++. A
- C++ wrapper around this provides an interface almost identical to before.
- Having LodePNG be pure ISO C90 makes it more portable. The C and C++ code
- are together in these files but it works both for C and C++ compilers.
-*) 29 dec 2007: (!) changed most integer types to unsigned int + other tweaks
-*) 30 aug 2007: bug fixed which makes this Borland C++ compatible
-*) 09 aug 2007: some VS2005 warnings removed again
-*) 21 jul 2007: deflate code placed in new namespace separate from zlib code
-*) 08 jun 2007: fixed bug with 2- and 4-bit color, and small interlaced images
-*) 04 jun 2007: improved support for Visual Studio 2005: crash with accessing
- invalid std::vector element [0] fixed, and level 3 and 4 warnings removed
-*) 02 jun 2007: made the encoder add a tag with version by default
-*) 27 may 2007: zlib and png code separated (but still in the same file),
- simple encoder/decoder functions added for more simple usage cases
-*) 19 may 2007: minor fixes, some code cleaning, new error added (error 69),
- moved some examples from here to lodepng_examples.cpp
-*) 12 may 2007: palette decoding bug fixed
-*) 24 apr 2007: changed the license from BSD to the zlib license
-*) 11 mar 2007: very simple addition: ability to encode bKGD chunks.
-*) 04 mar 2007: (!) tEXt chunk related fixes, and support for encoding
- palettized PNG images. Plus little interface change with palette and texts.
-*) 03 mar 2007: Made it encode dynamic Huffman shorter with repeat codes.
- Fixed a bug where the end code of a block had length 0 in the Huffman tree.
-*) 26 feb 2007: Huffman compression with dynamic trees (BTYPE 2) now implemented
- and supported by the encoder, resulting in smaller PNGs at the output.
-*) 27 jan 2007: Made the Adler-32 test faster so that a timewaste is gone.
-*) 24 jan 2007: gave encoder an error interface. Added color conversion from any
- greyscale type to 8-bit greyscale with or without alpha.
-*) 21 jan 2007: (!) Totally changed the interface. It allows more color types
- to convert to and is more uniform. See the manual for how it works now.
-*) 07 jan 2007: Some cleanup & fixes, and a few changes over the last days:
- encode/decode custom tEXt chunks, separate classes for zlib & deflate, and
- at last made the decoder give errors for incorrect Adler32 or Crc.
-*) 01 jan 2007: Fixed bug with encoding PNGs with less than 8 bits per channel.
-*) 29 dec 2006: Added support for encoding images without alpha channel, and
- cleaned out code as well as making certain parts faster.
-*) 28 dec 2006: Added "Settings" to the encoder.
-*) 26 dec 2006: The encoder now does LZ77 encoding and produces much smaller files now.
- Removed some code duplication in the decoder. Fixed little bug in an example.
-*) 09 dec 2006: (!) Placed output parameters of public functions as first parameter.
- Fixed a bug of the decoder with 16-bit per color.
-*) 15 okt 2006: Changed documentation structure
-*) 09 okt 2006: Encoder class added. It encodes a valid PNG image from the
- given image buffer, however for now it's not compressed.
-*) 08 sep 2006: (!) Changed to interface with a Decoder class
-*) 30 jul 2006: (!) LodePNG_InfoPng , width and height are now retrieved in different
- way. Renamed decodePNG to decodePNGGeneric.
-*) 29 jul 2006: (!) Changed the interface: image info is now returned as a
- struct of type LodePNG::LodePNG_Info, instead of a vector, which was a bit clumsy.
-*) 28 jul 2006: Cleaned the code and added new error checks.
- Corrected terminology "deflate" into "inflate".
-*) 23 jun 2006: Added SDL example in the documentation in the header, this
- example allows easy debugging by displaying the PNG and its transparency.
-*) 22 jun 2006: (!) Changed way to obtain error value. Added
- loadFile function for convenience. Made decodePNG32 faster.
-*) 21 jun 2006: (!) Changed type of info vector to unsigned.
- Changed position of palette in info vector. Fixed an important bug that
- happened on PNGs with an uncompressed block.
-*) 16 jun 2006: Internally changed unsigned into unsigned where
- needed, and performed some optimizations.
-*) 07 jun 2006: (!) Renamed functions to decodePNG and placed them
- in LodePNG namespace. Changed the order of the parameters. Rewrote the
- documentation in the header. Renamed files to lodepng.cpp and lodepng.h
-*) 22 apr 2006: Optimized and improved some code
-*) 07 sep 2005: (!) Changed to std::vector interface
-*) 12 aug 2005: Initial release
-
-
-16. contact information
------------------------
-
-Feel free to contact me with suggestions, problems, comments, ... concerning
-LodePNG. If you encounter a PNG image that doesn't work properly with this
-decoder, feel free to send it and I'll use it to find and fix the problem.
-
-My email address is (puzzle the account and domain together with an @ symbol):
-Domain: gmail dot com.
-Account: lode dot vandevenne.
-
-
-Copyright (c) 2005-2008 Lode Vandevenne
-*/
#include <qfileinfo.h>
#include <qdict.h>
#include <qvector.h>
-#define USE_ORIGINAL_TABLES
+//#define USE_ORIGINAL_TABLES
#include "markdown.h"
#include "growbuf.h"
i=0;
nl++;
}
+ else if (data[end]=='\'' && nb==1 && (end==size-1 || (end<size-1 && !isIdChar(end+1))))
+ { // look for quoted strings like `some word', but skip strings like `it's cool`
+ QCString textFragment;
+ convertStringFragment(textFragment,data+nb,end-nb);
+ out.addStr("‘");
+ out.addStr(textFragment);
+ out.addStr("’");
+ return end+1;
+ }
else
{
i=0;
f_end--;
}
- if (nb==1) // check for closing ' followed by space within f_begin..f_end
- {
- i=f_begin;
- while (i<f_end-1)
- {
- if (data[i]=='\'' && !isIdChar(i+1)) // reject `some word' and not `it's cool`
- {
- return 0;
- }
- i++;
- }
- }
//printf("found code span '%s'\n",QCString(data+f_begin).left(f_end-f_begin).data());
/* real code span */
}
+static int hasLineBreak(const char *data,int size)
+{
+ int i=0;
+ while (i<size && data[i]!='\n') i++;
+ if (i>=size) return 0; // empty line
+ if (i<2) return 0; // not long enough
+ return (data[i-1]==' ' && data[i-2]==' ');
+}
+
+
void writeOneLineHeaderOrRuler(GrowBuf &out,const char *data,int size)
{
int level;
else // nothing interesting -> just output the line
{
out.addStr(data,size);
+ if (hasLineBreak(data,size))
+ {
+ out.addStr("<br>");
+ }
}
}
//printf("MemberDef::MemberDef(%s)\n",na);
m_impl = new MemberDefImpl;
m_impl->init(this,t,a,e,p,v,s,r,mt,tal,al);
+ number_of_flowkw = 1;
m_isLinkableCached = 0;
m_isConstructorCached = 0;
m_isDestructorCached = 0;
scope, // scope
getBodyDef(), // fileScope
this, // self
- ts, // text
- TRUE // autoBreak
+ ts // text
);
}
ol.endDoxyAnchor(cfname,memAnchor);
if (!Config_getBool(EXTRACT_ALL) &&
Config_getBool(WARN_IF_UNDOCUMENTED) &&
Config_getBool(WARN_NO_PARAMDOC) &&
+ !isReference() &&
!Doxygen::suppressDocWarnings)
{
if (!hasDocumentedParams())
invalidateCachedTypesInArgumentList(m_impl->declArgList);
}
+void MemberDef::addFlowKeyWord()
+{
+ number_of_flowkw++;
+}
+
+int MemberDef::numberOfFlowKeyWords()
+{
+ return number_of_flowkw;
+}
+
//----------------
QCString MemberDef::displayName(bool) const
bool isStrongEnumValue() const;
bool livesInsideEnum() const;
+ int numberOfFlowKeyWords();
// derived getters
bool isFriendToHide() const;
bool isNotFriend() const;
// ---- setters -----
//-----------------------------------------------------------------------------------
+ void addFlowKeyWord();
+
// set functions
void setMemberType(MemberType t);
void setDefinition(const char *d);
void _addToSearchIndex();
static int s_indentLevel;
+
+ int number_of_flowkw;
+
// disable copying of member defs
MemberDef(const MemberDef &);
MemberDef &operator=(const MemberDef &);
{
ol.endDoxyAnchor(md->getOutputFileBase(),md->anchor());
}
+ ol.endMemberItem();
if (!md->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
{
DocRoot *rootNode = validatingParseDoc(
}
delete rootNode;
}
- ol.endMemberItem();
ol.endMemberDeclaration(md->anchor(),inheritId);
}
md->warnIfUndocumented();
return fileName;
}
-Definition *NamespaceDef::findInnerCompound(const char *n)
+Definition *NamespaceDef::findInnerCompound(const char *n) const
{
if (n==0) return 0;
Definition *d = m_innerCompounds->find(n);
void findSectionsInDocumentation();
void sortMemberLists();
- virtual Definition *findInnerCompound(const char *name);
+ virtual Definition *findInnerCompound(const char *name) const;
void addInnerCompound(Definition *d);
void addListReferences();
void setFileName(const QCString &fn);
ol.endTitleHead(manPageName, manPageName);
if (si)
{
- ol.generateDoc(docFile(),docLine(),this,0,si->title,TRUE,FALSE,0,TRUE,FALSE);
- ol.endSection(si->label,si->type);
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Man);
+ ol.writeString(" - ");
+ ol.popGeneratorState();
+
+ if (si->title != manPageName)
+ {
+ ol.generateDoc(docFile(),docLine(),this,0,si->title,TRUE,FALSE,0,TRUE,FALSE);
+ ol.endSection(si->label,si->type);
+ }
}
ol.popGeneratorState();
//2.}
ol.startTextBlock();
QCString docStr = documentation()+inbodyDocumentation();
- if (!docStr.isEmpty())
+ if (hasBriefDescription() && !Doxygen::sectionDict->find(name()))
{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Man);
* is associated (non null in case of an inline fragment
* for a member).
* @param[in] showLineNumbers if set to TRUE and also fileDef is not 0,
- * line numbers will be added to the source fragement
+ * line numbers will be added to the source fragment
* @param[in] searchCtx context under which search data has to be stored.
* @param[in] collectXRefs collect cross-reference relations.
*/
{
static QCString plantumlJarPath = Config_getString(PLANTUML_JAR_PATH);
static QCString plantumlConfigFile = Config_getString(PLANTUML_CFG_FILE);
+ static QCString dotPath = Config_getString(DOT_PATH);
QCString pumlExe = "java";
QCString pumlArgs = "";
pumlArgs += plantumlConfigFile;
pumlArgs += "\" ";
}
+ if (Config_getBool(HAVE_DOT) && !dotPath.isEmpty())
+ {
+ pumlArgs += "-graphvizdot \"";
+ pumlArgs += dotPath;
+ pumlArgs += "dot\" ";
+ }
pumlArgs+="-o \"";
pumlArgs+=outDir;
pumlArgs+="\" ";
}
}
#endif
+ return 1; // we should never get here
}
return -1;
}
-/*! preforms recursive macro expansion on the string \a expr
+/*! performs recursive macro expansion on the string \a expr
* starting at position \a pos.
* May read additional characters from the input while re-scanning!
* If \a expandAll is \c TRUE then all macros in the expression are
g_defArgsStr+=*yytext;
BEGIN(ReadString);
}
+<FindDefineArgs>' {
+ if (getLanguageFromFileName(g_yyFileName)!=SrcLangExt_Fortran) REJECT;
+ g_defArgsStr+=*yytext;
+ BEGIN(ReadString);
+ }
<FindDefineArgs>\n {
g_defArgsStr+=' ';
g_yyLineNr++;
g_defArgsStr+=*yytext;
BEGIN(FindDefineArgs);
}
+<ReadString>"'" {
+ if (getLanguageFromFileName(g_yyFileName)!=SrcLangExt_Fortran) REJECT;
+ g_defArgsStr+=*yytext;
+ BEGIN(FindDefineArgs);
+ }
+
<ReadString>"//"|"/*" {
g_defArgsStr+=yytext;
}
<SkipCComment,SkipVerbatim>. {
outputChar(*yytext);
}
-<CopyCComment>[^*a-z_A-Z\x80-\xFF\n]+ {
+<CopyCComment>[^*a-z_A-Z\x80-\xFF\n]*[^*a-z_A-Z\x80-\xFF\\\n] {
g_defLitText+=yytext;
g_defText+=escapeAt(yytext);
- }
+ }
+<CopyCComment>\\[\r]?\n {
+ g_defLitText+=yytext;
+ outputChar('\n');
+ g_defText+=" ";
+ g_yyLineNr++;
+ g_yyMLines++;
+ }
<CopyCComment>"*/" {
g_defLitText+=yytext;
g_defText+=yytext;
g_defLitText+=yytext;
g_defText+=yytext;
}
-<DefineText>\\[\r]?\n {
+<DefineText>\\[\r]?\n {
g_defLitText+=yytext;
outputChar('\n');
g_defText += ' ';
}
}
<*>"//"[/]? {
- if (YY_START==SkipVerbatim || YY_START==SkipCond)
+ if (YY_START==SkipVerbatim || YY_START==SkipCond || getLanguageFromFileName(g_yyFileName)==SrcLangExt_Fortran)
{
REJECT;
}
}
else // no INCLUDETEXT on this line
{
- // elaborate hoopla to skip the final "}" if we didn't include the
+ // elaborate hoopla to skip the final "}" if we didn't include the
// headers
if (!f.atEnd() || bIncludeHeader)
{
bool isVolatile=decl.find("volatile")!=-1;
current->section = Entry::CLASS_SEC ;
current->spec = Entry::Struct |
- (current->spec & Entry::Published); // preserve UNO IDL
+ (current->spec & Entry::Published) |
+ (current->spec & Entry::Inline); // preserve UNO IDL & Inline attributes
// bug 582676: can be a struct nested in an interface so keep insideObjC state
//current->objc = insideObjC = FALSE;
addType( current ) ;
}
}
}
+<SkipInits>">"{BN}*"{" { // C++11 style initializer (see bug 790788)
+ lineCount();
+ curlyCount=1;
+ BEGIN(SkipC11Inits);
+ }
<SkipInits>{ID}{BN}*"{" { // C++11 style initializer (see bug 688647)
lineCount();
curlyCount=1;
}
}
<CSAccessorDecl>"{" { curlyCount++; }
+<CSAccessorDecl>"}"{B}*"=" {
+ // fall back to next rule if it's not the right bracket
+ if (curlyCount != 0) REJECT;
+ current->initializer = "=";
+ current->endBodyLine=yyLineNr;
+ lastInitializerContext = FindMembers;
+ BEGIN(ReadInitializer);
+ }
<CSAccessorDecl>"}" {
if (curlyCount)
{
{
mtype = Method;
virt = Normal;
+ // not really important, but while we are at it
+ current->endBodyLine=yyLineNr;
unput(';');
BEGIN(FindMembers);
}
}
<SkipComment>[^\*\n]+
-"[[" { // C++11 attribute
+<*>"[[" { // C++11 attribute
lastC11AttributeContext = YY_START;
BEGIN( SkipC11Attribute );
}
/******************************************************************************
*
- *
+ *
*
* 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
+ * 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.
*
// file format: (all multi-byte values are stored in big endian format)
// 4 byte header
// 256*256*4 byte index (4 bytes)
-// for each index entry: a zero terminated list of words
+// for each index entry: a zero terminated list of words
// for each word: a \0 terminated string + 4 byte offset to the stats info
// padding bytes to align at 4 byte boundary
-// for each word: the number of urls (4 bytes)
+// for each word: the number of urls (4 bytes)
// + for each url containing the word 8 bytes statistics
// (4 bytes index to url string + 4 bytes frequency counter)
// for each url: a \0 terminated string
//--------------------------------------------------------------------
-SearchIndex::SearchIndex() : SearchIndexIntf(Internal),
+SearchIndex::SearchIndex() : SearchIndexIntf(Internal),
m_words(328829), m_index(numIndexEntries), m_url2IdMap(10007), m_urls(10007), m_urlIndex(-1)
{
int i;
QCString url=isSourceFile ? ((FileDef*)ctx)->getSourceFileBase() : ctx->getOutputFileBase();
url+=Config_getString(HTML_FILE_EXTENSION);
QCString baseUrl = url;
- if (anchor) url+=QCString("#")+anchor;
+ if (anchor) url+=QCString("#")+anchor;
if (!isSourceFile) baseUrl=url;
QCString name=ctx->qualifiedName();
if (ctx->definitionType()==Definition::TypeMember)
{
MemberDef *md = (MemberDef *)ctx;
- name.prepend((md->getLanguage()==SrcLangExt_Fortran ?
+ name.prepend((md->getLanguage()==SrcLangExt_Fortran ?
theTranslator->trSubprogram(TRUE,TRUE) :
theTranslator->trMember(TRUE,TRUE))+" ");
}
//register ushort h=0;
//const char *k = word;
//ushort mask=0xfc00;
- //while ( *k )
+ //while ( *k )
//{
// h = (h&mask)^(h<<6)^(*k++);
//}
IndexWord *iw;
for (iwi.toFirst();(iw=iwi.current());++iwi)
{
- int ws = iw->word().length()+1;
+ int ws = iw->word().length()+1;
size+=ws+4; // word + url info list offset
}
size+=1; // zero list terminator
IndexWord *iw;
for (iwi.toFirst();(iw=iwi.current());++iwi)
{
- offset+= iw->word().length()+1;
- offset+=4; // word + offset to url info array
+ offset+= iw->word().length()+1;
+ offset+=4; // word + offset to url info array
}
offset+=1; // zero list terminator
}
//int statsOffset = size;
//IndexWord *iw;
int *wordStatOffsets = new int[m_words.count()];
-
+
int count=0;
// third pass: compute offset to stats info for each word
QCString name;
QCString args;
QCString extId;
- QCString url;
+ QCString url;
GrowBuf importantText;
GrowBuf normalText;
};
{
switch(ctx->definitionType())
{
- case Definition::TypeClass:
+ case Definition::TypeClass:
return ((ClassDef*)ctx)->compoundTypeString();
case Definition::TypeFile:
return "file";
}
}
}
- else if (isLinkable &&
- (((nd=md->getNamespaceDef()) && nd->isLinkable()) ||
+ else if (isLinkable &&
+ (((nd=md->getNamespaceDef()) && nd->isLinkable()) ||
((fd=md->getFileDef()) && fd->isLinkable())
)
)
{
QCString n = md->name();
- if (!n.isEmpty())
+ if (!n.isEmpty())
{
uint letter = getUtf8CodeToLower(n,0);
g_searchIndexInfo[SEARCH_INDEX_ALL].symbolList.append(letter,md);
- if (md->isFunction())
+ if (md->isFunction())
{
g_searchIndexInfo[SEARCH_INDEX_FUNCTIONS].symbolList.append(letter,md);
}
- else if (md->isVariable())
+ else if (md->isVariable())
{
g_searchIndexInfo[SEARCH_INDEX_VARIABLES].symbolList.append(letter,md);
}
t << "<div class=\"SRStatus\" id=\"Loading\">" << theTranslator->trLoading() << "</div>" << endl;
t << "<div id=\"SRResults\"></div>" << endl; // here the results will be inserted
t << "<script type=\"text/javascript\"><!--" << endl;
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
t << "createResults();" << endl; // this function will insert the results
+ t << "/* @license-end */\n";
t << "--></script>" << endl;
- t << "<div class=\"SRStatus\" id=\"Searching\">"
+ t << "<div class=\"SRStatus\" id=\"Searching\">"
<< theTranslator->trSearching() << "</div>" << endl;
t << "<div class=\"SRStatus\" id=\"NoMatches\">"
<< theTranslator->trNoMatches() << "</div>" << endl;
t << "<script type=\"text/javascript\"><!--" << endl;
+ t << "/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */\n";
t << "document.getElementById(\"Loading\").style.display=\"none\";" << endl;
t << "document.getElementById(\"NoMatches\").style.display=\"none\";" << endl;
t << "var searchResults = new SearchResults(\"searchResults\");" << endl;
t << "searchResults.Search();" << endl;
+ t << "/* @license-end */\n";
t << "--></script>" << endl;
t << "</div>" << endl; // SRIndex
t << "</body>" << endl;
bool found=FALSE;
overloadedFunction = ((prevScope!=0 && scope==prevScope) ||
(scope && scope==nextScope)
- ) && md &&
+ ) && md &&
(md->isFunction() || md->isSlot());
QCString prefix;
if (md) prefix=convertToXML(md->localName());
if (overloadedFunction) // overloaded member function
{
- prefix+=convertToXML(md->argsString());
+ prefix+=convertToXML(md->argsString());
// show argument list to disambiguate overloaded functions
}
else if (md) // unique member function
}
}
}
- else if (md && (md->getClassDef() || md->getNamespaceDef()))
+ else if (md && (md->getClassDef() || md->getNamespaceDef()))
// member in class or namespace scope
{
SrcLangExt lang = md->getLanguage();
- name = convertToXML(d->getOuterScope()->qualifiedName())
+ name = convertToXML(d->getOuterScope()->qualifiedName())
+ getLanguageSpecificSeparator(lang) + prefix;
found = TRUE;
}
{
delete Doxygen::searchIndex;
}
-
-
"\tattributes TEXT,\n"
"\ttype TEXT,\n"
"\tdeclname TEXT,\n"
- "\tdefname TEXT,\n"
+ "\tdefname TEXT,\n"
"\tarray TEXT,\n"
"\tdefval TEXT,\n"
"\tbriefdescription TEXT\n"
");"
+ "CREATE UNIQUE INDEX idx_params ON params\n"
+ "\t(type, defname);"
},
{ "memberdef_params",
"CREATE TABLE IF NOT EXISTS memberdef_params (\n"
struct SqlStmt {
const char *query;
sqlite3_stmt *stmt;
+ sqlite3 *db;
};
//////////////////////////////////////////////////////
SqlStmt incl_insert = { "INSERT INTO includes "
":readable,"
":writable,"
":gettable,"
- ":privategettable,"
+ ":protectedsettable,"
":protectedgettable,"
":settable,"
":privatesettable,"
};
-static void bindTextParameter(SqlStmt &s,const char *name,const char *value, bool _static=TRUE)
+static bool bindTextParameter(SqlStmt &s,const char *name,const char *value, bool _static=TRUE)
{
int idx = sqlite3_bind_parameter_index(s.stmt, name);
- sqlite3_bind_text(s.stmt, idx, value, -1, _static==TRUE?SQLITE_STATIC:SQLITE_TRANSIENT);
+ if (idx==0) {
+ msg("sqlite3_bind_parameter_index(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));
+ return false;
+ }
+ int rv = sqlite3_bind_text(s.stmt, idx, value, -1, _static==TRUE?SQLITE_STATIC:SQLITE_TRANSIENT);
+ if (rv!=SQLITE_OK) {
+ msg("sqlite3_bind_text(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));
+ return false;
+ }
+ return true;
}
-static void bindIntParameter(SqlStmt &s,const char *name,int value)
+static bool bindIntParameter(SqlStmt &s,const char *name,int value)
{
int idx = sqlite3_bind_parameter_index(s.stmt, name);
- sqlite3_bind_int(s.stmt, idx, value);
+ if (idx==0) {
+ msg("sqlite3_bind_parameter_index(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));
+ return false;
+ }
+ int rv = sqlite3_bind_int(s.stmt, idx, value);
+ if (rv!=SQLITE_OK) {
+ msg("sqlite3_bind_int(%s)[%s] failed: %s\n", name, s.query, sqlite3_errmsg(s.db));
+ return false;
+ }
+ return true;
}
-static int step(sqlite3 *db, SqlStmt &s,bool getRowId=FALSE, bool select=FALSE)
+static int step(SqlStmt &s,bool getRowId=FALSE, bool select=FALSE)
{
int rowid=-1;
int rc = sqlite3_step(s.stmt);
if (rc!=SQLITE_DONE && rc!=SQLITE_ROW)
{
- msg("sqlite3_step failed: %s\n", sqlite3_errmsg(db));
+ msg("sqlite3_step: %s\n", sqlite3_errmsg(s.db));
+ sqlite3_reset(s.stmt);
sqlite3_clear_bindings(s.stmt);
return -1;
}
- if (getRowId && select) rowid = sqlite3_column_int(s.stmt, 0); // works on selects, doesnt on inserts
- if (getRowId && !select) rowid = sqlite3_last_insert_rowid(db); //works on inserts, doesnt on selects
+ if (getRowId && select) rowid = sqlite3_column_int(s.stmt, 0); // works on selects, doesn't on inserts
+ if (getRowId && !select) rowid = sqlite3_last_insert_rowid(s.db); //works on inserts, doesn't on selects
sqlite3_reset(s.stmt);
sqlite3_clear_bindings(s.stmt); // XXX When should this really be called
return rowid;
}
-static int insertFile(sqlite3 *db, const char* name)
+static int insertFile(const char* name)
{
int rowid=-1;
if (name==0) return rowid;
bindTextParameter(files_select,":name",name);
- rowid=step(db,files_select,TRUE,TRUE);
+ rowid=step(files_select,TRUE,TRUE);
if (rowid==0)
{
bindTextParameter(files_insert,":name",name);
- rowid=step(db,files_insert,TRUE);
+ rowid=step(files_insert,TRUE);
}
return rowid;
}
-static int insertRefid(sqlite3 *db, const char *refid)
+static int insertRefid(const char *refid)
{
int rowid=-1;
if (refid==0) return rowid;
bindTextParameter(refids_select,":refid",refid);
- rowid=step(db,refids_select,TRUE,TRUE);
+ rowid=step(refids_select,TRUE,TRUE);
if (rowid==0)
{
bindTextParameter(refids_insert,":refid",refid);
- rowid=step(db,refids_insert,TRUE);
+ rowid=step(refids_insert,TRUE);
}
return rowid;
}
-static void insertMemberReference(sqlite3 *db, int refid_src, int refid_dst,
+static bool insertMemberReference(int refid_src, int refid_dst,
int id_file, int line, int column)
{
if (id_file==-1||refid_src==-1||refid_dst==-1)
- return;
+ return false;
- bindIntParameter(xrefs_insert,":refid_src",refid_src);
- bindIntParameter(xrefs_insert,":refid_dst",refid_dst);
- bindIntParameter(xrefs_insert,":id_file",id_file);
- bindIntParameter(xrefs_insert,":line",line);
- bindIntParameter(xrefs_insert,":column",column);
- step(db,xrefs_insert);
+ if (
+ !bindIntParameter(xrefs_insert,":refid_src",refid_src) ||
+ !bindIntParameter(xrefs_insert,":refid_dst",refid_dst) ||
+ !bindIntParameter(xrefs_insert,":id_file",id_file) ||
+ !bindIntParameter(xrefs_insert,":line",line) ||
+ !bindIntParameter(xrefs_insert,":column",column)
+ )
+ {
+ return false;
+ }
+
+ step(xrefs_insert);
+ return true;
}
-static void insertMemberReference(sqlite3 *db, MemberDef *src, MemberDef *dst)
+static void insertMemberReference(const MemberDef *src, const MemberDef *dst)
{
QCString qrefid_dst = dst->getOutputFileBase() + "_1" + dst->anchor();
QCString qrefid_src = src->getOutputFileBase() + "_1" + src->anchor();
if (dst->getStartBodyLine()!=-1 && dst->getBodyDef())
{
- int refid_src = insertRefid(db,qrefid_src.data());
- int refid_dst = insertRefid(db,qrefid_dst.data());
- int id_file = insertFile(db,"no-file"); // TODO: replace no-file with proper file
- insertMemberReference(db,refid_src,refid_dst,id_file,dst->getStartBodyLine(),-1);
+ int refid_src = insertRefid(qrefid_src.data());
+ int refid_dst = insertRefid(qrefid_dst.data());
+ int id_file = insertFile("no-file"); // TODO: replace no-file with proper file
+ insertMemberReference(refid_src,refid_dst,id_file,dst->getStartBodyLine(),-1);
}
}
-static void insertMemberFunctionParams(sqlite3 *db,int id_memberdef,MemberDef *md,Definition *def)
+static void insertMemberFunctionParams(int id_memberdef, const MemberDef *md, const Definition *def)
{
ArgumentList *declAl = md->declArgumentList();
ArgumentList *defAl = md->argumentList();
while ((s=li.current()))
{
QCString qrefid_src = md->getOutputFileBase() + "_1" + md->anchor();
- int refid_src = insertRefid(db,qrefid_src.data());
- int refid_dst = insertRefid(db,s->data());
- int id_file = insertFile(db,stripFromPath(def->getDefFileName()));
- insertMemberReference(db,refid_src,refid_dst,id_file,md->getDefLine(),-1);
+ int refid_src = insertRefid(qrefid_src.data());
+ int refid_dst = insertRefid(s->data());
+ int id_file = insertFile(stripFromPath(def->getDefFileName()));
+ insertMemberReference(refid_src,refid_dst,id_file,md->getDefLine(),-1);
++li;
}
bindTextParameter(params_select,":type",a->type.data());
}
if (defArg) ++defAli;
- int id_param=step(db,params_select,TRUE,TRUE);
+ int id_param=step(params_select,TRUE,TRUE);
if (id_param==0) {
- id_param=step(db,params_insert,TRUE);
+ id_param=step(params_insert,TRUE);
+ }
+ if (id_param==-1) {
+ msg("error INSERT params failed\n");
+ continue;
}
bindIntParameter(memberdef_params_insert,":id_memberdef",id_memberdef);
bindIntParameter(memberdef_params_insert,":id_param",id_param);
- step(db,memberdef_params_insert);
+ step(memberdef_params_insert);
}
}
}
-static void insertMemberDefineParams(sqlite3 *db,int id_memberdef,MemberDef *md,Definition *def)
+static void insertMemberDefineParams(int id_memberdef,const MemberDef *md, const Definition *def)
{
if (md->argumentList()->count()==0) // special case for "foo()" to
// disguish it from "foo".
for (ali.toFirst();(a=ali.current());++ali)
{
bindTextParameter(params_insert,":defname",a->type.data());
- int id_param=step(db,params_insert,TRUE);
+ int id_param=step(params_insert,TRUE);
+ if (id_param==-1) {
+ msg("error INSERT param(%s) failed\n", a->type.data());
+ continue;
+ }
bindIntParameter(memberdef_params_insert,":id_memberdef",id_memberdef);
bindIntParameter(memberdef_params_insert,":id_param",id_param);
- step(db,memberdef_params_insert);
+ step(memberdef_params_insert);
}
}
}
if (rc!=SQLITE_OK)
{
msg("prepare failed for %s\n%s\n", s.query, sqlite3_errmsg(db));
+ s.db = NULL;
return -1;
}
+ s.db = db;
return rc;
}
for (unsigned int k = 0; k < sizeof(schema_queries) / sizeof(schema_queries[0]); k++)
{
const char *q = schema_queries[k][1];
- // create table
- rc = sqlite3_prepare_v2(db, q, -1, &stmt, 0);
+ char *errmsg;
+ rc = sqlite3_exec(db, q, NULL, NULL, &errmsg);
if (rc != SQLITE_OK)
{
- msg("failed to prepare query: %s\n\t%s\n", q, sqlite3_errmsg(db));
- return -1;
- }
- rc = sqlite3_step(stmt);
- if (rc != SQLITE_DONE)
- {
- msg("failed to execute query: %s\n\t%s\n", q, sqlite3_errmsg(db));
+ msg("failed to execute query: %s\n\t%s\n", q, errmsg);
return -1;
}
- sqlite3_finalize(stmt);
}
return 0;
}
////////////////////////////////////////////
-static void writeInnerClasses(sqlite3*db,const ClassSDict *cl)
+static void writeInnerClasses(const ClassSDict *cl)
{
if (!cl) return;
{
if (!cd->isHidden() && cd->name().find('@')==-1) // skip anonymous scopes
{
- int refid = insertRefid(db, cd->getOutputFileBase());
+ int refid = insertRefid(cd->getOutputFileBase());
bindIntParameter(innerclass_insert,":refid", refid);
bindIntParameter(innerclass_insert,":prot",cd->protection());
bindTextParameter(innerclass_insert,":name",cd->name());
- step(db,innerclass_insert);
+ step(innerclass_insert);
}
}
}
-static void writeInnerNamespaces(sqlite3 *db,const NamespaceSDict *nl)
+static void writeInnerNamespaces(const NamespaceSDict *nl)
{
if (nl)
{
{
if (!nd->isHidden() && nd->name().find('@')==-1) // skip anonymouse scopes
{
- int refid = insertRefid(db, nd->getOutputFileBase());
+ int refid = insertRefid(nd->getOutputFileBase());
bindIntParameter(innernamespace_insert,":refid",refid);
bindTextParameter(innernamespace_insert,":name",nd->name(),FALSE);
- step(db,innernamespace_insert);
+ step(innernamespace_insert);
}
}
}
}
-static void writeTemplateArgumentList(sqlite3* db,
- ArgumentList * al,
- Definition * scope,
- FileDef * fileScope)
+static void writeTemplateArgumentList(const ArgumentList * al,
+ const Definition * scope,
+ const FileDef * fileScope)
{
if (al)
{
bindTextParameter(params_select,":defval",a->defval);
bindTextParameter(params_insert,":defval",a->defval);
}
- if (!step(db,params_select,TRUE,TRUE))
- step(db,params_insert);
+ if (!step(params_select,TRUE,TRUE))
+ step(params_insert);
}
}
}
-static void writeMemberTemplateLists(sqlite3* db,MemberDef *md)
+static void writeMemberTemplateLists(const MemberDef *md)
{
ArgumentList *templMd = md->templateArguments();
if (templMd) // function template prefix
{
- writeTemplateArgumentList(db,templMd,md->getClassDef(),md->getFileDef());
+ writeTemplateArgumentList(templMd,md->getClassDef(),md->getFileDef());
}
}
-static void writeTemplateList(sqlite3*db,ClassDef *cd)
+static void writeTemplateList(const ClassDef *cd)
{
- writeTemplateArgumentList(db,cd->templateArguments(),cd,0);
+ writeTemplateArgumentList(cd->templateArguments(),cd,0);
}
////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
-static void generateSqlite3ForMember(sqlite3*db,MemberDef *md,Definition *def)
+static void generateSqlite3ForMember(const MemberDef *md, const Definition *def)
{
// + declaration/definition arg lists
// + reimplements
// memberdef
QCString qrefid = md->getOutputFileBase() + "_1" + md->anchor();
- int refid = insertRefid(db, qrefid.data());
+ int refid = insertRefid(qrefid.data());
bindIntParameter(memberdef_insert,":refid", refid);
bindIntParameter(memberdef_insert,":kind",md->memberType());
{
if (md->memberType()!=MemberType_Typedef)
{
- writeMemberTemplateLists(db,md);
+ writeMemberTemplateLists(md);
}
QCString typeStr = md->typeString();
stripQualifiers(typeStr);
StringList l;
- linkifyText(TextGeneratorSqlite3Impl(l),def,md->getBodyDef(),md,typeStr);
+ linkifyText(TextGeneratorSqlite3Impl(l), def, md->getBodyDef(),md,typeStr);
if (typeStr.data())
{
bindTextParameter(memberdef_insert,":type",typeStr.data(),FALSE);
md->getBodyDef()->getDefFileName().data(),
md->getStartBodyLine()));
QCString qrefid_src = md->getOutputFileBase() + "_1" + md->anchor();
- int refid_src = insertRefid(db,qrefid_src.data());
- int refid_dst = insertRefid(db,s->data());
- int id_file = insertFile(db,stripFromPath(md->getBodyDef()->getDefFileName()));
- insertMemberReference(db,refid_src,refid_dst,id_file,md->getStartBodyLine(),-1);
+ int refid_src = insertRefid(qrefid_src.data());
+ int refid_dst = insertRefid(s->data());
+ int id_file = insertFile(stripFromPath(md->getBodyDef()->getDefFileName()));
+ insertMemberReference(refid_src,refid_dst,id_file,md->getStartBodyLine(),-1);
}
++li;
}
// File location
if (md->getDefLine() != -1)
{
- int id_file = insertFile(db,stripFromPath(md->getDefFileName()));
+ int id_file = insertFile(stripFromPath(md->getDefFileName()));
if (id_file!=-1)
{
bindIntParameter(memberdef_insert,":id_file",id_file);
if (md->getStartBodyLine()!=-1)
{
- int id_bodyfile = insertFile(db,stripFromPath(md->getBodyDef()->absFilePath()));
+ int id_bodyfile = insertFile(stripFromPath(md->getBodyDef()->absFilePath()));
if (id_bodyfile == -1)
{
sqlite3_clear_bindings(memberdef_insert.stmt);
}
}
- int id_memberdef=step(db,memberdef_insert,TRUE);
+ int id_memberdef=step(memberdef_insert,TRUE);
if (isFunc)
{
- insertMemberFunctionParams(db,id_memberdef,md,def);
+ insertMemberFunctionParams(id_memberdef,md,def);
}
else if (md->memberType()==MemberType_Define &&
md->argsString())
{
- insertMemberDefineParams(db,id_memberdef,md,def);
+ insertMemberDefineParams(id_memberdef,md,def);
}
// + source references
MemberDef *rmd;
for (mdi.toFirst();(rmd=mdi.current());++mdi)
{
- insertMemberReference(db,md,rmd);//,mdi.currentKey());
+ insertMemberReference(md,rmd);//,mdi.currentKey());
}
}
// + source referenced by
MemberDef *rmd;
for (mdi.toFirst();(rmd=mdi.current());++mdi)
{
- insertMemberReference(db,rmd,md);//,mdi.currentKey());
+ insertMemberReference(rmd,md);//,mdi.currentKey());
}
}
}
-static void generateSqlite3Section(sqlite3*db,
- Definition *d,
- MemberList *ml,const char * /*kind*/,const char * /*header*/=0,
+static void generateSqlite3Section( const Definition *d,
+ const MemberList *ml,
+ const char * /*kind*/,
+ const char * /*header*/=0,
const char * /*documentation*/=0)
{
if (ml==0) return;
// to prevent this duplication in the XML output, we filter those here.
//if (d->definitionType()!=Definition::TypeFile || md->getNamespaceDef()==0)
{
- generateSqlite3ForMember(db,md,d);
+ generateSqlite3ForMember(md,d);
}
}
}
-static void generateSqlite3ForClass(sqlite3 *db, ClassDef *cd)
+static void generateSqlite3ForClass(const ClassDef *cd)
{
// + list of direct super classes
// + list of direct sub classes
bindTextParameter(compounddef_insert,":name",cd->name());
bindTextParameter(compounddef_insert,":kind",cd->compoundTypeString(),FALSE);
bindIntParameter(compounddef_insert,":prot",cd->protection());
- int refid = insertRefid(db, cd->getOutputFileBase());
+ int refid = insertRefid(cd->getOutputFileBase());
bindIntParameter(compounddef_insert,":refid", refid);
- int id_file = insertFile(db,stripFromPath(cd->getDefFileName()));
+ int id_file = insertFile(stripFromPath(cd->getDefFileName()));
bindIntParameter(compounddef_insert,":id_file",id_file);
bindIntParameter(compounddef_insert,":line",cd->getDefLine());
bindIntParameter(compounddef_insert,":column",cd->getDefColumn());
- step(db,compounddef_insert);
+ step(compounddef_insert);
// + list of direct super classes
if (cd->baseClasses())
BaseClassDef *bcd;
for (bcli.toFirst();(bcd=bcli.current());++bcli)
{
- int refid = insertRefid(db, bcd->classDef->getOutputFileBase());
+ int refid = insertRefid(bcd->classDef->getOutputFileBase());
bindIntParameter(basecompoundref_insert,":refid", refid);
bindIntParameter(basecompoundref_insert,":prot",bcd->prot);
bindIntParameter(basecompoundref_insert,":virt",bcd->virt);
bindTextParameter(basecompoundref_insert,":base",bcd->classDef->displayName(),FALSE);
}
bindTextParameter(basecompoundref_insert,":derived",cd->displayName(),FALSE);
- step(db,basecompoundref_insert);
+ step(basecompoundref_insert);
}
}
{
bindTextParameter(derivedcompoundref_insert,":derived",bcd->classDef->displayName(),FALSE);
}
- int refid = insertRefid(db, bcd->classDef->getOutputFileBase());
+ int refid = insertRefid(bcd->classDef->getOutputFileBase());
bindIntParameter(derivedcompoundref_insert,":refid", refid);
bindIntParameter(derivedcompoundref_insert,":prot",bcd->prot);
bindIntParameter(derivedcompoundref_insert,":virt",bcd->virt);
- step(db,derivedcompoundref_insert);
+ step(derivedcompoundref_insert);
}
}
if (nm.isEmpty() && ii->fileDef) nm = ii->fileDef->docName();
if (!nm.isEmpty())
{
- int id_dst=insertFile(db,nm);
+ int id_dst=insertFile(nm);
if (id_dst!=-1) {
bindIntParameter(incl_select,":local",ii->local);
bindIntParameter(incl_select,":id_src",id_file);
bindIntParameter(incl_select,":id_dst",id_dst);
- int count=step(db,incl_select,TRUE,TRUE);
+ int count=step(incl_select,TRUE,TRUE);
if (count==0)
{
bindIntParameter(incl_insert,":local",ii->local);
bindIntParameter(incl_insert,":id_src",id_file);
bindIntParameter(incl_insert,":id_dst",id_dst);
- step(db,incl_insert);
+ step(incl_insert);
}
}
}
}
// + list of inner classes
- writeInnerClasses(db,cd->getClassSDict());
+ writeInnerClasses(cd->getClassSDict());
// - template argument list(s)
- writeTemplateList(db,cd);
+ writeTemplateList(cd);
// + member groups
if (cd->getMemberGroupSDict())
MemberGroup *mg;
for (;(mg=mgli.current());++mgli)
{
- generateSqlite3Section(db,cd,mg->members(),"user-defined",mg->header(),
+ generateSqlite3Section(cd,mg->members(),"user-defined",mg->header(),
mg->documentation());
}
}
{
if ((ml->listType()&MemberListType_detailedLists)==0)
{
- generateSqlite3Section(db,cd,ml,"user-defined");//g_xmlSectionMapper.find(ml->listType()));
+ generateSqlite3Section(cd,ml,"user-defined");//g_xmlSectionMapper.find(ml->listType()));
}
}
}
-static void generateSqlite3ForNamespace(sqlite3 *db, NamespaceDef *nd)
+static void generateSqlite3ForNamespace(const NamespaceDef *nd)
{
// + contained class definitions
// + contained namespace definitions
if (nd->isReference() || nd->isHidden()) return; // skip external references
// + contained class definitions
- writeInnerClasses(db,nd->getClassSDict());
+ writeInnerClasses(nd->getClassSDict());
// + contained namespace definitions
- writeInnerNamespaces(db,nd->getNamespaceSDict());
+ writeInnerNamespaces(nd->getNamespaceSDict());
// + member groups
if (nd->getMemberGroupSDict())
MemberGroup *mg;
for (;(mg=mgli.current());++mgli)
{
- generateSqlite3Section(db,nd,mg->members(),"user-defined",mg->header(),
+ generateSqlite3Section(nd,mg->members(),"user-defined",mg->header(),
mg->documentation());
}
}
{
if ((ml->listType()&MemberListType_declarationLists)!=0)
{
- generateSqlite3Section(db,nd,ml,"user-defined");//g_xmlSectionMapper.find(ml->listType()));
+ generateSqlite3Section(nd,ml,"user-defined");//g_xmlSectionMapper.find(ml->listType()));
}
}
}
-static void generateSqlite3ForFile(sqlite3 *db, FileDef *fd)
+static void generateSqlite3ForFile(const FileDef *fd)
{
// + includes files
// + includedby files
QListIterator<IncludeInfo> ili(*fd->includeFileList());
for (ili.toFirst();(ii=ili.current());++ili)
{
- int id_src=insertFile(db,fd->absFilePath().data());
- int id_dst=insertFile(db,ii->includeName.data());
+ int id_src=insertFile(fd->absFilePath().data());
+ int id_dst=insertFile(ii->includeName.data());
bindIntParameter(incl_select,":local",ii->local);
bindIntParameter(incl_select,":id_src",id_src);
bindIntParameter(incl_select,":id_dst",id_dst);
- if (step(db,incl_select,TRUE,TRUE)==0) {
+ if (step(incl_select,TRUE,TRUE)==0) {
bindIntParameter(incl_insert,":local",ii->local);
bindIntParameter(incl_insert,":id_src",id_src);
bindIntParameter(incl_insert,":id_dst",id_dst);
- step(db,incl_insert);
+ step(incl_insert);
}
}
}
QListIterator<IncludeInfo> ili(*fd->includedByFileList());
for (ili.toFirst();(ii=ili.current());++ili)
{
- int id_src=insertFile(db,ii->includeName);
- int id_dst=insertFile(db,fd->absFilePath());
+ int id_src=insertFile(ii->includeName);
+ int id_dst=insertFile(fd->absFilePath());
bindIntParameter(incl_select,":local",ii->local);
bindIntParameter(incl_select,":id_src",id_src);
bindIntParameter(incl_select,":id_dst",id_dst);
- if (step(db,incl_select,TRUE,TRUE)==0) {
+ if (step(incl_select,TRUE,TRUE)==0) {
bindIntParameter(incl_insert,":local",ii->local);
bindIntParameter(incl_insert,":id_src",id_src);
bindIntParameter(incl_insert,":id_dst",id_dst);
- step(db,incl_insert);
+ step(incl_insert);
}
}
}
// + contained class definitions
if (fd->getClassSDict())
{
- writeInnerClasses(db,fd->getClassSDict());
+ writeInnerClasses(fd->getClassSDict());
}
// + contained namespace definitions
if (fd->getNamespaceSDict())
{
- writeInnerNamespaces(db,fd->getNamespaceSDict());
+ writeInnerNamespaces(fd->getNamespaceSDict());
}
// + member groups
MemberGroup *mg;
for (;(mg=mgli.current());++mgli)
{
- generateSqlite3Section(db,fd,mg->members(),"user-defined",mg->header(),
+ generateSqlite3Section(fd,mg->members(),"user-defined",mg->header(),
mg->documentation());
}
}
{
if ((ml->listType()&MemberListType_declarationLists)!=0)
{
- generateSqlite3Section(db,fd,ml,"user-defined");//g_xmlSectionMapper.find(ml->listType()));
+ generateSqlite3Section(fd,ml,"user-defined");//g_xmlSectionMapper.find(ml->listType()));
}
}
}
-static void generateSqlite3ForGroup(sqlite3*db,GroupDef *gd)
+static void generateSqlite3ForGroup(const GroupDef *gd)
{
#warning WorkInProgress
}
-static void generateSqlite3ForDir(sqlite3 *db,DirDef *dd)
+static void generateSqlite3ForDir(const DirDef *dd)
{
#warning WorkInProgress
}
-static void generateSqlite3ForPage(sqlite3 *db,PageDef *pd,bool isExample)
+static void generateSqlite3ForPage(const PageDef *pd,bool isExample)
{
#warning WorkInProgress
}
+
+
+static sqlite3* openDbConnection()
+{
+
+ QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
+ QDir sqlite3Dir(outputDirectory);
+ sqlite3 *db;
+ int rc;
+
+ rc = sqlite3_initialize();
+ if (rc != SQLITE_OK)
+ {
+ msg("sqlite3_initialize failed\n");
+ return NULL;
+ }
+ rc = sqlite3_open_v2(outputDirectory+"/doxygen_sqlite3.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
+ if (rc != SQLITE_OK)
+ {
+ sqlite3_close(db);
+ msg("database open failed: %s\n", "doxygen_sqlite3.db");
+ return NULL;
+ }
+ return db;
+}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void generateSqlite3()
// + related pages
// + examples
// + main page
-
- QCString outputDirectory = Config_getString(OUTPUT_DIRECTORY);
- QDir sqlite3Dir(outputDirectory);
sqlite3 *db;
- sqlite3_initialize();
- int rc = sqlite3_open_v2(outputDirectory+"/doxygen_sqlite3.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
- if (rc != SQLITE_OK)
+
+ db = openDbConnection();
+ if (db==NULL)
{
- sqlite3_close(db);
- msg("database open failed: %s\n", "doxygen_sqlite3.db");
return;
}
beginTransaction(db);
for (cli.toFirst();(cd=cli.current());++cli)
{
msg("Generating Sqlite3 output for class %s\n",cd->name().data());
- generateSqlite3ForClass(db,cd);
+ generateSqlite3ForClass(cd);
}
// + namespaces
for (nli.toFirst();(nd=nli.current());++nli)
{
msg("Generating Sqlite3 output for namespace %s\n",nd->name().data());
- generateSqlite3ForNamespace(db,nd);
+ generateSqlite3ForNamespace(nd);
}
// + files
for (;(fd=fni.current());++fni)
{
msg("Generating Sqlite3 output for file %s\n",fd->name().data());
- generateSqlite3ForFile(db,fd);
+ generateSqlite3ForFile(fd);
}
}
for (;(gd=gli.current());++gli)
{
msg("Generating Sqlite3 output for group %s\n",gd->name().data());
- generateSqlite3ForGroup(db,gd);
+ generateSqlite3ForGroup(gd);
}
// + page
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
msg("Generating Sqlite3 output for page %s\n",pd->name().data());
- generateSqlite3ForPage(db,pd,FALSE);
+ generateSqlite3ForPage(pd,FALSE);
}
}
for (sdi.toFirst();(dir=sdi.current());++sdi)
{
msg("Generating Sqlite3 output for dir %s\n",dir->name().data());
- generateSqlite3ForDir(db,dir);
+ generateSqlite3ForDir(dir);
}
}
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
msg("Generating Sqlite3 output for example %s\n",pd->name().data());
- generateSqlite3ForPage(db,pd,TRUE);
+ generateSqlite3ForPage(pd,TRUE);
}
}
if (Doxygen::mainPage)
{
msg("Generating Sqlite3 output for the main page\n");
- generateSqlite3ForPage(db,Doxygen::mainPage,FALSE);
+ generateSqlite3ForPage(Doxygen::mainPage,FALSE);
}
endTransaction(db);
QCString file_name; // name of used file
ParserInterface *this_parser; // myself
int command; // true if command was found
- int comment; // set true if comment was scaned
+ int comment; // set true if comment was scanned
int brace_level; // bookkeeping of braces
int bracket_level; // bookkeeping of brackets
int bracket_quote; // bookkeeping of quotes (toggles)
static void tcl_name_SnippetAware(const QCString &ns0, const QCString &name0, QCString &ns, QCString &name)
{
// If we are inside an inlined code snippet then ns0
- // already containes the complete namespace path.
+ // already contains the complete namespace path.
// Any namespace qualifiers in name0 are redundant.
int i = name0.findRev("::");
if (i>=0 && tcl.memberdef)
}
else
{
- err("Cound not open template file %s\n",fileName.data());
+ err("Could not open template file %s\n",fileName.data());
}
}
return templ;
{ return "Մանրամասն..."; }\r
\r
/*! put in the class documentation */\r
- /* Dosn't use when optimization for C is on. */\r
+ /* Isn't used when optimization for C is on. */\r
virtual QCString trListOfAllMembers()\r
{\r
return "Բոլոր անդամների ցուցակը";\r
}\r
\r
/*! used as the title of the "list of all members" page of a class */\r
- /* Dosn't use when optimization for C is on. */\r
+ /* Isn't used when optimization for C is on. */\r
virtual QCString trMemberList()\r
{\r
return "Անդամների ցուցակ";\r
}\r
\r
/*! this is the first part of a sentence that is followed by a class name */\r
- /* Dosn't use when optimization for C is on. */\r
+ /* Isn't used when optimization for C is on. */\r
virtual QCString trThisIsTheListOfAllMembers()\r
{ return "Սա դասի անդամների ամբողջական ցուցակն է "; }\r
\r
/*! this is the remainder of the sentence after the class name */\r
- /* Dosn't use when optimization for C is on. */\r
+ /* Isn't used when optimization for C is on. */\r
virtual QCString trIncludingInheritedMembers()\r
{ return ", ներառյալ բոլոր ժառանգված անդամները"; }\r
\r
/******************************************************************************
- * Copyright (C) 1997-2015 by Dimitri van Heesch.
+ * Copyright (C) 1997-2017 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
* input used in their production; they are not affected by this license.
*
* Brazilian Portuguese translation version 20100531
- * Maintainer: Fabio "FJTC" Jun Takada Chino <jun-chino at uol.com.br>
+ * Maintainer:
+ * Fabio "FJTC" Jun Takada Chino <jun-chino at uol.com.br>
+ * Collaborators:
+ * Emerson Ferreira <nuskorpios at gmail dot com>
* Thanks to Jorge Ramos, Fernando Carijo and others for their contributions.
*
* History:
+ * 20170123:
+ * - Full translation revision;
+ * - trLegendDocs() is now synchronized with the English version;
+ * - Merging most of the suggestions sent by Emerson Ferreira;
* 20131129:
* - Updated to 1.8.5;
* - Translation in the method trFileMembers() fixed;
// --- Language control methods -------------------
- /*! Used for identification of the language. May resemble
- * the string returned by latexBabelPackage(), but it is not used
- * for the same purpose. The identification should not be translated.
- * It should be replaced by the name of the language in English
- * (e.g. Czech, Japanese, Russian, etc.). It should be equal to
- * the identification in language.h.
+ /*! Used for identification of the language. The identification
+ * should not be translated. It should be replaced by the name
+ * of the language in English using lower-case characters only
+ * (e.g. "czech", "japanese", "russian", etc.). It should be equal to
+ * the identification used in language.cpp.
*/
virtual QCString idLanguage()
{
return "brazilian";
}
- /*! Used to get the command(s) for the language support. This method
- * was designed for languages which do not prefer babel package.
- * If this methods returns empty string, then the latexBabelPackage()
- * method is used to generate the command for using the babel package.
+ /*! Used to get the LaTeX command(s) for the language support.
+ * This method should return string with commands that switch
+ * LaTeX to the desired language. For example
+ * <pre>"\\usepackage[german]{babel}\n"
+ * </pre>
+ * or
+ * <pre>"\\usepackage{polski}\n"
+ * "\\usepackage[latin2]{inputenc}\n"
+ * "\\usepackage[T1]{fontenc}\n"
+ * </pre>
+ *
+ * The English LaTeX does not use such commands. Because of this
+ * the empty string is returned in this implementation.
*/
virtual QCString latexLanguageSupportCommand()
{
/*! header that is put before the detailed description of files, classes and namespaces. */
virtual QCString trDetailedDescription()
- { return "Descrição Detalhada"; }
+ { return "Descrição detalhada"; }
/*! header that is put before the list of typedefs. */
virtual QCString trMemberTypedefDocumentation()
- { return "Definições de Tipos"; }
+ { return "Definições de tipos"; }
/*! header that is put before the list of enumerations. */
virtual QCString trMemberEnumerationDocumentation()
/*! header that is put before the list of member functions. */
virtual QCString trMemberFunctionDocumentation()
- { return "Métodos"; }
+ {
+ if (Config_getBool(OPTIMIZE_OUTPUT_JAVA))
+ {
+ return "Métodos";
+ }
+ else
+ {
+ return "Funções membros";
+ }
+ }
/*! header that is put before the list of member attributes. */
virtual QCString trMemberDataDocumentation()
virtual QCString trGeneratedAutomatically(const char *s)
{ QCString result="Gerado automaticamente por Doxygen";
if (s) result+=(QCString)" para "+s;
- result+=" a partir de seu código-fonte.";
+ result+=" a partir do código-fonte.";
return result;
}
/*! put after an enum name in the list of all members */
virtual QCString trEnumName()
- { return "[Enumeração]"; }
+ { return "Enumeração"; }
/*! put after an enum value in the list of all members */
virtual QCString trEnumValue()
- { return "[Valor enumerado]"; }
+ { return "Valor da enumeração"; }
/*! put after an undocumented member in the list of all members */
virtual QCString trDefinedIn()
}
else
{
- return "Lista de Componentes";
+ return "Lista de Classes";
}
}
}
else
{
- return "Componentes Membros";
+ return "Membros de classe";
}
}
{
if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
{
- return "Globais";
+ return "Ítens globais";
}
else
{
/*! This is an introduction to the annotated compound list. */
virtual QCString trCompoundListDescription()
{
-
if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
{
return "Aqui estão as estruturas de dados, uniões e suas respectivas descrições:";
result+="todas as estruturas e campos de uniões ";
if (!extractAll)
{
- result+="documentas";
+ result+="documentados";
}
}
else
result+="todos os membros de classes ";
if (!extractAll)
{
- result+="documentos";
+ result+="documentados";
}
}
result+=" com referências para ";
/*! This is an introduction to the page with the list of all examples */
virtual QCString trExamplesDescription()
- { return "Esta é a lista com todos os exemplos:"; }
+ { return "Esta é a lista de todos os exemplos:"; }
/*! This is an introduction to the page with the list of related pages */
virtual QCString trRelatedPagesDescription()
- { return "Esta é a lista com toda a documentação relacionadas:"; }
+ { return "Esta é a lista de toda a documentação relacionadas:"; }
/*! This is an introduction to the page with the list of class/file groups */
virtual QCString trModulesDescription()
- { return "Esta é a lista com todos os módulos:"; }
+ { return "Esta é a lista de todos os módulos:"; }
/*! This is used in HTML as the title of index.html. */
virtual QCString trDocumentation()
- { return "\nDocumentação"; }
+ {
+ // TODO In the future, I think I'll suggest the replacement of this
+ // method to something like trDocumentationOf(projPrefix). This will allow
+ // the latin construction "Documentação de ProjA"
+ return "Documentação";
+ }
/*! This is used in LaTeX as the title of the chapter with the
* index of all groups.
* list of (global) variables
*/
virtual QCString trEnumerationValues()
- { return "Valores de enumerações"; }
+ { return "Enumeradores"; }
/*! This is used in the documentation of a file before the list of
* documentation blocks for defines
/*! this text is put before a class diagram */
virtual QCString trClassDiagram(const char *clName)
{
- return (QCString)"Diagrama de Hierarquia para "+clName+":";
+ return (QCString)"Diagrama de hierarquia para "+clName+":";
}
/*! this text is generated when the \\internal command is used. */
ClassDef::CompoundType compType,
bool isTemplate)
{
- QCString result="Referência da";
- if (isTemplate) result+=" Template de";
+ QCString result="Referência";
+ if (isTemplate) result+=" do <em>Template</em>";
+ if (compType == ClassDef::Protocol)
+ {
+ result+=" do ";
+ }
+ else
+ {
+ result+=" da ";
+ }
switch(compType)
{
- case ClassDef::Class: result+=" Classe "; break;
- case ClassDef::Struct: result+=" Estrutura "; break;
- case ClassDef::Union: result+=" União "; break;
- case ClassDef::Interface: result+=" Interface "; break;
- case ClassDef::Protocol: result+=" Protocolo "; break;
- case ClassDef::Category: result+=" Categoria "; break;
- case ClassDef::Exception: result+=" Exceção "; break;
+ case ClassDef::Class: result+="Classe "; break;
+ case ClassDef::Struct: result+="Estrutura "; break;
+ case ClassDef::Union: result+="União "; break;
+ case ClassDef::Interface: result+="Interface "; break;
+ case ClassDef::Protocol: result+="Protocolo "; break;
+ case ClassDef::Category: result+="Categoria "; break;
+ case ClassDef::Exception: result+="Exceção "; break;
default: break;
}
result+=(QCString)clName;
}
virtual QCString trPublicMembers()
- { return "Métodos Públicos"; }
+ {
+ if (Config_getBool(OPTIMIZE_OUTPUT_JAVA))
+ {
+ return "Métodos Públicos";
+ }
+ else
+ {
+ return "Membros Públicos";
+ }
+ }
+
virtual QCString trPublicSlots()
{ return "Slots Públicos"; }
+
virtual QCString trSignals()
{ return "Sinais"; }
+
virtual QCString trStaticPublicMembers()
- { return "Métodos Públicos Estáticos"; }
+ { return "Membros Públicos Estáticos"; }
+
virtual QCString trProtectedMembers()
- { return "Métodos Protegidos"; }
+ { return "Membros Protegidos"; }
+
virtual QCString trProtectedSlots()
{ return "Slots Protegidos"; }
+
virtual QCString trStaticProtectedMembers()
- { return "Métodos Protegidos Estáticos"; }
+ { return "Membros Protegidos Estáticos"; }
+
virtual QCString trPrivateMembers()
- { return "Métodos Privados"; }
+ { return "Membros Privados"; }
+
virtual QCString trPrivateSlots()
{ return "Slots Privados"; }
+
virtual QCString trStaticPrivateMembers()
- { return "Métodos Privados Estáticos"; }
+ { return "Membros Privados Estáticos"; }
/*! this function is used to produce a comma-separated list of items.
* use generateMarker(i) to indicate where item i should be put.
*/
virtual QCString trInheritsList(int numEntries)
{
- return "Herdeiro de " + trWriteList(numEntries) + ".";
+ return "Subclasse de " + trWriteList(numEntries) + ".";
}
/*! used in class documentation to produce a list of super classes,
*/
virtual QCString trReimplementedFromList(int numEntries)
{
- return "Reimplementação de "+trWriteList(numEntries)+".";
+ return "Reimplementa "+trWriteList(numEntries)+".";
}
/*! used in member documentation blocks to produce a list of
/*! This is put above each page as a link to all members of namespaces. */
virtual QCString trNamespaceMembers()
- { return "Membros do Namespace"; }
+ { return "Membros do <em>Namespace</em>"; }
/*! This is an introduction to the page with all namespace members */
virtual QCString trNamespaceMemberDescription(bool extractAll)
{
- QCString result="Esta é a lista com todos os membros do Namespace ";
+ QCString result="Essa é a lista com todos os membros ";
if (!extractAll) result+="documentados ";
- result+="com referências para ";
+ result+="do <em>Namespace</em> com referências para ";
if (extractAll)
- result+="a documentação de seus respectivos Namespaces:";
+ result+="a documentação do <em>Namespace</em> para cada membro:";
else
- result+="os seus respectivos namespaces:";
+ result+="os seus respectivos <em>Namespaces</em>:";
return result;
}
/*! This is used in LaTeX as the title of the chapter with the
* index of all namespaces.
*/
virtual QCString trNamespaceIndex()
- { return "Namespaces"; }
+ { return "<em>Namespaces</em>"; }
/*! This is used in LaTeX as the title of the chapter containing
* the documentation of all namespaces.
*/
virtual QCString trNamespaceDocumentation()
- { return "Namespaces"; }
+ { return "<em>Namespace</em>"; }
//////////////////////////////////////////////////////////////////////////
// new since 0.49-990522
* namespaces in a file.
*/
virtual QCString trNamespaces()
- { return "Namespaces"; }
+ { return "<em>Namespaces</em>"; }
//////////////////////////////////////////////////////////////////////////
// new since 0.49-990728
bool single)
{ // here s is one of " Class", " Struct" or " Union"
// single is true implies a single file
- QCString result=(QCString)"A documentação para esta ";
+ QCString result=(QCString)"A documentação para ";
+ if (compType == ClassDef::Protocol)
+ {
+ result+= "esse ";
+ }
+ else
+ {
+ result+= "essa ";
+ }
switch(compType)
{
case ClassDef::Class: result+="classe "; break;
* documentation. It should be an abbreviation of the word page.
*/
virtual QCString trPageAbbreviation()
- { return "pag."; }
+ {
+ // Decidi mudar de página para "p." para ficar mais compacto.
+ return "p.";
+ }
//////////////////////////////////////////////////////////////////////////
// new since 0.49-991003
virtual QCString trDeprecated()
{
- /*
- * This note is for brazilians only.
- * Esta é uma boa tradução para "deprecated"?
- */
- return "Descontinuado(a)";
+ return "Obsoleto(a)";
}
//////////////////////////////////////////////////////////////////////////
/*! header that is put before the list of constructor/destructors. */
virtual QCString trConstructorDocumentation()
{
- return "Construtores & Destrutores";
+ return "Construtores e Destrutores";
}
/*! Used in the file documentation to point to the corresponding sources. */
virtual QCString trGotoSourceCode()
{
- return "Vá para o código-fonte deste arquivo.";
+ return "Vá para o código-fonte desse arquivo.";
}
/*! Used in the file sources to point to the corresponding documentation. */
virtual QCString trGotoDocumentation()
{
- return "Vá para a documentação deste arquivo.";
+ return "Vá para a documentação desse arquivo.";
}
/*! Text for the \\pre command */
virtual QCString trPrecondition()
{
- return "Pré-Condição";
+ return "Pré-condição";
}
/*! Text for the \\post command */
virtual QCString trPostcondition()
{
- return "Pós-Condição";
+ return "Pós-condição";
}
/*! Text for the \\invariant command */
virtual QCString trInvariant()
/*! Text shown before a multi-line variable/enum initialization */
virtual QCString trInitialValue()
{
- return "Valor Inicial:";
+ return "Valor inicial:";
}
/*! Text used the source code in the file index */
virtual QCString trCode()
}
virtual QCString trGotoGraphicalHierarchy()
{
- return "Vá para o Gráfico de Hierarquia de Classes";
+ return "Vá para o gráfico de hierarquia de classes";
}
virtual QCString trGotoTextualHierarchy()
{
- return "Vá para a Hierarquia de Classes (texto)";
+ return "Vá para a hierarquia de classes (texto)";
}
virtual QCString trPageIndex()
{
/*! Used as a marker that is put before a todo item */
virtual QCString trTodo()
{
- return "Futuras Atividades";
+ return "Atividades futuras";
}
/*! Used as the header of the todo list */
virtual QCString trTodoList()
{
- return "Lista de Futuras Atividades";
+ return "Lista de atividades futuras";
}
//////////////////////////////////////////////////////////////////////////
virtual QCString trReferencedBy()
{
- return "Referenciado por";
+ return "Referenciado(a) por";
}
virtual QCString trRemarks()
{
}
virtual QCString trInclByDepGraph()
{
- return "Este grafo mostra quais arquivos estão direta ou indiretamente relacionados com este arquivo:";
+ return "Este grafo mostra quais arquivos estão direta ou indiretamente relacionados com esse arquivo:";
}
virtual QCString trSince()
{
{
return "Legenda do Grafo";
}
- /*! page explaining how the dot graph's should be interpreted */
+ /*! page explaining how the dot graph's should be interpreted
+ * The %A in the text below are to prevent link to classes called "A".
+ */
virtual QCString trLegendDocs()
{
return
"Esta página explica como interpretar os grafos gerados pelo doxygen.<p>\n"
"Considere o seguinte exemplo:\n"
"\\code\n"
- "/*! Invisible class because of truncation */\n"
+ "/*! Classe oculta por causa da truncagem */\n"
"class Invisible { };\n\n"
- "/*! Truncated class, inheritance relation is hidden */\n"
+ "/*! Classe Truncated, relação de herança está oculta */\n"
"class Truncated : public Invisible { };\n\n"
- "/* Class not documented with doxygen comments */\n"
+ "/* Classe não documentada com os comentários do Doxygen */\n"
"class Undocumented { };\n\n"
- "/*! Class that is inherited using public inheritance */\n"
+ "/*! Classe possui que possui uma relação de herança pública */\n"
"class PublicBase : public Truncated { };\n\n"
- "/*! A template class */\n"
+ "/*! Um template de classe */\n"
"template<class T> class Templ { };\n\n"
- "/*! Class that is inherited using protected inheritance */\n"
+ "/*! Classe possui que possui uma relação de herança protegida */\n"
"class ProtectedBase { };\n\n"
- "/*! Class that is inherited using private inheritance */\n"
+ "/*! Classe possui que possui uma relação de herança privada */\n"
"class PrivateBase { };\n\n"
- "/*! Class that is used by the Inherited class */\n"
+ "/*! Classe utilizada pela classe Inherited */\n"
"class Used { };\n\n"
- "/*! Super class that inherits a number of other classes */\n"
+ "/*! Super classe que herda outras classes */\n"
"class Inherited : public PublicBase,\n"
" protected ProtectedBase,\n"
" private PrivateBase,\n"
"Isto irá gerar o seguinte gráfo:"
"<p><center><img src=\"graph_legend."+getDotImageExtension()+"\"></center>\n"
"<p>\n"
- "As caixas no grafo acima tem as seguintes interpretações:\n"
+ "As caixas no grafo acima possuem os seguintes significados:\n"
+ "</p>\n"
"<ul>\n"
- "<li>Uma caixa inteiramente preta representa a estrutura ou a classe para qual "
- "o grafo foi gerado.\n"
- "<li>Uma caixa com bordas pretas denota uma estrutura ou classe documentada.\n"
- "<li>Uma caixa com bordas cinzas denota uma estrutura ou classe não documentada.\n"
-
- "<li>Uma caixa com bordas vermelhas denota uma estrutura ou classe documentada para\n"
- "a qual nem todas as heranças ou componentes são mostradas no grafo. Um grafo é "
- "truncado quando este é maior que o tamanho especificado."
+ "<li>Uma caixa cinza denota a estrutura ou a classe que gerou"
+ "este grafo.</li>\n"
+ "<li>Uma caixa com a borda preta denota uma estrutura ou classe documentada.</li>\n"
+ "<li>Uma caixa com a borda cinza denota uma estrutura ou classe não documentada.</li>\n"
+ "<li>Uma caixa com a borda vermelha denota uma estrutura ou classe na"
+ "qual nem todas as relações são mostradas. Um grafo é truncado quando "
+ "esse não cabe no espaço especificado.</li>\n"
"</ul>\n"
- "As setas tem os seguintes significados:\n"
+ "<p>\n"
+ "As setas possuem os seguintes significados:\n"
+ "</p>\n"
"<ul>\n"
- "<li>Uma seta azul escura é utilizada para denotar uma relação de herança "
- "pública entre duas classes.\n"
- "<li>Uma seta verde escura é utilizada para denotar uma herança protegida.\n"
- "<li>Uma seta vermelho escura é utilizada para denotar uma herança privada.\n"
- "<li>Uma seta púrpura pontilhada é usada se uma classe está contida ou é utilizada"
- "por outra classe. A seta é marcada com a(s) variável(eis) "
- "através das quais a classe ou estrutura apontada está acessível. \n"
+ "<li>Uma seta azul escura denota a relação de herança pública entre "
+ "duas classes.</li>\n"
+ "<li>Uma seta verde escura denota a relação de herança protegida entre "
+ "duas classes.</li>\n"
+ "<li>Uma seta vermelha escura denota a relação de herança privada entre "
+ "duas classes.</li>\n"
+ "<li>Uma seta pontilhada púrpura denota a relação de uso e/ou agragação "
+ "por outra classe/estrutura. A etiqueta da seta denota o nome do(s) campo(s) "
+ "que representa(m) este apontamento.</li>\n"
+ "<li>Uma seta pontilhada amarela denota a relação de instanciação de uma "
+ "<em>template</em>. A etiqueta da seta denota os parâmetros de instanciação "
+ "desta <em>template</em>.</li>\n"
"</ul>\n";
}
/*! text for the link to the legend page */
/*! The description of the package index page */
virtual QCString trPackageListDescription()
{
- return "Esta é a lista com os pacotes e suas respectivas descrições (se disponíveis):";
+ return "Esta é a lista com os pacotes e suas respectivas descrições (quando disponíveis):";
}
/*! The link name in the Quick links header for each page */
virtual QCString trPackages()
/*! Used as a marker that is put before a \\bug item */
virtual QCString trBug()
{
- return "Problema";
+ return "Bug";
}
/*! Used as the header of the bug list */
virtual QCString trBugList()
{
- return "Lista de Problemas";
+ return "Lista de Bugs";
}
//////////////////////////////////////////////////////////////////////////
/*! Used as header RTF general index */
virtual QCString trRTFGeneralIndex()
{
- return "Índice";
+ return "Sumário";
}
/*! This is used for translation of the word that will possibly
*/
virtual QCString trReferences()
{
- return "Referências";
+ return "Referencias";
}
//////////////////////////////////////////////////////////////////////////
*/
virtual QCString trRTFTableOfContents()
{
- return "Conteúdo";
+ return "Sumário";
}
//////////////////////////////////////////////////////////////////////////
*/
virtual QCString trDeprecatedList()
{
- return "Lista de Descontinuados(as)";
+ return "Lista de itens obsoletos";
}
//////////////////////////////////////////////////////////////////////////
{
return "Tipos do Pacote";
}
-
/*! Used as a heading for a list of Java class functions with package
* scope.
*/
{
return "Funções do Pacote";
}
-
/*! Used as a heading for a list of static Java class functions with
* package scope.
*/
{
return "Funções Estáticas do Pacote";
}
-
/*! Used as a heading for a list of Java class variables with package
* scope.
*/
{
return "Atributos do Pacote";
}
-
/*! Used as a heading for a list of static Java class variables with
* package scope.
*/
/*! Put in front of the call graph for a function. */
virtual QCString trCallGraph()
{
- return "Este é o diagrama das funções utilizadas por esta função:";
+ return "Este é o diagrama das funções utilizadas por essa função:";
}
//////////////////////////////////////////////////////////////////////////
*/
virtual QCString trSearchResultsTitle()
{
- return "Resultado da Busca";
+ return "Resultado(s) da Busca";
}
/*! This string is put just before listing the search results. The
* text can be different depending on the number of documents found.
else
{
return "<b>$num</b> documentos encontrados. "
- "Os melhores resultados vem primeiro.";
+ "Mostrando os melhores resultados primeiro.";
}
}
/*! This string is put before the list of matched words, for each search
* of the directories.
*/
virtual QCString trDirDocumentation()
- { return "Documentação do Directório"; }
+ { return "Documentação do Diretório"; }
/*! This is used as the title of the directory index and also in the
* Quick links of a HTML page, to link to the directory hierarchy.
if (!singular) result+="s";
return result;
}
+
//////////////////////////////////////////////////////////////////////////
// new since 1.4.1
//////////////////////////////////////////////////////////////////////////
*/
virtual QCString trOverloadText()
{
- return "Este é um método provido por conveniência. "
+ return "Esse é um método provido por conveniência. "
"Ele difere do método acima apenas na lista de "
"argumentos que devem ser utilizados.";
}
/*! This is used to introduce a caller (or called-by) graph */
virtual QCString trCallerGraph()
{
- return "Este é o diagrama das funções que utilizam esta função:";
+ return "Esse é o diagrama das funções que utilizam essa função:";
}
/*! This is used in the documentation of a file/namespace before the list
{
QCString result = (QCString)"Referência ";
- if (isTemplate) result+="da Template ";
+ if (isTemplate) result+="do <em>Template</em> ";
switch(compType)
{
*/
virtual QCString trModule(bool first_capital, bool singular)
{
- QCString result((first_capital ? "Modulo" : "modulo"));
+ QCString result((first_capital ? "Módulo" : "módulo"));
if (!singular) result+="s";
return result;
}
+
/*! This is put at the bottom of a module documentation page and is
* followed by a list of files that were used to generate the page.
*/
virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
bool single)
- { // here s is one of " Module", " Struct" or " Union"
+ {
// single is true implies a single file
QCString result=(QCString)"A documentação para ";
switch(compType)
{
- case ClassDef::Class: result+="este modulo "; break;
- case ClassDef::Struct: result+="este tipo "; break;
- case ClassDef::Union: result+="esta união "; break;
- case ClassDef::Interface: result+="esta interface "; break;
- case ClassDef::Protocol: result+="esto protocolo "; break;
- case ClassDef::Category: result+="esta categoria "; break;
- case ClassDef::Exception: result+="esta exceção "; break;
+ case ClassDef::Class: result+="esse modulo "; break;
+ case ClassDef::Struct: result+="esse tipo "; break;
+ case ClassDef::Union: result+="essa união "; break;
+ case ClassDef::Interface: result+="essa interface "; break;
+ case ClassDef::Protocol: result+="esso protocolo "; break;
+ case ClassDef::Category: result+="essa categoria "; break;
+ case ClassDef::Exception: result+="essa exceção "; break;
default: break;
}
return result;
}
+
/*! This is used for translation of the word that will possibly
* be followed by a single name or by a list of names
* of the category.
if (!singular) result+="s";
return result;
}
+
/*! This is used for translation of the word that will possibly
* be followed by a single name or by a list of names
* of the category.
*/
virtual QCString trSubprogram(bool first_capital, bool singular)
{
- QCString result((first_capital ? "Subprograma" : "subprograma"));
+ QCString result((first_capital ? "Subrotina" : "subrotina"));
if (!singular) result+="s";
return result;
}
// new since 1.6.0 (mainly for the new search engine)
//////////////////////////////////////////////////////////////////////////
- /*! directory relation for \a name
- */
+ /*! directory relation for \a name */
virtual QCString trDirRelation(const char *name)
{
return "Relação " + QCString(name);
/*! Label used for search results in the global namespace */
virtual QCString trGlobalNamespace()
{
- return "Namespace global";
+ return "<em>Namespace</em> global";
}
/*! Message shown while searching */
/*! Text shown when no search results are found */
virtual QCString trNoMatches()
{
- return "Nenhuma entrada encontrada";
+ return "Nenhum resultado encontrado";
}
//////////////////////////////////////////////////////////////////////////
/*! Section header for list of template parameters */
virtual QCString trTemplateParameters()
- { return "Parâmetros de template"; }
+ { return "Parâmetros do <em>template</em>"; }
/*! Used in dot graph when UML_LOOK is enabled and there are many fields */
virtual QCString trAndMore(const QCString &number)
/*! Used file list for a Java enum */
virtual QCString trEnumGeneratedFromFiles(bool single)
- { QCString result = "A documentação para esta enumeração foi gerada a partir";
+ { QCString result = "A documentação para essa enumeração foi gerada a partir ";
if (single) {
result += "do seguinte arquivo:";
} else {
*/
virtual QCString trClassMethods()
{
- return "Métodos de classe";
+ return "Métodos da classe";
}
/*! Used as the header of a list of instance methods in Objective-C.
*/
virtual QCString trInstanceMethods()
{
- return "Métodos de instância";
+ return "Métodos da instância";
}
/*! Used as the header of the member functions of an Objective-C class.
/** old style UNO IDL services: inherited services */
virtual QCString trServices()
- { return "Serviços Incluídos"; }
+ { return "Serviços Inclusos"; }
/** UNO IDL constant groups */
virtual QCString trConstantGroups()
result += namespaceName;
return result;
}
-
/** UNO IDL service page title */
virtual QCString trServiceReference(const char *sName)
{
result += sName;
return result;
}
-
/** UNO IDL singleton page title */
virtual QCString trSingletonReference(const char *sName)
{
+ // TODO: Emerson Ferreira proposes to add emphasis around the word
+ // Singleton but I'm not sure if this will work for non HTML generators.
QCString result = "Referência do Singleton ";
result += sName;
return result;
}
-
/** UNO IDL service page */
virtual QCString trServiceGeneratedFromFiles(bool single)
{
// single is true implies a single file
- QCString result=(QCString)"A documentação para este serviço "
+ QCString result=(QCString)"A documentação para esse serviço "
"foi gerada a partir ";
if (single) {
result+="do seguinte arquivo:";
} else {
- result+="dos: seguintes arquivos:";
+ result+="dos seguintes arquivos:";
}
return result;
}
-
/** UNO IDL singleton page */
virtual QCString trSingletonGeneratedFromFiles(bool single)
{
// single is true implies a single file
- QCString result=(QCString)"A documentação para este singleton "
+ QCString result=(QCString)"A documentação para esse <em>Singleton</em> "
"foi gerada a partir ";
if (single) {
result+="do seguinte arquivo:";
}
//////////////////////////////////////////////////////////////////////////
+
};
-#endif
+#endif
virtual QCString trReferencedBy()
{
- return "参考自";
+ return "被这些函数引用";
}
virtual QCString trRemarks()
*/
virtual QCString trReferences()
{
- return "å\8f\82è\80\83";
+ return "å¼\95ç\94¨äº\86";
}
//////////////////////////////////////////////////////////////////////////
// 2016/03/15 Carsten Schumann (carsten at familie-schumann dot info)
// - Updated for "new since 1.8.4" version
//
+// 2017/10/12 Arnd Weber (arnd dot weber at bafg dot de)
+// Beatrix Konz
+// - Updated for 1.8.13
+// - Resynced trMemberDataDocumentation() and trFileMembers() to include the
+// boolean switch OPTIMIZE_OUTPUT_FOR_C
+// - Replaced "\t" by " "
+//
// Todo:
// - see FIXME
#ifndef TRANSLATOR_DE_H
#define TRANSLATOR_DE_H
-class TranslatorGerman : public TranslatorAdapter_1_8_4
+class TranslatorGerman : public Translator
{
public:
/*! header that is put before the list of member attributes. */
virtual QCString trMemberDataDocumentation()
- { /* No difference if "OPTIMIZE_OUTPUT_FOR_C" is set! */
- return "Dokumentation der Datenelemente";
+ {
+ if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
+ {
+ return "Dokumentation der Felder";
+ }
+ else
+ {
+ return "Dokumentation der Datenelemente";
+ }
}
/*! this is the text of a link put after brief descriptions. */
/*! This is put above each page as a link to all members of files. */
virtual QCString trFileMembers()
- /* No difference if "OPTIMIZE_OUTPUT_FOR_C" is set! */
- { return "Datei-Elemente"; }
+ {
+ if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
+ {
+ return "Globale Elemente";
+ }
+ else
+ {
+ return "Datei-Elemente";
+ }
+ }
/*! This is put above each page as a link to all related pages. */
virtual QCString trRelatedPages()
{
if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
{
- return "Hier folgt die Aufzählung aller Datenstrukturen "
- "mit einer Kurzbeschreibung:";
+ return "Hier folgt die Aufzählung aller Datenstrukturen "
+ "mit einer Kurzbeschreibung:";
}
else
{
- return "Hier folgt die Aufzählung aller Klassen, Strukturen, "
- "Varianten und Schnittstellen mit einer Kurzbeschreibung:";
+ return "Hier folgt die Aufzählung aller Klassen, Strukturen, "
+ "Varianten und Schnittstellen mit einer Kurzbeschreibung:";
}
}
virtual QCString trCompoundIndex()
{
if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
- return "Datenstruktur-Verzeichnis";
+ return "Datenstruktur-Verzeichnis";
else
return "Klassen-Verzeichnis";
}
/*! this text is used in the title page of a LaTeX document. */
virtual QCString trGeneratedBy()
{ return "Erzeugt von"; }
-
//////////////////////////////////////////////////////////////////////////
// new since 0.49-990307
virtual QCString trClasses()
{
if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
+ {
return "Datenstrukturen";
+ }
else
+ {
return "Klassen";
+ }
}
/*! Used as the title of a Java package */
else
{
return "Es wurden <b>$num</b> Dokumente zu Ihrer Suchanfrage "
- "gefunden. Die besten Treffer werden zuerst angezeigt.";
+ "gefunden. Die besten Treffer werden zuerst angezeigt.";
}
}
/*! This string is put before the list of matched words, for each search
*/
virtual QCString trDirDescription()
{ return "Diese Verzeichnishierarchie ist -mit Einschränkungen- "
- "alphabetisch sortiert:";
+ "alphabetisch sortiert:";
}
/*! This returns the title of a directory page. The name of the
/*! This is an introduction to the annotated compound list (Fortran). */
virtual QCString trCompoundListDescriptionFortran()
- { return "Hier folgen die Datentypen mit Kurzbeschreibungen:"; }
+ { return "Hier folgen die Datentypen mit Kurzbeschreibungen:"; }
/*! This is an introduction to the page with all data types (Fortran). */
virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
/*! Used file list for a Java enum */
virtual QCString trEnumGeneratedFromFiles(bool single)
{ QCString result = "Die Dokumentation für diesen enum wurde aus ";
- if (single)
- result += "der folgenden Datei";
- else
- result += "den folgenden Dateien";
+ if (single)
+ result += "der folgenden Datei";
+ else
+ result += "den folgenden Dateien";
result+=" generiert:";
return result;
}
{
return "Übersicht";
}
+
//////////////////////////////////////////////////////////////////////////
// new since 1.8.4
//////////////////////////////////////////////////////////////////////////
+
/** old style UNO IDL services: implemented interfaces */
virtual QCString trInterfaces()
{ return "Exportierte Interfaces"; }
result+=" Dienstreferenz";
return result;
}
+
/** UNO IDL singleton page title */
virtual QCString trSingletonReference(const char *sName)
{
result+=" Singleton-Referenz";
return result;
}
+
/** UNO IDL service page */
virtual QCString trServiceGeneratedFromFiles(bool single)
{
if (single) result+="folgender Datei: "; else result+="folgenden Dateien: ";
return result;
}
+
/** UNO IDL singleton page */
virtual QCString trSingletonGeneratedFromFiles(bool single)
{
QCString result=(QCString)"Die Dokumentation für diesen Singleton wurde generiert aus ";
-
if (single) result+="folgender Datei:"; else result+="folgenden Dateien:";
return result;
}
-
-
//////////////////////////////////////////////////////////////////////////
};
*/
virtual QCString latexLanguageSupportCommand()
{
- return "\\usepackage[french]{babel}\n";
+ return "\\usepackage[french]{babel}\n"
+ "\\NoAutoSpaceBeforeFDP\n";
}
// --- Language translation methods -------------------
{ return "Подробнее..."; }
/*! put in the class documentation */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trListOfAllMembers()
{
return "Полный список членов класса";
}
/*! used as the title of the "list of all members" page of a class */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trMemberList()
{
return "Cписок членов класса";
}
/*! this is the first part of a sentence that is followed by a class name */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trThisIsTheListOfAllMembers()
{ return "Полный список членов класса "; }
/*! this is the remainder of the sentence after the class name */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trIncludingInheritedMembers()
{ return ", включая наследуемые из базового класса"; }
{ return "Детальніше..."; }
/*! put in the class documentation */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trListOfAllMembers()
{
return "Список всіх елементів" ;
}
/*! used as the title of the "list of all members" page of a class */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trMemberList()
{
return "Cписок елементів" ;
}
/*! this is the first part of a sentence that is followed by a class name */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trThisIsTheListOfAllMembers()
{ return "Повний список елементів"; }
/*! this is the remainder of the sentence after the class name */
- /* Dosn't use when optimization for C is on. */
+ /* Isn't used when optimization for C is on. */
virtual QCString trIncludingInheritedMembers()
{ return ", включаючи всі успадковані елементи"; }
static QDict<Definition> g_visitedNamespaces;
// forward declaration
-static ClassDef *getResolvedClassRec(Definition *scope,
- FileDef *fileScope,
+static ClassDef *getResolvedClassRec(const Definition *scope,
+ const FileDef *fileScope,
const char *n,
MemberDef **pTypeDef,
QCString *pTemplSpec,
QCString *pResolvedType
);
-int isAccessibleFromWithExpScope(Definition *scope,FileDef *fileScope,Definition *item,
+int isAccessibleFromWithExpScope(const Definition *scope,const FileDef *fileScope,const Definition *item,
const QCString &explicitScopePart);
/*! Returns the class representing the value of the typedef represented by \a md
*
* Example: typedef int T; will return 0, since "int" is not a class.
*/
-ClassDef *newResolveTypedef(FileDef *fileScope,MemberDef *md,
+ClassDef *newResolveTypedef(const FileDef *fileScope,MemberDef *md,
MemberDef **pMemType,QCString *pTemplSpec,
QCString *pResolvedType,
ArgumentList *actTemplParams)
/*! Substitutes a simple unqualified \a name within \a scope. Returns the
* value of the typedef or \a name if no typedef was found.
*/
-static QCString substTypedef(Definition *scope,FileDef *fileScope,const QCString &name,
+static QCString substTypedef(const Definition *scope,const FileDef *fileScope,const QCString &name,
MemberDef **pTypeDef=0)
{
QCString result=name;
* searched. If found the scope definition is returned, otherwise 0
* is returned.
*/
-static Definition *followPath(Definition *start,FileDef *fileScope,const QCString &path)
+static const Definition *followPath(const Definition *start,const FileDef *fileScope,const QCString &path)
{
int is,ps;
int l;
- Definition *current=start;
+ const Definition *current=start;
ps=0;
//printf("followPath: start='%s' path='%s'\n",start?start->name().data():"<none>",path.data());
// for each part of the explicit scope
return type;
}
}
- Definition *next = current->findInnerCompound(qualScopePart);
+ const Definition *next = current->findInnerCompound(qualScopePart);
//printf("++ Looking for %s inside %s result %s\n",
// qualScopePart.data(),
// current->name().data(),
}
bool accessibleViaUsingClass(const SDict<Definition> *cl,
- FileDef *fileScope,
- Definition *item,
+ const FileDef *fileScope,
+ const Definition *item,
const QCString &explicitScopePart=""
)
{
for (cli.toFirst();(ucd=cli.current());++cli)
{
//printf("Trying via used class %s\n",ucd->name().data());
- Definition *sc = explicitScopePartEmpty ? ucd : followPath(ucd,fileScope,explicitScopePart);
+ const Definition *sc = explicitScopePartEmpty ? ucd : followPath(ucd,fileScope,explicitScopePart);
if (sc && sc==item) return TRUE;
//printf("Try via used class done\n");
}
}
bool accessibleViaUsingNamespace(const NamespaceSDict *nl,
- FileDef *fileScope,
- Definition *item,
+ const FileDef *fileScope,
+ const Definition *item,
const QCString &explicitScopePart="")
{
static QDict<void> visitedDict;
{
//printf("[Trying via used namespace %s: count=%d/%d\n",und->name().data(),
// count,nl->count());
- Definition *sc = explicitScopePart.isEmpty() ? und : followPath(und,fileScope,explicitScopePart);
+ const Definition *sc = explicitScopePart.isEmpty() ? und : followPath(und,fileScope,explicitScopePart);
if (sc && item->getOuterScope()==sc)
{
//printf("] found it\n");
{
public:
AccessStack() : m_index(0) {}
- void push(Definition *scope,FileDef *fileScope,Definition *item)
+ void push(const Definition *scope,const FileDef *fileScope,const Definition *item)
{
if (m_index<MAX_STACK_SIZE)
{
m_index++;
}
}
- void push(Definition *scope,FileDef *fileScope,Definition *item,const QCString &expScope)
+ void push(const Definition *scope,const FileDef *fileScope,const Definition *item,const QCString &expScope)
{
if (m_index<MAX_STACK_SIZE)
{
{
if (m_index>0) m_index--;
}
- bool find(Definition *scope,FileDef *fileScope, Definition *item)
+ bool find(const Definition *scope,const FileDef *fileScope, const Definition *item)
{
int i=0;
for (i=0;i<m_index;i++)
}
return FALSE;
}
- bool find(Definition *scope,FileDef *fileScope, Definition *item,const QCString &expScope)
+ bool find(const Definition *scope,const FileDef *fileScope, const Definition *item,const QCString &expScope)
{
int i=0;
for (i=0;i<m_index;i++)
/** Element in the stack. */
struct AccessElem
{
- Definition *scope;
- FileDef *fileScope;
- Definition *item;
+ const Definition *scope;
+ const FileDef *fileScope;
+ const Definition *item;
QCString expScope;
};
int m_index;
/* Returns the "distance" (=number of levels up) from item to scope, or -1
* if item in not inside scope.
*/
-int isAccessibleFrom(Definition *scope,FileDef *fileScope,Definition *item)
+int isAccessibleFrom(const Definition *scope,const FileDef *fileScope,const Definition *item)
{
//printf("<isAccesibleFrom(scope=%s,item=%s itemScope=%s)\n",
// scope->name().data(),item->name().data(),item->getOuterScope()->name().data());
* not found and then A::I is searched in the global scope, which matches and
* thus the result is 1.
*/
-int isAccessibleFromWithExpScope(Definition *scope,FileDef *fileScope,
- Definition *item,const QCString &explicitScopePart)
+int isAccessibleFromWithExpScope(const Definition *scope,const FileDef *fileScope,
+ const Definition *item,const QCString &explicitScopePart)
{
if (explicitScopePart.isEmpty())
{
// item?item->name().data():"<none>",
// explicitScopePart.data());
int result=0; // assume we found it
- Definition *newScope = followPath(scope,fileScope,explicitScopePart);
+ const Definition *newScope = followPath(scope,fileScope,explicitScopePart);
if (newScope) // explicitScope is inside scope => newScope is the result
{
Definition *itemScope = item->getOuterScope();
return name.findRev("::",i==-1 ? name.length() : i);
}
-static void getResolvedSymbol(Definition *scope,
- FileDef *fileScope,
+static void getResolvedSymbol(const Definition *scope,
+ const FileDef *fileScope,
Definition *d,
const QCString &explicitScopePart,
ArgumentList *actTemplParams,
* match against the input name. Can recursively call itself when
* resolving typedefs.
*/
-static ClassDef *getResolvedClassRec(Definition *scope,
- FileDef *fileScope,
+static ClassDef *getResolvedClassRec(const Definition *scope,
+ const FileDef *fileScope,
const char *n,
MemberDef **pTypeDef,
QCString *pTemplSpec,
* Loops through scope and each of its parent scopes looking for a
* match against the input name.
*/
-ClassDef *getResolvedClass(Definition *scope,
- FileDef *fileScope,
+ClassDef *getResolvedClass(const Definition *scope,
+ const FileDef *fileScope,
const char *n,
MemberDef **pTypeDef,
QCString *pTemplSpec,
}
-void linkifyText(const TextGeneratorIntf &out,Definition *scope,
- FileDef *fileScope,Definition *self,
+void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
+ const FileDef *fileScope,const Definition *self,
const char *text, bool autoBreak,bool external,
bool keepSpaces,int indentLevel)
{
if (md!=self && (self==0 || md->name()!=self->name()))
// name check is needed for overloaded members, where getDefs just returns one
{
- out.writeLink(md->getReference(),md->getOutputFileBase(),
- md->anchor(),word);
- //printf("found symbol %s\n",matchWord.data());
- found=TRUE;
+ /* in case of Fortran scop and the variable is a non Fortran variable: don't link,
+ * see also getLink in fortrancode.l
+ */
+ if (!(scope && (scope->getLanguage() == SrcLangExt_Fortran) && md->isVariable() && (md->getLanguage() != SrcLangExt_Fortran)))
+ {
+ out.writeLink(md->getReference(),md->getOutputFileBase(),
+ md->anchor(),word);
+ //printf("found symbol %s\n",matchWord.data());
+ found=TRUE;
+ }
}
}
}
{
return resolveRef(scName,name,inSeeBlock,resContext,resMember,FALSE,0,checkScope);
}
- if (bracePos!=-1) // Try without parameters as well, could be a contructor invocation
+ if (bracePos!=-1) // Try without parameters as well, could be a constructor invocation
{
*resContext=getClass(fullName.left(bracePos));
if (*resContext)
break;
case '"': t << "\\char`\\\"{}";
break;
+ case '`': t << "\\`{}";
+ break;
case '\'': t << "\\textquotesingle{}";
break;
case ' ': if (keepSpaces) { if (insideTabbing) t << "\\>"; else t << '~'; } else t << ' ';
updateLanguageMapping(".sql", "sql");
}
-SrcLangExt getLanguageFromFileName(const QCString fileName)
+SrcLangExt getLanguageFromFileName(const QCString& fileName)
{
int i = fileName.findRev('.');
if (i!=-1) // name has an extension
bool patternMatch(const QFileInfo &fi,const QStrList *patList)
{
- bool found=FALSE;
+ static bool caseSenseNames = Config_getBool(CASE_SENSE_NAMES);
+ bool found = FALSE;
+
+ // For Windows/Mac, always do the case insensitive match
+#if defined(_WIN32) || defined(__MACOSX__)
+ caseSenseNames = FALSE;
+#endif
+
if (patList)
- {
+ {
QStrListIterator it(*patList);
QCString pattern;
int i=pattern.find('=');
if (i!=-1) pattern=pattern.left(i); // strip of the extension specific filter name
-#if defined(_WIN32) || defined(__MACOSX__) // Windows or MacOSX
- QRegExp re(pattern,FALSE,TRUE); // case insensitive match
-#else // unix
- QRegExp re(pattern,TRUE,TRUE); // case sensitive match
-#endif
+ QRegExp re(pattern,caseSenseNames,TRUE);
+
found = re.match(fn)!=-1 ||
re.match(fp)!=-1 ||
re.match(afp)!=-1;
}
-/*! @brief Returns one unicode character as ian unsigned interger
+/*! @brief Returns one unicode character as an unsigned integer
* from utf-8 string, making the character upper case if it was lower case.
*
* @param s utf-8 encoded string
//--------------------------------------------------------------------
void linkifyText(const TextGeneratorIntf &ol,
- Definition *scope,
- FileDef *fileScope,
- Definition *self,
+ const Definition *scope,
+ const FileDef *fileScope,
+ const Definition *self,
const char *text,
bool autoBreak=FALSE,
bool external=TRUE,
ClassDef *getClass(const char *key);
-ClassDef *getResolvedClass(Definition *scope,
- FileDef *fileScope,
+ClassDef *getResolvedClass(const Definition *scope,
+ const FileDef *fileScope,
const char *key,
MemberDef **pTypeDef=0,
QCString *pTemplSpec=0,
void replaceNamespaceAliases(QCString &scope,int i);
-int isAccessibleFrom(Definition *scope,FileDef *fileScope,Definition *item);
+int isAccessibleFrom(const Definition *scope,const FileDef *fileScope,const Definition *item);
-int isAccessibleFromWithExpScope(Definition *scope,FileDef *fileScope,Definition *item,
+int isAccessibleFromWithExpScope(const Definition *scope,const FileDef *fileScope,const Definition *item,
const QCString &explicitScopePart);
int computeQualifiedIndex(const QCString &name);
// const QCString &anchor="");
bool updateLanguageMapping(const QCString &extension,const QCString &parser);
-SrcLangExt getLanguageFromFileName(const QCString fileName);
+SrcLangExt getLanguageFromFileName(const QCString& fileName);
void initDefaultExtensionMapping();
void addCodeOnlyMappings();
const char *n);
bool checkIfTypedef(Definition *scope,FileDef *fileScope,const char *n);
-ClassDef *newResolveTypedef(FileDef *fileScope,MemberDef *md,
+ClassDef *newResolveTypedef(const FileDef *fileScope,MemberDef *md,
MemberDef **pMemType=0,QCString *pTemplSpec=0,
QCString *pResolvedType=0,
ArgumentList *actTemplParams=0);
*
*/
/******************************************************************************
- * Parser for syntax hightlighting and references for vhdl subset
+ * Parser for syntax highlighting and references for vhdl subset
* written by M. Kreis
* supports VHDL-87/93/2008
******************************************************************************/
}//codifymaplines
/*
-* writes a function|procedure prototype and links the function|procedure name
+* writes a function|procedure prototype and links the function|procedure name
*/
static void writeFuncProto()
}
}// writeFuncProto
-/* writes a process prototype to the ouput */
+/* writes a process prototype to the output */
static void writeProcessProto(){
codifyLines(g_FuncProto.data(),g_CurrClass.data());
writeFont("vhdlkeyword",vhdlcodeYYtext);
}
-<Bases>^{B}*("use"|"library"){BN}+ { //found package or library
+<Bases>^{B}*("use"|"library"){BN}+ { //found package or library
writeFont("vhdlkeyword",vhdlcodeYYtext);
BEGIN(ParsePackage);
}
}
}
-// Creates a svg image. All in/out/inout ports are shown with brief description and direction.
+// Creates an svg image. All in/out/inout ports are shown with brief description and direction.
// Brief descriptions for entities are shown too.
void VhdlDocGen::writeOverview()
{
"map","mod",
"nand","new","next","nor","not","null",
"of","on","open","or","others","out",
- "package","parameter","port","postponed","procedure","process","property","proctected","pure",
+ "package","parameter","port","postponed","procedure","process","property","protected","pure",
"range","record","register","reject","release","restrict","restrict_guarantee","rem","report","rol","ror","return",
"select","sequence","severity","signal","shared","sla","sll","sra","srl","strong","subtype",
"then","to","transport","type",
QCString VhdlDocGen::trDesignUnitListDescription()
{
return "Here is a list of all design unit members with links to "
- "the Entities they belong to:";
+ "the Entities they belong to:";
}
QCString VhdlDocGen::trDesignUnitIndex()
/*
// file foo.vhd
-// enitity foo
+// entity foo
// .....
// end entity
//const MemberDef *m=VhdlDocGen::getFlowMember();
//if (m)
- // fprintf(stderr,"\n creating flowchart : %s %s in file %s \n",VhdlDocGen::trTypeString(m->getMemberSpecifiers()),m->name().data(),m->getFileDef()->name().data());
+ // fprintf(stderr,"\n creating flowchart : %s %s in file %s \n",VhdlDocGen::trTypeString(m->getMemberSpecifiers()),m->name().data(),m->getFileDef()->name().data());
- QCString dir=" -o "+ov+qcs;
+ QCString dir=" -o \""+ov+qcs+"\"";
ov+="/flow_design.dot";
- QCString vlargs="-Tsvg "+ov+dir ;
+ QCString vlargs="-Tsvg \""+ov+"\" "+dir ;
if (portable_system("dot",vlargs)!=0)
{
VhdlParser::lastEntity=0;
VhdlParser::currentCompound=0;
VhdlParser::lastEntity=0;
+ oldEntry = 0;
VhdlParser::current=new Entry();
VhdlParser::initEntry(VhdlParser::current);
groupEnterFile(fileName,yyLineNr);
*
*/
/******************************************************************************
- * Parser for syntax hightlighting and references for XML
+ * Parser for syntax highlighting and references for XML
* written by Weston Thayer
******************************************************************************/
switch(s->type())
{
case DocVerbatim::Code: // fall though
- m_t << "<programlisting>";
+ m_t << "<programlisting";
+ if (!s->language().isEmpty())
+ m_t << " filename=\"" << lang << "\">";
+ else
+ m_t << ">";
Doxygen::parserManager->getParser(lang)
->parseCode(m_ci,s->context(),s->text(),langExt,
s->isExample(),s->exampleFile());
{
case DocInclude::IncWithLines:
{
- m_t << "<programlisting>";
+ m_t << "<programlisting filename=\"" << inc->file() << "\">";
QFileInfo cfi( inc->file() );
FileDef fd( cfi.dirPath().utf8(), cfi.fileName().utf8() );
Doxygen::parserManager->getParser(inc->extension())
}
break;
case DocInclude::Include:
- m_t << "<programlisting>";
+ m_t << "<programlisting filename=\"" << inc->file() << "\">";
Doxygen::parserManager->getParser(inc->extension())
->parseCode(m_ci,inc->context(),
inc->text(),
m_t << "</verbatim>";
break;
case DocInclude::Snippet:
- m_t << "<programlisting>";
+ m_t << "<programlisting filename=\"" << inc->file() << "\">";
Doxygen::parserManager->getParser(inc->extension())
->parseCode(m_ci,
inc->context(),
break;
case DocInclude::SnipWithLines:
{
- m_t << "<programlisting>";
+ m_t << "<programlisting filename=\"" << inc->file() << "\">";
QFileInfo cfi( inc->file() );
FileDef fd( cfi.dirPath().utf8(), cfi.fileName().utf8() );
Doxygen::parserManager->getParser(inc->extension())
{
if (!m_hide)
{
- m_t << "<programlisting>";
+ m_t << "<programlisting filename=\"" << op->includeFileName() << "\">";
}
pushEnabled();
m_hide = TRUE;
visitPreStart(m_t, "image", FALSE, this, img->children(), baseName, TRUE, img->type(), img->width(), img->height());
// copy the image to the output dir
- QFile inImage(img->name());
- QFile outImage(Config_getString(XML_OUTPUT)+"/"+baseName.data());
- if (inImage.open(IO_ReadOnly))
+ FileDef *fd;
+ bool ambig;
+ if ((fd=findFileDef(Doxygen::imageNameDict,img->name(),ambig)))
{
- if (outImage.open(IO_WriteOnly))
+ QFile inImage(fd->absFilePath());
+ QFile outImage(Config_getString(XML_OUTPUT)+"/"+baseName.data());
+ if (inImage.open(IO_ReadOnly))
{
- char *buffer = new char[inImage.size()];
- inImage.readBlock(buffer,inImage.size());
- outImage.writeBlock(buffer,inImage.size());
- outImage.flush();
- delete[] buffer;
+ if (outImage.open(IO_WriteOnly))
+ {
+ char *buffer = new char[inImage.size()];
+ inImage.readBlock(buffer,inImage.size());
+ outImage.writeBlock(buffer,inImage.size());
+ outImage.flush();
+ delete[] buffer;
+ }
}
}
}
case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18:
case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26:
case 27: case 28: case 29: case 30: case 31:
- break; // skip invalid XML characters (see http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char)
+ // encode invalid XML characters (see http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char)
+ t << "<sp value=\"" << int(c) << "\"/>";
+ break;
default: s=writeUtf8Char(t,s-1); col++; break;
}
}
if (md->isInline()) t << "yes"; else t << "no";
t << "\"";
- if (al->refQualifier!=RefQualifierNone)
+ if (al!=0 && al->refQualifier!=RefQualifierNone)
{
t << " refqual=\"";
if (al->refQualifier==RefQualifierLValue) t << "lvalue"; else t << "rvalue";
t << "\"";
}
+ if (md->memberType() == MemberType_Enumeration)
+ {
+ t << " strong=\"";
+ if (md->isStrong()) t << "yes"; else t << "no";
+ t << "\"";
+ }
+
if (md->memberType() == MemberType_Variable)
{
//ArgumentList *al = md->argumentList();
md->memberType()!=MemberType_Enumeration
)
{
- if (md->memberType()!=MemberType_Typedef)
- {
- writeMemberTemplateLists(md,t);
- }
+ writeMemberTemplateLists(md,t);
QCString typeStr = md->typeString(); //replaceAnonymousScopes(md->typeString());
stripQualifiers(typeStr);
t << " <type>";
t << " <argsstring>" << convertToXML(md->argsString()) << "</argsstring>" << endl;
}
+ if (md->memberType() == MemberType_Enumeration)
+ {
+ t << " <type>";
+ linkifyText(TextGeneratorXMLImpl(t),def,md->getBodyDef(),md,md->enumBaseType());
+ t << "</type>" << endl;
+ }
+
t << " <name>" << convertToXML(md->name()) << "</name>" << endl;
if (md->memberType() == MemberType_Property)
{
ArgumentList *declAl = md->declArgumentList();
ArgumentList *defAl = md->argumentList();
- if (declAl && declAl->count()>0)
+ if (declAl && defAl && declAl->count()>0)
{
ArgumentListIterator declAli(*declAl);
ArgumentListIterator defAli(*defAl);
}
}
writeInnerPages(pd->getSubPages(),t);
+ if(pd->showToc())
+ {
+ t << " <tableofcontents/>" << endl;
+ }
+ t << " <briefdescription>" << endl;
+ writeXMLDocBlock(t,pd->briefFile(),pd->briefLine(),pd,0,pd->briefDescription());
+ t << " </briefdescription>" << endl;
t << " <detaileddescription>" << endl;
if (isExample)
{
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
function toggleVisibility(linkObj)
{
var base = $(linkObj).attr('id');
summary.hide();
$(linkObj).removeClass('closed').addClass('opened');
$(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
- }
+ }
return false;
}
$(this).show();
} else if (l==level+1) {
i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
- a.html('►');
+ a.html('▶');
$(this).show();
} else {
$(this).hide();
// replace down arrow by right arrow for current row
var currentRowSpans = currentRow.find("span");
currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
- currentRowSpans.filter(".arrow").html('►');
+ currentRowSpans.filter(".arrow").html('▶');
rows.filter("[id^=row_"+id+"]").hide(); // hide all children
} else { // we are SHOWING
// replace right arrow by down arrow for current row
// replace down arrows by right arrows for child rows
var childRowsSpans = childRows.find("span");
childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
- childRowsSpans.filter(".arrow").html('►');
+ childRowsSpans.filter(".arrow").html('▶');
childRows.show(); //show all children
}
updateStripes();
$(img).attr('src',src.substring(0,src.length-10)+'open.png');
}
}
-
+/* @license-end */
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
function SearchBox(name, resultsPath, inFrame, label)
{
this.searchLabel = label;
{
lastPage-=firstPage;
firstPage=0;
- }
+ }
if (lastPage>data.pages)
{
lastPage=data.pages;
}
});
}
+/* @license-end */
--- /dev/null
+.tabs, .tabs2, .tabs3 {
+ background-image: url('tab_b.png');
+ width: 100%;
+ z-index: 101;
+ font-size: 13px;
+ font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+}
+
+.tabs2 {
+ font-size: 10px;
+}
+.tabs3 {
+ font-size: 9px;
+}
+
+.tablist {
+ margin: 0;
+ padding: 0;
+ display: table;
+}
+
+.tablist li {
+ float: left;
+ display: table-cell;
+ background-image: url('tab_b.png');
+ line-height: 36px;
+ list-style: none;
+}
+
+.tablist a {
+ display: block;
+ padding: 0 20px;
+ font-weight: bold;
+ background-image:url('tab_s.png');
+ background-repeat:no-repeat;
+ background-position:right;
+ color: ##30;
+ text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+ text-decoration: none;
+ outline: none;
+}
+
+.tabs3 .tablist a {
+ padding: 0 10px;
+}
+
+.tablist a:hover {
+ background-image: url('tab_h.png');
+ background-repeat:repeat-x;
+ color: #fff;
+ text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
+ text-decoration: none;
+}
+
+.tablist li.current a {
+ background-image: url('tab_a.png');
+ background-repeat:repeat-x;
+ color: #fff;
+ text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
+}
+
<script type="text/javascript" src="{{ page.relPath }}navtreedata.js"></script>
<script type="text/javascript" src="{{ page.relPath }}navtree.js"></script>
<script type="text/javascript">
+ /* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
$(document).ready(initResizable);
+ /* @license-end */
</script>
{% endif %}
{% if not config.DISABLE_INDEX %}
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
$(function() {
initMenu('',{% if config.SEARCHENGINE %}true{% else %}false{% endif %},'{{ tr.search }}');
});
+/* @license-end */
</script>
{% endif %}
{% if config.SEARCHENGINE %}
<script type="text/javascript" src="{{ page.relPath }}search/search.js"></script>
{% if config.SERVER_BASED_SEARCH %}
<script type="text/javascript">
+ /* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
$(document).ready(function() {
if ($('.searchresults').length > 0) { searchBox.DOMSearchField().focus(); }
});
+ /* @license-end */
</script>
<link rel="search" href="{{ page.relPath }}search-opensearch.php?v=opensearch.xml" type="application/opensearchdescription+xml" title="{{ config.PROJECT_NAME }}"/>
{% else %}
<script type="text/javascript">
+ /* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
$(document).ready(function() { init_search(); });
+ /* @license-end */
</script>
{% endif %}
{% endif %}
{% block search %}
{% if config.SEARCHENGINE %}
<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
var searchBox = new SearchBox("searchBox", "{{ page.relPath }}search",false,'{{ tr.search }}');
+/* @license-end */
</script>
{% endif %}
{% endblock %}
</div>
</div>
<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
$(document).ready(function(){initNavTree('{{ page.fileName }}{% if page_postfix %}{{ page_postfix }}{% endif %}{{ config.HTML_FILE_EXTENSION }}','{{ page.relPath }}');});
+/* @license-end */
</script>
<div id="doc-content">
{% endif %}
{% else %}
{{ tr.generatedBy }}
{% endif %}
- <a href="http://www.doxygen.org/index.html"><img class="footer" src="{{ page.relPath }}doxygen.png" alt="doxygen"/></a>
+ <a href="http://www.doxygen.org/index.html"><img class="footer" src="{{ page.relPath }}doxygen.png" alt="doxygen"/></a>
{{ doxygen.version }}
</small></address>
{% endif %}
{% else %}
<span style="width:{{ (node.level)*16 }}px;display:inline-block;"> </span>
<span id="arr_{{ node.id }}" class="arrow" onclick="toggleFolder('{{ node.id}}')">
- {%if node.level+1<tree.preferredDepth %}▼{% else %}►{% endif %}
+ {%if node.level+1<tree.preferredDepth %}▼{% else %}▶{% endif %}
</span>
{% endif %}
{% if node.namespace %}
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
var menudata={children:[
{text:'{{ tr.mainPage }}',url:'index{{ config.HTML_FILE_EXTENSION }}'}
{% if pageTree.tree %}
,{text:'{{ tr.examples }}',url:'examples{{ config.HTML_FILE_EXTENSION }}'}
{% endif %}
]}
-
<div class="SRStatus" id="Loading">{{ tr.loading }}</div>
<div id="SRResults"></div>
<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
createResults();
+/* @license-end */
--></script>
<div class="SRStatus" id="Searching">{{ tr.searching }}</div>
<div class="SRStatus" id="NoMatches">{{ tr.noMatches }}</div>
<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
document.getElementById("Loading").style.display="none";
document.getElementById("NoMatches").style.display="none";
var searchResults = new SearchResults("searchResults");
searchResults.Search();
+/* @license-end */
--></script>
</div>
</body>
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
/*!
* jQuery JavaScript Library v1.7.1
* http://jquery.com/
(function(b,c){var a=false;b(document).mouseup(function(d){a=false});b.widget("ui.mouse",{options:{cancel:":input,option",distance:1,delay:0},_mouseInit:function(){var d=this;this.element.bind("mousedown."+this.widgetName,function(e){return d._mouseDown(e)}).bind("click."+this.widgetName,function(e){if(true===b.data(e.target,d.widgetName+".preventClickEvent")){b.removeData(e.target,d.widgetName+".preventClickEvent");e.stopImmediatePropagation();return false}});this.started=false},_mouseDestroy:function(){this.element.unbind("."+this.widgetName)},_mouseDown:function(f){if(a){return}(this._mouseStarted&&this._mouseUp(f));this._mouseDownEvent=f;var e=this,g=(f.which==1),d=(typeof this.options.cancel=="string"&&f.target.nodeName?b(f.target).closest(this.options.cancel).length:false);if(!g||d||!this._mouseCapture(f)){return true}this.mouseDelayMet=!this.options.delay;if(!this.mouseDelayMet){this._mouseDelayTimer=setTimeout(function(){e.mouseDelayMet=true},this.options.delay)}if(this._mouseDistanceMet(f)&&this._mouseDelayMet(f)){this._mouseStarted=(this._mouseStart(f)!==false);if(!this._mouseStarted){f.preventDefault();return true}}if(true===b.data(f.target,this.widgetName+".preventClickEvent")){b.removeData(f.target,this.widgetName+".preventClickEvent")}this._mouseMoveDelegate=function(h){return e._mouseMove(h)};this._mouseUpDelegate=function(h){return e._mouseUp(h)};b(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate);f.preventDefault();a=true;return true},_mouseMove:function(d){if(b.browser.msie&&!(document.documentMode>=9)&&!d.button){return this._mouseUp(d)}if(this._mouseStarted){this._mouseDrag(d);return d.preventDefault()}if(this._mouseDistanceMet(d)&&this._mouseDelayMet(d)){this._mouseStarted=(this._mouseStart(this._mouseDownEvent,d)!==false);(this._mouseStarted?this._mouseDrag(d):this._mouseUp(d))}return !this._mouseStarted},_mouseUp:function(d){b(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate);if(this._mouseStarted){this._mouseStarted=false;if(d.target==this._mouseDownEvent.target){b.data(d.target,this.widgetName+".preventClickEvent",true)}this._mouseStop(d)}return false},_mouseDistanceMet:function(d){return(Math.max(Math.abs(this._mouseDownEvent.pageX-d.pageX),Math.abs(this._mouseDownEvent.pageY-d.pageY))>=this.options.distance)},_mouseDelayMet:function(d){return this.mouseDelayMet},_mouseStart:function(d){},_mouseDrag:function(d){},_mouseStop:function(d){},_mouseCapture:function(d){return true}})})(jQuery);(function(c,d){c.widget("ui.resizable",c.ui.mouse,{widgetEventPrefix:"resize",options:{alsoResize:false,animate:false,animateDuration:"slow",animateEasing:"swing",aspectRatio:false,autoHide:false,containment:false,ghost:false,grid:false,handles:"e,s,se",helper:false,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:1000},_create:function(){var f=this,k=this.options;this.element.addClass("ui-resizable");c.extend(this,{_aspectRatio:!!(k.aspectRatio),aspectRatio:k.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:k.helper||k.ghost||k.animate?k.helper||"ui-resizable-helper":null});if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)){this.element.wrap(c('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")}));this.element=this.element.parent().data("resizable",this.element.data("resizable"));this.elementIsWrapper=true;this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")});this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0});this.originalResizeStyle=this.originalElement.css("resize");this.originalElement.css("resize","none");this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"}));this.originalElement.css({margin:this.originalElement.css("margin")});this._proportionallyResize()}this.handles=k.handles||(!c(".ui-resizable-handle",this.element).length?"e,s,se":{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"});if(this.handles.constructor==String){if(this.handles=="all"){this.handles="n,e,s,w,se,sw,ne,nw"}var l=this.handles.split(",");this.handles={};for(var g=0;g<l.length;g++){var j=c.trim(l[g]),e="ui-resizable-"+j;var h=c('<div class="ui-resizable-handle '+e+'"></div>');if(/sw|se|ne|nw/.test(j)){h.css({zIndex:++k.zIndex})}if("se"==j){h.addClass("ui-icon ui-icon-gripsmall-diagonal-se")}this.handles[j]=".ui-resizable-"+j;this.element.append(h)}}this._renderAxis=function(q){q=q||this.element;for(var n in this.handles){if(this.handles[n].constructor==String){this.handles[n]=c(this.handles[n],this.element).show()}if(this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)){var o=c(this.handles[n],this.element),p=0;p=/sw|ne|nw|se|n|s/.test(n)?o.outerHeight():o.outerWidth();var m=["padding",/ne|nw|n/.test(n)?"Top":/se|sw|s/.test(n)?"Bottom":/^e$/.test(n)?"Right":"Left"].join("");q.css(m,p);this._proportionallyResize()}if(!c(this.handles[n]).length){continue}}};this._renderAxis(this.element);this._handles=c(".ui-resizable-handle",this.element).disableSelection();this._handles.mouseover(function(){if(!f.resizing){if(this.className){var i=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)}f.axis=i&&i[1]?i[1]:"se"}});if(k.autoHide){this._handles.hide();c(this.element).addClass("ui-resizable-autohide").hover(function(){if(k.disabled){return}c(this).removeClass("ui-resizable-autohide");f._handles.show()},function(){if(k.disabled){return}if(!f.resizing){c(this).addClass("ui-resizable-autohide");f._handles.hide()}})}this._mouseInit()},destroy:function(){this._mouseDestroy();var e=function(g){c(g).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};if(this.elementIsWrapper){e(this.element);var f=this.element;f.after(this.originalElement.css({position:f.css("position"),width:f.outerWidth(),height:f.outerHeight(),top:f.css("top"),left:f.css("left")})).remove()}this.originalElement.css("resize",this.originalResizeStyle);e(this.originalElement);return this},_mouseCapture:function(f){var g=false;for(var e in this.handles){if(c(this.handles[e])[0]==f.target){g=true}}return !this.options.disabled&&g},_mouseStart:function(g){var j=this.options,f=this.element.position(),e=this.element;this.resizing=true;this.documentScroll={top:c(document).scrollTop(),left:c(document).scrollLeft()};if(e.is(".ui-draggable")||(/absolute/).test(e.css("position"))){e.css({position:"absolute",top:f.top,left:f.left})}this._renderProxy();var k=b(this.helper.css("left")),h=b(this.helper.css("top"));if(j.containment){k+=c(j.containment).scrollLeft()||0;h+=c(j.containment).scrollTop()||0}this.offset=this.helper.offset();this.position={left:k,top:h};this.size=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalSize=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalPosition={left:k,top:h};this.sizeDiff={width:e.outerWidth()-e.width(),height:e.outerHeight()-e.height()};this.originalMousePosition={left:g.pageX,top:g.pageY};this.aspectRatio=(typeof j.aspectRatio=="number")?j.aspectRatio:((this.originalSize.width/this.originalSize.height)||1);var i=c(".ui-resizable-"+this.axis).css("cursor");c("body").css("cursor",i=="auto"?this.axis+"-resize":i);e.addClass("ui-resizable-resizing");this._propagate("start",g);return true},_mouseDrag:function(e){var h=this.helper,g=this.options,m={},q=this,j=this.originalMousePosition,n=this.axis;var r=(e.pageX-j.left)||0,p=(e.pageY-j.top)||0;var i=this._change[n];if(!i){return false}var l=i.apply(this,[e,r,p]),k=c.browser.msie&&c.browser.version<7,f=this.sizeDiff;this._updateVirtualBoundaries(e.shiftKey);if(this._aspectRatio||e.shiftKey){l=this._updateRatio(l,e)}l=this._respectSize(l,e);this._propagate("resize",e);h.css({top:this.position.top+"px",left:this.position.left+"px",width:this.size.width+"px",height:this.size.height+"px"});if(!this._helper&&this._proportionallyResizeElements.length){this._proportionallyResize()}this._updateCache(l);this._trigger("resize",e,this.ui());return false},_mouseStop:function(h){this.resizing=false;var i=this.options,m=this;if(this._helper){var g=this._proportionallyResizeElements,e=g.length&&(/textarea/i).test(g[0].nodeName),f=e&&c.ui.hasScroll(g[0],"left")?0:m.sizeDiff.height,k=e?0:m.sizeDiff.width;var n={width:(m.helper.width()-k),height:(m.helper.height()-f)},j=(parseInt(m.element.css("left"),10)+(m.position.left-m.originalPosition.left))||null,l=(parseInt(m.element.css("top"),10)+(m.position.top-m.originalPosition.top))||null;if(!i.animate){this.element.css(c.extend(n,{top:l,left:j}))}m.helper.height(m.size.height);m.helper.width(m.size.width);if(this._helper&&!i.animate){this._proportionallyResize()}}c("body").css("cursor","auto");this.element.removeClass("ui-resizable-resizing");this._propagate("stop",h);if(this._helper){this.helper.remove()}return false},_updateVirtualBoundaries:function(g){var j=this.options,i,h,f,k,e;e={minWidth:a(j.minWidth)?j.minWidth:0,maxWidth:a(j.maxWidth)?j.maxWidth:Infinity,minHeight:a(j.minHeight)?j.minHeight:0,maxHeight:a(j.maxHeight)?j.maxHeight:Infinity};if(this._aspectRatio||g){i=e.minHeight*this.aspectRatio;f=e.minWidth/this.aspectRatio;h=e.maxHeight*this.aspectRatio;k=e.maxWidth/this.aspectRatio;if(i>e.minWidth){e.minWidth=i}if(f>e.minHeight){e.minHeight=f}if(h<e.maxWidth){e.maxWidth=h}if(k<e.maxHeight){e.maxHeight=k}}this._vBoundaries=e},_updateCache:function(e){var f=this.options;this.offset=this.helper.offset();if(a(e.left)){this.position.left=e.left}if(a(e.top)){this.position.top=e.top}if(a(e.height)){this.size.height=e.height}if(a(e.width)){this.size.width=e.width}},_updateRatio:function(h,g){var i=this.options,j=this.position,f=this.size,e=this.axis;if(a(h.height)){h.width=(h.height*this.aspectRatio)}else{if(a(h.width)){h.height=(h.width/this.aspectRatio)}}if(e=="sw"){h.left=j.left+(f.width-h.width);h.top=null}if(e=="nw"){h.top=j.top+(f.height-h.height);h.left=j.left+(f.width-h.width)}return h},_respectSize:function(l,g){var j=this.helper,i=this._vBoundaries,r=this._aspectRatio||g.shiftKey,q=this.axis,t=a(l.width)&&i.maxWidth&&(i.maxWidth<l.width),m=a(l.height)&&i.maxHeight&&(i.maxHeight<l.height),h=a(l.width)&&i.minWidth&&(i.minWidth>l.width),s=a(l.height)&&i.minHeight&&(i.minHeight>l.height);if(h){l.width=i.minWidth}if(s){l.height=i.minHeight}if(t){l.width=i.maxWidth}if(m){l.height=i.maxHeight}var f=this.originalPosition.left+this.originalSize.width,p=this.position.top+this.size.height;var k=/sw|nw|w/.test(q),e=/nw|ne|n/.test(q);if(h&&k){l.left=f-i.minWidth}if(t&&k){l.left=f-i.maxWidth}if(s&&e){l.top=p-i.minHeight}if(m&&e){l.top=p-i.maxHeight}var n=!l.width&&!l.height;if(n&&!l.left&&l.top){l.top=null}else{if(n&&!l.top&&l.left){l.left=null}}return l},_proportionallyResize:function(){var k=this.options;if(!this._proportionallyResizeElements.length){return}var g=this.helper||this.element;for(var f=0;f<this._proportionallyResizeElements.length;f++){var h=this._proportionallyResizeElements[f];if(!this.borderDif){var e=[h.css("borderTopWidth"),h.css("borderRightWidth"),h.css("borderBottomWidth"),h.css("borderLeftWidth")],j=[h.css("paddingTop"),h.css("paddingRight"),h.css("paddingBottom"),h.css("paddingLeft")];this.borderDif=c.map(e,function(l,n){var m=parseInt(l,10)||0,o=parseInt(j[n],10)||0;return m+o})}if(c.browser.msie&&!(!(c(g).is(":hidden")||c(g).parents(":hidden").length))){continue}h.css({height:(g.height()-this.borderDif[0]-this.borderDif[2])||0,width:(g.width()-this.borderDif[1]-this.borderDif[3])||0})}},_renderProxy:function(){var f=this.element,i=this.options;this.elementOffset=f.offset();if(this._helper){this.helper=this.helper||c('<div style="overflow:hidden;"></div>');var e=c.browser.msie&&c.browser.version<7,g=(e?1:0),h=(e?2:-1);this.helper.addClass(this._helper).css({width:this.element.outerWidth()+h,height:this.element.outerHeight()+h,position:"absolute",left:this.elementOffset.left-g+"px",top:this.elementOffset.top-g+"px",zIndex:++i.zIndex});this.helper.appendTo("body").disableSelection()}else{this.helper=this.element}},_change:{e:function(g,f,e){return{width:this.originalSize.width+f}},w:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{left:i.left+f,width:g.width-f}},n:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{top:i.top+e,height:g.height-e}},s:function(g,f,e){return{height:this.originalSize.height+e}},se:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},sw:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[g,f,e]))},ne:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},nw:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[g,f,e]))}},_propagate:function(f,e){c.ui.plugin.call(this,f,[e,this.ui()]);(f!="resize"&&this._trigger(f,e,this.ui()))},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}});c.extend(c.ui.resizable,{version:"1.8.18"});c.ui.plugin.add("resizable","alsoResize",{start:function(f,g){var e=c(this).data("resizable"),i=e.options;var h=function(j){c(j).each(function(){var k=c(this);k.data("resizable-alsoresize",{width:parseInt(k.width(),10),height:parseInt(k.height(),10),left:parseInt(k.css("left"),10),top:parseInt(k.css("top"),10)})})};if(typeof(i.alsoResize)=="object"&&!i.alsoResize.parentNode){if(i.alsoResize.length){i.alsoResize=i.alsoResize[0];h(i.alsoResize)}else{c.each(i.alsoResize,function(j){h(j)})}}else{h(i.alsoResize)}},resize:function(g,i){var f=c(this).data("resizable"),j=f.options,h=f.originalSize,l=f.originalPosition;var k={height:(f.size.height-h.height)||0,width:(f.size.width-h.width)||0,top:(f.position.top-l.top)||0,left:(f.position.left-l.left)||0},e=function(m,n){c(m).each(function(){var q=c(this),r=c(this).data("resizable-alsoresize"),p={},o=n&&n.length?n:q.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];c.each(o,function(s,u){var t=(r[u]||0)+(k[u]||0);if(t&&t>=0){p[u]=t||null}});q.css(p)})};if(typeof(j.alsoResize)=="object"&&!j.alsoResize.nodeType){c.each(j.alsoResize,function(m,n){e(m,n)})}else{e(j.alsoResize)}},stop:function(e,f){c(this).removeData("resizable-alsoresize")}});c.ui.plugin.add("resizable","animate",{stop:function(i,n){var p=c(this).data("resizable"),j=p.options;var h=p._proportionallyResizeElements,e=h.length&&(/textarea/i).test(h[0].nodeName),f=e&&c.ui.hasScroll(h[0],"left")?0:p.sizeDiff.height,l=e?0:p.sizeDiff.width;var g={width:(p.size.width-l),height:(p.size.height-f)},k=(parseInt(p.element.css("left"),10)+(p.position.left-p.originalPosition.left))||null,m=(parseInt(p.element.css("top"),10)+(p.position.top-p.originalPosition.top))||null;p.element.animate(c.extend(g,m&&k?{top:m,left:k}:{}),{duration:j.animateDuration,easing:j.animateEasing,step:function(){var o={width:parseInt(p.element.css("width"),10),height:parseInt(p.element.css("height"),10),top:parseInt(p.element.css("top"),10),left:parseInt(p.element.css("left"),10)};if(h&&h.length){c(h[0]).css({width:o.width,height:o.height})}p._updateCache(o);p._propagate("resize",i)}})}});c.ui.plugin.add("resizable","containment",{start:function(f,r){var t=c(this).data("resizable"),j=t.options,l=t.element;var g=j.containment,k=(g instanceof c)?g.get(0):(/parent/.test(g))?l.parent().get(0):g;if(!k){return}t.containerElement=c(k);if(/document/.test(g)||g==document){t.containerOffset={left:0,top:0};t.containerPosition={left:0,top:0};t.parentData={element:c(document),left:0,top:0,width:c(document).width(),height:c(document).height()||document.body.parentNode.scrollHeight}}else{var n=c(k),i=[];c(["Top","Right","Left","Bottom"]).each(function(p,o){i[p]=b(n.css("padding"+o))});t.containerOffset=n.offset();t.containerPosition=n.position();t.containerSize={height:(n.innerHeight()-i[3]),width:(n.innerWidth()-i[1])};var q=t.containerOffset,e=t.containerSize.height,m=t.containerSize.width,h=(c.ui.hasScroll(k,"left")?k.scrollWidth:m),s=(c.ui.hasScroll(k)?k.scrollHeight:e);t.parentData={element:k,left:q.left,top:q.top,width:h,height:s}}},resize:function(g,q){var t=c(this).data("resizable"),i=t.options,f=t.containerSize,p=t.containerOffset,m=t.size,n=t.position,r=t._aspectRatio||g.shiftKey,e={top:0,left:0},h=t.containerElement;if(h[0]!=document&&(/static/).test(h.css("position"))){e=p}if(n.left<(t._helper?p.left:0)){t.size.width=t.size.width+(t._helper?(t.position.left-p.left):(t.position.left-e.left));if(r){t.size.height=t.size.width/i.aspectRatio}t.position.left=i.helper?p.left:0}if(n.top<(t._helper?p.top:0)){t.size.height=t.size.height+(t._helper?(t.position.top-p.top):t.position.top);if(r){t.size.width=t.size.height*i.aspectRatio}t.position.top=t._helper?p.top:0}t.offset.left=t.parentData.left+t.position.left;t.offset.top=t.parentData.top+t.position.top;var l=Math.abs((t._helper?t.offset.left-e.left:(t.offset.left-e.left))+t.sizeDiff.width),s=Math.abs((t._helper?t.offset.top-e.top:(t.offset.top-p.top))+t.sizeDiff.height);var k=t.containerElement.get(0)==t.element.parent().get(0),j=/relative|absolute/.test(t.containerElement.css("position"));if(k&&j){l-=t.parentData.left}if(l+t.size.width>=t.parentData.width){t.size.width=t.parentData.width-l;if(r){t.size.height=t.size.width/t.aspectRatio}}if(s+t.size.height>=t.parentData.height){t.size.height=t.parentData.height-s;if(r){t.size.width=t.size.height*t.aspectRatio}}},stop:function(f,n){var q=c(this).data("resizable"),g=q.options,l=q.position,m=q.containerOffset,e=q.containerPosition,i=q.containerElement;var j=c(q.helper),r=j.offset(),p=j.outerWidth()-q.sizeDiff.width,k=j.outerHeight()-q.sizeDiff.height;if(q._helper&&!g.animate&&(/relative/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}if(q._helper&&!g.animate&&(/static/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}}});c.ui.plugin.add("resizable","ghost",{start:function(g,h){var e=c(this).data("resizable"),i=e.options,f=e.size;e.ghost=e.originalElement.clone();e.ghost.css({opacity:0.25,display:"block",position:"relative",height:f.height,width:f.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass(typeof i.ghost=="string"?i.ghost:"");e.ghost.appendTo(e.helper)},resize:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost){e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})}},stop:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost&&e.helper){e.helper.get(0).removeChild(e.ghost.get(0))}}});c.ui.plugin.add("resizable","grid",{resize:function(e,m){var p=c(this).data("resizable"),h=p.options,k=p.size,i=p.originalSize,j=p.originalPosition,n=p.axis,l=h._aspectRatio||e.shiftKey;h.grid=typeof h.grid=="number"?[h.grid,h.grid]:h.grid;var g=Math.round((k.width-i.width)/(h.grid[0]||1))*(h.grid[0]||1),f=Math.round((k.height-i.height)/(h.grid[1]||1))*(h.grid[1]||1);if(/^(se|s|e)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f}else{if(/^(ne)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f}else{if(/^(sw)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.left=j.left-g}else{p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f;p.position.left=j.left-g}}}}});var b=function(e){return parseInt(e,10)||0};var a=function(e){return !isNaN(parseInt(e,10))}})(jQuery);/*!
* jQuery hashchange event - v1.3 - 7/21/2010
* http://benalman.com/projects/jquery-hashchange-plugin/
- *
+ *
* Copyright (c) 2010 "Cowboy" Ben Alman
* Dual licensed under the MIT and GPL licenses.
* http://benalman.com/about/license/
*
* Licensed MIT
*/
-(function(a){if(typeof define==="function"&&define.amd){define(["jquery"],a)}else{if(typeof module==="object"&&typeof module.exports==="object"){module.exports=a(require("jquery"))}else{a(jQuery)}}}(function(a){var b=[],e=!!window.createPopup,f=false,d="ontouchstart" in window,h=false,g=window.requestAnimationFrame||function(l){return setTimeout(l,1000/60)},c=window.cancelAnimationFrame||function(l){clearTimeout(l)};function k(m){var n=".smartmenus_mouse";if(!h&&!m){var o=true,l=null;a(document).bind(i([["mousemove",function(s){var t={x:s.pageX,y:s.pageY,timeStamp:new Date().getTime()};if(l){var q=Math.abs(l.x-t.x),p=Math.abs(l.y-t.y);if((q>0||p>0)&&q<=2&&p<=2&&t.timeStamp-l.timeStamp<=300){f=true;if(o){var r=a(s.target).closest("a");if(r.is("a")){a.each(b,function(){if(a.contains(this.$root[0],r[0])){this.itemEnter({currentTarget:r[0]});return false}})}o=false}}}l=t}],[d?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut",function(p){if(j(p.originalEvent)){f=false}}]],n));h=true}else{if(h&&m){a(document).unbind(n);h=false}}}function j(l){return !/^(4|mouse)$/.test(l.pointerType)}function i(l,n){if(!n){n=""}var m={};a.each(l,function(o,p){m[p[0].split(" ").join(n+" ")+n]=p[1]});return m}a.SmartMenus=function(m,l){this.$root=a(m);this.opts=l;this.rootId="";this.accessIdPrefix="";this.$subArrow=null;this.activatedItems=[];this.visibleSubMenus=[];this.showTimeout=0;this.hideTimeout=0;this.scrollTimeout=0;this.clickActivated=false;this.focusActivated=false;this.zIndexInc=0;this.idInc=0;this.$firstLink=null;this.$firstSub=null;this.disabled=false;this.$disableOverlay=null;this.$touchScrollingSub=null;this.cssTransforms3d="perspective" in m.style||"webkitPerspective" in m.style;this.wasCollapsible=false;this.init()};a.extend(a.SmartMenus,{hideAll:function(){a.each(b,function(){this.menuHideAll()})},destroy:function(){while(b.length){b[0].destroy()}k(true)},prototype:{init:function(n){var l=this;if(!n){b.push(this);this.rootId=(new Date().getTime()+Math.random()+"").replace(/\D/g,"");this.accessIdPrefix="sm-"+this.rootId+"-";if(this.$root.hasClass("sm-rtl")){this.opts.rightToLeftSubMenus=true}var r=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).bind(i([["mouseover focusin",a.proxy(this.rootOver,this)],["mouseout focusout",a.proxy(this.rootOut,this)],["keydown",a.proxy(this.rootKeyDown,this)]],r)).delegate("a",i([["mouseenter",a.proxy(this.itemEnter,this)],["mouseleave",a.proxy(this.itemLeave,this)],["mousedown",a.proxy(this.itemDown,this)],["focus",a.proxy(this.itemFocus,this)],["blur",a.proxy(this.itemBlur,this)],["click",a.proxy(this.itemClick,this)]],r));r+=this.rootId;if(this.opts.hideOnClick){a(document).bind(i([["touchstart",a.proxy(this.docTouchStart,this)],["touchmove",a.proxy(this.docTouchMove,this)],["touchend",a.proxy(this.docTouchEnd,this)],["click",a.proxy(this.docClick,this)]],r))}a(window).bind(i([["resize orientationchange",a.proxy(this.winResize,this)]],r));if(this.opts.subIndicators){this.$subArrow=a("<span/>").addClass("sub-arrow");if(this.opts.subIndicatorsText){this.$subArrow.html(this.opts.subIndicatorsText)}}k()}this.$firstSub=this.$root.find("ul").each(function(){l.menuInit(a(this))}).eq(0);this.$firstLink=this.$root.find("a").eq(0);if(this.opts.markCurrentItem){var p=/(index|default)\.[^#\?\/]*/i,m=/#.*/,q=window.location.href.replace(p,""),o=q.replace(m,"");this.$root.find("a").each(function(){var s=this.href.replace(p,""),t=a(this);if(s==q||s==o){t.addClass("current");if(l.opts.markCurrentTree){t.parentsUntil("[data-smartmenus-id]","ul").each(function(){a(this).dataSM("parent-a").addClass("current")})}}})}this.wasCollapsible=this.isCollapsible()},destroy:function(m){if(!m){var n=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").unbind(n).undelegate(n);n+=this.rootId;a(document).unbind(n);a(window).unbind(n);if(this.opts.subIndicators){this.$subArrow=null}}this.menuHideAll();var l=this;this.$root.find("ul").each(function(){var o=a(this);if(o.dataSM("scroll-arrows")){o.dataSM("scroll-arrows").remove()}if(o.dataSM("shown-before")){if(l.opts.subMenusMinWidth||l.opts.subMenusMaxWidth){o.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap")}if(o.dataSM("scroll-arrows")){o.dataSM("scroll-arrows").remove()}o.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})}if((o.attr("id")||"").indexOf(l.accessIdPrefix)==0){o.removeAttr("id")}}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("ie-shim").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded");this.$root.find("a.has-submenu").each(function(){var o=a(this);if(o.attr("id").indexOf(l.accessIdPrefix)==0){o.removeAttr("id")}}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub");if(this.opts.subIndicators){this.$root.find("span.sub-arrow").remove()}if(this.opts.markCurrentItem){this.$root.find("a.current").removeClass("current")}if(!m){this.$root=null;this.$firstLink=null;this.$firstSub=null;if(this.$disableOverlay){this.$disableOverlay.remove();this.$disableOverlay=null}b.splice(a.inArray(this,b),1)}},disable:function(l){if(!this.disabled){this.menuHideAll();if(!l&&!this.opts.isPopup&&this.$root.is(":visible")){var m=this.$root.offset();this.$disableOverlay=a('<div class="sm-jquery-disable-overlay"/>').css({position:"absolute",top:m.top,left:m.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(true),opacity:0}).appendTo(document.body)}this.disabled=true}},docClick:function(l){if(this.$touchScrollingSub){this.$touchScrollingSub=null;return}if(this.visibleSubMenus.length&&!a.contains(this.$root[0],l.target)||a(l.target).is("a")){this.menuHideAll()}},docTouchEnd:function(m){if(!this.lastTouch){return}if(this.visibleSubMenus.length&&(this.lastTouch.x2===undefined||this.lastTouch.x1==this.lastTouch.x2)&&(this.lastTouch.y2===undefined||this.lastTouch.y1==this.lastTouch.y2)&&(!this.lastTouch.target||!a.contains(this.$root[0],this.lastTouch.target))){if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}var l=this;this.hideTimeout=setTimeout(function(){l.menuHideAll()},350)}this.lastTouch=null},docTouchMove:function(m){if(!this.lastTouch){return}var l=m.originalEvent.touches[0];this.lastTouch.x2=l.pageX;this.lastTouch.y2=l.pageY},docTouchStart:function(m){var l=m.originalEvent.touches[0];this.lastTouch={x1:l.pageX,y1:l.pageY,target:l.target}},enable:function(){if(this.disabled){if(this.$disableOverlay){this.$disableOverlay.remove();this.$disableOverlay=null}this.disabled=false}},getClosestMenu:function(m){var l=a(m).closest("ul");while(l.dataSM("in-mega")){l=l.parent().closest("ul")}return l[0]||null},getHeight:function(l){return this.getOffset(l,true)},getOffset:function(n,l){var m;if(n.css("display")=="none"){m={position:n[0].style.position,visibility:n[0].style.visibility};n.css({position:"absolute",visibility:"hidden"}).show()}var o=n[0].getBoundingClientRect&&n[0].getBoundingClientRect(),p=o&&(l?o.height||o.bottom-o.top:o.width||o.right-o.left);if(!p&&p!==0){p=l?n[0].offsetHeight:n[0].offsetWidth}if(m){n.hide().css(m)}return p},getStartZIndex:function(l){var m=parseInt(this[l?"$root":"$firstSub"].css("z-index"));if(!l&&isNaN(m)){m=parseInt(this.$root.css("z-index"))}return !isNaN(m)?m:1},getTouchPoint:function(l){return l.touches&&l.touches[0]||l.changedTouches&&l.changedTouches[0]||l},getViewport:function(l){var m=l?"Height":"Width",o=document.documentElement["client"+m],n=window["inner"+m];if(n){o=Math.min(o,n)}return o},getViewportHeight:function(){return this.getViewport(true)},getViewportWidth:function(){return this.getViewport()},getWidth:function(l){return this.getOffset(l)},handleEvents:function(){return !this.disabled&&this.isCSSOn()},handleItemEvents:function(l){return this.handleEvents()&&!this.isLinkInMegaMenu(l)},isCollapsible:function(){return this.$firstSub.css("position")=="static"},isCSSOn:function(){return this.$firstLink.css("display")=="block"},isFixed:function(){var l=this.$root.css("position")=="fixed";if(!l){this.$root.parentsUntil("body").each(function(){if(a(this).css("position")=="fixed"){l=true;return false}})}return l},isLinkInMegaMenu:function(l){return a(this.getClosestMenu(l[0])).hasClass("mega-menu")},isTouchMode:function(){return !f||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(p,l){var n=p.closest("ul"),q=n.dataSM("level");if(q>1&&(!this.activatedItems[q-2]||this.activatedItems[q-2][0]!=n.dataSM("parent-a")[0])){var m=this;a(n.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(n).each(function(){m.itemActivate(a(this).dataSM("parent-a"))})}if(!this.isCollapsible()||l){this.menuHideSubMenus(!this.activatedItems[q-1]||this.activatedItems[q-1][0]!=p[0]?q-1:q)}this.activatedItems[q-1]=p;if(this.$root.triggerHandler("activate.smapi",p[0])===false){return}var o=p.dataSM("sub");if(o&&(this.isTouchMode()||(!this.opts.showOnClick||this.clickActivated))){this.menuShow(o)}},itemBlur:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}this.$root.triggerHandler("blur.smapi",l[0])},itemClick:function(o){var n=a(o.currentTarget);if(!this.handleItemEvents(n)){return}if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==n.closest("ul")[0]){this.$touchScrollingSub=null;o.stopPropagation();return false}if(this.$root.triggerHandler("click.smapi",n[0])===false){return false}var p=a(o.target).is("span.sub-arrow"),m=n.dataSM("sub"),l=m?m.dataSM("level")==2:false;if(m&&!m.is(":visible")){if(this.opts.showOnClick&&l){this.clickActivated=true}this.itemActivate(n);if(m.is(":visible")){this.focusActivated=true;return false}}else{if(this.isCollapsible()&&p){this.itemActivate(n);this.menuHide(m);return false}}if(this.opts.showOnClick&&l||n.hasClass("disabled")||this.$root.triggerHandler("select.smapi",n[0])===false){return false}},itemDown:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}l.dataSM("mousedown",true)},itemEnter:function(n){var m=a(n.currentTarget);if(!this.handleItemEvents(m)){return}if(!this.isTouchMode()){if(this.showTimeout){clearTimeout(this.showTimeout);this.showTimeout=0}var l=this;this.showTimeout=setTimeout(function(){l.itemActivate(m)},this.opts.showOnClick&&m.closest("ul").dataSM("level")==1?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",m[0])},itemFocus:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}if(this.focusActivated&&(!this.isTouchMode()||!l.dataSM("mousedown"))&&(!this.activatedItems.length||this.activatedItems[this.activatedItems.length-1][0]!=l[0])){this.itemActivate(l,true)}this.$root.triggerHandler("focus.smapi",l[0])},itemLeave:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}if(!this.isTouchMode()){l[0].blur();if(this.showTimeout){clearTimeout(this.showTimeout);this.showTimeout=0}}l.removeDataSM("mousedown");this.$root.triggerHandler("mouseleave.smapi",l[0])},menuHide:function(m){if(this.$root.triggerHandler("beforehide.smapi",m[0])===false){return}m.stop(true,true);if(m.css("display")!="none"){var l=function(){m.css("z-index","")};if(this.isCollapsible()){if(this.opts.collapsibleHideFunction){this.opts.collapsibleHideFunction.call(this,m,l)}else{m.hide(this.opts.collapsibleHideDuration,l)}}else{if(this.opts.hideFunction){this.opts.hideFunction.call(this,m,l)}else{m.hide(this.opts.hideDuration,l)}}if(m.dataSM("ie-shim")){m.dataSM("ie-shim").remove().css({"-webkit-transform":"",transform:""})}if(m.dataSM("scroll")){this.menuScrollStop(m);m.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).unbind(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()}m.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false");m.attr({"aria-expanded":"false","aria-hidden":"true"});var n=m.dataSM("level");this.activatedItems.splice(n-1,1);this.visibleSubMenus.splice(a.inArray(m,this.visibleSubMenus),1);this.$root.triggerHandler("hide.smapi",m[0])}},menuHideAll:function(){if(this.showTimeout){clearTimeout(this.showTimeout);this.showTimeout=0}var m=this.opts.isPopup?1:0;for(var l=this.visibleSubMenus.length-1;l>=m;l--){this.menuHide(this.visibleSubMenus[l])}if(this.opts.isPopup){this.$root.stop(true,true);if(this.$root.is(":visible")){if(this.opts.hideFunction){this.opts.hideFunction.call(this,this.$root)}else{this.$root.hide(this.opts.hideDuration)}if(this.$root.dataSM("ie-shim")){this.$root.dataSM("ie-shim").remove()}}}this.activatedItems=[];this.visibleSubMenus=[];this.clickActivated=false;this.focusActivated=false;this.zIndexInc=0;this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(n){for(var l=this.activatedItems.length-1;l>=n;l--){var m=this.activatedItems[l].dataSM("sub");if(m){this.menuHide(m)}}},menuIframeShim:function(l){if(e&&this.opts.overlapControlsInIE&&!l.dataSM("ie-shim")){l.dataSM("ie-shim",a("<iframe/>").attr({src:"javascript:0",tabindex:-9}).css({position:"absolute",top:"auto",left:"0",opacity:0,border:"0"}))}},menuInit:function(l){if(!l.dataSM("in-mega")){if(l.hasClass("mega-menu")){l.find("ul").dataSM("in-mega",true)}var q=2,m=l[0];while((m=m.parentNode.parentNode)!=this.$root[0]){q++}var n=l.prevAll("a").eq(-1);if(!n.length){n=l.prevAll().find("a").eq(-1)}n.addClass("has-submenu").dataSM("sub",l);l.dataSM("parent-a",n).dataSM("level",q).parent().dataSM("sub",l);var o=n.attr("id")||this.accessIdPrefix+(++this.idInc),p=l.attr("id")||this.accessIdPrefix+(++this.idInc);n.attr({id:o,"aria-haspopup":"true","aria-controls":p,"aria-expanded":"false"});l.attr({id:p,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"});if(this.opts.subIndicators){n[this.opts.subIndicatorsPos](this.$subArrow.clone())}}},menuPosition:function(K){var r=K.dataSM("parent-a"),D=r.closest("li"),E=D.parent(),l=K.dataSM("level"),t=this.getWidth(K),J=this.getHeight(K),u=r.offset(),o=u.left,m=u.top,q=this.getWidth(r),F=this.getHeight(r),H=a(window),v=H.scrollLeft(),s=H.scrollTop(),z=this.getViewportWidth(),L=this.getViewportHeight(),w=E.parent().is("[data-sm-horizontal-sub]")||l==2&&!E.hasClass("sm-vertical"),B=this.opts.rightToLeftSubMenus&&!D.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&D.is("[data-sm-reverse]"),p=l==2?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,n=l==2?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY,C,A;if(w){C=B?q-t-p:p;A=this.opts.bottomToTopSubMenus?-J-n:F+n}else{C=B?p-t:q-p;A=this.opts.bottomToTopSubMenus?F-n-J:n}if(this.opts.keepInViewport){var N=o+C,M=m+A;if(B&&N<v){C=w?v-N+C:q-p}else{if(!B&&N+t>v+z){C=w?v+z-t-N+C:p-t}}if(!w){if(J<L&&M+J>s+L){A+=s+L-J-M}else{if(J>=L||M<s){A+=s-M}}}if(w&&(M+J>s+L+0.49||M<s)||!w&&J>L+0.49){var G=this;if(!K.dataSM("scroll-arrows")){K.dataSM("scroll-arrows",a([a('<span class="scroll-up"><span class="scroll-up-arrow"></span></span>')[0],a('<span class="scroll-down"><span class="scroll-down-arrow"></span></span>')[0]]).bind({mouseenter:function(){K.dataSM("scroll").up=a(this).hasClass("scroll-up");G.menuScroll(K)},mouseleave:function(x){G.menuScrollStop(K);G.menuScrollOut(K,x)},"mousewheel DOMMouseScroll":function(x){x.preventDefault()}}).insertAfter(K))}var I=".smartmenus_scroll";K.dataSM("scroll",{y:this.cssTransforms3d?0:A-F,step:1,itemH:F,subH:J,arrowDownH:this.getHeight(K.dataSM("scroll-arrows").eq(1))}).bind(i([["mouseover",function(x){G.menuScrollOver(K,x)}],["mouseout",function(x){G.menuScrollOut(K,x)}],["mousewheel DOMMouseScroll",function(x){G.menuScrollMousewheel(K,x)}]],I)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:C+(parseInt(K.css("border-left-width"))||0),width:t-(parseInt(K.css("border-left-width"))||0)-(parseInt(K.css("border-right-width"))||0),zIndex:K.css("z-index")}).eq(w&&this.opts.bottomToTopSubMenus?0:1).show();if(this.isFixed()){K.css({"touch-action":"none","-ms-touch-action":"none"}).bind(i([[d?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp",function(x){G.menuScrollTouch(K,x)}]],I))}}}K.css({top:"auto",left:"0",marginLeft:C,marginTop:A-F});this.menuIframeShim(K);if(K.dataSM("ie-shim")){K.dataSM("ie-shim").css({zIndex:K.css("z-index"),width:t,height:J,marginLeft:C,marginTop:A-F})}},menuScroll:function(r,m,n){var p=r.dataSM("scroll"),q=r.dataSM("scroll-arrows"),o=p.up?p.upEnd:p.downEnd,s;if(!m&&p.momentum){p.momentum*=0.92;s=p.momentum;if(s<0.5){this.menuScrollStop(r);return}}else{s=n||(m||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(p.step))}var l=r.dataSM("level");if(this.activatedItems[l-1]&&this.activatedItems[l-1].dataSM("sub")&&this.activatedItems[l-1].dataSM("sub").is(":visible")){this.menuHideSubMenus(l-1)}p.y=p.up&&o<=p.y||!p.up&&o>=p.y?p.y:(Math.abs(o-p.y)>s?p.y+(p.up?s:-s):o);r.add(r.dataSM("ie-shim")).css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+p.y+"px, 0)",transform:"translate3d(0, "+p.y+"px, 0)"}:{marginTop:p.y});if(f&&(p.up&&p.y>p.downEnd||!p.up&&p.y<p.upEnd)){q.eq(p.up?1:0).show()}if(p.y==o){if(f){q.eq(p.up?0:1).hide()}this.menuScrollStop(r)}else{if(!m){if(this.opts.scrollAccelerate&&p.step<this.opts.scrollStep){p.step+=0.2}var t=this;this.scrollTimeout=g(function(){t.menuScroll(r)})}}},menuScrollMousewheel:function(m,n){if(this.getClosestMenu(n.target)==m[0]){n=n.originalEvent;var l=(n.wheelDelta||-n.detail)>0;if(m.dataSM("scroll-arrows").eq(l?0:1).is(":visible")){m.dataSM("scroll").up=l;this.menuScroll(m,true)}}n.preventDefault()},menuScrollOut:function(l,m){if(f){if(!/^scroll-(up|down)/.test((m.relatedTarget||"").className)&&(l[0]!=m.relatedTarget&&!a.contains(l[0],m.relatedTarget)||this.getClosestMenu(m.relatedTarget)!=l[0])){l.dataSM("scroll-arrows").css("visibility","hidden")}}},menuScrollOver:function(n,o){if(f){if(!/^scroll-(up|down)/.test(o.target.className)&&this.getClosestMenu(o.target)==n[0]){this.menuScrollRefreshData(n);var m=n.dataSM("scroll"),l=a(window).scrollTop()-n.dataSM("parent-a").offset().top-m.itemH;n.dataSM("scroll-arrows").eq(0).css("margin-top",l).end().eq(1).css("margin-top",l+this.getViewportHeight()-m.arrowDownH).end().css("visibility","visible")}}},menuScrollRefreshData:function(n){var m=n.dataSM("scroll"),l=a(window).scrollTop()-n.dataSM("parent-a").offset().top-m.itemH;if(this.cssTransforms3d){l=-(parseFloat(n.css("margin-top"))-l)}a.extend(m,{upEnd:l,downEnd:l+this.getViewportHeight()-m.subH})},menuScrollStop:function(l){if(this.scrollTimeout){c(this.scrollTimeout);this.scrollTimeout=0;l.dataSM("scroll").step=1;return true}},menuScrollTouch:function(p,q){q=q.originalEvent;if(j(q)){var m=this.getTouchPoint(q);if(this.getClosestMenu(m.target)==p[0]){var o=p.dataSM("scroll");if(/(start|down)$/i.test(q.type)){if(this.menuScrollStop(p)){q.preventDefault();this.$touchScrollingSub=p}else{this.$touchScrollingSub=null}this.menuScrollRefreshData(p);a.extend(o,{touchStartY:m.pageY,touchStartTime:q.timeStamp})}else{if(/move$/i.test(q.type)){var n=o.touchY!==undefined?o.touchY:o.touchStartY;if(n!==undefined&&n!=m.pageY){this.$touchScrollingSub=p;var l=n<m.pageY;if(o.up!==undefined&&o.up!=l){a.extend(o,{touchStartY:m.pageY,touchStartTime:q.timeStamp})}a.extend(o,{up:l,touchY:m.pageY});this.menuScroll(p,true,Math.abs(m.pageY-n))}q.preventDefault()}else{if(o.touchY!==undefined){if(o.momentum=Math.pow(Math.abs(m.pageY-o.touchStartY)/(q.timeStamp-o.touchStartTime),2)*15){this.menuScrollStop(p);this.menuScroll(p);q.preventDefault()}delete o.touchY}}}}}},menuShow:function(n){if(!n.dataSM("beforefirstshowfired")){n.dataSM("beforefirstshowfired",true);if(this.$root.triggerHandler("beforefirstshow.smapi",n[0])===false){return}}if(this.$root.triggerHandler("beforeshow.smapi",n[0])===false){return}n.dataSM("shown-before",true).stop(true,true);if(!n.is(":visible")){var m=n.dataSM("parent-a");if(this.opts.keepHighlighted||this.isCollapsible()){m.addClass("highlighted")}if(this.isCollapsible()){n.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""})}else{n.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1);if(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth){n.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap");if(this.opts.subMenusMinWidth){n.css("min-width",this.opts.subMenusMinWidth)}if(this.opts.subMenusMaxWidth){var o=this.getWidth(n);n.css("max-width",this.opts.subMenusMaxWidth);if(o>this.getWidth(n)){n.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}}}this.menuPosition(n);if(n.dataSM("ie-shim")){n.dataSM("ie-shim").insertBefore(n)}}var l=function(){n.css("overflow","")};if(this.isCollapsible()){if(this.opts.collapsibleShowFunction){this.opts.collapsibleShowFunction.call(this,n,l)}else{n.show(this.opts.collapsibleShowDuration,l)}}else{if(this.opts.showFunction){this.opts.showFunction.call(this,n,l)}else{n.show(this.opts.showDuration,l)}}m.attr("aria-expanded","true");n.attr({"aria-expanded":"true","aria-hidden":"false"});this.visibleSubMenus.push(n);this.$root.triggerHandler("show.smapi",n[0])}},popupHide:function(l){if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}var m=this;this.hideTimeout=setTimeout(function(){m.menuHideAll()},l?1:this.opts.hideTimeout)},popupShow:function(o,n){if(!this.opts.isPopup){alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.');return}if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}this.$root.dataSM("shown-before",true).stop(true,true);if(!this.$root.is(":visible")){this.$root.css({left:o,top:n});this.menuIframeShim(this.$root);if(this.$root.dataSM("ie-shim")){this.$root.dataSM("ie-shim").css({zIndex:this.$root.css("z-index"),width:this.getWidth(this.$root),height:this.getHeight(this.$root),left:o,top:n}).insertBefore(this.$root)}var m=this,l=function(){m.$root.css("overflow","")};if(this.opts.showFunction){this.opts.showFunction.call(this,this.$root,l)}else{this.$root.show(this.opts.showDuration,l)}this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(true);this.init(true)},rootKeyDown:function(o){if(!this.handleEvents()){return}switch(o.keyCode){case 27:var m=this.activatedItems[0];if(m){this.menuHideAll();m[0].focus();var n=m.dataSM("sub");if(n){this.menuHide(n)}}break;case 32:var l=a(o.target);if(l.is("a")&&this.handleItemEvents(l)){var n=l.dataSM("sub");if(n&&!n.is(":visible")){this.itemClick({currentTarget:o.target});o.preventDefault()}}break}},rootOut:function(m){if(!this.handleEvents()||this.isTouchMode()||m.target==this.$root[0]){return}if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}if(!this.opts.showOnClick||!this.opts.hideOnClick){var l=this;this.hideTimeout=setTimeout(function(){l.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(l){if(!this.handleEvents()||this.isTouchMode()||l.target==this.$root[0]){return}if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}},winResize:function(m){if(!this.handleEvents()){if(this.$disableOverlay){var n=this.$root.offset();this.$disableOverlay.css({top:n.top,left:n.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}return}if(!("onorientationchange" in window)||m.type=="orientationchange"){var l=this.isCollapsible();if(!(this.wasCollapsible&&l)){if(this.activatedItems.length){this.activatedItems[this.activatedItems.length-1][0].blur()}this.menuHideAll()}this.wasCollapsible=l}}}});a.fn.dataSM=function(l,m){if(m){return this.data(l+"_smartmenus",m)}return this.data(l+"_smartmenus")};a.fn.removeDataSM=function(l){return this.removeData(l+"_smartmenus")};a.fn.smartmenus=function(m){if(typeof m=="string"){var l=arguments,o=m;Array.prototype.shift.call(l);return this.each(function(){var p=a(this).data("smartmenus");if(p&&p[o]){p[o].apply(p,l)}})}var n=a.extend({},a.fn.smartmenus.defaults,m);return this.each(function(){new a.SmartMenus(this,n)})};a.fn.smartmenus.defaults={isPopup:false,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:true,subIndicatorsPos:"prepend",subIndicatorsText:"+",scrollStep:30,scrollAccelerate:true,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(m,l){m.fadeOut(200,l)},collapsibleShowDuration:0,collapsibleShowFunction:function(m,l){m.slideDown(200,l)},collapsibleHideDuration:0,collapsibleHideFunction:function(m,l){m.slideUp(200,l)},showOnClick:false,hideOnClick:true,noMouseOver:false,keepInViewport:true,keepHighlighted:true,markCurrentItem:false,markCurrentTree:true,rightToLeftSubMenus:false,bottomToTopSubMenus:false,overlapControlsInIE:true};return a}));
\ No newline at end of file
+(function(a){if(typeof define==="function"&&define.amd){define(["jquery"],a)}else{if(typeof module==="object"&&typeof module.exports==="object"){module.exports=a(require("jquery"))}else{a(jQuery)}}}(function(a){var b=[],e=!!window.createPopup,f=false,d="ontouchstart" in window,h=false,g=window.requestAnimationFrame||function(l){return setTimeout(l,1000/60)},c=window.cancelAnimationFrame||function(l){clearTimeout(l)};function k(m){var n=".smartmenus_mouse";if(!h&&!m){var o=true,l=null;a(document).bind(i([["mousemove",function(s){var t={x:s.pageX,y:s.pageY,timeStamp:new Date().getTime()};if(l){var q=Math.abs(l.x-t.x),p=Math.abs(l.y-t.y);if((q>0||p>0)&&q<=2&&p<=2&&t.timeStamp-l.timeStamp<=300){f=true;if(o){var r=a(s.target).closest("a");if(r.is("a")){a.each(b,function(){if(a.contains(this.$root[0],r[0])){this.itemEnter({currentTarget:r[0]});return false}})}o=false}}}l=t}],[d?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut",function(p){if(j(p.originalEvent)){f=false}}]],n));h=true}else{if(h&&m){a(document).unbind(n);h=false}}}function j(l){return !/^(4|mouse)$/.test(l.pointerType)}function i(l,n){if(!n){n=""}var m={};a.each(l,function(o,p){m[p[0].split(" ").join(n+" ")+n]=p[1]});return m}a.SmartMenus=function(m,l){this.$root=a(m);this.opts=l;this.rootId="";this.accessIdPrefix="";this.$subArrow=null;this.activatedItems=[];this.visibleSubMenus=[];this.showTimeout=0;this.hideTimeout=0;this.scrollTimeout=0;this.clickActivated=false;this.focusActivated=false;this.zIndexInc=0;this.idInc=0;this.$firstLink=null;this.$firstSub=null;this.disabled=false;this.$disableOverlay=null;this.$touchScrollingSub=null;this.cssTransforms3d="perspective" in m.style||"webkitPerspective" in m.style;this.wasCollapsible=false;this.init()};a.extend(a.SmartMenus,{hideAll:function(){a.each(b,function(){this.menuHideAll()})},destroy:function(){while(b.length){b[0].destroy()}k(true)},prototype:{init:function(n){var l=this;if(!n){b.push(this);this.rootId=(new Date().getTime()+Math.random()+"").replace(/\D/g,"");this.accessIdPrefix="sm-"+this.rootId+"-";if(this.$root.hasClass("sm-rtl")){this.opts.rightToLeftSubMenus=true}var r=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).bind(i([["mouseover focusin",a.proxy(this.rootOver,this)],["mouseout focusout",a.proxy(this.rootOut,this)],["keydown",a.proxy(this.rootKeyDown,this)]],r)).delegate("a",i([["mouseenter",a.proxy(this.itemEnter,this)],["mouseleave",a.proxy(this.itemLeave,this)],["mousedown",a.proxy(this.itemDown,this)],["focus",a.proxy(this.itemFocus,this)],["blur",a.proxy(this.itemBlur,this)],["click",a.proxy(this.itemClick,this)]],r));r+=this.rootId;if(this.opts.hideOnClick){a(document).bind(i([["touchstart",a.proxy(this.docTouchStart,this)],["touchmove",a.proxy(this.docTouchMove,this)],["touchend",a.proxy(this.docTouchEnd,this)],["click",a.proxy(this.docClick,this)]],r))}a(window).bind(i([["resize orientationchange",a.proxy(this.winResize,this)]],r));if(this.opts.subIndicators){this.$subArrow=a("<span/>").addClass("sub-arrow");if(this.opts.subIndicatorsText){this.$subArrow.html(this.opts.subIndicatorsText)}}k()}this.$firstSub=this.$root.find("ul").each(function(){l.menuInit(a(this))}).eq(0);this.$firstLink=this.$root.find("a").eq(0);if(this.opts.markCurrentItem){var p=/(index|default)\.[^#\?\/]*/i,m=/#.*/,q=window.location.href.replace(p,""),o=q.replace(m,"");this.$root.find("a").each(function(){var s=this.href.replace(p,""),t=a(this);if(s==q||s==o){t.addClass("current");if(l.opts.markCurrentTree){t.parentsUntil("[data-smartmenus-id]","ul").each(function(){a(this).dataSM("parent-a").addClass("current")})}}})}this.wasCollapsible=this.isCollapsible()},destroy:function(m){if(!m){var n=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").unbind(n).undelegate(n);n+=this.rootId;a(document).unbind(n);a(window).unbind(n);if(this.opts.subIndicators){this.$subArrow=null}}this.menuHideAll();var l=this;this.$root.find("ul").each(function(){var o=a(this);if(o.dataSM("scroll-arrows")){o.dataSM("scroll-arrows").remove()}if(o.dataSM("shown-before")){if(l.opts.subMenusMinWidth||l.opts.subMenusMaxWidth){o.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap")}if(o.dataSM("scroll-arrows")){o.dataSM("scroll-arrows").remove()}o.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})}if((o.attr("id")||"").indexOf(l.accessIdPrefix)==0){o.removeAttr("id")}}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("ie-shim").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded");this.$root.find("a.has-submenu").each(function(){var o=a(this);if(o.attr("id").indexOf(l.accessIdPrefix)==0){o.removeAttr("id")}}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub");if(this.opts.subIndicators){this.$root.find("span.sub-arrow").remove()}if(this.opts.markCurrentItem){this.$root.find("a.current").removeClass("current")}if(!m){this.$root=null;this.$firstLink=null;this.$firstSub=null;if(this.$disableOverlay){this.$disableOverlay.remove();this.$disableOverlay=null}b.splice(a.inArray(this,b),1)}},disable:function(l){if(!this.disabled){this.menuHideAll();if(!l&&!this.opts.isPopup&&this.$root.is(":visible")){var m=this.$root.offset();this.$disableOverlay=a('<div class="sm-jquery-disable-overlay"/>').css({position:"absolute",top:m.top,left:m.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(true),opacity:0}).appendTo(document.body)}this.disabled=true}},docClick:function(l){if(this.$touchScrollingSub){this.$touchScrollingSub=null;return}if(this.visibleSubMenus.length&&!a.contains(this.$root[0],l.target)||a(l.target).is("a")){this.menuHideAll()}},docTouchEnd:function(m){if(!this.lastTouch){return}if(this.visibleSubMenus.length&&(this.lastTouch.x2===undefined||this.lastTouch.x1==this.lastTouch.x2)&&(this.lastTouch.y2===undefined||this.lastTouch.y1==this.lastTouch.y2)&&(!this.lastTouch.target||!a.contains(this.$root[0],this.lastTouch.target))){if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}var l=this;this.hideTimeout=setTimeout(function(){l.menuHideAll()},350)}this.lastTouch=null},docTouchMove:function(m){if(!this.lastTouch){return}var l=m.originalEvent.touches[0];this.lastTouch.x2=l.pageX;this.lastTouch.y2=l.pageY},docTouchStart:function(m){var l=m.originalEvent.touches[0];this.lastTouch={x1:l.pageX,y1:l.pageY,target:l.target}},enable:function(){if(this.disabled){if(this.$disableOverlay){this.$disableOverlay.remove();this.$disableOverlay=null}this.disabled=false}},getClosestMenu:function(m){var l=a(m).closest("ul");while(l.dataSM("in-mega")){l=l.parent().closest("ul")}return l[0]||null},getHeight:function(l){return this.getOffset(l,true)},getOffset:function(n,l){var m;if(n.css("display")=="none"){m={position:n[0].style.position,visibility:n[0].style.visibility};n.css({position:"absolute",visibility:"hidden"}).show()}var o=n[0].getBoundingClientRect&&n[0].getBoundingClientRect(),p=o&&(l?o.height||o.bottom-o.top:o.width||o.right-o.left);if(!p&&p!==0){p=l?n[0].offsetHeight:n[0].offsetWidth}if(m){n.hide().css(m)}return p},getStartZIndex:function(l){var m=parseInt(this[l?"$root":"$firstSub"].css("z-index"));if(!l&&isNaN(m)){m=parseInt(this.$root.css("z-index"))}return !isNaN(m)?m:1},getTouchPoint:function(l){return l.touches&&l.touches[0]||l.changedTouches&&l.changedTouches[0]||l},getViewport:function(l){var m=l?"Height":"Width",o=document.documentElement["client"+m],n=window["inner"+m];if(n){o=Math.min(o,n)}return o},getViewportHeight:function(){return this.getViewport(true)},getViewportWidth:function(){return this.getViewport()},getWidth:function(l){return this.getOffset(l)},handleEvents:function(){return !this.disabled&&this.isCSSOn()},handleItemEvents:function(l){return this.handleEvents()&&!this.isLinkInMegaMenu(l)},isCollapsible:function(){return this.$firstSub.css("position")=="static"},isCSSOn:function(){return this.$firstLink.css("display")=="block"},isFixed:function(){var l=this.$root.css("position")=="fixed";if(!l){this.$root.parentsUntil("body").each(function(){if(a(this).css("position")=="fixed"){l=true;return false}})}return l},isLinkInMegaMenu:function(l){return a(this.getClosestMenu(l[0])).hasClass("mega-menu")},isTouchMode:function(){return !f||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(p,l){var n=p.closest("ul"),q=n.dataSM("level");if(q>1&&(!this.activatedItems[q-2]||this.activatedItems[q-2][0]!=n.dataSM("parent-a")[0])){var m=this;a(n.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(n).each(function(){m.itemActivate(a(this).dataSM("parent-a"))})}if(!this.isCollapsible()||l){this.menuHideSubMenus(!this.activatedItems[q-1]||this.activatedItems[q-1][0]!=p[0]?q-1:q)}this.activatedItems[q-1]=p;if(this.$root.triggerHandler("activate.smapi",p[0])===false){return}var o=p.dataSM("sub");if(o&&(this.isTouchMode()||(!this.opts.showOnClick||this.clickActivated))){this.menuShow(o)}},itemBlur:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}this.$root.triggerHandler("blur.smapi",l[0])},itemClick:function(o){var n=a(o.currentTarget);if(!this.handleItemEvents(n)){return}if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==n.closest("ul")[0]){this.$touchScrollingSub=null;o.stopPropagation();return false}if(this.$root.triggerHandler("click.smapi",n[0])===false){return false}var p=a(o.target).is("span.sub-arrow"),m=n.dataSM("sub"),l=m?m.dataSM("level")==2:false;if(m&&!m.is(":visible")){if(this.opts.showOnClick&&l){this.clickActivated=true}this.itemActivate(n);if(m.is(":visible")){this.focusActivated=true;return false}}else{if(this.isCollapsible()&&p){this.itemActivate(n);this.menuHide(m);return false}}if(this.opts.showOnClick&&l||n.hasClass("disabled")||this.$root.triggerHandler("select.smapi",n[0])===false){return false}},itemDown:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}l.dataSM("mousedown",true)},itemEnter:function(n){var m=a(n.currentTarget);if(!this.handleItemEvents(m)){return}if(!this.isTouchMode()){if(this.showTimeout){clearTimeout(this.showTimeout);this.showTimeout=0}var l=this;this.showTimeout=setTimeout(function(){l.itemActivate(m)},this.opts.showOnClick&&m.closest("ul").dataSM("level")==1?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",m[0])},itemFocus:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}if(this.focusActivated&&(!this.isTouchMode()||!l.dataSM("mousedown"))&&(!this.activatedItems.length||this.activatedItems[this.activatedItems.length-1][0]!=l[0])){this.itemActivate(l,true)}this.$root.triggerHandler("focus.smapi",l[0])},itemLeave:function(m){var l=a(m.currentTarget);if(!this.handleItemEvents(l)){return}if(!this.isTouchMode()){l[0].blur();if(this.showTimeout){clearTimeout(this.showTimeout);this.showTimeout=0}}l.removeDataSM("mousedown");this.$root.triggerHandler("mouseleave.smapi",l[0])},menuHide:function(m){if(this.$root.triggerHandler("beforehide.smapi",m[0])===false){return}m.stop(true,true);if(m.css("display")!="none"){var l=function(){m.css("z-index","")};if(this.isCollapsible()){if(this.opts.collapsibleHideFunction){this.opts.collapsibleHideFunction.call(this,m,l)}else{m.hide(this.opts.collapsibleHideDuration,l)}}else{if(this.opts.hideFunction){this.opts.hideFunction.call(this,m,l)}else{m.hide(this.opts.hideDuration,l)}}if(m.dataSM("ie-shim")){m.dataSM("ie-shim").remove().css({"-webkit-transform":"",transform:""})}if(m.dataSM("scroll")){this.menuScrollStop(m);m.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).unbind(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()}m.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false");m.attr({"aria-expanded":"false","aria-hidden":"true"});var n=m.dataSM("level");this.activatedItems.splice(n-1,1);this.visibleSubMenus.splice(a.inArray(m,this.visibleSubMenus),1);this.$root.triggerHandler("hide.smapi",m[0])}},menuHideAll:function(){if(this.showTimeout){clearTimeout(this.showTimeout);this.showTimeout=0}var m=this.opts.isPopup?1:0;for(var l=this.visibleSubMenus.length-1;l>=m;l--){this.menuHide(this.visibleSubMenus[l])}if(this.opts.isPopup){this.$root.stop(true,true);if(this.$root.is(":visible")){if(this.opts.hideFunction){this.opts.hideFunction.call(this,this.$root)}else{this.$root.hide(this.opts.hideDuration)}if(this.$root.dataSM("ie-shim")){this.$root.dataSM("ie-shim").remove()}}}this.activatedItems=[];this.visibleSubMenus=[];this.clickActivated=false;this.focusActivated=false;this.zIndexInc=0;this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(n){for(var l=this.activatedItems.length-1;l>=n;l--){var m=this.activatedItems[l].dataSM("sub");if(m){this.menuHide(m)}}},menuIframeShim:function(l){if(e&&this.opts.overlapControlsInIE&&!l.dataSM("ie-shim")){l.dataSM("ie-shim",a("<iframe/>").attr({src:"javascript:0",tabindex:-9}).css({position:"absolute",top:"auto",left:"0",opacity:0,border:"0"}))}},menuInit:function(l){if(!l.dataSM("in-mega")){if(l.hasClass("mega-menu")){l.find("ul").dataSM("in-mega",true)}var q=2,m=l[0];while((m=m.parentNode.parentNode)!=this.$root[0]){q++}var n=l.prevAll("a").eq(-1);if(!n.length){n=l.prevAll().find("a").eq(-1)}n.addClass("has-submenu").dataSM("sub",l);l.dataSM("parent-a",n).dataSM("level",q).parent().dataSM("sub",l);var o=n.attr("id")||this.accessIdPrefix+(++this.idInc),p=l.attr("id")||this.accessIdPrefix+(++this.idInc);n.attr({id:o,"aria-haspopup":"true","aria-controls":p,"aria-expanded":"false"});l.attr({id:p,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"});if(this.opts.subIndicators){n[this.opts.subIndicatorsPos](this.$subArrow.clone())}}},menuPosition:function(K){var r=K.dataSM("parent-a"),D=r.closest("li"),E=D.parent(),l=K.dataSM("level"),t=this.getWidth(K),J=this.getHeight(K),u=r.offset(),o=u.left,m=u.top,q=this.getWidth(r),F=this.getHeight(r),H=a(window),v=H.scrollLeft(),s=H.scrollTop(),z=this.getViewportWidth(),L=this.getViewportHeight(),w=E.parent().is("[data-sm-horizontal-sub]")||l==2&&!E.hasClass("sm-vertical"),B=this.opts.rightToLeftSubMenus&&!D.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&D.is("[data-sm-reverse]"),p=l==2?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,n=l==2?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY,C,A;if(w){C=B?q-t-p:p;A=this.opts.bottomToTopSubMenus?-J-n:F+n}else{C=B?p-t:q-p;A=this.opts.bottomToTopSubMenus?F-n-J:n}if(this.opts.keepInViewport){var N=o+C,M=m+A;if(B&&N<v){C=w?v-N+C:q-p}else{if(!B&&N+t>v+z){C=w?v+z-t-N+C:p-t}}if(!w){if(J<L&&M+J>s+L){A+=s+L-J-M}else{if(J>=L||M<s){A+=s-M}}}if(w&&(M+J>s+L+0.49||M<s)||!w&&J>L+0.49){var G=this;if(!K.dataSM("scroll-arrows")){K.dataSM("scroll-arrows",a([a('<span class="scroll-up"><span class="scroll-up-arrow"></span></span>')[0],a('<span class="scroll-down"><span class="scroll-down-arrow"></span></span>')[0]]).bind({mouseenter:function(){K.dataSM("scroll").up=a(this).hasClass("scroll-up");G.menuScroll(K)},mouseleave:function(x){G.menuScrollStop(K);G.menuScrollOut(K,x)},"mousewheel DOMMouseScroll":function(x){x.preventDefault()}}).insertAfter(K))}var I=".smartmenus_scroll";K.dataSM("scroll",{y:this.cssTransforms3d?0:A-F,step:1,itemH:F,subH:J,arrowDownH:this.getHeight(K.dataSM("scroll-arrows").eq(1))}).bind(i([["mouseover",function(x){G.menuScrollOver(K,x)}],["mouseout",function(x){G.menuScrollOut(K,x)}],["mousewheel DOMMouseScroll",function(x){G.menuScrollMousewheel(K,x)}]],I)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:C+(parseInt(K.css("border-left-width"))||0),width:t-(parseInt(K.css("border-left-width"))||0)-(parseInt(K.css("border-right-width"))||0),zIndex:K.css("z-index")}).eq(w&&this.opts.bottomToTopSubMenus?0:1).show();if(this.isFixed()){K.css({"touch-action":"none","-ms-touch-action":"none"}).bind(i([[d?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp",function(x){G.menuScrollTouch(K,x)}]],I))}}}K.css({top:"auto",left:"0",marginLeft:C,marginTop:A-F});this.menuIframeShim(K);if(K.dataSM("ie-shim")){K.dataSM("ie-shim").css({zIndex:K.css("z-index"),width:t,height:J,marginLeft:C,marginTop:A-F})}},menuScroll:function(r,m,n){var p=r.dataSM("scroll"),q=r.dataSM("scroll-arrows"),o=p.up?p.upEnd:p.downEnd,s;if(!m&&p.momentum){p.momentum*=0.92;s=p.momentum;if(s<0.5){this.menuScrollStop(r);return}}else{s=n||(m||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(p.step))}var l=r.dataSM("level");if(this.activatedItems[l-1]&&this.activatedItems[l-1].dataSM("sub")&&this.activatedItems[l-1].dataSM("sub").is(":visible")){this.menuHideSubMenus(l-1)}p.y=p.up&&o<=p.y||!p.up&&o>=p.y?p.y:(Math.abs(o-p.y)>s?p.y+(p.up?s:-s):o);r.add(r.dataSM("ie-shim")).css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+p.y+"px, 0)",transform:"translate3d(0, "+p.y+"px, 0)"}:{marginTop:p.y});if(f&&(p.up&&p.y>p.downEnd||!p.up&&p.y<p.upEnd)){q.eq(p.up?1:0).show()}if(p.y==o){if(f){q.eq(p.up?0:1).hide()}this.menuScrollStop(r)}else{if(!m){if(this.opts.scrollAccelerate&&p.step<this.opts.scrollStep){p.step+=0.2}var t=this;this.scrollTimeout=g(function(){t.menuScroll(r)})}}},menuScrollMousewheel:function(m,n){if(this.getClosestMenu(n.target)==m[0]){n=n.originalEvent;var l=(n.wheelDelta||-n.detail)>0;if(m.dataSM("scroll-arrows").eq(l?0:1).is(":visible")){m.dataSM("scroll").up=l;this.menuScroll(m,true)}}n.preventDefault()},menuScrollOut:function(l,m){if(f){if(!/^scroll-(up|down)/.test((m.relatedTarget||"").className)&&(l[0]!=m.relatedTarget&&!a.contains(l[0],m.relatedTarget)||this.getClosestMenu(m.relatedTarget)!=l[0])){l.dataSM("scroll-arrows").css("visibility","hidden")}}},menuScrollOver:function(n,o){if(f){if(!/^scroll-(up|down)/.test(o.target.className)&&this.getClosestMenu(o.target)==n[0]){this.menuScrollRefreshData(n);var m=n.dataSM("scroll"),l=a(window).scrollTop()-n.dataSM("parent-a").offset().top-m.itemH;n.dataSM("scroll-arrows").eq(0).css("margin-top",l).end().eq(1).css("margin-top",l+this.getViewportHeight()-m.arrowDownH).end().css("visibility","visible")}}},menuScrollRefreshData:function(n){var m=n.dataSM("scroll"),l=a(window).scrollTop()-n.dataSM("parent-a").offset().top-m.itemH;if(this.cssTransforms3d){l=-(parseFloat(n.css("margin-top"))-l)}a.extend(m,{upEnd:l,downEnd:l+this.getViewportHeight()-m.subH})},menuScrollStop:function(l){if(this.scrollTimeout){c(this.scrollTimeout);this.scrollTimeout=0;l.dataSM("scroll").step=1;return true}},menuScrollTouch:function(p,q){q=q.originalEvent;if(j(q)){var m=this.getTouchPoint(q);if(this.getClosestMenu(m.target)==p[0]){var o=p.dataSM("scroll");if(/(start|down)$/i.test(q.type)){if(this.menuScrollStop(p)){q.preventDefault();this.$touchScrollingSub=p}else{this.$touchScrollingSub=null}this.menuScrollRefreshData(p);a.extend(o,{touchStartY:m.pageY,touchStartTime:q.timeStamp})}else{if(/move$/i.test(q.type)){var n=o.touchY!==undefined?o.touchY:o.touchStartY;if(n!==undefined&&n!=m.pageY){this.$touchScrollingSub=p;var l=n<m.pageY;if(o.up!==undefined&&o.up!=l){a.extend(o,{touchStartY:m.pageY,touchStartTime:q.timeStamp})}a.extend(o,{up:l,touchY:m.pageY});this.menuScroll(p,true,Math.abs(m.pageY-n))}q.preventDefault()}else{if(o.touchY!==undefined){if(o.momentum=Math.pow(Math.abs(m.pageY-o.touchStartY)/(q.timeStamp-o.touchStartTime),2)*15){this.menuScrollStop(p);this.menuScroll(p);q.preventDefault()}delete o.touchY}}}}}},menuShow:function(n){if(!n.dataSM("beforefirstshowfired")){n.dataSM("beforefirstshowfired",true);if(this.$root.triggerHandler("beforefirstshow.smapi",n[0])===false){return}}if(this.$root.triggerHandler("beforeshow.smapi",n[0])===false){return}n.dataSM("shown-before",true).stop(true,true);if(!n.is(":visible")){var m=n.dataSM("parent-a");if(this.opts.keepHighlighted||this.isCollapsible()){m.addClass("highlighted")}if(this.isCollapsible()){n.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""})}else{n.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1);if(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth){n.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap");if(this.opts.subMenusMinWidth){n.css("min-width",this.opts.subMenusMinWidth)}if(this.opts.subMenusMaxWidth){var o=this.getWidth(n);n.css("max-width",this.opts.subMenusMaxWidth);if(o>this.getWidth(n)){n.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}}}this.menuPosition(n);if(n.dataSM("ie-shim")){n.dataSM("ie-shim").insertBefore(n)}}var l=function(){n.css("overflow","")};if(this.isCollapsible()){if(this.opts.collapsibleShowFunction){this.opts.collapsibleShowFunction.call(this,n,l)}else{n.show(this.opts.collapsibleShowDuration,l)}}else{if(this.opts.showFunction){this.opts.showFunction.call(this,n,l)}else{n.show(this.opts.showDuration,l)}}m.attr("aria-expanded","true");n.attr({"aria-expanded":"true","aria-hidden":"false"});this.visibleSubMenus.push(n);this.$root.triggerHandler("show.smapi",n[0])}},popupHide:function(l){if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}var m=this;this.hideTimeout=setTimeout(function(){m.menuHideAll()},l?1:this.opts.hideTimeout)},popupShow:function(o,n){if(!this.opts.isPopup){alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.');return}if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}this.$root.dataSM("shown-before",true).stop(true,true);if(!this.$root.is(":visible")){this.$root.css({left:o,top:n});this.menuIframeShim(this.$root);if(this.$root.dataSM("ie-shim")){this.$root.dataSM("ie-shim").css({zIndex:this.$root.css("z-index"),width:this.getWidth(this.$root),height:this.getHeight(this.$root),left:o,top:n}).insertBefore(this.$root)}var m=this,l=function(){m.$root.css("overflow","")};if(this.opts.showFunction){this.opts.showFunction.call(this,this.$root,l)}else{this.$root.show(this.opts.showDuration,l)}this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(true);this.init(true)},rootKeyDown:function(o){if(!this.handleEvents()){return}switch(o.keyCode){case 27:var m=this.activatedItems[0];if(m){this.menuHideAll();m[0].focus();var n=m.dataSM("sub");if(n){this.menuHide(n)}}break;case 32:var l=a(o.target);if(l.is("a")&&this.handleItemEvents(l)){var n=l.dataSM("sub");if(n&&!n.is(":visible")){this.itemClick({currentTarget:o.target});o.preventDefault()}}break}},rootOut:function(m){if(!this.handleEvents()||this.isTouchMode()||m.target==this.$root[0]){return}if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}if(!this.opts.showOnClick||!this.opts.hideOnClick){var l=this;this.hideTimeout=setTimeout(function(){l.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(l){if(!this.handleEvents()||this.isTouchMode()||l.target==this.$root[0]){return}if(this.hideTimeout){clearTimeout(this.hideTimeout);this.hideTimeout=0}},winResize:function(m){if(!this.handleEvents()){if(this.$disableOverlay){var n=this.$root.offset();this.$disableOverlay.css({top:n.top,left:n.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}return}if(!("onorientationchange" in window)||m.type=="orientationchange"){var l=this.isCollapsible();if(!(this.wasCollapsible&&l)){if(this.activatedItems.length){this.activatedItems[this.activatedItems.length-1][0].blur()}this.menuHideAll()}this.wasCollapsible=l}}}});a.fn.dataSM=function(l,m){if(m){return this.data(l+"_smartmenus",m)}return this.data(l+"_smartmenus")};a.fn.removeDataSM=function(l){return this.removeData(l+"_smartmenus")};a.fn.smartmenus=function(m){if(typeof m=="string"){var l=arguments,o=m;Array.prototype.shift.call(l);return this.each(function(){var p=a(this).data("smartmenus");if(p&&p[o]){p[o].apply(p,l)}})}var n=a.extend({},a.fn.smartmenus.defaults,m);return this.each(function(){new a.SmartMenus(this,n)})};a.fn.smartmenus.defaults={isPopup:false,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:true,subIndicatorsPos:"prepend",subIndicatorsText:"+",scrollStep:30,scrollAccelerate:true,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(m,l){m.fadeOut(200,l)},collapsibleShowDuration:0,collapsibleShowFunction:function(m,l){m.slideDown(200,l)},collapsibleHideDuration:0,collapsibleHideFunction:function(m,l){m.slideUp(200,l)},showOnClick:false,hideOnClick:true,noMouseOver:false,keepInViewport:true,keepHighlighted:true,markCurrentItem:false,markCurrentTree:true,rightToLeftSubMenus:false,bottomToTopSubMenus:false,overlapControlsInIE:true};return a}));
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
function initMenu(relPath,searchEnabled,serverSide,searchPage,search) {
function makeTree(data,relPath) {
var result='';
}
$('#main-menu').smartmenus();
}
+/* @license-end */
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
var navTreeSubIndices = new Array();
var arrowDown = '▼';
-var arrowRight = '►';
+var arrowRight = '▶';
function getData(varName)
{
}
}
}
- head.appendChild(script);
+ head.appendChild(script);
}
function createIndent(o,domNode,node,level)
}
})
}
-
+/* @license-end */
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
function initResizable()
{
var cookie_namespace = 'doxygen';
$(".ui-resizable-handle").dblclick(collapseExpand);
$(window).load(resizeHeight);
}
-
-
+/* @license-end */
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
function convertToId(search)
{
var result = '';
}
searchBox.OnSelectItem(0);
}
-
+/* @license-end */
--- /dev/null
+/*---------------- Search Box */
+
+#FSearchBox {
+ float: left;
+}
+
+#MSearchBox {
+ white-space : nowrap;
+ position: absolute;
+ float: none;
+ display: inline;
+ margin-top: 8px;
+ right: 0px;
+ width: 170px;
+ z-index: 102;
+ background-color: white;
+}
+
+#MSearchBox .left
+{
+ display:block;
+ position:absolute;
+ left:10px;
+ width:20px;
+ height:19px;
+ background:url('search_l.png') no-repeat;
+ background-position:right;
+}
+
+#MSearchSelect {
+ display:block;
+ position:absolute;
+ width:20px;
+ height:19px;
+}
+
+.left #MSearchSelect {
+ left:4px;
+}
+
+.right #MSearchSelect {
+ right:5px;
+}
+
+#MSearchField {
+ display:block;
+ position:absolute;
+ height:19px;
+ background:url('search_m.png') repeat-x;
+ border:none;
+ width:111px;
+ margin-left:20px;
+ padding-left:4px;
+ color: #909090;
+ outline: none;
+ font: 9pt Arial, Verdana, sans-serif;
+}
+
+#FSearchBox #MSearchField {
+ margin-left:15px;
+}
+
+#MSearchBox .right {
+ display:block;
+ position:absolute;
+ right:10px;
+ top:0px;
+ width:20px;
+ height:19px;
+ background:url('search_r.png') no-repeat;
+ background-position:left;
+}
+
+#MSearchClose {
+ display: none;
+ position: absolute;
+ top: 4px;
+ background : none;
+ border: none;
+ margin: 0px 4px 0px 0px;
+ padding: 0px 0px;
+ outline: none;
+}
+
+.left #MSearchClose {
+ left: 6px;
+}
+
+.right #MSearchClose {
+ right: 2px;
+}
+
+.MSearchBoxActive #MSearchField {
+ color: #000000;
+}
+
+/*---------------- Search filter selection */
+
+#MSearchSelectWindow {
+ display: none;
+ position: absolute;
+ left: 0; top: 0;
+ border: 1px solid ##A0;
+ background-color: ##FA;
+ z-index: 1;
+ padding-top: 4px;
+ padding-bottom: 4px;
+ -moz-border-radius: 4px;
+ -webkit-border-top-left-radius: 4px;
+ -webkit-border-top-right-radius: 4px;
+ -webkit-border-bottom-left-radius: 4px;
+ -webkit-border-bottom-right-radius: 4px;
+ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+.SelectItem {
+ font: 8pt Arial, Verdana, sans-serif;
+ padding-left: 2px;
+ padding-right: 12px;
+ border: 0px;
+}
+
+span.SelectionMark {
+ margin-right: 4px;
+ font-family: monospace;
+ outline-style: none;
+ text-decoration: none;
+}
+
+a.SelectItem {
+ display: block;
+ outline-style: none;
+ color: #000000;
+ text-decoration: none;
+ padding-left: 6px;
+ padding-right: 12px;
+}
+
+a.SelectItem:focus,
+a.SelectItem:active {
+ color: #000000;
+ outline-style: none;
+ text-decoration: none;
+}
+
+a.SelectItem:hover {
+ color: #FFFFFF;
+ background-color: ##50;
+ outline-style: none;
+ text-decoration: none;
+ cursor: pointer;
+ display: block;
+}
+
+/*---------------- Search results window */
+
+iframe#MSearchResults {
+ width: 60ex;
+ height: 15em;
+}
+
+#MSearchResultsWindow {
+ display: none;
+ position: absolute;
+ left: 0; top: 0;
+ border: 1px solid #000;
+ background-color: ##F0;
+}
+
+/* ----------------------------------- */
+
+
+#SRIndex {
+ clear:both;
+ padding-bottom: 15px;
+}
+
+.SREntry {
+ font-size: 10pt;
+ padding-left: 1ex;
+}
+
+.SRPage .SREntry {
+ font-size: 8pt;
+ padding: 1px 5px;
+}
+
+body.SRPage {
+ margin: 5px 2px;
+}
+
+.SRChildren {
+ padding-left: 3ex; padding-bottom: .5em
+}
+
+.SRPage .SRChildren {
+ display: none;
+}
+
+.SRSymbol {
+ font-weight: bold;
+ color: ##58;
+ font-family: Arial, Verdana, sans-serif;
+ text-decoration: none;
+ outline: none;
+}
+
+a.SRScope {
+ display: block;
+ color: ##58;
+ font-family: Arial, Verdana, sans-serif;
+ text-decoration: none;
+ outline: none;
+}
+
+a.SRSymbol:focus, a.SRSymbol:active,
+a.SRScope:focus, a.SRScope:active {
+ text-decoration: underline;
+}
+
+span.SRScope {
+ padding-left: 4px;
+}
+
+.SRPage .SRStatus {
+ padding: 2px 5px;
+ font-size: 8pt;
+ font-style: italic;
+}
+
+.SRResult {
+ display: none;
+}
+
+DIV.searchresults {
+ margin-left: 10px;
+ margin-right: 10px;
+}
+
+/*---------------- External search page results */
+
+.searchresult {
+ background-color: ##F2;
+}
+
+.pages b {
+ color: white;
+ padding: 5px 5px 3px 5px;
+ background-image: url("../tab_a.png");
+ background-repeat: repeat-x;
+ text-shadow: 0 1px 1px #000000;
+}
+
+.pages {
+ line-height: 17px;
+ margin-left: 4px;
+ text-decoration: none;
+}
+
+.hl {
+ font-weight: bold;
+}
+
+#searchresults {
+ margin-bottom: 20px;
+}
+
+.searchpages {
+ margin-top: 10px;
+}
+
+/*
+ @licstart The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ 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.
+
+ @licend The above is the entire license notice
+ for the JavaScript code in this file
+ */
/**
* The code below is based on SVGPan Library 1.2 and was modified for doxygen
* to support both zooming and panning via the mouse and via embedded bottons.
* This code is licensed under the following BSD license:
*
* Copyright 2009-2010 Andrea Leofreddi <a.leofreddi@itcharm.com>. All rights reserved.
- *
+ *
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
- *
+ *
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
- *
+ *
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
- *
+ *
* THIS SOFTWARE IS PROVIDED BY Andrea Leofreddi ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Andrea Leofreddi OR
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
+ *
* The views and conclusions contained in the software and documentation are those of the
* authors and should not be interpreted as representing official policies, either expressed
* or implied, of Andrea Leofreddi.
if (!window) window=this;
/**
- * Show the graph in the middle of the view, scaled to fit
+ * Show the graph in the middle of the view, scaled to fit
*/
function show()
{
/**
* Register handlers
*/
-function init(evt)
+function init(evt)
{
svgDoc = evt.target.ownerDocument;
try {
if (window.addEventListener)
{
- if (navigator.userAgent.toLowerCase().indexOf('webkit') >= 0 ||
- navigator.userAgent.toLowerCase().indexOf("opera") >= 0 ||
+ if (navigator.userAgent.toLowerCase().indexOf('webkit') >= 0 ||
+ navigator.userAgent.toLowerCase().indexOf("opera") >= 0 ||
navigator.appVersion.indexOf("MSIE") != -1)
{
window.addEventListener('mousewheel', handleMouseWheel, false); // Chrome/Safari/IE9
/**
* Instance an SVGPoint object with given event coordinates.
*/
-function getEventPoint(evt)
+function getEventPoint(evt)
{
var p = root.createSVGPoint();
p.x = evt.clientX;
/**
* Sets the current transform matrix of an element.
*/
-function setCTM(element, matrix)
+function setCTM(element, matrix)
{
var s = "matrix(" + matrix.a + "," + matrix.b + "," + matrix.c + "," + matrix.d + "," + matrix.e + "," + matrix.f + ")";
element.setAttribute("transform", s);
/**
* Handle mouse move event.
*/
-function handleMouseWheel(evt)
+function handleMouseWheel(evt)
{
if (!evt) evt = window.evt;
if (!evt.shiftKey) return; // only zoom when shift is pressed
/**
* Handle mouse move event.
*/
-function handleMouseMove(evt)
+function handleMouseMove(evt)
{
if(evt.preventDefault)
evt.preventDefault();
var g = svgDoc.getElementById("viewport");
- if (state == 'pan')
+ if (state == 'pan')
{
// Pan mode
var p = getEventPoint(evt).matrixTransform(stateTf);
setCTM(g,stateTf.inverse().translate(p.x - stateOrigin.x, p.y - stateOrigin.y));
- }
+ }
}
/**
* Handle click event.
*/
-function handleMouseDown(evt)
+function handleMouseDown(evt)
{
if(evt.preventDefault)
evt.preventDefault();
/**
* Handle mouse button release event.
*/
-function handleMouseUp(evt)
+function handleMouseUp(evt)
{
if (evt.preventDefault) evt.preventDefault();
evt.returnValue = false;
/**
* Dumps a matrix to a string (useful for debug).
*/
-function dumpMatrix(matrix)
+function dumpMatrix(matrix)
{
var s = "[ " + matrix.a + ", " + matrix.c + ", " + matrix.e + "\n " + matrix.b + ", " + matrix.d + ", " + matrix.f + "\n 0, 0, 1 ]";
return s;
doZoom(g,p,factor);
}
-function serializeXmlNode(xmlNode)
+function serializeXmlNode(xmlNode)
{
if (typeof window.XMLSerializer != "undefined") {
return (new window.XMLSerializer()).serializeToString(xmlNode);
return "";
}
-/**
+/**
* Handler for print function
*/
function handlePrint(evt)
alert('Failed to open popup window needed for printing!\n'+e.message);
}
}
-
-
-
-
+/* @license-end */
-# synchonized view disabled button
+# synchronized view disabled button
# width & height
24 24
# luma data
-# synchonized view enabled button
+# synchronized view enabled button
# width & height
24 24
# luma data
<xsd:element name="innergroup" type="refType" minOccurs="0" maxOccurs="unbounded" />
<xsd:element name="templateparamlist" type="templateparamlistType" minOccurs="0" />
<xsd:element name="sectiondef" type="sectiondefType" minOccurs="0" maxOccurs="unbounded" />
+ <xsd:element name="tableofcontents" minOccurs="0" maxOccurs="1" />
<xsd:element name="briefdescription" type="descriptionType" minOccurs="0" />
<xsd:element name="detaileddescription" type="descriptionType" minOccurs="0" />
<xsd:element name="inheritancegraph" type="graphType" minOccurs="0" />
<xsd:attribute name="id" type="xsd:string" />
<xsd:attribute name="prot" type="DoxProtectionKind" />
<xsd:attribute name="static" type="DoxBool" />
+ <xsd:attribute name="strong" type="DoxBool" use="optional"/>
<xsd:attribute name="const" type="DoxBool" use="optional"/>
<xsd:attribute name="explicit" type="DoxBool" use="optional"/>
<xsd:attribute name="inline" type="DoxBool" use="optional"/>
<xsd:sequence>
<xsd:element name="codeline" type="codelineType" minOccurs="0" maxOccurs="unbounded" />
</xsd:sequence>
+ <xsd:attribute name="filename" type="xsd:string" use="optional"/>
</xsd:complexType>
<xsd:complexType name="codelineType">
<xsd:complexType name="highlightType" mixed="true">
<xsd:choice minOccurs="0" maxOccurs="unbounded">
- <xsd:element name="sp" />
+ <xsd:element name="sp" type="spType" />
<xsd:element name="ref" type="refTextType" />
</xsd:choice>
<xsd:attribute name="class" type="DoxHighlightClass" />
</xsd:complexType>
+ <xsd:complexType name="spType" mixed="true">
+ <xsd:attribute name="value" type="xsd:integer" use="optional"/>
+ </xsd:complexType>
+
<xsd:complexType name="referenceType" mixed="true">
<xsd:attribute name="refid" type="xsd:string" />
<xsd:attribute name="compoundref" type="xsd:string" use="optional" />
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Text <emphasis>argument</emphasis> more text. </para>
</detaileddescription>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<indexentry>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para><ref refid="index_1myanchor" kindref="member">See Anchor</ref> Some text. <anchor id="index_1myanchor"/>More text. </para>
</detaileddescription>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para><itemizedlist><listitem><para><computeroutput>AlignLeft</computeroutput> left alignment. </para></listitem><listitem><para><computeroutput>AlignCenter</computeroutput> center alignment. </para></listitem><listitem><para><computeroutput>AlignRight</computeroutput> right alignment</para></listitem></itemizedlist>
No other types of alignment are supported.</para>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<simplesect kind="attention">
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<simplesect kind="author">
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Text <bold>bold</bold> normal text. </para>
</detaileddescription>
<compounddef id="bug" kind="page">
<compoundname>bug</compoundname>
<title>Bug List</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<variablelist>
<compounddef id="deprecated" kind="page">
<compoundname>deprecated</compoundname>
<title>Deprecated List</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<variablelist>
<compounddef id="reminders" kind="page">
<compoundname>reminders</compoundname>
<title>Reminders</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<variablelist>
<compounddef id="test" kind="page">
<compoundname>test</compoundname>
<title>Test List</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<variablelist>
<compounddef id="todo" kind="page">
<compoundname>todo</compoundname>
<title>Todo List</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<variablelist>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Text <computeroutput>code</computeroutput> normal text.</para>
<para>Text <computeroutput>code</computeroutput> normal text. </para>
<compounddef id="citelist" kind="page">
<compoundname>citelist</compoundname>
<title>Bibliography</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<variablelist>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>See <ref refid="citelist_1CITEREF_knuth79" kindref="member">[1]</ref> for more info. </para>
</detaileddescription>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
- <programlisting>
+ <programlisting filename=".py">
<codeline>
<highlight class="comment">#<sp/>comment<sp/>in<sp/>Python</highlight>
<highlight class="normal"/>
</programlisting>
</para>
<para>
- <programlisting>
+ <programlisting filename=".cpp">
<codeline>
<highlight class="comment">//<sp/>comment<sp/>in<sp/>a<sp/>code<sp/>block</highlight>
<highlight class="normal"/>
</codeline>
</programlisting>
</para>
+ <para>
+ <programlisting>
+ <codeline>
+ <highlight class="normal">//<sp />implicit<sp />code<sp />language</highlight>
+ </codeline>
+ </programlisting>
+ </para>
</detaileddescription>
</compounddef>
</doxygen>
* // comment in a code block
* class Cpp {};
* \endcode
+ *
+ * \code
+ * // implicit code language
+ * \endcode
*/
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<simplesect kind="copyright">
</memberdef>
</sectiondef>
<sectiondef kind="enum">
- <memberdef kind="enum" id="018__def_8c_1aa57b8491d1d8fc1014dd54bcf83b130a" prot="public" static="no">
+ <memberdef kind="enum" id="018__def_8c_1aa57b8491d1d8fc1014dd54bcf83b130a" prot="public" static="no" strong="no">
+ <type/>
<name>E</name>
<enumvalue id="018__def_8c_1aa57b8491d1d8fc1014dd54bcf83b130aab1710e6a49014ba389d57c8753c530f4" prot="public">
<name>E1</name>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Text.
XML
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
- <para> Our main function starts like this: <programlisting><codeline><highlight class="normal">void<sp/>main()</highlight></codeline><codeline><highlight class="normal">{</highlight></codeline></programlisting> First we create a object <computeroutput>t</computeroutput> of the <ref refid="class_test" kindref="compound">Test</ref> class. <programlisting><codeline><highlight class="normal"><sp/><sp/>Test<sp/>t;</highlight></codeline></programlisting> Then we call the example member function <programlisting><codeline><highlight class="normal"><sp/><sp/>t.example();</highlight></codeline></programlisting> After that our little test routine ends. <programlisting><codeline><highlight class="normal">}</highlight></codeline></programlisting> </para>
+ <para> Our main function starts like this: <programlisting filename="example_test.cpp"><codeline><highlight class="normal">void<sp/>main()</highlight></codeline><codeline><highlight class="normal">{</highlight></codeline></programlisting> First we create a object <computeroutput>t</computeroutput> of the <ref refid="class_test" kindref="compound">Test</ref> class. <programlisting filename="example_test.cpp"><codeline><highlight class="normal"><sp/><sp/>Test<sp/>t;</highlight></codeline></programlisting> Then we call the example member function <programlisting filename="example_test.cpp"><codeline><highlight class="normal"><sp/><sp/>t.example();</highlight></codeline></programlisting> After that our little test routine ends. <programlisting filename="example_test.cpp"><codeline><highlight class="normal">}</highlight></codeline></programlisting> </para>
</detaileddescription>
</compounddef>
</doxygen>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Class relations expressed via an inline dot graph: <dot>
digraph example {
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Normal <emphasis>emphasis</emphasis> and more <emphasis>emphasis</emphasis> back to normal. </para>
</detaileddescription>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Unconditional (start) Enabled (if). Enabled (else). Unconditional (middle) Enabled (else). Unconditional (end) </para>
</detaileddescription>
<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="">
<compounddef id="example_test_8cpp-example" kind="example">
<compoundname>example_test.cpp</compoundname>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>This is an example of how to use the <ref refid="class_test" kindref="compound">Test</ref> class.</para>
- <para>More details about this example. <programlisting><codeline><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/>main()</highlight></codeline><codeline><highlight class="normal">{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><ref refid="class_test" kindref="compound">Test</ref><sp/>t;</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>t.<ref refid="class_test_1a47b775f65718978f1ffcd96376f8ecfa" kindref="member">example</ref>();</highlight></codeline><codeline><highlight class="normal">}</highlight></codeline><codeline><highlight class="normal"/></codeline></programlisting> </para>
+ <para>More details about this example. <programlisting filename="example_test.cpp"><codeline><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/>main()</highlight></codeline><codeline><highlight class="normal">{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keyword">const</highlight><highlight class="normal"><sp/></highlight><highlight class="keywordtype">char</highlight><highlight class="normal">*<sp/>a<sp/>=<sp/></highlight><highlight class="stringliteral">"Some<sp/>special<sp/>character<sp/>here:<sp/><sp value="7"/><sp/>"</highlight><highlight class="normal">;</highlight></codeline><codeline><highlight class="normal"/></codeline><codeline><highlight class="normal"><sp/><sp/><ref refid="class_test" kindref="compound">Test</ref><sp/>t;</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>t.<ref refid="class_test_1a47b775f65718978f1ffcd96376f8ecfa" kindref="member">example</ref>();</highlight></codeline><codeline><highlight class="normal">}</highlight></codeline><codeline><highlight class="normal"/></codeline></programlisting> </para>
</detaileddescription>
</compounddef>
</doxygen>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Here are some formulas:<orderedlist><listitem><para>The distance between <formula id="0">$(x_1,y_1)$</formula> and <formula id="1">$(x_2,y_2)$</formula> is <formula id="2">$\sqrt{(x_2-x_1)^2+(y_2-y_1)^2}$</formula>.</para></listitem><listitem><para>Unnumbered formula: <formula id="3">\[ |I_2|=\left| \int_{0}^T \psi(t) \left\{ u(a,t)- \int_{\gamma(t)}^a \frac{d\theta}{k(\theta,t)} \int_{a}^\theta c(\xi)u_t(\xi,t)\,d\xi \right\} dt \right| \]</formula></para></listitem><listitem><para>Formula in different environment <formula id="4">\begin{eqnarray*} g &=& \frac{Gm_2}{r^2} \\ &=& \frac{(6.673 \times 10^{-11}\,\mbox{m}^3\,\mbox{kg}^{-1}\, \mbox{s}^{-2})(5.9736 \times 10^{24}\,\mbox{kg})}{(6371.01\,\mbox{km})^2} \\ &=& 9.82066032\,\mbox{m/s}^2 \end{eqnarray*}</formula> </para></listitem></orderedlist>
</para>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Some text. <htmlonly><h1>Hello world</h1>
</htmlonly> More text. </para>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Some text. <image type="html" name="sample.png"/>
<image type="latex" name="sample.png" width="5cm">Doxygen logo</image>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
- <para>Some text. <programlisting><codeline><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/>main()</highlight></codeline><codeline><highlight class="normal">{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>Test<sp/>t;</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>t.example();</highlight></codeline><codeline><highlight class="normal">}</highlight></codeline><codeline><highlight class="normal"/></codeline></programlisting> More text. <programlisting><codeline lineno="1"><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/>main()</highlight></codeline><codeline lineno="2"><highlight class="normal">{</highlight></codeline><codeline lineno="3"><highlight class="normal"><sp/><sp/>Test<sp/>t;</highlight></codeline><codeline lineno="4"><highlight class="normal"><sp/><sp/>t.example();</highlight></codeline><codeline lineno="5"><highlight class="normal">}</highlight></codeline><codeline lineno="6"><highlight class="normal"/></codeline></programlisting> End. </para>
+ <para>Some text. <programlisting filename="example_test.cpp"><codeline><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/>main()</highlight></codeline><codeline><highlight class="normal">{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keyword">const</highlight><highlight class="normal"><sp/></highlight><highlight class="keywordtype">char</highlight><highlight class="normal">*<sp/>a<sp/>=<sp/></highlight><highlight class="stringliteral">"Some<sp/>special<sp/>character<sp/>here:<sp/><sp value="7"/><sp/>"</highlight><highlight class="normal">;</highlight></codeline><codeline><highlight class="normal"/></codeline><codeline><highlight class="normal"><sp/><sp/>Test<sp/>t;</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>t.example();</highlight></codeline><codeline><highlight class="normal">}</highlight></codeline><codeline><highlight class="normal"/></codeline></programlisting> More text. <programlisting filename="example_test.cpp"><codeline lineno="1"><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/>main()</highlight></codeline><codeline lineno="2"><highlight class="normal">{</highlight></codeline><codeline lineno="3"><highlight class="normal"><sp/><sp/></highlight><highlight class="keyword">const</highlight><highlight class="normal"><sp/></highlight><highlight class="keywordtype">char</highlight><highlight class="normal">*<sp/>a<sp/>=<sp/></highlight><highlight class="stringliteral">"Some<sp/>special<sp/>character<sp/>here:<sp/><sp value="7"/><sp/>"</highlight><highlight class="normal">;</highlight></codeline><codeline lineno="4"><highlight class="normal"/></codeline><codeline lineno="5"><highlight class="normal"><sp/><sp/>Test<sp/>t;</highlight></codeline><codeline lineno="6"><highlight class="normal"><sp/><sp/>t.example();</highlight></codeline><codeline lineno="7"><highlight class="normal">}</highlight></codeline><codeline lineno="8"><highlight class="normal"/></codeline></programlisting> End. </para>
</detaileddescription>
</compounddef>
</doxygen>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Some text.</para>
<para>More visible text. </para>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Some text. </para>
<internal>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Text<linebreak/>
New line<linebreak/>
<compounddef id="another" kind="page">
<compoundname>another</compoundname>
<title>Another Page</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Another page's text. </para>
</detaileddescription>
<compoundname>mypage</compoundname>
<title>Page Title</title>
<innerpage refid="another">Another Page</innerpage>
+ <tableofcontents/>
+ <briefdescription>
+ <para>Page brief description. </para>
+ </briefdescription>
<detaileddescription>
+ <para>Page brief description.</para>
<para>Text at page level. See <ref refid="mypage_1mysect" kindref="member">Section Title.</ref> for more. </para>
<sect1 id="mypage_1mysect">
<title>Section Title.</title>
// check: mypage.xml
// check: another.xml
/** \page mypage Page Title
+ * \brief Page brief description.
+ *
+ * @tableofcontents
+ *
* Text at page level. See \ref mysect for more.
* \section mysect Section Title.
* Text at section level. See \ref mysubsect for more.
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<toclist>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
- <para>A bubble sort algorithm First get the inputs <programlisting><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(i=0<sp/>;<sp/>i<n<sp/>;<sp/>i++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>printf(</highlight><highlight class="stringliteral">"<sp/>Array[%d]<sp/>=<sp/>"</highlight><highlight class="normal">,i);</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>scanf(</highlight><highlight class="stringliteral">"%d"</highlight><highlight class="normal">,&arr[i]);</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>}</highlight></codeline></programlisting>Then do the bubbling <programlisting><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(i=0<sp/>;<sp/>i<n<sp/>;<sp/>i++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(j=0<sp/>;<sp/>j<n-i-1<sp/>;<sp/>j++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/></highlight><highlight class="keywordflow">if</highlight><highlight class="normal">(arr[j]>arr[j+1])<sp/></highlight><highlight class="comment">//Swapping<sp/>Condition<sp/>is<sp/>Checked</highlight><highlight class="normal"/></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/><sp/><sp/>temp=arr[j];</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/><sp/><sp/>arr[j]=arr[j+1];</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/><sp/><sp/>arr[j+1]=temp;</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/>}</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>}</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>}</highlight></codeline></programlisting>Then write the result <programlisting><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(i=0<sp/>;<sp/>i<n<sp/>;<sp/>i++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>printf(</highlight><highlight class="stringliteral">"<sp/>%4d"</highlight><highlight class="normal">,arr[i]);</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>}</highlight></codeline></programlisting></para>
+ <para>A bubble sort algorithm First get the inputs <programlisting filename="snippet_test.cpp"><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(i=0<sp/>;<sp/>i<n<sp/>;<sp/>i++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>printf(</highlight><highlight class="stringliteral">"<sp/>Array[%d]<sp/>=<sp/>"</highlight><highlight class="normal">,i);</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>scanf(</highlight><highlight class="stringliteral">"%d"</highlight><highlight class="normal">,&arr[i]);</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>}</highlight></codeline></programlisting>Then do the bubbling <programlisting filename="snippet_test.cpp"><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(i=0<sp/>;<sp/>i<n<sp/>;<sp/>i++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(j=0<sp/>;<sp/>j<n-i-1<sp/>;<sp/>j++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/></highlight><highlight class="keywordflow">if</highlight><highlight class="normal">(arr[j]>arr[j+1])<sp/></highlight><highlight class="comment">//Swapping<sp/>Condition<sp/>is<sp/>Checked</highlight><highlight class="normal"/></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/><sp/><sp/>temp=arr[j];</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/><sp/><sp/>arr[j]=arr[j+1];</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/><sp/><sp/>arr[j+1]=temp;</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/><sp/><sp/>}</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>}</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>}</highlight></codeline></programlisting>Then write the result <programlisting filename="snippet_test.cpp"><codeline><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">for</highlight><highlight class="normal">(i=0<sp/>;<sp/>i<n<sp/>;<sp/>i++)</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>{</highlight></codeline><codeline><highlight class="normal"><sp/><sp/><sp/><sp/>printf(</highlight><highlight class="stringliteral">"<sp/>%4d"</highlight><highlight class="normal">,arr[i]);</highlight></codeline><codeline><highlight class="normal"><sp/><sp/>}</highlight></codeline></programlisting></para>
</detaileddescription>
</compounddef>
</doxygen>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Some normal text. <verbatim>A verbatim section with a /* C comment */ in it
</verbatim> Showing a file as verbatim <verbatim>@book{knuth79,
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Dollar $ At @ Backslash \ Amphasand & Less < Greater > Hash # Percent % Quote " Dot . Double colon :: Pipe | Plus + Minus - </para>
</detaileddescription>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>This is English. Output for all languages. </para>
</detaileddescription>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Dit is Nederlands. Output for all languages. </para>
</detaileddescription>
<compounddef id="md_055_markdown" kind="page">
<compoundname>md_055_markdown</compoundname>
<title>055_markdown</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>
<heading level="1">Foo</heading>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>Some text. <latexonly>\section{Hello world}
</latexonly> More text. </para>
<compounddef id="indexpage" kind="page">
<compoundname>index</compoundname>
<title>My Project</title>
+ <briefdescription>
+ </briefdescription>
<detaileddescription>
<para>これは日本語(en)です. Output for all languages. </para>
</detaileddescription>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="">
+ <compounddef id="class_class1" kind="class" language="C#" prot="public">
+ <compoundname>Class1</compoundname>
+ <sectiondef kind="property">
+ <memberdef kind="property" id="class_class1_1a6b0b2ab73516e37adb38b8ff33f97c40" prot="public" static="no" readable="no" writable="no" gettable="yes" privategettable="no" protectedgettable="no" settable="no" privatesettable="no" protectedsettable="no">
+ <type>int</type>
+ <definition>int Class1.Property1</definition>
+ <argsstring/>
+ <name>Property1</name>
+ <initializer>= 1</initializer>
+ <briefdescription>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <inbodydescription>
+ </inbodydescription>
+ <location file="066_property_initializer.cs" line="5" column="1" bodyfile="066_property_initializer.cs" bodystart="5" bodyend="5"/>
+ </memberdef>
+ <memberdef kind="property" id="class_class1_1a0d5b843d48ebc2c078e003d6ff3a1610" prot="public" static="no" readable="no" writable="no" gettable="yes" privategettable="no" protectedgettable="no" settable="yes" privatesettable="no" protectedsettable="no">
+ <type>string</type>
+ <definition>string Class1.Property2</definition>
+ <argsstring/>
+ <name>Property2</name>
+ <briefdescription>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <inbodydescription>
+ </inbodydescription>
+ <location file="066_property_initializer.cs" line="6" column="1" bodyfile="066_property_initializer.cs" bodystart="6" bodyend="6"/>
+ </memberdef>
+ </sectiondef>
+ <briefdescription>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <location file="066_property_initializer.cs" line="4" column="1" bodyfile="066_property_initializer.cs" bodystart="3" bodyend="7"/>
+ <listofallmembers>
+ <member refid="class_class1_1a6b0b2ab73516e37adb38b8ff33f97c40" prot="public" virt="non-virtual">
+ <scope>Class1</scope>
+ <name>Property1</name>
+ </member>
+ <member refid="class_class1_1a0d5b843d48ebc2c078e003d6ff3a1610" prot="public" virt="non-virtual">
+ <scope>Class1</scope>
+ <name>Property2</name>
+ </member>
+ </listofallmembers>
+ </compounddef>
+</doxygen>
--- /dev/null
+// objective: C# property initializer
+// check: class_class1.xml
+class Class1
+{
+ public int Property1 { get; } = 1;
+ public string Property2 { get; set; }
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="">
+ <compounddef id="067__using_8cpp" kind="file" language="C++">
+ <compoundname>067_using.cpp</compoundname>
+ <sectiondef kind="typedef">
+ <memberdef kind="typedef" id="067__using_8cpp_1a1b01c504448c96cd2191a5184dd31acf" prot="public" static="no">
+ <templateparamlist>
+ <param>
+ <type>class T</type>
+ </param>
+ </templateparamlist>
+ <type>std::vector< T ></type>
+ <definition>using Vec = std::vector<T></definition>
+ <argsstring/>
+ <name>Vec</name>
+ <briefdescription>
+ <para>A vector. </para>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <inbodydescription>
+ </inbodydescription>
+ <location file="067_using.cpp" line="7" column="1" bodyfile="067_using.cpp" bodystart="7" bodyend="-1"/>
+ </memberdef>
+ </sectiondef>
+ <briefdescription>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <location file="067_using.cpp"/>
+ </compounddef>
+</doxygen>
--- /dev/null
+// objective: test template parameters for a type alias
+// check: 067__using_8cpp.xml
+
+/** \file */
+
+/** @brief A vector */
+template<class T> using Vec = std::vector<T>;
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="">
+ <compounddef id="068__typed__enum_8cpp" kind="file" language="C++">
+ <compoundname>068_typed_enum.cpp</compoundname>
+ <sectiondef kind="enum">
+ <memberdef kind="enum" id="068__typed__enum_8cpp_1aa72902e6181db009a6a84502f81612c2" prot="public" static="no" strong="yes">
+ <type>unsigned short</type>
+ <name>E</name>
+ <briefdescription>
+ <para>A strongly-typed enum. </para>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <inbodydescription>
+ </inbodydescription>
+ <location file="068_typed_enum.cpp" line="7" column="1" bodyfile="068_typed_enum.cpp" bodystart="7" bodyend="7"/>
+ </memberdef>
+ </sectiondef>
+ <briefdescription>
+ </briefdescription>
+ <detaileddescription>
+ </detaileddescription>
+ <location file="068_typed_enum.cpp"/>
+ </compounddef>
+</doxygen>
--- /dev/null
+// objective: test underlying type and strongness for an enum
+// check: 068__typed__enum_8cpp.xml
+
+/** \file */
+
+/** @brief A strongly-typed enum */
+enum class E: unsigned short {};
-find_program(XMLLINT NAMES xmllint)
-find_program(DIFF NAMES diff)
-
add_custom_target(tests
- COMMENT "Running doxygen tests..."
- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/testing/runtests.py --all --doxygen ${PROJECT_BINARY_DIR}/bin/doxygen --inputdir ${CMAKE_SOURCE_DIR}/testing --outputdir ${PROJECT_BINARY_DIR}/testing
- DEPENDS doxygen
+ COMMENT "Running doxygen tests..."
+ COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/testing/runtests.py --all --doxygen ${PROJECT_BINARY_DIR}/bin/doxygen --inputdir ${CMAKE_SOURCE_DIR}/testing --outputdir ${PROJECT_BINARY_DIR}/testing
+ DEPENDS doxygen
+)
+add_test(NAME suite
+ COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/testing/runtests.py --all --doxygen $<TARGET_FILE:doxygen> --inputdir ${CMAKE_SOURCE_DIR}/testing --outputdir ${PROJECT_BINARY_DIR}/testing
)
void main()
{
+ const char* a = "Some special character here: \a ";
+
Test t;
t.example();
}
-/* Generated By:JavaCC: Do not edit this line. CharStream.cc Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. CharStream.cc Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#include "CharStream.h"
}
}
-/* JavaCC - OriginalChecksum=ade3c1b57a731a003629de593814ffa6 (do not edit this line) */
+/* JavaCC - OriginalChecksum=e709b9ee1adf0fcb6b1c5e1641f10348 (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. CharStream.h Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. CharStream.h Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#ifndef CHARSTREAM_H
#define CHARSTREAM_H
class CharStream {
-public:
- void setTabSize(int i) { tabSize = i; }
- int getTabSize(int i) { return tabSize; }
- private:
- int getBufcolumn(int pos) {
- if (trackLineColumn && pos>=0) {
- return bufcolumn[pos];
- } else {
- return -1;
- }
- }
- int getBufline(int pos) {
- if (trackLineColumn && pos>=0) {
- return bufline[pos];
- } else {
- return -1;
- }
- }
public:
- virtual int getColumn() { return getBufcolumn(bufpos); }
- virtual int getLine() { return getBufline(bufpos); }
- virtual int getEndColumn() { return getBufcolumn(bufpos); }
- virtual int getEndLine() { return getBufline(bufpos); }
- virtual int getBeginColumn() { return getBufcolumn(tokenBegin); }
- virtual int getBeginLine() { return getBufline(tokenBegin); }
-
- virtual bool getTrackLineColumn() { return trackLineColumn; }
+ void setTabSize(int i) { tabSize = i; }
+ int getTabSize(int i) { return tabSize; }
+ virtual int getColumn() { return trackLineColumn ? bufcolumn[bufpos] : -1; }
+ virtual int getLine() { return trackLineColumn ? bufline[bufpos] : -1; }
+ virtual int getEndColumn() { return trackLineColumn ? bufcolumn[bufpos] : -1; }
+ virtual int getEndLine() { return trackLineColumn ? bufline[bufpos] : -1; }
+ virtual int getBeginColumn() { return trackLineColumn ? bufcolumn[tokenBegin] : -1; }
+ virtual int getBeginLine() { return trackLineColumn ? bufline[tokenBegin] : -1; }
+
+ virtual bool getTrackLineColumn() { return trackLineColumn; }
virtual void setTrackLineColumn(bool val) { trackLineColumn = val; }
/**
* (longer) token. So, they will be used again as the prefix of the next
* token and it is the implemetation's responsibility to do this right.
*/
- virtual inline void backup(int amount) {
- inBuf += amount;
- bufpos -= amount;
- if (bufpos < 0) {
- bufpos += bufsize;
- }
+virtual inline void backup(int amount) {
+ inBuf += amount;
+ bufpos -= amount;
+ if (bufpos < 0) {
+ bufpos += bufsize;
}
+}
/**
* Returns the next character that marks the beginning of the next token.
* All characters must remain in the buffer between two successive calls
* to this method to implement backup correctly.
*/
- virtual inline JAVACC_CHAR_TYPE BeginToken() {
- tokenBegin = -1;
- JAVACC_CHAR_TYPE c = readChar();
- tokenBegin = bufpos;
- return c;
- }
+virtual inline JAVACC_CHAR_TYPE BeginToken() {
+ tokenBegin = -1;
+ JAVACC_CHAR_TYPE c = readChar();
+ tokenBegin = bufpos;
+ return c;
+}
/**
* of selecting the input is the responsibility of the class
* implementing this class.
*/
- virtual inline JAVACC_CHAR_TYPE readChar() {
- if (inBuf > 0) {
- --inBuf;
- ++bufpos;
- if (bufpos == bufsize) {
- bufpos = 0;
- }
- return buffer[bufpos];
- }
-
+virtual inline JAVACC_CHAR_TYPE readChar() {
+ if (inBuf > 0) {
+ --inBuf;
++bufpos;
- if (bufpos >= maxNextCharInd) {
- FillBuff();
+ if (bufpos == bufsize) {
+ bufpos = 0;
}
- JAVACC_CHAR_TYPE c = buffer[bufpos];
+ return buffer[bufpos];
+ }
- if (trackLineColumn) {
- UpdateLineColumn(c);
- }
+ ++bufpos;
+ if (bufpos >= maxNextCharInd) {
+ FillBuff();
+ }
- return c;
+ JAVACC_CHAR_TYPE c = buffer[bufpos];
+
+ if (trackLineColumn) {
+ UpdateLineColumn(c);
}
+ return c;
+}
+
virtual void ExpandBuff(bool wrapAround);
virtual void FillBuff();
if (bufpos >= tokenBegin)
return JAVACC_STRING_TYPE(buffer + tokenBegin, bufpos - tokenBegin + 1);
else
- return JAVACC_STRING_TYPE(buffer + tokenBegin, bufsize - tokenBegin).append(buffer, bufpos + 1);
+ return JAVACC_STRING_TYPE(buffer + tokenBegin, bufsize - tokenBegin)
+ .append(buffer, bufpos + 1);
}
/**
if ((bufpos + 1) >= len) {
return JAVACC_STRING_TYPE(buffer + bufpos - len + 1, len);
}
- return JAVACC_STRING_TYPE(buffer + bufsize - (len - bufpos - 1), len - bufpos - 1).append(buffer, bufpos + 1);
+ return JAVACC_STRING_TYPE(buffer + bufsize - (len - bufpos - 1), len - bufpos - 1)
+ .append(buffer, bufpos + 1);
}
/**
}
bool endOfInput() {
- return inBuf == 0 && bufpos + 1 >= maxNextCharInd && inputStream->endOfInput();
+ return inBuf == 0 && bufpos + 1 >= maxNextCharInd &&
+ inputStream->endOfInput();
}
CharStream(const JAVACC_CHAR_TYPE *buf, int sz, int startline,
int startcolumn, int buffersize) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0),tabSize(8), trackLineColumn(true) {
ReInit(JAVACC_STRING_TYPE(buf, sz), startline, startcolumn, buffersize);
}
CharStream(const JAVACC_CHAR_TYPE *buf, int sz, int startline, int startcolumn) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0),tabSize(8), trackLineColumn(true) {
ReInit(JAVACC_STRING_TYPE(buf, sz), startline, startcolumn, INITIAL_BUFFER_SIZE);
}
CharStream(const JAVACC_STRING_TYPE& str, int startline,
int startcolumn, int buffersize) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0),tabSize(8), trackLineColumn(true) {
ReInit(str, startline, startcolumn, buffersize);
}
CharStream(const JAVACC_STRING_TYPE& str, int startline, int startcolumn) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0) ,tabSize(8), trackLineColumn(true){
ReInit(str, startline, startcolumn, INITIAL_BUFFER_SIZE);
}
CharStream(ReaderStream *input_stream, int startline,
int startcolumn, int buffersize) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0),tabSize(8), trackLineColumn(true) {
ReInit(input_stream, startline, startcolumn, INITIAL_BUFFER_SIZE);
}
CharStream(ReaderStream *input_stream, int startline, int startcolumn) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0),tabSize(8), trackLineColumn(true) {
ReInit(input_stream, startline, startcolumn, INITIAL_BUFFER_SIZE);
}
CharStream(ReaderStream *input_stream) :
- bufline(NULL), bufcolumn(NULL), buffer(NULL), bufpos(0), bufsize(0),
- tokenBegin(0), column(0), line(0), prevCharIsCR(false), prevCharIsLF(false),
- available(0), maxNextCharInd(0), inBuf(0), tabSize(1), trackLineColumn(true),
- inputStream(NULL), deleteStream(false) {
+ bufline(NULL), bufcolumn(NULL), inputStream(NULL), deleteStream(false),
+ buffer(NULL), bufpos(0), bufsize(0), tokenBegin(0), column(0), line(0),
+ prevCharIsCR (false), prevCharIsLF (false), available(0), maxNextCharInd(0),
+ inBuf(0),tabSize(8), trackLineColumn(true) {
ReInit(input_stream, 1, 1, INITIAL_BUFFER_SIZE);
}
- virtual void ReInit(ReaderStream *input_stream, int startline, int startcolumn, int buffersize);
+ virtual void ReInit(ReaderStream *input_stream, int startline, int startcolumn,
+ int buffersize);
- virtual void ReInit(ReaderStream *input_stream, int startline, int startcolumn) {
+ virtual void ReInit(ReaderStream *input_stream, int startline,
+ int startcolumn) {
ReInit(input_stream, startline, startcolumn, INITIAL_BUFFER_SIZE);
}
protected:
virtual void UpdateLineColumn(JAVACC_CHAR_TYPE c);
- int* bufline;
- int* bufcolumn;
- JAVACC_CHAR_TYPE* buffer;
- int bufpos;
- int bufsize;
- int tokenBegin;
- int column;
- int line;
- bool prevCharIsCR;
- bool prevCharIsLF;
- int available;
- int maxNextCharInd;
- int inBuf;
- int tabSize;
- bool trackLineColumn;
- ReaderStream* inputStream;
- bool deleteStream;
+ int *bufline;
+ int *bufcolumn;
+ ReaderStream *inputStream;
+ bool deleteStream;
+ JAVACC_CHAR_TYPE * buffer;
+ int bufpos;
+ int bufsize;
+ int tokenBegin;
+ int column;
+ int line;
+ bool prevCharIsCR ;
+ bool prevCharIsLF ;
+ int available;
+ int maxNextCharInd;
+ int inBuf ;
+ int tabSize ;
+ bool trackLineColumn;
};
}
}
#endif
-/* JavaCC - OriginalChecksum=3f0e693d1617236429891c8c95713d73 (do not edit this line) */
+/* JavaCC - OriginalChecksum=5eaf75ef6a2c7859369c80cf6fd037e0 (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. ErrorHandler.h Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. ErrorHandler.h Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true,BUILD_PARSER=true,BUILD_TOKEN_MANAGER=true */
#ifndef ERRORHANDLER_H
#define ERRORHANDLER_H
-#include <stdio.h>
#include <string>
#include "JavaCC.h"
#include "Token.h"
}
#endif
-/* JavaCC - OriginalChecksum=c18f1105ba178be8e21cc9f279f94496 (do not edit this line) */
+/* JavaCC - OriginalChecksum=685d19cb4cd943b60089f599e45f23ad (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. ParseException.cc Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. ParseException.cc Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#include "ParseException.h"
for (int i = 0; i < str.length(); i++) {
switch (str.charAt(i))
{
+ case 0 :
+ continue;
case '\b':
retval.append("\\b");
continue;
}
}
-/* JavaCC - OriginalChecksum=9f6af8fd72f5fe3e4210cf02acbd8387 (do not edit this line) */
+/* JavaCC - OriginalChecksum=99d488e13335cf377284c90700f070ed (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. ParseException.h Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. ParseException.h Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#ifndef _PARSE_EXCEPTION_H
#define _PARSE_EXCEPTION_H
}
}
#endif
-/* JavaCC - OriginalChecksum=bd87c2fc11a4306bd2c2482fd1025b7c (do not edit this line) */
+/* JavaCC - OriginalChecksum=8c47c56fc2030f05b43e20cae6ca5d66 (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. Token.cc Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. Token.cc Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true,TOKEN_INCLUDES=,TOKEN_EXTENDS= */
#include "Token.h"
}
}
-/* JavaCC - OriginalChecksum=dcb0f64486aa6455ae5af05d6bb539ec (do not edit this line) */
+/* JavaCC - OriginalChecksum=9db9ca693072c4c37bb7cc933c0c5e35 (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. Token.h Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. Token.h Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true,TOKEN_INCLUDES=,TOKEN_EXTENDS= */
#ifndef TOKEN_H
#define TOKEN_H
*/
Token(int kind, JAVACC_STRING_TYPE image);
- virtual ~Token();
-
/**
* Returns the image.
*/
JAVACC_STRING_TYPE toString();
+ public: virtual ~Token();
/**
* Returns a new Token void *, by default. However, if you want, you
}
}
#endif
-/* JavaCC - OriginalChecksum=4748c3d6443aa3445d3c95ab54f14c2a (do not edit this line) */
+/* JavaCC - OriginalChecksum=2f5eb1c937adc983dfa2008c4fe383a7 (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. TokenManager.h Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. TokenManager.h Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#ifndef TOKENMANAGER_H
#define TOKENMANAGER_H
-#include <iostream>
#include "JavaCC.h"
#include "Token.h"
-using namespace std;
namespace vhdl {
namespace parser {
/** This gets the next token from the input stream.
* A token of kind 0 (<EOF>) should be returned on EOF.
*/
- virtual ~TokenManager() { }
- virtual Token *getNextToken() = 0;
- virtual void lexicalError() {
- cerr << "Lexical error encountered." << endl;
+ public: virtual Token *getNextToken() = 0;
+ public: virtual ~TokenManager() { }
+ public: virtual void lexicalError() {
+ fprintf(stderr, "Lexical error encountered.\n");
}
};
}
}
#endif
-/* JavaCC - OriginalChecksum=918e2eba53e028d6c4142283ce3f498f (do not edit this line) */
+/* JavaCC - OriginalChecksum=9e6cfa00cefe7e342b80eb59f1a114ff (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. TokenMgrError.cc Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. TokenMgrError.cc Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#include "TokenMgrError.h"
// i < 16 - guaranteed
char hexChar(int i) {
if (i < 10) {
- return i + '0';
+ return i - '0';
}
return 'a' + (i - 10);
}
JAVACC_CHAR_TYPE ch = str[i];
switch (ch)
{
+ case 0 :
+ retval += EMPTY[0];
+ continue;
case '\b':
retval.append("\\b");
continue;
}
}
-/* JavaCC - OriginalChecksum=72f292bc267bd0602e63291bf864f942 (do not edit this line) */
+/* JavaCC - OriginalChecksum=2bf63f131c8e60fd30c70d0b4f660016 (do not edit this line) */
-/* Generated By:JavaCC: Do not edit this line. TokenMgrError.h Version 6.2 */
+/* Generated By:JavaCC: Do not edit this line. TokenMgrError.h Version 6.0 */
/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
#ifndef _TOKENMGRERROR_H
#define _TOKENMGRERROR_H
namespace vhdl {
namespace parser {
-enum LexerErrors {
+ enum LexerErrors {
/**
* Lexical error occurred.
*/
* Detected (and bailed out of) an infinite loop in the token manager.
*/
LOOP_DETECTED = 3,
-};
+ };
-class TokenMgrError {
-public:
+class TokenMgrError
+{
+ public:
/*
* Ordinals for various reasons why an Error of this type can be thrown.
*/
*/
JAVACC_STRING_TYPE LexicalError(bool EOFSeen, int lexState, int errorLine, int errorColumn, JAVACC_STRING_TYPE errorAfter, JAVACC_CHAR_TYPE curChar);
-private:
- JAVACC_STRING_TYPE message;
+ private: JAVACC_STRING_TYPE message;
/**
* You can also modify the body of this method to customize your error messages.
*
* from this method for such cases in the release version of your parser.
*/
-public:
JAVACC_STRING_TYPE getMessage() ;
/*
*/
/** No arg constructor. */
- TokenMgrError() ;
+ public: TokenMgrError() ;
/** Constructor with message and reason. */
- TokenMgrError(JAVACC_STRING_TYPE message, int reason) ;
+ public: TokenMgrError(JAVACC_STRING_TYPE message, int reason) ;
/** Full Constructor. */
- TokenMgrError(bool EOFSeen, int lexState, int errorLine, int errorColumn, JAVACC_STRING_TYPE errorAfter, JAVACC_CHAR_TYPE curChar, int reason) ;
+ public: TokenMgrError(bool EOFSeen, int lexState, int errorLine, int errorColumn, JAVACC_STRING_TYPE errorAfter, JAVACC_CHAR_TYPE curChar, int reason) ;
};
}
}
#endif
-/* JavaCC - OriginalChecksum=c22a1b25630ec91deb47dcba22b6b39d (do not edit this line) */
+/* JavaCC - OriginalChecksum=c7d825cb4d037b031ae43569d383f738 (do not edit this line) */
/* VhdlParser.cc */
-#include "VhdlParser.h"
-#include "TokenMgrError.h"
+#include "./VhdlParser.h"
namespace vhdl {
namespace parser {
unsigned int jj_la1_0[] = {
unsigned int jj_la1_4[] = {
0x0,0x0,0x60000,0x30,0x40,0x100,0x0,0x0,0x0,0x0,0x40000,0x0,0x40001,0x0,0x0,0x0,0x0,0x40,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x40001,0x0,0x0,0x0,0x0,0x10000000,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x20000,0x40,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x40000,0x40000,0x40000,0x40000,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x4,0x40001,0x0,0x0,0x40000,0x1,0x0,0x0,0x40000,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x40031,0x0,0x1,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x40000008,0x40000,0x40,0x1,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x1,0x0,0x0,0x0,0x40001,0x1,0x0,0x40000,0xfc00,0xfc00,0x0,0x0,0x0,0x40031,0x1,0x0,0x40,0x40,0x0,0x0,0x0,0x30,0x0,0x40001,0x0,0x80,0x0,0x40,0x40000,0x40,0x40000,0x0,0x30,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x40001,0x0,0x40001,0x0,0x1,0x0,0x40,0x40,0x40001,0x0,0x80,0x0,0x0,0x0,0x0,0x40,0x40031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40001,0x0,0xa0000000,0x20000000,0x0,0x1,0x40001,0x0,0x0,0x0,0x0,0x40031,0x0,0x8000000,0x40000,0x8000000,0x0,0x8000000,0x0,0x240,0x240,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x1,0x0,};
unsigned int jj_la1_5[] = {
-0x1420,0x0,0x1c0,0x0,0x0,0x0,0x2,0x3c0,0x0,0x0,0x1c0,0x0,0x80001c0,0x0,0x0,0x0,0x180,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x80001c0,0x180,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x8000000,0x8000000,0x2,0x0,0x0,0x3c0,0x3c0,0x1c0,0x1c0,0x3c0,0x380,0x0,0x180,0x180,0x0,0x0,0x0,0x0,0x817e0,0x0,0x0,0x1e0,0x0,0x180,0x0,0x3c0,0x0,0x180,0x0,0x180,0x0,0x0,0x180,0x0,0x817e0,0x0,0x0,0x180,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x180,0x0,0x180,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x180,0x180,0x0,0x180,0x1420,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x1c0,0x0,0x0,0x0,0x180,0x1c0,0x0,0x180,0x1c0,0x0,0x0,0x180,0x0,0x180,0x817e0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x1c0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x240,0x1c0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x817e0,0x0,0x180,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x80001c0,0x0,0x1,0x0,0x1,0x0,0x1c0,0x0,0x0,0x0,0x0,0x817e0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x180,};
+0x1420,0x0,0x1c0,0x0,0x0,0x0,0x2,0x3c0,0x0,0x0,0x1c0,0x0,0x200001c0,0x0,0x0,0x0,0x180,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x200001c0,0x180,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x20000000,0x20000000,0x2,0x0,0x0,0x3c0,0x3c0,0x1c0,0x1c0,0x3c0,0x380,0x0,0x180,0x180,0x0,0x0,0x0,0x0,0x1017e0,0x0,0x0,0x1e0,0x0,0x180,0x0,0x3c0,0x0,0x180,0x0,0x180,0x0,0x0,0x180,0x0,0x1017e0,0x0,0x0,0x180,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x180,0x0,0x180,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x180,0x180,0x0,0x180,0x1420,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x1c0,0x0,0x0,0x0,0x180,0x1c0,0x0,0x180,0x1c0,0x0,0x0,0x180,0x0,0x180,0x1017e0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x1c0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x240,0x1c0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x1017e0,0x0,0x180,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x200001c0,0x0,0x1,0x0,0x1,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1017e0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x180,};
/** Constructor with user supplied TokenManager. */
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::access_type_definition() {Token *tok=0;QCString str,str1;if (!hasError) {
str=tok->image.c_str(); return str+str1;
assert(false);
-}
+ }
QCString VhdlParser::actual_designator() {QCString str;Token *t=0;
}
}
assert(false);
-}
+ }
QCString VhdlParser::actual_parameter_part() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::actual_part() {QCString s,s1;
}
}
assert(false);
-}
+ }
QCString VhdlParser::adding_operator() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::aggregate() {QCString s,s1,s2;if (!hasError) {
return "("+s+")";
assert(false);
-}
+ }
QCString VhdlParser::alias_declaration() {QCString s,s1,s2;if (!hasError) {
return s2+" "+s+";";
assert(false);
-}
+ }
QCString VhdlParser::alias_designator() {Token *tok=0;QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::allocator() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::architecture_body() {QCString s,s1;if (!hasError) {
}
lastEntity=0;lastCompound=0; genLabels.resize(0);
-}
+ }
void VhdlParser::architecture_declarative_part() {if (!hasError) {
end_label_2: ;
}
-}
+ }
void VhdlParser::architecture_statement_part() {if (!hasError) {
end_label_3: ;
}
-}
+ }
QCString VhdlParser::array_type_definition() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::assertion() {QCString s,s1,s2;Token *t=0;Token *t1=0;if (!hasError) {
if(t1) s2.prepend(" report ");
return s+s1+s2;
assert(false);
-}
+ }
QCString VhdlParser::assertion_statement() {QCString s,s1,s2;Token *t=0;if (!hasError) {
if(t) s+=":";
return s+s1+";";
assert(false);
-}
+ }
QCString VhdlParser::association_element() {QCString s,s1;if (!hasError) {
return s+" => "+s1;
assert(false);
-}
+ }
QCString VhdlParser::association_list() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::attribute_declaration() {QCString s,s1;if (!hasError) {
addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
return " attribute "+s+":"+s1+";";
assert(false);
-}
+ }
QCString VhdlParser::attribute_designator() {QCString s;Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::attribute_name() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::attribute_specification() {QCString s,s1,s2;if (!hasError) {
addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
return " attribute "+s+" of "+s1+ " is "+s2+";";
assert(false);
-}
+ }
QCString VhdlParser::base() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::base_specifier() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::base_unit_declaration() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::based_integer() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::based_literal() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::basic_identifier() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
void VhdlParser::binding_indication() {if (!hasError) {
}
}
-}
+ }
QCString VhdlParser::bit_string_literal() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::bit_value() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
void VhdlParser::block_configuration() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::block_declarative_item() {
}
}
}
-}
+ }
void VhdlParser::block_declarative_part() {if (!hasError) {
end_label_7: ;
}
-}
+ }
void VhdlParser::block_header() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::block_specification() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::block_statement() {QCString s;if (!hasError) {
}
genLabels=popLabel(genLabels);
-}
+ }
void VhdlParser::block_statement_part() {if (!hasError) {
end_label_8: ;
}
-}
+ }
void VhdlParser::case_statement() {QCString s;if (!hasError) {
FlowChart::moveToPrevLevel();
FlowChart::addFlowChart(FlowChart::END_CASE,"end case",0);
-}
+ }
void VhdlParser::case_statement_alternative() {QCString s;if (!hasError) {
}
FlowChart::moveToPrevLevel();
-}
+ }
QCString VhdlParser::character_literal() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::choice() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::choices() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
void VhdlParser::component_configuration() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::component_declaration() {QCString s;if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::component_instantiation_statement() {QCString s,s1;if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::component_specification() {if (!hasError) {
name();
}
-}
+ }
QCString VhdlParser::composite_type_definition() {QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::concurrent_assertion_statement() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::concurrent_procedure_call_statement() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::concurrent_signal_assignment_statement() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::concurrent_statement() {
}
}
}
-}
+ }
QCString VhdlParser::condition() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::condition_clause() {QCString s;if (!hasError) {
return " until "+s;
assert(false);
-}
+ }
void VhdlParser::conditional_signal_assignment() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::conditional_waveforms() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::configuration_declaration() {QCString s,s1;if (!hasError) {
}
genLabels.resize(0); confName="";
-}
+ }
void VhdlParser::configuration_declarative_item() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::configuration_declarative_part() {if (!hasError) {
end_label_12: ;
}
-}
+ }
void VhdlParser::configuration_item() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::configuration_specification() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
QCString VhdlParser::constant_declaration() {QCString s,s1,s2;Token *t=0;if (!hasError) {
it.prepend("constant ");
return it;
assert(false);
-}
+ }
QCString VhdlParser::constraint_array_definition() {QCString s,s1;if (!hasError) {
return s+" "+s1;
assert(false);
-}
+ }
void VhdlParser::context_clause() {if (!hasError) {
end_label_13: ;
}
-}
+ }
QCString VhdlParser::constraint() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::context_item() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
QCString VhdlParser::decimal_literal() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::delay_mechanism() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::design_file() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::design_unit() {if (!hasError) {
library_unit();
}
-}
+ }
QCString VhdlParser::designator() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::direction() {Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::disconnection_specification() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::guarded_signal_specificatio() {if (!hasError) {
name();
}
-}
+ }
QCString VhdlParser::discrete_range() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::element_association() {QCString s,s1;if (!hasError) {
return s+"=>"+s1;
return s1;
assert(false);
-}
+ }
QCString VhdlParser::element_declaration() {QCString s,s1;if (!hasError) {
//addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
return s+":"+s1;
assert(false);
-}
+ }
QCString VhdlParser::entity_aspect() {Token *tok=0;QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::entity_class() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::entity_class_entry() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::entity_class_entry_list() {QCString s,s1,s2;if (!hasError) {
return s1+s2;
assert(false);
-}
+ }
void VhdlParser::entity_declaration() {QCString s;if (!hasError) {
}
lastEntity=0;lastCompound=0; genLabels.resize(0);
-}
+ }
void VhdlParser::entity_declarative_item() {
}
}
}
-}
+ }
void VhdlParser::entity_declarative_part() {if (!hasError) {
end_label_16: ;
}
-}
+ }
QCString VhdlParser::entity_designator() {QCString s,s1;if (!hasError) {
return s+s1;
assert(false);
-}
+ }
void VhdlParser::entity_header() {if (!hasError) {
}
}
-}
+ }
QCString VhdlParser::entity_name_list() {QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::entity_specification() {QCString s,s1;if (!hasError) {
return s+":"+s1;
assert(false);
-}
+ }
void VhdlParser::entity_statement() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::entity_statement_part() {if (!hasError) {
end_label_18: ;
}
-}
+ }
QCString VhdlParser::entity_tag() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::enumeration_literal() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::enumeration_type_definition() {QCString s,s1;if (!hasError) {
return "("+s+")";
assert(false);
-}
+ }
QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;if (!hasError) {
return s+s1+s2+";";
assert(false);
-}
+ }
QCString VhdlParser::expression() {QCString s,s1,s2;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::logop() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::extended_identifier() {Token *t;if (!hasError) {
return t->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::factor() {QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::file_declaration() {QCString s,s1,s2,s3;if (!hasError) {
addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
return " file "+s+":"+s2+" "+s3+";";
assert(false);
-}
+ }
QCString VhdlParser::file_logical_name() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::file_open_information() {QCString s,s1,s2;if (!hasError) {
s2="open "+s+" is "+s1; return s2;
assert(false);
-}
+ }
QCString VhdlParser::file_type_definition() {QCString s,s1;if (!hasError) {
s1=" file of "+s; return s1;
assert(false);
-}
+ }
QCString VhdlParser::floating_type_definition() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::formal_designator() {QCString s;Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::formal_parameter_list() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::formal_part() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::full_type_declaration() {Entry *tmpEntry;QCString s,s1,s2;if (!hasError) {
tmpEntry=0;
return "type "+s+" is "+s2+";";
assert(false);
-}
+ }
QCString VhdlParser::function_call() {QCString s,s1;if (!hasError) {
return s+"("+s1+")";
assert(false);
-}
+ }
void VhdlParser::generate_statement() {QCString s;if (!hasError) {
}
genLabels=popLabel(genLabels);
-}
+ }
void VhdlParser::generate_scheme() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::generic_clause() {QCString s;if (!hasError) {
}
parse_sec=0;
-}
+ }
QCString VhdlParser::generic_list() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
void VhdlParser::generic_map_aspect() {if (!hasError) {
jj_consume_token(RPAREN_T);
}
-}
+ }
QCString VhdlParser::group_constituent() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::group_constituent_list() {QCString s,s1,s2;if (!hasError) {
return s+s2;
assert(false);
-}
+ }
QCString VhdlParser::group_declaration() {QCString s,s1,s2;if (!hasError) {
return "group "+s+":"+s1+"("+s2+");";
assert(false);
-}
+ }
QCString VhdlParser::group_template_declaration() {QCString s,s1;if (!hasError) {
return "group "+s+ "is ("+s1+");";
assert(false);
-}
+ }
void VhdlParser::guarded_signal_specification() {if (!hasError) {
type_mark();
}
-}
+ }
QCString VhdlParser::identifier() {Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::identifier_list() {QCString str,str1;if (!hasError) {
return str;
assert(false);
-}
+ }
void VhdlParser::if_statement() {QCString s,s1;if (!hasError) {
FlowChart::moveToPrevLevel();
FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
-}
+ }
QCString VhdlParser::incomplete_type_declaration() {QCString s;if (!hasError) {
return "type "+s+";";
assert(false);
-}
+ }
QCString VhdlParser::index_constraint() {QCString s="("; QCString s1,s2;if (!hasError) {
return s+")";
assert(false);
-}
+ }
QCString VhdlParser::index_specification() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::index_subtype_definition() {QCString s;if (!hasError) {
return s+" range <> ";
assert(false);
-}
+ }
QCString VhdlParser::instantiation_unit() {QCString s,s1,s2;Token *tok;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::instantiation_list() {QCString s;Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::integer() {Token *t;if (!hasError) {
return t->image.c_str();
assert(false);
-}
+ }
QCString VhdlParser::integer_type_definition() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::interface_declaration() {QCString s,s1;
}
}
assert(false);
-}
+ }
QCString VhdlParser::interface_element() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::interface_file_declaration() {QCString s,s1;if (!hasError) {
addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
return " file "+s+":"+s1;
assert(false);
-}
+ }
QCString VhdlParser::interface_list() {QCString s,s1,s2;if (!hasError) {
return s+s2;
assert(false);
-}
+ }
QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;if (!hasError) {
} // if component
return it;
assert(false);
-}
+ }
QCString VhdlParser::iteration_scheme() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::label() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::library_clause() {QCString s;if (!hasError) {
QCString s1="library "+s;
return s1;
assert(false);
-}
+ }
QCString VhdlParser::library_unit() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::literal() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::logical_operator() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::loop_statement() {QCString s,s1,s2,s3;if (!hasError) {
FlowChart::addFlowChart(FlowChart::END_LOOP,endLoop.data(),0);
return q;
assert(false);
-}
+ }
QCString VhdlParser::miscellaneous_operator() {Token *t=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::mode() {Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::multiplying_operation() {Token *tok=0;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::name() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::name_ext1() {QCString s,s1,s2;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::name_ext() {QCString s,s1,s2;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::test_att_name() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::indexed_name() {QCString s,s1,s2;if (!hasError) {
return s+")";
assert(false);
-}
+ }
QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;if (!hasError) {
if(t1) s2.prepend("when ");
return s+s1+s2+";";
assert(false);
-}
+ }
QCString VhdlParser::null_statement() {QCString s;if (!hasError) {
return s+="null";
assert(false);
-}
+ }
QCString VhdlParser::numeric_literal() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::object_class() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::operator_symbol() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
void VhdlParser::options() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::package_body() {QCString s;if (!hasError) {
}
lastCompound=0; genLabels.resize(0);
-}
+ }
void VhdlParser::package_body_declarative_item() {
}
}
}
-}
+ }
void VhdlParser::package_body_declarative_part() {if (!hasError) {
end_label_29: ;
}
-}
+ }
void VhdlParser::package_declaration() {QCString s;if (!hasError) {
}
lastEntity=0;lastCompound=0; genLabels.resize(0);
-}
+ }
void VhdlParser::geninter() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::package_declarative_item() {
}
}
}
-}
+ }
void VhdlParser::package_declarative_part() {if (!hasError) {
end_label_30: ;
}
-}
+ }
QCString VhdlParser::parameter_specification() {QCString s,s1;if (!hasError) {
return s+" in "+s1;
assert(false);
-}
+ }
QCString VhdlParser::physical_literal() {QCString s,s1;if (!hasError) {
s+=" ";s+=s1;s.prepend(" "); return s;
assert(false);
-}
+ }
QCString VhdlParser::physical_type_definition() {QCString s,s1,s2;if (!hasError) {
return s+"%";
assert(false);
-}
+ }
void VhdlParser::port_clause() {if (!hasError) {
}
currP=0;
-}
+ }
QCString VhdlParser::port_list() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
void VhdlParser::port_map_aspect() {if (!hasError) {
jj_consume_token(RPAREN_T);
}
-}
+ }
QCString VhdlParser::primary() {QCString s,s1;
}
}
assert(false);
-}
+ }
void VhdlParser::primary_unit() {
}
}
}
-}
+ }
QCString VhdlParser::procedure_call() {QCString s,s1;if (!hasError) {
return s+s1;
assert(false);
-}
+ }
QCString VhdlParser::procedure_call_statement() {QCString s,s1;if (!hasError) {
return s+s1+";";
assert(false);
-}
+ }
QCString VhdlParser::process_declarative_item() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::process_declarative_part() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;if (!hasError) {
createFlow();
currName="";
newEntry();
-}
+ }
void VhdlParser::process_statement_part() {if (!hasError) {
end_label_33: ;
}
-}
+ }
QCString VhdlParser::qualified_expression() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::range() {QCString s,s1,s2;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::range_constraint() {QCString s,s1;if (!hasError) {
return " range "+s;
assert(false);
-}
+ }
void VhdlParser::record_type_definition() {if (!hasError) {
}
}
-}
+ }
QCString VhdlParser::relation() {QCString s,s1,s2;if (!hasError) {
return s+s1+s2;
assert(false);
-}
+ }
QCString VhdlParser::relation_operator() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::report_statement() {Token *t=0;Token *t1=0;QCString s,s1,s2;if (!hasError) {
if(t1) s2.prepend(" severity ");
return s+s1+s2+";";
assert(false);
-}
+ }
QCString VhdlParser::return_statement() {QCString s,s1;if (!hasError) {
return s+" return "+s1+";";
assert(false);
-}
+ }
QCString VhdlParser::scalar_type_definition() {QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::secondary_unit() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
QCString VhdlParser::secondary_unit_declaration() {QCString s,s1;if (!hasError) {
return s+"="+s1;
assert(false);
-}
+ }
QCString VhdlParser::selected_name() {QCString s,s1;if (!hasError) {
return s+"."+s1;
assert(false);
-}
+ }
void VhdlParser::selected_signal_assignment() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::selected_waveforms() {if (!hasError) {
end_label_35: ;
}
-}
+ }
QCString VhdlParser::sensitivity_clause() {QCString s;if (!hasError) {
s.prepend(" on ");
return s;
assert(false);
-}
+ }
QCString VhdlParser::sensitivity_list() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::sequence_of_statement() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::sequential_statement() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::shift_expression() {QCString s,s1,s2;if (!hasError) {
return s+s1+s2;
assert(false);
-}
+ }
QCString VhdlParser::shift_operator() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::sign() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::signal_assignment_statement() {QCString s,s1,s2,s3;
}
}
assert(false);
-}
+ }
void VhdlParser::semi() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;if (!hasError) {
s3.prepend(":=");
s4=s1+s2+s3;
addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
-}
+ }
QCString VhdlParser::signal_kind() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::signal_list() {QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::signature() {QCString s,s1,s2;if (!hasError) {
s1="["+s+"]";return s1;
assert(false);
-}
+ }
QCString VhdlParser::simple_expression() {QCString s,s1,s2;if (!hasError) {
return s;
assert(false);
-}
+ }
void VhdlParser::simple_name() {if (!hasError) {
name();
}
-}
+ }
QCString VhdlParser::slice_name() {QCString s,s1;if (!hasError) {
return s+"("+s1+")";
assert(false);
-}
+ }
QCString VhdlParser::string_literal() {Token *tok=0;if (!hasError) {
return tok->image.c_str();
assert(false);
-}
+ }
void VhdlParser::subprogram_body() {QCString s;if (!hasError) {
tempEntry->endBodyLine=getLine(END_T);
createFlow();
currP=0;
-}
+ }
void VhdlParser::subprogram_declaration() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::subprogram_1() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
QCString VhdlParser::subprogram_declarative_item() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::subprogram_declarative_part() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
void VhdlParser::subprogram_kind() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::subprogram_specification() {QCString s;Token *tok=0;Token *t;
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::subprogram_statement_part() {if (!hasError) {
end_label_42: ;
}
-}
+ }
QCString VhdlParser::subtype_declaration() {QCString s,s1;if (!hasError) {
addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
return " subtype "+s+" is "+s1+";";
assert(false);
-}
+ }
QCString VhdlParser::subtype_indication() {QCString s,s1,s2;if (!hasError) {
return s+" "+s1+" "+s2;
assert(false);
-}
+ }
QCString VhdlParser::suffix() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::target() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::term() {QCString s,s1,s2;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::timeout_clause() {QCString s;if (!hasError) {
return " for "+s;
assert(false);
-}
+ }
QCString VhdlParser::type_conversion() {QCString s,s1;if (!hasError) {
return s+"("+s1+")";
assert(false);
-}
+ }
QCString VhdlParser::type_declaration() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::type_definition() {QCString s;
}
}
assert(false);
-}
+ }
QCString VhdlParser::type_mark() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::unconstraint_array_definition() {QCString s,s1,s2,s3;if (!hasError) {
return "array("+s+s3+") of "+s2;
assert(false);
-}
+ }
QCString VhdlParser::use_clause() {QCString s,s1;if (!hasError) {
s1="use "+s;
return s1;
assert(false);
-}
+ }
QCString VhdlParser::variable_assignment_statement() {QCString s,s1,s2;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s,s1,s2;if (!hasError) {
addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
return val;
assert(false);
-}
+ }
QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;if (!hasError) {
if(t) s.append(":");
return s+" wait "+s1+s2+s3+";";
assert(false);
-}
+ }
QCString VhdlParser::waveform() {QCString s,s1;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::waveform_element() {QCString s,s1;if (!hasError) {
return s+s1;
assert(false);
-}
+ }
QCString VhdlParser::protected_type_body() {if (!hasError) {
return "";
assert(false);
-}
+ }
void VhdlParser::protected_type_body_declarative_item() {
}
}
}
-}
+ }
void VhdlParser::protected_type_body_declarative_part() {if (!hasError) {
end_label_47: ;
}
-}
+ }
QCString VhdlParser::protected_type_declaration() {if (!hasError) {
return "";
assert(false);
-}
+ }
void VhdlParser::protected_type_declarative_item() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::protected_type_declarative_part() {if (!hasError) {
end_label_48: ;
}
-}
+ }
QCString VhdlParser::context_ref() {QCString s;if (!hasError) {
return "context "+s ;
assert(false);
-}
+ }
void VhdlParser::context_declaration() {QCString s,s1;if (!hasError) {
parse_sec=0;
addVhdlType(s.data(),getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
-}
+ }
QCString VhdlParser::libustcont_stats() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
void VhdlParser::package_instantiation_declaration() {QCString s,s1,s2;if (!hasError) {
QCString q=" is new "+s1+s2;
addVhdlType(s.data(),getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
-}
+ }
QCString VhdlParser::interface_package_declaration() {QCString s,s1;if (!hasError) {
current->name=s;
return "package "+s+" is new "+s1;
assert(false);
-}
+ }
QCString VhdlParser::subprogram_instantiation_declaration() {QCString s,s1,s2;if (!hasError) {
addVhdlType(s.data(),getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
return q;
assert(false);
-}
+ }
void VhdlParser::gen_assoc_list() {if (!hasError) {
jj_consume_token(RPAREN_T);
}
-}
+ }
void VhdlParser::gen_interface_list() {if (!hasError) {
jj_consume_token(RPAREN_T);
}
-}
+ }
void VhdlParser::case_scheme() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::when_stats() {if (!hasError) {
end_label_50: ;
}
-}
+ }
void VhdlParser::ttend() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::generate_statement_body() {if (!hasError) {
generate_statement_body();
}
-}
+ }
void VhdlParser::generate_statement_body1() {if (!hasError) {
end_label_52: ;
}
-}
+ }
QCString VhdlParser::external_name() {QCString s,s1,s2;if (!hasError) {
QCString t1=s1+":"+s2+">>";
return s+s1;
assert(false);
-}
+ }
QCString VhdlParser::sig_stat() {Token *t;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::external_pathname() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::absolute_pathname() {QCString s,s1;
}
}
assert(false);
-}
+ }
QCString VhdlParser::relative_pathname() {QCString s,s1,s2;if (!hasError) {
return s+s1+s2;
assert(false);
-}
+ }
QCString VhdlParser::neg_list() {QCString s;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::pathname_element() {QCString s,s1;if (!hasError) {
return s;
assert(false);
-}
+ }
QCString VhdlParser::pathname_element_list() {QCString s,s1,s2;if (!hasError) {
return s+s2;
assert(false);
-}
+ }
QCString VhdlParser::package_path_name() {QCString s;if (!hasError) {
return "@"+s;
assert(false);
-}
+ }
void VhdlParser::conditional_signal_assignment_wave() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::conditional_waveform_assignment() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::else_wave_list() {if (!hasError) {
}
}
-}
+ }
void VhdlParser::conditional_force_assignment() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::selected_signal_assignment_wave() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::selected_variable_assignment() {if (!hasError) {
sel_var_list();
}
-}
+ }
void VhdlParser::select_name() {
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
}
-}
+ }
void VhdlParser::selected_waveform_assignment() {if (!hasError) {
sel_wave_list();
}
-}
+ }
void VhdlParser::selected_force_assignment() {if (!hasError) {
sel_var_list();
}
-}
+ }
void VhdlParser::sel_var_list() {if (!hasError) {
end_label_55: ;
}
-}
+ }
void VhdlParser::sel_wave_list() {if (!hasError) {
jj_consume_token(SEMI_T);
}
-}
+ }
void VhdlParser::inout_stat() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
void VhdlParser::else_stat() {if (!hasError) {
end_label_57: ;
}
-}
+ }
QCString VhdlParser::interface_subprogram_declaration() {QCString s;
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
assert(false);
-}
+ }
QCString VhdlParser::iproc() {QCString s,s1;if (!hasError) {
current->name=s;
return "procedure "+s+s1;
assert(false);
-}
+ }
QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;if (!hasError) {
}
currP=0;return "";
assert(false);
-}
+ }
QCString VhdlParser::param() {QCString s,s1;Token *tok=0;if (!hasError) {
param_sec=0;
return s+"("+s1+")";
assert(false);
-}
+ }
void VhdlParser::parseInline() {
jj_consume_token(-1);
errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
}
-}
+ }
VhdlParser::VhdlParser(TokenManager *tm){
head = NULL;
- errorHandlerCreated = false;
ReInit(tm);
}
-VhdlParser::~VhdlParser()
+ VhdlParser::~VhdlParser()
{
- clear();
+ if (token_source) delete token_source;
+ if (head) {
+ Token *next, *t = head;
+ while (t) {
+ next = t->next;
+ delete t;
+ t = next;
+ }
+ }
+ if (errorHandlerCreated) {
+ delete errorHandler;
+ }
}
void VhdlParser::ReInit(TokenManager *tm){
- clear();
+ if (head) delete head;
errorHandler = new ErrorHandler();
errorHandlerCreated = true;
hasError = false;
}
-void VhdlParser::clear(){
- //Since token manager was generate from outside,
- //parser should not take care of deleting
- //if (token_source) delete token_source;
- if (head) {
- Token *next, *t = head;
- while (t) {
- next = t->next;
- delete t;
- t = next;
- }
- }
- if (errorHandlerCreated) {
- delete errorHandler;
- }
-}
-
-
Token * VhdlParser::jj_consume_token(int kind) {
Token *oldToken;
if ((oldToken = token)->next != NULL) token = token->next;
token = oldToken;
jj_kind = kind;
JAVACC_STRING_TYPE image = kind >= 0 ? tokenImage[kind] : tokenImage[0];
- errorHandler->handleUnexpectedToken(kind, image.substr(1, image.size() - 2), getToken(1), this);
- hasError = true;
+ errorHandler->handleUnexpectedToken(kind, image.substr(1, image.size() - 2), getToken(1), this), hasError = true;
return token;
}
}
- void VhdlParser::jj_add_error_token(int kind, int pos) {
+void VhdlParser::jj_add_error_token(int kind, int pos) {
}
+ /** Generate ParseException. */
void VhdlParser::parseError() {
fprintf(stderr, "Parse error at: %d:%d, after token: %s encountered: %s\n", token->beginLine, token->beginColumn, addUnicodeEscapes(token->image).c_str(), addUnicodeEscapes(getToken(1)->image).c_str());
}
- void VhdlParser::enable_tracing() {
+ void VhdlParser::enable_tracing() {
}
- void VhdlParser::disable_tracing() {
+ /** Disable tracing. */
+
+ void VhdlParser::disable_tracing() {
}
- void VhdlParser::jj_rescan_token(){
+void VhdlParser::jj_rescan_token(){
jj_rescan = true;
for (int i = 0; i < 115; i++) {
JJCalls *p = &jj_2_rtns[i];
}
- void VhdlParser::jj_save(int index, int xla){
+void VhdlParser::jj_save(int index, int xla){
JJCalls *p = &jj_2_rtns[index];
while (p->gen > jj_gen) {
if (p->next == NULL) { p = p->next = new JJCalls(); break; }
namespace vhdl {
namespace parser {
struct JJCalls {
- int gen;
- int arg;
- JJCalls* next;
- Token* first;
+ int gen;
+ Token *first;
+ int arg;
+ JJCalls *next;
~JJCalls() { if (next) delete next; }
- JJCalls() { next = NULL; arg = 0; gen = -1; first = NULL; }
+ JJCalls() { next = NULL; arg = 0; gen = -1; first = NULL; }
};
class VhdlParser {
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_1() || jj_done);
+ return !jj_3_1() || jj_done;
{ jj_save(0, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_2() || jj_done);
+ return !jj_3_2() || jj_done;
{ jj_save(1, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_3() || jj_done);
+ return !jj_3_3() || jj_done;
{ jj_save(2, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_4() || jj_done);
+ return !jj_3_4() || jj_done;
{ jj_save(3, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_5() || jj_done);
+ return !jj_3_5() || jj_done;
{ jj_save(4, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_6() || jj_done);
+ return !jj_3_6() || jj_done;
{ jj_save(5, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_7() || jj_done);
+ return !jj_3_7() || jj_done;
{ jj_save(6, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_8() || jj_done);
+ return !jj_3_8() || jj_done;
{ jj_save(7, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_9() || jj_done);
+ return !jj_3_9() || jj_done;
{ jj_save(8, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_10() || jj_done);
+ return !jj_3_10() || jj_done;
{ jj_save(9, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_11() || jj_done);
+ return !jj_3_11() || jj_done;
{ jj_save(10, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_12() || jj_done);
+ return !jj_3_12() || jj_done;
{ jj_save(11, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_13() || jj_done);
+ return !jj_3_13() || jj_done;
{ jj_save(12, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_14() || jj_done);
+ return !jj_3_14() || jj_done;
{ jj_save(13, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_15() || jj_done);
+ return !jj_3_15() || jj_done;
{ jj_save(14, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_16() || jj_done);
+ return !jj_3_16() || jj_done;
{ jj_save(15, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_17() || jj_done);
+ return !jj_3_17() || jj_done;
{ jj_save(16, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_18() || jj_done);
+ return !jj_3_18() || jj_done;
{ jj_save(17, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_19() || jj_done);
+ return !jj_3_19() || jj_done;
{ jj_save(18, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_20() || jj_done);
+ return !jj_3_20() || jj_done;
{ jj_save(19, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_21() || jj_done);
+ return !jj_3_21() || jj_done;
{ jj_save(20, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_22() || jj_done);
+ return !jj_3_22() || jj_done;
{ jj_save(21, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_23() || jj_done);
+ return !jj_3_23() || jj_done;
{ jj_save(22, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_24() || jj_done);
+ return !jj_3_24() || jj_done;
{ jj_save(23, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_25() || jj_done);
+ return !jj_3_25() || jj_done;
{ jj_save(24, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_26() || jj_done);
+ return !jj_3_26() || jj_done;
{ jj_save(25, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_27() || jj_done);
+ return !jj_3_27() || jj_done;
{ jj_save(26, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_28() || jj_done);
+ return !jj_3_28() || jj_done;
{ jj_save(27, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_29() || jj_done);
+ return !jj_3_29() || jj_done;
{ jj_save(28, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_30() || jj_done);
+ return !jj_3_30() || jj_done;
{ jj_save(29, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_31() || jj_done);
+ return !jj_3_31() || jj_done;
{ jj_save(30, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_32() || jj_done);
+ return !jj_3_32() || jj_done;
{ jj_save(31, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_33() || jj_done);
+ return !jj_3_33() || jj_done;
{ jj_save(32, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_34() || jj_done);
+ return !jj_3_34() || jj_done;
{ jj_save(33, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_35() || jj_done);
+ return !jj_3_35() || jj_done;
{ jj_save(34, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_36() || jj_done);
+ return !jj_3_36() || jj_done;
{ jj_save(35, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_37() || jj_done);
+ return !jj_3_37() || jj_done;
{ jj_save(36, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_38() || jj_done);
+ return !jj_3_38() || jj_done;
{ jj_save(37, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_39() || jj_done);
+ return !jj_3_39() || jj_done;
{ jj_save(38, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_40() || jj_done);
+ return !jj_3_40() || jj_done;
{ jj_save(39, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_41() || jj_done);
+ return !jj_3_41() || jj_done;
{ jj_save(40, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_42() || jj_done);
+ return !jj_3_42() || jj_done;
{ jj_save(41, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_43() || jj_done);
+ return !jj_3_43() || jj_done;
{ jj_save(42, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_44() || jj_done);
+ return !jj_3_44() || jj_done;
{ jj_save(43, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_45() || jj_done);
+ return !jj_3_45() || jj_done;
{ jj_save(44, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_46() || jj_done);
+ return !jj_3_46() || jj_done;
{ jj_save(45, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_47() || jj_done);
+ return !jj_3_47() || jj_done;
{ jj_save(46, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_48() || jj_done);
+ return !jj_3_48() || jj_done;
{ jj_save(47, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_49() || jj_done);
+ return !jj_3_49() || jj_done;
{ jj_save(48, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_50() || jj_done);
+ return !jj_3_50() || jj_done;
{ jj_save(49, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_51() || jj_done);
+ return !jj_3_51() || jj_done;
{ jj_save(50, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_52() || jj_done);
+ return !jj_3_52() || jj_done;
{ jj_save(51, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_53() || jj_done);
+ return !jj_3_53() || jj_done;
{ jj_save(52, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_54() || jj_done);
+ return !jj_3_54() || jj_done;
{ jj_save(53, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_55() || jj_done);
+ return !jj_3_55() || jj_done;
{ jj_save(54, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_56() || jj_done);
+ return !jj_3_56() || jj_done;
{ jj_save(55, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_57() || jj_done);
+ return !jj_3_57() || jj_done;
{ jj_save(56, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_58() || jj_done);
+ return !jj_3_58() || jj_done;
{ jj_save(57, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_59() || jj_done);
+ return !jj_3_59() || jj_done;
{ jj_save(58, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_60() || jj_done);
+ return !jj_3_60() || jj_done;
{ jj_save(59, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_61() || jj_done);
+ return !jj_3_61() || jj_done;
{ jj_save(60, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_62() || jj_done);
+ return !jj_3_62() || jj_done;
{ jj_save(61, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_63() || jj_done);
+ return !jj_3_63() || jj_done;
{ jj_save(62, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_64() || jj_done);
+ return !jj_3_64() || jj_done;
{ jj_save(63, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_65() || jj_done);
+ return !jj_3_65() || jj_done;
{ jj_save(64, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_66() || jj_done);
+ return !jj_3_66() || jj_done;
{ jj_save(65, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_67() || jj_done);
+ return !jj_3_67() || jj_done;
{ jj_save(66, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_68() || jj_done);
+ return !jj_3_68() || jj_done;
{ jj_save(67, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_69() || jj_done);
+ return !jj_3_69() || jj_done;
{ jj_save(68, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_70() || jj_done);
+ return !jj_3_70() || jj_done;
{ jj_save(69, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_71() || jj_done);
+ return !jj_3_71() || jj_done;
{ jj_save(70, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_72() || jj_done);
+ return !jj_3_72() || jj_done;
{ jj_save(71, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_73() || jj_done);
+ return !jj_3_73() || jj_done;
{ jj_save(72, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_74() || jj_done);
+ return !jj_3_74() || jj_done;
{ jj_save(73, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_75() || jj_done);
+ return !jj_3_75() || jj_done;
{ jj_save(74, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_76() || jj_done);
+ return !jj_3_76() || jj_done;
{ jj_save(75, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_77() || jj_done);
+ return !jj_3_77() || jj_done;
{ jj_save(76, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_78() || jj_done);
+ return !jj_3_78() || jj_done;
{ jj_save(77, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_79() || jj_done);
+ return !jj_3_79() || jj_done;
{ jj_save(78, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_80() || jj_done);
+ return !jj_3_80() || jj_done;
{ jj_save(79, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_81() || jj_done);
+ return !jj_3_81() || jj_done;
{ jj_save(80, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_82() || jj_done);
+ return !jj_3_82() || jj_done;
{ jj_save(81, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_83() || jj_done);
+ return !jj_3_83() || jj_done;
{ jj_save(82, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_84() || jj_done);
+ return !jj_3_84() || jj_done;
{ jj_save(83, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_85() || jj_done);
+ return !jj_3_85() || jj_done;
{ jj_save(84, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_86() || jj_done);
+ return !jj_3_86() || jj_done;
{ jj_save(85, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_87() || jj_done);
+ return !jj_3_87() || jj_done;
{ jj_save(86, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_88() || jj_done);
+ return !jj_3_88() || jj_done;
{ jj_save(87, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_89() || jj_done);
+ return !jj_3_89() || jj_done;
{ jj_save(88, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_90() || jj_done);
+ return !jj_3_90() || jj_done;
{ jj_save(89, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_91() || jj_done);
+ return !jj_3_91() || jj_done;
{ jj_save(90, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_92() || jj_done);
+ return !jj_3_92() || jj_done;
{ jj_save(91, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_93() || jj_done);
+ return !jj_3_93() || jj_done;
{ jj_save(92, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_94() || jj_done);
+ return !jj_3_94() || jj_done;
{ jj_save(93, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_95() || jj_done);
+ return !jj_3_95() || jj_done;
{ jj_save(94, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_96() || jj_done);
+ return !jj_3_96() || jj_done;
{ jj_save(95, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_97() || jj_done);
+ return !jj_3_97() || jj_done;
{ jj_save(96, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_98() || jj_done);
+ return !jj_3_98() || jj_done;
{ jj_save(97, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_99() || jj_done);
+ return !jj_3_99() || jj_done;
{ jj_save(98, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_100() || jj_done);
+ return !jj_3_100() || jj_done;
{ jj_save(99, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_101() || jj_done);
+ return !jj_3_101() || jj_done;
{ jj_save(100, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_102() || jj_done);
+ return !jj_3_102() || jj_done;
{ jj_save(101, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_103() || jj_done);
+ return !jj_3_103() || jj_done;
{ jj_save(102, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_104() || jj_done);
+ return !jj_3_104() || jj_done;
{ jj_save(103, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_105() || jj_done);
+ return !jj_3_105() || jj_done;
{ jj_save(104, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_106() || jj_done);
+ return !jj_3_106() || jj_done;
{ jj_save(105, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_107() || jj_done);
+ return !jj_3_107() || jj_done;
{ jj_save(106, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_108() || jj_done);
+ return !jj_3_108() || jj_done;
{ jj_save(107, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_109() || jj_done);
+ return !jj_3_109() || jj_done;
{ jj_save(108, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_110() || jj_done);
+ return !jj_3_110() || jj_done;
{ jj_save(109, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_111() || jj_done);
+ return !jj_3_111() || jj_done;
{ jj_save(110, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_112() || jj_done);
+ return !jj_3_112() || jj_done;
{ jj_save(111, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_113() || jj_done);
+ return !jj_3_113() || jj_done;
{ jj_save(112, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_114() || jj_done);
+ return !jj_3_114() || jj_done;
{ jj_save(113, xla); }
}
{
jj_la = xla; jj_lastpos = jj_scanpos = token;
jj_done = false;
- return (!jj_3_115() || jj_done);
+ return !jj_3_115() || jj_done;
{ jj_save(114, xla); }
}
- inline bool jj_3R_228()
- {
- if (jj_done) return true;
- if (jj_3R_94()) return true;
- return false;
- }
-
- inline bool jj_3R_106()
- {
- if (jj_done) return true;
- Token * xsp;
- xsp = jj_scanpos;
- if (jj_3R_228()) {
- jj_scanpos = xsp;
- if (jj_3R_229()) {
- jj_scanpos = xsp;
- if (jj_3R_230()) {
- jj_scanpos = xsp;
- if (jj_3R_231()) {
- jj_scanpos = xsp;
- if (jj_3R_232()) return true;
- }
- }
- }
- }
- return false;
- }
-
inline bool jj_3_43()
{
if (jj_done) return true;
jj_scanpos = xsp;
if (jj_3R_503()) {
jj_scanpos = xsp;
- if (jj_scan_token(187)) return true;
+ if (jj_scan_token(189)) return true;
}
}
}
return false;
}
+ inline bool jj_3R_228()
+ {
+ if (jj_done) return true;
+ if (jj_3R_94()) return true;
+ return false;
+ }
+
+ inline bool jj_3R_106()
+ {
+ if (jj_done) return true;
+ Token * xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_228()) {
+ jj_scanpos = xsp;
+ if (jj_3R_229()) {
+ jj_scanpos = xsp;
+ if (jj_3R_230()) {
+ jj_scanpos = xsp;
+ if (jj_3R_231()) {
+ jj_scanpos = xsp;
+ if (jj_3R_232()) return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
-public:
- TokenManager *token_source;
- CharStream *jj_input_stream;
+ public: TokenManager *token_source;
+ public: CharStream *jj_input_stream;
/** Current token. */
- Token *token;
+ public: Token *token;
/** Next token. */
- Token *jj_nt;
-private:
- int jj_ntk;
- JJCalls jj_2_rtns[116];
- bool jj_rescan;
- int jj_gc;
- Token *jj_scanpos, *jj_lastpos;
- int jj_la;
+ public: Token *jj_nt;
+ private: int jj_ntk;
+ private: JJCalls jj_2_rtns[116];
+ private: bool jj_rescan;
+ private: int jj_gc;
+ private: Token *jj_scanpos, *jj_lastpos;
+ private: int jj_la;
/** Whether we are looking ahead. */
- bool jj_lookingAhead;
- bool jj_semLA;
- int jj_gen;
- int jj_la1[294];
- ErrorHandler *errorHandler;
- bool errorHandlerCreated;
-protected:
- bool hasError;
-public:
- void setErrorHandler(ErrorHandler *eh) {
+ private: bool jj_lookingAhead;
+ private: bool jj_semLA;
+ private: int jj_gen;
+ private: int jj_la1[294];
+ private: ErrorHandler *errorHandler;
+ private: bool errorHandlerCreated;
+ protected: bool hasError;
+ public: void setErrorHandler(ErrorHandler *eh) {
if (errorHandlerCreated) delete errorHandler;
errorHandler = eh;
errorHandlerCreated = false;
}
- Token *head;
-public:
+ Token *head;
+ public:
VhdlParser(TokenManager *tm);
- virtual ~VhdlParser();
+ public: virtual ~VhdlParser();
void ReInit(TokenManager *tm);
-void clear();
-
Token * jj_consume_token(int kind);
bool jj_scan_token(int kind);
Token * getToken(int index);
int jj_ntk_f();
-private:
- int jj_kind;
+ private: int jj_kind;
int **jj_expentries;
int *jj_expentry;
- void jj_add_error_token(int kind, int pos);
-protected:
- /** Generate ParseException. */
-
- virtual void parseError();
-private:
- int trace_indent;
- bool trace_enabled;
+void jj_add_error_token(int kind, int pos);
-public:
+protected: virtual void parseError();
+ private: int trace_indent;
+ private: bool trace_enabled;
+ /** Enable tracing. */
- void enable_tracing();
+public: void enable_tracing();
- void disable_tracing();
+public: void disable_tracing();
- void jj_rescan_token();
+void jj_rescan_token();
- void jj_save(int index, int xla);
+void jj_save(int index, int xla);
typedef unsigned long long uint64;
static Entry* current_root;
static void createFlow();
static void error_skipto(int kind);
static void oneLineComment(QCString qcs);
-static void setMultCommentLine();
+static void setMultCommentLine();private: bool jj_done;
-private:
- bool jj_done;
};
}
}
/** RegularExpression Id. */
const int LETTER_OR_DIGIT = 176;
/** RegularExpression Id. */
-const int LETTER = 177;
+const int LETTER_OR_DIGIT_OR_STD = 177;
/** RegularExpression Id. */
-const int UPPER_CASE_LETTER = 178;
+const int LETTER = 178;
/** RegularExpression Id. */
-const int BIT_STRING_LITERAL = 179;
+const int UPPER_CASE_LETTER = 179;
/** RegularExpression Id. */
-const int BASE_SPECIFIER = 180;
+const int BIT_STRING_LITERAL = 180;
/** RegularExpression Id. */
-const int DIGIT = 181;
+const int BASE_SPECIFIER = 181;
/** RegularExpression Id. */
-const int SPECIAL_CHARACTER = 182;
+const int STD_LOGIC = 182;
/** RegularExpression Id. */
-const int OTHER_SPECIAL_CHARACTER = 183;
+const int DIGIT = 183;
/** RegularExpression Id. */
-const int SPACE_CHARACTER = 184;
+const int SPECIAL_CHARACTER = 184;
/** RegularExpression Id. */
-const int LOWER_CASE_LETTER = 185;
+const int OTHER_SPECIAL_CHARACTER = 185;
/** RegularExpression Id. */
-const int QUOTE = 186;
+const int SPACE_CHARACTER = 186;
/** RegularExpression Id. */
-const int VHDL2008TOOLDIR = 187;
+const int LOWER_CASE_LETTER = 187;
+ /** RegularExpression Id. */
+const int QUOTE = 188;
+ /** RegularExpression Id. */
+const int VHDL2008TOOLDIR = 189;
/** Lexical state. */
const int DEFAULT = 0;
static JAVACC_CHAR_TYPE tokenImage_arr_176[] =
{0x22, 0x3c, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x5f, 0x4f, 0x52, 0x5f, 0x44, 0x49, 0x47, 0x49, 0x54, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_177[] =
-{0x22, 0x3c, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x5f, 0x4f, 0x52, 0x5f, 0x44, 0x49, 0x47, 0x49, 0x54, 0x5f, 0x4f, 0x52, 0x5f, 0x53, 0x54, 0x44, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_178[] =
-{0x22, 0x3c, 0x55, 0x50, 0x50, 0x45, 0x52, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_179[] =
-{0x22, 0x3c, 0x42, 0x49, 0x54, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x4c, 0x49, 0x54, 0x45, 0x52, 0x41, 0x4c, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x55, 0x50, 0x50, 0x45, 0x52, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_180[] =
-{0x22, 0x3c, 0x42, 0x41, 0x53, 0x45, 0x5f, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x42, 0x49, 0x54, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x4c, 0x49, 0x54, 0x45, 0x52, 0x41, 0x4c, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_181[] =
-{0x22, 0x3c, 0x44, 0x49, 0x47, 0x49, 0x54, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x42, 0x41, 0x53, 0x45, 0x5f, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x52, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_182[] =
-{0x22, 0x3c, 0x53, 0x50, 0x45, 0x43, 0x49, 0x41, 0x4c, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x41, 0x43, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x53, 0x54, 0x44, 0x5f, 0x4c, 0x4f, 0x47, 0x49, 0x43, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_183[] =
-{0x22, 0x3c, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x5f, 0x53, 0x50, 0x45, 0x43, 0x49, 0x41, 0x4c, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x41, 0x43, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x44, 0x49, 0x47, 0x49, 0x54, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_184[] =
-{0x22, 0x3c, 0x53, 0x50, 0x41, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x41, 0x43, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x53, 0x50, 0x45, 0x43, 0x49, 0x41, 0x4c, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x41, 0x43, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_185[] =
-{0x22, 0x3c, 0x4c, 0x4f, 0x57, 0x45, 0x52, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x5f, 0x53, 0x50, 0x45, 0x43, 0x49, 0x41, 0x4c, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x41, 0x43, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_186[] =
-{0x22, 0x3c, 0x51, 0x55, 0x4f, 0x54, 0x45, 0x3e, 0x22, 0};
+{0x22, 0x3c, 0x53, 0x50, 0x41, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x41, 0x43, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
static JAVACC_CHAR_TYPE tokenImage_arr_187[] =
+{0x22, 0x3c, 0x4c, 0x4f, 0x57, 0x45, 0x52, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x4c, 0x45, 0x54, 0x54, 0x45, 0x52, 0x3e, 0x22, 0};
+ static JAVACC_CHAR_TYPE tokenImage_arr_188[] =
+{0x22, 0x3c, 0x51, 0x55, 0x4f, 0x54, 0x45, 0x3e, 0x22, 0};
+ static JAVACC_CHAR_TYPE tokenImage_arr_189[] =
{0x22, 0x3c, 0x56, 0x48, 0x44, 0x4c, 0x32, 0x30, 0x30, 0x38, 0x54, 0x4f, 0x4f, 0x4c, 0x44, 0x49, 0x52, 0x3e, 0x22, 0};
static JAVACC_STRING_TYPE tokenImage[] = {
tokenImage_arr_0,
tokenImage_arr_185,
tokenImage_arr_186,
tokenImage_arr_187,
+tokenImage_arr_188,
+tokenImage_arr_189,
};
}
/* VhdlParserTokenManager.cc */
-#include "VhdlParserTokenManager.h"
-#include "TokenMgrError.h"
+#include "./VhdlParserTokenManager.h"
namespace vhdl {
namespace parser {
static const unsigned long long jjbitVec0[] = {
0x0ULL, 0x0ULL, 0xffffffff00000000ULL, 0xffffffffffffffffULL
};
static const int jjnextStates[] = {
- 54, 55, 56, 57, 58, 61, 65, 66, 67, 48, 49, 2, 37, 38, 0, 3,
- 4, 5, 7, 12, 13, 15, 16, 24, 23, 25, 33, 34, 36, 39, 40, 42,
- 56, 57, 58, 61, 60, 59, 61, 65, 66, 67, 68, 69, 71, 9, 10, 28,
- 29, 45, 47, 50, 52, 27, 30,
+ 54, 55, 56, 57, 58, 61, 65, 66, 67, 76, 21, 48, 49, 2, 37, 38,
+ 0, 3, 4, 5, 7, 12, 13, 15, 16, 24, 23, 25, 33, 34, 36, 39,
+ 40, 42, 56, 57, 58, 61, 60, 59, 61, 65, 66, 67, 68, 69, 71, 9,
+ 10, 28, 29, 45, 47, 50, 52, 27, 30,
};
static JAVACC_CHAR_TYPE jjstrLiteralChars_0[] = {0};
static JAVACC_CHAR_TYPE jjstrLiteralChars_1[] = {0};
static JAVACC_CHAR_TYPE jjstrLiteralChars_185[] = {0};
static JAVACC_CHAR_TYPE jjstrLiteralChars_186[] = {0};
static JAVACC_CHAR_TYPE jjstrLiteralChars_187[] = {0};
+static JAVACC_CHAR_TYPE jjstrLiteralChars_188[] = {0};
+static JAVACC_CHAR_TYPE jjstrLiteralChars_189[] = {0};
static const JAVACC_STRING_TYPE jjstrLiteralImages[] = {
jjstrLiteralChars_0,
jjstrLiteralChars_1,
jjstrLiteralChars_185,
jjstrLiteralChars_186,
jjstrLiteralChars_187,
+jjstrLiteralChars_188,
+jjstrLiteralChars_189,
};
/** Lexer state names. */
lexStateNames_arr_0,
};
static const unsigned long long jjtoToken[] = {
- 0xfffffffffffff801ULL, 0xffffffffffffffffULL, 0x8081fffffffffffULL,
+ 0xfffffffffffff801ULL, 0xffffffffffffffffULL, 0x20101fffffffffffULL,
};
static const unsigned long long jjtoSkip[] = {
0x7deULL, 0x0ULL, 0x0ULL,
curChar = input_stream->readChar();
curPos = 0;
int startsAt = 0;
- jjnewStateCnt = 76;
+ jjnewStateCnt = 77;
int i = 1;
jjstateSet[0] = startState;
int kind = 0x7fffffff;
{
if (kind > 165)
kind = 165;
- { jjCheckNAddStates(0, 8); }
+ { jjCheckNAddStates(0, 10); }
}
else if ((0x100000200ULL & l) != 0L)
{ jjCheckNAddTwoStates(0, 3); }
else if (curChar == 47)
- { jjAddStates(9, 10); }
+ { jjAddStates(11, 12); }
else if (curChar == 45)
- { jjCheckNAddStates(11, 13); }
+ { jjCheckNAddStates(13, 15); }
else if (curChar == 39)
jjstateSet[jjnewStateCnt++] = 18;
else if (curChar == 34)
break;
if (kind > 6)
kind = 6;
- { jjCheckNAddStates(14, 18); }
+ { jjCheckNAddStates(16, 20); }
break;
case 2:
if (curChar == 45)
break;
if (kind > 6)
kind = 6;
- { jjCheckNAddStates(14, 18); }
+ { jjCheckNAddStates(16, 20); }
break;
case 5:
if ((0x2400ULL & l) == 0L)
break;
if (kind > 167)
kind = 167;
- { jjAddStates(19, 20); }
+ { jjAddStates(21, 22); }
break;
case 15:
if ((0xfffffffb00000200ULL & l) != 0L)
- { jjAddStates(21, 22); }
+ { jjAddStates(23, 24); }
break;
case 17:
if (curChar == 39)
{ jjCheckNAdd(23); }
break;
case 23:
- if ((0x3ff000000000000ULL & l) != 0L)
- { jjCheckNAddStates(23, 25); }
+ if ((0x3ff200000000000ULL & l) != 0L)
+ { jjCheckNAddStates(25, 27); }
break;
case 25:
- if (curChar == 34 && kind > 179)
- kind = 179;
+ if (curChar == 34 && kind > 180)
+ kind = 180;
break;
case 27:
if (curChar == 34)
case 29:
if (curChar != 34)
break;
- if (kind > 187)
- kind = 187;
+ if (kind > 189)
+ kind = 189;
{ jjCheckNAddTwoStates(27, 30); }
break;
case 30:
if ((0xfffffffb00000200ULL & l) == 0L)
break;
- if (kind > 187)
- kind = 187;
+ if (kind > 189)
+ kind = 189;
{ jjCheckNAddTwoStates(27, 30); }
break;
case 31:
if (curChar == 45)
- { jjCheckNAddStates(11, 13); }
+ { jjCheckNAddStates(13, 15); }
break;
case 32:
if (curChar != 35)
break;
if (kind > 7)
kind = 7;
- { jjCheckNAddStates(26, 28); }
+ { jjCheckNAddStates(28, 30); }
break;
case 33:
if ((0xffffffffffffdbffULL & l) == 0L)
break;
if (kind > 7)
kind = 7;
- { jjCheckNAddStates(26, 28); }
+ { jjCheckNAddStates(28, 30); }
break;
case 34:
if ((0x2400ULL & l) != 0L && kind > 7)
break;
if (kind > 8)
kind = 8;
- { jjCheckNAddStates(29, 31); }
+ { jjCheckNAddStates(31, 33); }
break;
case 39:
if ((0xffffffffffffdbffULL & l) == 0L)
break;
if (kind > 8)
kind = 8;
- { jjCheckNAddStates(29, 31); }
+ { jjCheckNAddStates(31, 33); }
break;
case 40:
if ((0x2400ULL & l) != 0L && kind > 8)
break;
case 43:
if (curChar == 47)
- { jjAddStates(9, 10); }
+ { jjAddStates(11, 12); }
break;
case 44:
if (curChar == 33)
break;
if (kind > 165)
kind = 165;
- { jjCheckNAddStates(0, 8); }
+ { jjCheckNAddStates(0, 10); }
break;
case 55:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 170)
kind = 170;
- { jjCheckNAddStates(32, 35); }
+ { jjCheckNAddStates(34, 37); }
break;
case 58:
if (curChar == 46)
break;
if (kind > 170)
kind = 170;
- { jjCheckNAddStates(36, 38); }
+ { jjCheckNAddStates(38, 40); }
break;
case 62:
if ((0x280000000000ULL & l) != 0L)
break;
case 66:
if ((0x3ff000000000000ULL & l) != 0L)
- { jjCheckNAddStates(39, 41); }
+ { jjCheckNAddStates(41, 43); }
break;
case 67:
if (curChar == 35)
break;
case 68:
if ((0x3ff000000000000ULL & l) != 0L)
- { jjCheckNAddStates(42, 44); }
+ { jjCheckNAddStates(44, 46); }
break;
case 69:
if (curChar == 46)
kind = 172;
{ jjCheckNAddTwoStates(75, 74); }
break;
+ case 76:
+ if ((0x3ff000000000000ULL & l) != 0L)
+ { jjCheckNAddTwoStates(76, 21); }
+ break;
default : break;
}
} while(i != startsAt);
kind = 167;
{ jjCheckNAddTwoStates(12, 13); }
}
- if ((0x100800401008004ULL & l) != 0L)
+ if ((0x100801401008014ULL & l) != 0L)
jjstateSet[jjnewStateCnt++] = 22;
break;
case 4:
if (kind > 6)
kind = 6;
- { jjAddStates(14, 18); }
+ { jjAddStates(16, 20); }
break;
case 9:
if ((0x7fffffffffffffffULL & l) != 0L)
- { jjAddStates(45, 46); }
+ { jjAddStates(47, 48); }
break;
case 12:
if (curChar == 95)
{ jjCheckNAdd(20); }
break;
case 21:
- if ((0x100800401008004ULL & l) != 0L)
+ if ((0x100801401008014ULL & l) != 0L)
jjstateSet[jjnewStateCnt++] = 22;
break;
case 23:
if ((0x7fffffe07fffffeULL & l) != 0L)
- { jjCheckNAddStates(23, 25); }
+ { jjCheckNAddStates(25, 27); }
break;
case 24:
if (curChar == 95)
break;
case 28:
if ((0x7fffffffffffffffULL & l) != 0L)
- { jjAddStates(47, 48); }
+ { jjAddStates(49, 50); }
break;
case 30:
if ((0x7fffffffffffffffULL & l) == 0L)
break;
- if (kind > 187)
- kind = 187;
+ if (kind > 189)
+ kind = 189;
{ jjCheckNAddTwoStates(27, 30); }
break;
case 33:
if (kind > 7)
kind = 7;
- { jjAddStates(26, 28); }
+ { jjAddStates(28, 30); }
break;
case 39:
if (kind > 8)
kind = 8;
- { jjAddStates(29, 31); }
+ { jjAddStates(31, 33); }
break;
case 45:
- { jjAddStates(49, 50); }
+ { jjAddStates(51, 52); }
break;
case 50:
- { jjAddStates(51, 52); }
+ { jjAddStates(53, 54); }
break;
case 54:
if (curChar == 95)
break;
case 68:
if ((0x7fffffe07fffffeULL & l) != 0L)
- { jjCheckNAddStates(42, 44); }
+ { jjCheckNAddStates(44, 46); }
break;
case 70:
if ((0x7fffffe07fffffeULL & l) != 0L)
break;
if (kind > 6)
kind = 6;
- { jjAddStates(14, 18); }
+ { jjAddStates(16, 20); }
break;
case 9:
if (jjCanMove_1(hiByte, i1, i2, l1, l2))
- { jjAddStates(45, 46); }
+ { jjAddStates(47, 48); }
break;
case 15:
if (jjCanMove_1(hiByte, i1, i2, l1, l2))
- { jjAddStates(21, 22); }
+ { jjAddStates(23, 24); }
break;
case 18:
if (jjCanMove_1(hiByte, i1, i2, l1, l2))
break;
case 28:
if (jjCanMove_1(hiByte, i1, i2, l1, l2))
- { jjAddStates(47, 48); }
+ { jjAddStates(49, 50); }
break;
case 30:
if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
break;
- if (kind > 187)
- kind = 187;
- { jjAddStates(53, 54); }
+ if (kind > 189)
+ kind = 189;
+ { jjAddStates(55, 56); }
break;
case 33:
if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
break;
if (kind > 7)
kind = 7;
- { jjAddStates(26, 28); }
+ { jjAddStates(28, 30); }
break;
case 39:
if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
break;
if (kind > 8)
kind = 8;
- { jjAddStates(29, 31); }
+ { jjAddStates(31, 33); }
break;
case 45:
if (jjCanMove_0(hiByte, i1, i2, l1, l2))
- { jjAddStates(49, 50); }
+ { jjAddStates(51, 52); }
break;
case 50:
if (jjCanMove_0(hiByte, i1, i2, l1, l2))
- { jjAddStates(51, 52); }
+ { jjAddStates(53, 54); }
break;
default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
}
kind = 0x7fffffff;
}
++curPos;
- if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 76 - startsAt)))
+ if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 77 - startsAt)))
break;
if (input_stream->endOfInput()) { break; }
curChar = input_stream->readChar();
Token * VhdlParserTokenManager::jjFillToken(){
Token *t;
JAVACC_STRING_TYPE curTokenImage;
- int beginLine = -1;
- int endLine = -1;
- int beginColumn = -1;
- int endColumn = -1;
+ int beginLine;
+ int endLine;
+ int beginColumn;
+ int endColumn;
JAVACC_STRING_TYPE im = jjstrLiteralImages[jjmatchedKind];
curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
if (input_stream->getTrackLineColumn()) {
endLine = input_stream->getEndLine();
endColumn = input_stream->getEndColumn();
}
- t = Token::newToken(jjmatchedKind);
- t->kind = jjmatchedKind;
- t->image = curTokenImage;
+ t = Token::newToken(jjmatchedKind, curTokenImage);
t->specialToken = NULL;
t->next = NULL;
}
/** Reinitialise parser. */
void VhdlParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState, VhdlParser *parserArg) {
- clear();
+ if (input_stream) delete input_stream;
jjmatchedPos = jjnewStateCnt = 0;
curLexState = lexState;
input_stream = stream;
void VhdlParserTokenManager::ReInitRounds() {
int i;
jjround = 0x80000001;
- for (i = 76; i-- > 0;)
+ for (i = 77; i-- > 0;)
jjrounds[i] = 0x80000000;
}
/** Switch to specified lex state. */
void VhdlParserTokenManager::SwitchTo(int lexState) {
- if (lexState >= 1 || lexState < 0) {
- JAVACC_STRING_TYPE message;
-#ifdef WIDE_CHAR
- message += L"Error: Ignoring invalid lexical state : ";
- message += lexState; message += L". State unchanged.";
-#else
- message += "Error: Ignoring invalid lexical state : ";
- message += lexState; message += ". State unchanged.";
-#endif
- throw new TokenMgrError(message, INVALID_LEXICAL_STATE);
- } else
+ if (lexState >= 1 || lexState < 0)
+ assert(false);
+ //throw 1;//new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+ else
curLexState = lexState;
}
VhdlParserTokenManager::VhdlParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState, VhdlParser *parserArg)
{
input_stream = NULL;
- errorHandlerCreated = false;
ReInit(stream, lexState, parserArg);
}
// Destructor
VhdlParserTokenManager::~VhdlParserTokenManager () {
- clear();
+ if (input_stream) delete input_stream;
+ if (errorHandlerCreated) delete errorHandler;
}
- // clear
- void VhdlParserTokenManager::clear() {
- //Since input_stream was generated outside of TokenManager
- //TokenManager should not take care of deleting it
- //if (input_stream) delete input_stream;
- if (errorHandlerCreated) delete errorHandler;
- }
-
-
}
}
#ifndef VHDLPARSERTOKENMANAGER_H
#define VHDLPARSERTOKENMANAGER_H
-#include "stdio.h"
#include "JavaCC.h"
#include "CharStream.h"
#include "Token.h"
public: virtual ~VhdlParserTokenManager();
void ReInit(JAVACC_CHARSTREAM *stream, int lexState = 0, VhdlParser *parserArg = NULL);
void SwitchTo(int lexState);
- void clear();
const JAVACC_SIMPLE_STRING jjKindsForBitVector(int i, unsigned long long vec);
const JAVACC_SIMPLE_STRING jjKindsForStateVector(int lexState, int vec[], int start, int end);
- JAVACC_CHARSTREAM* input_stream;
- int jjrounds[76];
- int jjstateSet[2 * 76];
- JAVACC_STRING_TYPE jjimage;
- JAVACC_STRING_TYPE image;
- int jjimageLen;
- int lengthOfMatch;
- JAVACC_CHAR_TYPE curChar;
- TokenManagerErrorHandler* errorHandler;
- bool errorHandlerCreated;
-
-public:
- void setErrorHandler(TokenManagerErrorHandler *eh) {
+ JAVACC_CHARSTREAM *input_stream;
+ int jjrounds[77];
+ int jjstateSet[2 * 77];
+ JAVACC_STRING_TYPE jjimage;
+ JAVACC_STRING_TYPE image;
+ int jjimageLen;
+ int lengthOfMatch;
+ JAVACC_CHAR_TYPE curChar;
+ TokenManagerErrorHandler *errorHandler;
+ bool errorHandlerCreated;
+ public: void setErrorHandler(TokenManagerErrorHandler *eh) {
if (errorHandlerCreated && errorHandler != NULL) delete errorHandler;
errorHandler = eh;
errorHandlerCreated = false;
}
-
};
}
}
| < #BASIC_GRAPHIC_CHARACTER: (<UPPER_CASE_LETTER>|<DIGIT>|<SPECIAL_CHARACTER>|<SPACE_CHARACTER>) >
| < #GRAPHIC_CHARACTER: ( <BASIC_GRAPHIC_CHARACTER>|<LOWER_CASE_LETTER>|<OTHER_SPECIAL_CHARACTER> ) >
| < #LETTER_OR_DIGIT: ( <LETTER> | <DIGIT> ) >
+ | < #LETTER_OR_DIGIT_OR_STD: (<LETTER_OR_DIGIT> | <STD_LOGIC> ) >
| < #LETTER: (<UPPER_CASE_LETTER>|<LOWER_CASE_LETTER>) >
| < #UPPER_CASE_LETTER: ["A"-"Z"] >
- | <BIT_STRING_LITERAL : <BASE_SPECIFIER >["\""](<LETTER_OR_DIGIT>((["_"])*<LETTER_OR_DIGIT>)*) ["\""] >
- | <#BASE_SPECIFIER:["B","O","X","b","o","x"]>
+ | <BIT_STRING_LITERAL : (<DIGIT>)*<BASE_SPECIFIER>["\""](<LETTER_OR_DIGIT_OR_STD>((["_"])*<LETTER_OR_DIGIT_OR_STD>)*)["\""] >
+ | <#BASE_SPECIFIER:["B","O","X","b","o","x","d","D"]>
+ | <#STD_LOGIC:["0","1","L","H","X","Z","W","-","l","h","x","z","w"]>
| < #DIGIT: ["0"-"9"] >
| < #SPECIAL_CHARACTER: ["#","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","_","|"] >
| < #OTHER_SPECIAL_CHARACTER: ["%","!","$","@","?","[","\\","]","^","`","{","}","~","\u00A0"-"\u00FF"]>
projects / platform / upstream / doxygen.git / commitdiff