Go back to Richel Bilderbeek's homepage.

Go back to Richel Bilderbeek's C++ page.

 

 

 

 

 

(C++) CodeToHtml source code version 1.24

 

The source code of CodeToHtml version 1.24.

 

 

 

 

 

Technical facts

 

Application type(s)

Operating system(s) or programming environment(s)

IDE(s):

Project type:

C++ standard:

Compiler(s):

Libraries used:

 

 

 

 

 

Qt project file: /home/richel/Projects/Tools/ToolCodeToHtml/ToolCodeToHtmlConsole.pro

 

#-------------------------------------------------
#
# Project created by QtCreator 2010-07-24T16:04:35
#
#-------------------------------------------------
QT += core gui
TARGET = codetohtml
TEMPLATE = app
QMAKE_CXXFLAGS += -std=c++0x

INCLUDEPATH += \
    ../../Classes/CppAbout \
    ../../Classes/CppProFile \
    ../../Classes/CppQtAboutDialog

SOURCES += \
    ../../Classes/CppAbout/about.cpp \
    codetohtmlmenudialog.cpp \
    codetohtmlconvertcodedialog.cpp \
    codetohtmlconvertfolderdialog.cpp \
    codetohtml.cpp \
    main.cpp \
    codetohtmlheader.cpp \
    codetohtmlfooter.cpp \
    codetohtmltechnicalinfo.cpp \
    codetohtmlversion.cpp \
    codetohtmlcontent.cpp \
    codetohtmlreplacements.cpp \
    codetohtmlreplacementscpp.cpp \
    codetohtmlreplacementspro.cpp \
    ../../Classes/CppProFile/profile.cpp
HEADERS += \
    ../../Classes/CppAbout/about.h \
    codetohtmlmenudialog.h \
    codetohtmlconvertcodedialog.h \
    codetohtmlconvertfolderdialog.h \
    codetohtml.h \
    codetohtmlheader.h \
    codetohtmlfooter.h \
    codetohtmltechnicalinfo.h \
    codetohtmlversion.h \
    codetohtmlcontent.h \
    codetohtmlreplacements.h \
    ../../Classes/CppProFile/profile.h

LIBS += \
  -lboost_filesystem \
  -lboost_program_options \
  -lboost_regex      \
  -lboost_system

 

 

 

 

 

Qt project file: /home/richel/Projects/Tools/ToolCodeToHtml/ToolCodeToHtmlDesktop.pro

 

#-------------------------------------------------
#
# Project created by QtCreator 2010-07-24T16:04:35
#
#-------------------------------------------------
QT += core gui
TARGET = ToolCodeToHtmlDesktop
TEMPLATE = app
QMAKE_CXXFLAGS += -std=c++0x

INCLUDEPATH += \
    ../../Classes/CppAbout \
    ../../Classes/CppQtAboutDialog \
    ../../Classes/CppProFile \
    ../../Classes/CppTrace

SOURCES += qtmain.cpp \
    codetohtmlversion.cpp \
    ../../Classes/CppAbout/about.cpp \
    ../../Classes/CppQtAboutDialog/qtaboutdialog.cpp \
    qtcodetohtmlmenudialog.cpp \
    qtcodetohtmlconvertcodedialog.cpp \
    codetohtmlmenudialog.cpp \
    codetohtmlconvertcodedialog.cpp \
    codetohtml.cpp \
    codetohtmlheader.cpp \
    codetohtmlfooter.cpp \
    codetohtmltechnicalinfo.cpp \
    codetohtmlcontent.cpp \
    ../../Classes/CppProFile/profile.cpp \
    codetohtmlreplacementspro.cpp \
    codetohtmlreplacementscpp.cpp \
    codetohtmlreplacements.cpp \
    codetohtmlconvertfolderdialog.cpp \
    qtcodetohtmlconvertfolderdialog.cpp \
    qtcodetohtmlcreateemptypagedialog.cpp \
    codetohtmlcreateemptypagedialog.cpp
HEADERS += \
    codetohtmlversion.h \
    ../../Classes/CppAbout/about.h \
    ../../Classes/CppQtAboutDialog/qtaboutdialog.h \
    qtcodetohtmlmenudialog.h \
    qtcodetohtmlconvertcodedialog.h \
    codetohtmlmenudialog.h \
    codetohtmlconvertcodedialog.h \
    codetohtml.h \
    codetohtmlheader.h \
    codetohtmlfooter.h \
    codetohtmltechnicalinfo.h \
    codetohtmlcontent.h \
    ../../Classes/CppProFile/profile.h \
    codetohtmlreplacements.h \
    codetohtmlconvertfolderdialog.h \
    qtcodetohtmlconvertfolderdialog.h \
    qtcodetohtmlcreateemptypagedialog.h \
    codetohtmlcreateemptypagedialog.h \
    ../../Classes/CppTrace/trace.h
FORMS += \
    ../../Classes/CppQtAboutDialog/qtaboutdialog.ui \
    qtcodetohtmlmenudialog.ui \
    qtcodetohtmlconvertcodedialog.ui \
    qtcodetohtmlconvertfolderdialog.ui \
    qtcodetohtmlcreateemptypagedialog.ui
LIBS += \
  -lboost_filesystem \
  -lboost_regex      \
  -lboost_system     \
#  -lphonon           \
  -lQtDBus           \
  -lQtNetwork        \
  -lQtWebKit         \
  -lQtXml            \
  -lQtXmlPatterns

#For QuantLib
LIBS += -L/opt/local/lib -lQuantLib

RESOURCES += resources.qrc

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtml.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTML_H
#define CODETOHTML_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/shared_ptr.hpp>
//---------------------------------------------------------------------------
struct CodeToHtml
{
  ///The different page types
  ///-cpp: C++
  ///-text: plain text
  ///-music: music
  ///-tool: tool
  enum PageType { cpp, text, music, tool };

  CodeToHtml(const PageType page_type = cpp);

  ///Convert a code snippet
  const std::vector<std::string> ConvertCodeSnippet(const std::vector<std::string>& code);

  ///Convert a file
  const std::vector<std::string> ConvertFile(const std::string& filename);

  ///Convert a folder/directory
  const std::vector<std::string> ConvertFolder(const std::string& foldername);

  ///Convert a .pro file
  const std::vector<std::string> ConvertProject(const std::string& filename);

  ///FileToVector reads a file and converts it to a std::vector<std::string>
  //From http://www.richelbilderbeek.nl/CppFileToVector.htm
  static const std::vector<std::string> FileToVector(const std::string& filename);

  ///Filter files: only let .pro, .h, .hpp, . cpp, .c and .sh files pass
  static const std::vector<std::string> FilterFiles(const std::vector<std::string>& files);

  //From http://www.richelbilderbeek.nl/CppGetFilesInFolder.htm
  static const std::vector<std::string> GetFilesInFolder(const std::string& folder);

  ///Sort files: .pro files first, then X.h, X.cpp, then .sh files
  static const std::vector<std::string> SortFiles(std::vector<std::string> files);

  private:

  ///The page type used
  PageType m_page_type;

  ///Obtain the sorted files in a folder
  static const std::vector<std::string> GetSortedFilesInFolder(const std::string& folder);
};
//---------------------------------------------------------------------------
#endif // CODETOHTML_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtml.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <fstream>
#include <iostream>
//---------------------------------------------------------------------------
#include <boost/filesystem.hpp>
//---------------------------------------------------------------------------
#include "codetohtml.h"
#include "codetohtmlcontent.h"
#include "codetohtmlfooter.h"
#include "codetohtmlheader.h"
#include "codetohtmltechnicalinfo.h"
#include "profile.h"
//---------------------------------------------------------------------------
CodeToHtml::CodeToHtml(const PageType page_type)
  : m_page_type(page_type)
{
  //Test SortedFiles
  {
    const std::vector<std::string> result
      =
      {
        "a.pro",
        "b.pro",
        "c.pro",
        "d.pro",
        "e.pro",
        "a.h",
        "a.cpp",
        "b.h",
        "b.cpp",
        "c.h",
        "c.cpp",
        "d.h",
        "d.cpp",
        "e.h",
        "e.cpp",
        "a.sh",
        "b.sh",
        "c.sh",
        "d.sh",
        "e.sh"
      };
    std::vector<std::string> v = result;
    v.push_back("x.txt"); //Should not be added
    std::random_shuffle(v.begin(),v.end());
    v = SortFiles(FilterFiles(v));
    assert(v == result);
  }
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::ConvertCodeSnippet(const std::vector<std::string>& code)
{
  CodeToHtmlContent content("",code);
  switch (m_page_type)
  {
    case cpp:
    case tool:
      content.SetContentType(CodeToHtmlContent::cpp);
      break;
    case text:
    case music:
      content.SetContentType(CodeToHtmlContent::txt);
  }

  return content.ToHtml();
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::ConvertFile(const std::string& filename)
{
  if (boost::filesystem::extension(filename) == ".pro")
  {
    return ConvertProject(filename);
  }
  const std::vector<std::string> v = FileToVector(filename);
  CodeToHtmlContent content(filename,v);
  return content.ToHtml();
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::ConvertFolder(const std::string& foldername)
{
  std::vector<std::string> v;
  {
    CodeToHtmlHeader c(m_page_type);
    const std::vector<std::string> w = c.ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  {
    const std::vector<std::string> w = CodeToHtmlTechnicalInfo().ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  {
    const std::vector<std::string> files = GetSortedFilesInFolder(foldername);
    std::copy(files.begin(),files.end(),std::ostream_iterator<std::string>(std::cout,"\n"));
    std::for_each(files.begin(),files.end(),
      [&v](const std::string& filename)
      {
        const std::vector<std::string> w = CodeToHtmlContent(filename,FileToVector(filename)).ToHtml();
        std::copy(w.begin(),w.end(),std::back_inserter(v));
      }
    );
  }
  {
    CodeToHtmlFooter c(m_page_type);
    const std::vector<std::string> w = c.ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::ConvertProject(const std::string& filename)
{
  assert(boost::filesystem::extension(filename) == ".pro");
  ProFile pro_file(filename);

  std::vector<std::string> v;
  {
    const std::vector<std::string> w = CodeToHtmlHeader().ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  {
    const std::vector<std::string> w = CodeToHtmlTechnicalInfo().ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  {
    std::vector<std::string> files;
    {
      const std::vector<std::string> w = pro_file.GetHeadersFull();
      std::copy(w.begin(),w.end(),std::back_inserter(files));
    }
    {
      const std::vector<std::string> w = pro_file.GetSourcesFull();
      std::copy(w.begin(),w.end(),std::back_inserter(files));
    }
    std::for_each(files.begin(),files.end(),
      [&v](const std::string& filename)
      {
        const std::vector<std::string> w = CodeToHtmlContent(filename,FileToVector(filename)).ToHtml();
        std::copy(w.begin(),w.end(),std::back_inserter(v));
      }
    );
  }
  {
    const std::vector<std::string> w = CodeToHtmlFooter().ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::FileToVector(const std::string& filename)
{
  if (!boost::filesystem::exists(filename))
  {
    std::clog << filename << '\n';
  }
  assert(boost::filesystem::exists(filename));
  std::vector<std::string> v;
  std::ifstream in(filename.c_str());
  std::string s;
  for (int i=0; !in.eof(); ++i)
  {
    std::getline(in,s);
    v.push_back(s);
  }
  return v;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::GetFilesInFolder(const std::string& folder)
{
  std::vector<std::string> v;

  const boost::filesystem::path my_folder
    = boost::filesystem::system_complete(
        boost::filesystem::path(folder));

  if (!boost::filesystem::is_directory(my_folder)) return v;

  const boost::filesystem::directory_iterator j;
  for ( boost::filesystem::directory_iterator i(my_folder);
        i != j;
        ++i)
  {
    if ( boost::filesystem::is_regular_file( i->status() ) )
    {
      const std::string filename = i->path().filename();
      const std::string full_filename = folder + "/" + filename;
      v.push_back(full_filename);
    }
  }
  return v;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::GetSortedFilesInFolder(const std::string& folder)
{
  std::vector<std::string> files = GetFilesInFolder(folder);
  files = SortFiles(files);
  return files;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::FilterFiles(const std::vector<std::string>& files)
{
  std::vector<std::string> v;
  std::copy_if(files.begin(), files.end(),std::back_inserter(v),
    [](const std::string& file)
    {
      const std::string ext = boost::filesystem::extension(file);
      return
           ext == ".c"
        || ext == ".cpp"
        || ext == ".h"
        || ext == ".hpp"
        || ext == ".pro"
        || ext == ".sh";
    }
  );

  return v;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtml::SortFiles(std::vector<std::string> files)
{
  std::sort(files.begin(), files.end(),
    [](const std::string& lhs,const std::string& rhs)
    {
      const std::string lhs_base = boost::filesystem::basename(lhs);
      const std::string rhs_base = boost::filesystem::basename(rhs);
      const std::string lhs_ext = boost::filesystem::extension(lhs);
      const std::string rhs_ext = boost::filesystem::extension(rhs);
      static const std::string pro(".pro");
      static const std::string sh(".sh");
      static const std::string h(".h");
      static const std::string cpp(".cpp");
      if (lhs_ext == pro)
      {
        //.pro files first
        if (rhs_ext != pro)
        {
          return true;
        }
        if (rhs_ext == pro)
        {
          return lhs_base < rhs_base;
        }
      }
      if (lhs_ext == h && rhs_ext == cpp && lhs_base == rhs_base)
      {
        return true;
      }
      if ( (lhs_ext == h || lhs_ext == cpp) && rhs_ext == pro)
      {
        return false;
      }
      if ( (lhs_ext == h || lhs_ext == cpp) && rhs_ext == sh)
      {
        return true;
      }

      if ( (lhs_ext == h || lhs_ext == cpp) && (rhs_ext == h || rhs_ext == cpp) )
      {
        return lhs_base < rhs_base;
      }

      //.sh last
      if (lhs_ext == sh)
      {
        if (rhs_ext != sh)
        {
          return false;
        }
        if (rhs_ext == sh)
        {
          return lhs_base < rhs_base;
        }
      }
      return false;
    }
  );

  return files;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlcontent.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLCONTENT_H
#define CODETOHTMLCONTENT_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "codetohtml.h"
#include "codetohtmlreplacements.h"
//---------------------------------------------------------------------------
///CodeToHtmlContent contains a piece of content like
///C++ source code, a text file, a .pro file, a .sh file
struct CodeToHtmlContent
{
  ///The types of content
  ///text: .txt file
  ///cpp: .h or .hpp or .c or .cpp file
  ///pro: .pro file
  ///sh: .sh file
  ///code_snippet: file without an extension
  ///other: file with other extension
  enum ContentType { code_snippet, cpp, pro, sh, txt, other };

  CodeToHtmlContent(
    const std::string& filename,
    const std::vector<std::string>& content);

  ///Convert the content to HTML
  const std::vector<std::string> ToHtml() const;

  ///Set the content type
  void SetContentType(const ContentType t) { m_content_type = t; }

  private:

  ///\brief
  ///The type of content
  ///
  ///m_content_type is deduced automatically from the filename extension,
  ///but this can be overridden by SetContentType
  ContentType m_content_type;

  ///The contents
  const std::vector<std::string> m_contents;

  ///The filename of the contents file
  const std::string m_filename;

  ///The C++ replacements
  static const CodeToHtmlReplacements m_replacements_cpp;

  ///The .pro file replacements
  static const CodeToHtmlReplacements m_replacements_pro;

  ///The text file replacements
  static const CodeToHtmlReplacements m_replacements_txt;

  //static void CheckReplacement(const std::pair<std::string,std::string>& p);

  //static void CheckReplacements(const std::vector<std::pair<std::string,std::string> >& v);

  ///CreateCppReplacements creates the (many) replacements when
  ///code is converted to HTML. It uses all the replacements from a .pro file
  static const std::vector<std::pair<std::string,std::string> > CreateCppReplacements();

  ///CreateProFileReplacements creates the replacements when
  ///a Qt project file is converted to HTML
  static const std::vector<std::pair<std::string,std::string> > CreateProReplacements();

  ///Deduce the content type from a filename
  static ContentType DeduceContentType(const std::string& filename);

  static const std::string MultiReplace(
    const std::string& line,
    const std::vector<std::pair<std::string,std::string> >& replacements);

  static const std::vector<std::string> MultiReplace(
    const std::vector<std::string>& text,
    const std::vector<std::pair<std::string,std::string> >& replacements);

  static const std::string ReplaceAll(
    std::string s,
    const std::string& replaceWhat,
    const std::string& replaceWithWhat);
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLCONTENT_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlcontent.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <iostream>
//---------------------------------------------------------------------------
#include <boost/regex.hpp>
//---------------------------------------------------------------------------
#include "codetohtml.h"
#include "codetohtmlcontent.h"
#include "codetohtmlfooter.h"
#include "codetohtmlheader.h"
#include "codetohtmlreplacements.h"
//---------------------------------------------------------------------------
#define PROGRAM_HANGS
//---------------------------------------------------------------------------
const CodeToHtmlReplacements CodeToHtmlContent::m_replacements_cpp
  = CodeToHtmlContent::CreateCppReplacements();
const CodeToHtmlReplacements CodeToHtmlContent::m_replacements_pro
  = CodeToHtmlContent::CreateProReplacements();
const CodeToHtmlReplacements CodeToHtmlContent::m_replacements_txt
  = CodeToHtmlReplacements(std::vector<std::pair<std::string,std::string> >());
//---------------------------------------------------------------------------
CodeToHtmlContent::CodeToHtmlContent(
  const std::string& filename,
  const std::vector<std::string>& content)
    : m_content_type(DeduceContentType(filename)),
      m_contents(content),
      m_filename(filename)
{
}
//---------------------------------------------------------------------------
CodeToHtmlContent::ContentType CodeToHtmlContent::DeduceContentType(const std::string& filename)
{
  if (boost::regex_match(filename,boost::regex(".*\\.(pro)\\z")))
  {
    return pro;
  }
  else if (boost::regex_match(filename,boost::regex(".*\\.(c|cpp|h|hpp)\\z")))
  {
    return cpp;
  }
  else if (boost::regex_match(filename,boost::regex(".*\\.(sh)\\z")))
  {
    return sh;
  }
  else if (boost::regex_match(filename,boost::regex(".*\\.(txt)\\z")))
  {
    return txt;
  }
  return other;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlContent::ToHtml() const
{
  std::vector<std::string> v;
  switch(m_content_type)
  {
    case code_snippet:
    case cpp:
    {
      v.push_back(
        std::string("<h2>") + m_filename + std::string("</h2>"));
      v.push_back("<p>&nbsp;</p>");
      v.push_back("<!-- start of code -->");
      v.push_back("<table border = \"1\"><tr><td><code>");
      const std::vector<std::string> w = MultiReplace(m_contents,m_replacements_cpp.m_all_replacements);
      std::copy(w.begin(),w.end(),std::back_inserter(v));
    }
    break;
    case pro:
    {
      v.push_back(
        std::string("<h2><a href=\"CppQtProjectFile.htm\">Qt project file</a>: ")
        + m_filename + std::string("</h2>"));
      v.push_back("<p>&nbsp;</p>");
      v.push_back("<!-- start of code -->");
      v.push_back("<table border = \"1\"><tr><td><code>");
      const std::vector<std::string> w = MultiReplace(m_contents,m_replacements_pro.m_all_replacements);
      std::copy(w.begin(),w.end(),std::back_inserter(v));

    }
    break;
    case sh:
    case txt:
    {
      v.push_back(
        std::string("<h2>") + m_filename + std::string("</h2>"));
      v.push_back("<p>&nbsp;</p>");
      v.push_back("<!-- start of code -->");
      v.push_back("<table border = \"1\"><tr><td><code>");
      const std::vector<std::string> w = MultiReplace(m_contents,m_replacements_txt.m_all_replacements);
      std::copy(w.begin(),w.end(),std::back_inserter(v));
    }
    break;
    case other:
      return v;
  }

  v.push_back("</code></td></tr></table>");
  v.push_back("<!-- end of the code -->");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  return v;
}
//---------------------------------------------------------------------------
const std::string CodeToHtmlContent::MultiReplace(const std::string& line, const std::vector<std::pair<std::string,std::string> >& replacements)
{
  std::string s(line);
  #ifdef DEBUG_PROGRAM_HANGS
  std::clog << "Before: " << s << '\n';
  #endif
  typedef std::vector<std::pair<std::string,std::string> >::const_iterator Iterator;
  const Iterator j = replacements.end();
  for (Iterator i = replacements.begin(); i!=j; ++i)
  {
    std::string from = i->first;
    const std::string to = i->second;
    s = ReplaceAll(s,from,to);
  }
  return s;
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlContent::MultiReplace(const std::vector<std::string>& text, const std::vector<std::pair<std::string,std::string> >& replacements)
{
  std::vector<std::string> v = text;
  typedef std::vector<std::string>::iterator Iterator;
  const Iterator j = v.end();
  for (Iterator i = v.begin(); i!=j; ++i)
  {
    //std::cout << "Before: " << *i << std::endl;
    *i = MultiReplace(*i,replacements);
    //std::cout << "After: " << *i << std::endl;
    *i += "<br/>";
  }
  return v;
}
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppReplaceAll.htm
const std::string CodeToHtmlContent::ReplaceAll(
  std::string s,
  const std::string& replaceWhat,
  const std::string& replaceWithWhat)
{
  while(1)
  {
    const size_t pos = s.find(replaceWhat);
    if (pos==std::string::npos) break;
    s.replace(pos,replaceWhat.size(),replaceWithWhat);
  }
  return s;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlconvertcodedialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLCONVERTCODEDIALOG_H
#define CODETOHTMLCONVERTCODEDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "codetohtml.h"
//---------------------------------------------------------------------------
///CodeToHtmlConvertCodeDialog is the GUI independent UI of
///CodeToHtml for converting code only
struct CodeToHtmlConvertCodeDialog
{
  CodeToHtmlConvertCodeDialog(
    const std::vector<std::string>& code,
    const CodeToHtml::PageType type);

  const std::vector<std::string> ToHtml() const;

  private:
  const std::vector<std::string> m_code;

  const CodeToHtml::PageType m_type;
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLCONVERTCODEDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlconvertcodedialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlconvertcodedialog.h"
//---------------------------------------------------------------------------
CodeToHtmlConvertCodeDialog::CodeToHtmlConvertCodeDialog(
  const std::vector<std::string>& code,
  const CodeToHtml::PageType type)
  : m_code(code),
    m_type(type)
{

}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlConvertCodeDialog::ToHtml() const
{
  CodeToHtml c(m_type);
  return c.ConvertCodeSnippet(m_code);
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlconvertfolderdialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLCONVERTPROJECTDIALOG_H
#define CODETOHTMLCONVERTPROJECTDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/regex.hpp>
//---------------------------------------------------------------------------
///CodeToHtmlConvertFolderDialog is the GUI independent UI of
///CodeToHtml for converting a folder
struct CodeToHtmlConvertFolderDialog
{
  CodeToHtmlConvertFolderDialog(const std::string& folder);

  const std::string& GetFolder() const { return m_folder; }

  const std::vector<std::string> ToHtml() const;

  private:
  const std::string m_folder;

};
//---------------------------------------------------------------------------
#endif // CODETOHTMLCONVERTPROJECTDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlconvertfolderdialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iterator>
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/version.hpp>
//---------------------------------------------------------------------------
#include "codetohtmlcontent.h"
#include "codetohtmlfooter.h"
#include "codetohtmlheader.h"
#include "codetohtmltechnicalinfo.h"
#include "codetohtmlconvertfolderdialog.h"
#include "codetohtmlversion.h"
//---------------------------------------------------------------------------
CodeToHtmlConvertFolderDialog::CodeToHtmlConvertFolderDialog(
  const std::string& folder)
  : m_folder(folder)
{
  assert(boost::filesystem::is_directory(folder));
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlConvertFolderDialog::ToHtml() const
{
  std::vector<std::string> v;

  //Add header
  {
    //Add header
    {
      CodeToHtmlHeader header(CodeToHtml::cpp);
      v = header.ToHtml();
    }
    //Add file information
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    {
      CodeToHtmlTechnicalInfo info;
      const std::vector<std::string> w = info.ToHtml();
      std::copy(w.begin(),w.end(),std::back_inserter(v));
    }
  }

  //Obtain the C++ filenames
  const std::vector<std::string> files
    = CodeToHtml::SortFiles(
        CodeToHtml::FilterFiles(
          CodeToHtml::GetFilesInFolder(m_folder)));


  //Add project information
  std::for_each(files.begin(),files.end(),
    [&v,this](const std::string& file)
    {
      //CodeToHtmlContent content(file,CodeToHtml::FileToVector(this->m_folder + "/" + file));
      CodeToHtmlContent content(file,CodeToHtml::FileToVector(file));
      const std::vector<std::string> w = content.ToHtml();
      std::copy(w.begin(),w.end(),std::back_inserter(v));
    }
  );


  //Add end part of webpage
  {
    CodeToHtmlFooter footer(CodeToHtml::cpp);
    const std::vector<std::string> w = footer.ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }

  return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlcreateemptypagedialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLCREATEEMPTYPAGEDIALOG_H
#define CODETOHTMLCREATEEMPTYPAGEDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
struct CodeToHtmlCreateEmptyPageDialog
{
  CodeToHtmlCreateEmptyPageDialog(const bool add_tech_info = true);

  const std::vector<std::string> ToHtml() const;

  private:
  ///Add the technical info?
  bool m_add_tech_info;
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLCREATEEMPTYPAGEDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlcreateemptypagedialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlcreateemptypagedialog.h"
#include "codetohtmlfooter.h"
#include "codetohtmlheader.h"
#include "codetohtmltechnicalinfo.h"
//---------------------------------------------------------------------------
CodeToHtmlCreateEmptyPageDialog::CodeToHtmlCreateEmptyPageDialog(
  const bool add_tech_info)
  : m_add_tech_info(add_tech_info)
{

}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlCreateEmptyPageDialog::ToHtml() const
{
  std::vector<std::string> v;

  //Add header
  {
    //Add header
    {
      CodeToHtmlHeader header(CodeToHtml::cpp);
      v = header.ToHtml();
    }
    //Add file information
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    v.push_back("<p>&nbsp;</p>");
    if (m_add_tech_info)
    {
      CodeToHtmlTechnicalInfo info;
      const std::vector<std::string> w = info.ToHtml();
      std::copy(w.begin(),w.end(),std::back_inserter(v));
    }
  }
  //Add end part of webpage
  {
    CodeToHtmlFooter footer(CodeToHtml::cpp);
    const std::vector<std::string> w = footer.ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlfooter.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFOOTER_H
#define CODETOHTMLFOOTER_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "codetohtml.h"
//---------------------------------------------------------------------------
///Defines the header of the resulting HTML page
struct CodeToHtmlFooter
{
  CodeToHtmlFooter(const CodeToHtml::PageType page_type = CodeToHtml::cpp);

  CodeToHtml::PageType GetPageType() const { return m_page_type; }

  void SetPageType(const CodeToHtml::PageType page_type) { m_page_type = page_type; }

  const std::vector<std::string> ToHtml() const;

  private:
  CodeToHtml::PageType m_page_type;
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLFOOTER_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlfooter.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <cassert>
//---------------------------------------------------------------------------
#include "codetohtmlfooter.h"
//---------------------------------------------------------------------------
CodeToHtmlFooter::CodeToHtmlFooter(const CodeToHtml::PageType page_type)
{
  SetPageType(page_type);
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlFooter::ToHtml() const
{
  std::vector<std::string> v;
  switch (m_page_type)
  {
    case CodeToHtml::cpp:
    case CodeToHtml::text:
      v.push_back("<p><a href=\"Cpp.htm\">Go back to Richel Bilderbeek's C++ page</a>.</p>");
      break;
    case CodeToHtml::music:
      v.push_back("<p><a href=\"Music.htm\">Go back to Richel Bilderbeek's music page</a>.</p>");
      break;
    case CodeToHtml::tool:
      v.push_back("<p><a href=\"Tools.htm\">Go back to Richel Bilderbeek's tools</a>.</p>");
      break;
    default:
      assert(!"Should not get here");
    break;
  }
  v.push_back("<p><a href=\"index.htm\">Go back to Richel Bilderbeek's homepage</a>.</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p><a href=\"http://validator.w3.org/check?uri=referer\"><img src=\"valid-xhtml10.png\" alt=\"Valid XHTML 1.0 Strict\" height=\"31\" width=\"88\" /></a></p>");
  v.push_back("</body>");
  v.push_back("</html>");
  return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlheader.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLHEADER_H
#define CODETOHTMLHEADER_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "codetohtml.h"
//---------------------------------------------------------------------------
///Defines the header of the resulting HTML page
struct CodeToHtmlHeader
{
  CodeToHtmlHeader(const CodeToHtml::PageType page_type = CodeToHtml::cpp);

  CodeToHtml::PageType GetPageType() const { return m_page_type; }

  void SetPageType(const CodeToHtml::PageType page_type) { m_page_type = page_type; }

  const std::vector<std::string> ToHtml() const;

  private:
  CodeToHtml::PageType m_page_type;
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLHEADER_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlheader.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <cassert>
//---------------------------------------------------------------------------
#include "codetohtmlheader.h"
//---------------------------------------------------------------------------
CodeToHtmlHeader::CodeToHtmlHeader(const CodeToHtml::PageType page_type)
{
  SetPageType(page_type);
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlHeader::ToHtml() const
{
  std::vector<std::string> v;
  v.push_back("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"");
  v.push_back("\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">");
  v.push_back("<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en\" xml:lang=\"en\">");
  v.push_back("<head>");
  v.push_back("  <meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"/>");
  switch (m_page_type)
  {
    case CodeToHtml::text:
    case CodeToHtml::cpp:
      v.push_back("  <title>XXX</title>");
      v.push_back("  <meta name=\"description\" content=\"C++ XXX\"/>");
      v.push_back("  <meta name=\"keywords\" content=\"C++ XXX code snippet\"/>");
    break;
    case CodeToHtml::music:
      v.push_back("  <title>XXX</title>");
      v.push_back("  <meta name=\"description\" content=\"Song XXX\"/>");
      v.push_back("  <meta name=\"keywords\" content=\"Richel Bilderbeek Music Song XXX\"/>");
    break;
    case CodeToHtml::tool:
      v.push_back("  <title>XXX</title>");
      v.push_back("  <meta name=\"description\" content=\"C++ Tool XXX\"/>");
      v.push_back("  <meta name=\"keywords\" content=\"C++ Tool XXX\"/>");
    break;
    default:
      assert(!"Should not get here");
    break;
  }
  v.push_back("  <link rel=\"stylesheet\" href=\"Richelbilderbeek.css\" type=\"text/css\"/>");
  v.push_back("</head>");
  v.push_back("<!-- End of head, start of body -->");
  v.push_back("<body>");
  v.push_back("<p><a href=\"index.htm\">Go back to Richel Bilderbeek's homepage</a>.</p>");
  switch (m_page_type)
  {
    case CodeToHtml::cpp:
    case CodeToHtml::text:
      v.push_back("<p><a href=\"Cpp.htm\">Go back to Richel Bilderbeek's C++ page</a>.</p>");
      break;
    case CodeToHtml::music:
      v.push_back("<p><a href=\"Music.htm\">Go back to Richel Bilderbeek's music page</a>.</p>");
      break;
    case CodeToHtml::tool:
      v.push_back("<p><a href=\"Tools.htm\">Go back to Richel Bilderbeek's tools</a>.</p>");
      break;
    default:
      assert(!"Should not get here");
    break;
  }
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<!-- Page header -->");

  switch (m_page_type)
  {
    case CodeToHtml::cpp:
    case CodeToHtml::text:
      v.push_back("<h1>(<a href=\"Cpp.htm\">C++</a>) <a href=\"CppXXX.htm\">XXX</a></h1>");
      break;
    case CodeToHtml::music:
      v.push_back("<h1>(<a href=\"Music.htm\">Music</a>) <a href=\"SongXXX.htm\">XXX</a></h1>");
      break;
    case CodeToHtml::tool:
      v.push_back("<h1>(<a href=\"Tools.htm\">Tool</a>) <a href=\"ToolXXX.htm\">XXX</a></h1>");
      break;
    default:
      assert(!"Should not get here");
    break;
  }
  v.push_back("<p>&nbsp;</p>");
  return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlmenudialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLMENUDIALOG_H
#define CODETOHTMLMENUDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "about.h"
//---------------------------------------------------------------------------
///GUI independent CodeToHtml menu dialog
struct CodeToHtmlMenuDialog
{
  CodeToHtmlMenuDialog();
  static const About GetAbout();
  static const std::string GetVersion();
  static const std::vector<std::string> GetVersionHistory();
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLMENUDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlmenudialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlmenudialog.h"
#include "profile.h"
//---------------------------------------------------------------------------
CodeToHtmlMenuDialog::CodeToHtmlMenuDialog()
{
}
//---------------------------------------------------------------------------
const About CodeToHtmlMenuDialog::GetAbout()
{
  About a(
    "Richel Bilderbeek",
    "CodeToHtml",
    "tool to convert code to heavily-linked HTML",
    "the 11th of September 2011",
    "2010-2011",
    "http://www.richelbilderbeek.nl/ToolCodeToHtml.htm",
    GetVersion(),
    GetVersionHistory());
  a.AddLibrary("ProFile version: " + ProFile::GetVersion());
  return a;
}
//---------------------------------------------------------------------------
const std::string CodeToHtmlMenuDialog::GetVersion()
{
  return "1.24";
}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlMenuDialog::GetVersionHistory()
{
  std::vector<std::string> v;
  v.push_back("2010-03-14: version 1.0:  programmed initial console version of CodeToHtml. Due to my switch from Windows to Ubuntu, I had to abandon MS Word as my favorite HTML editor. Then I had to write my webpages in plain HTML, but adding links to all my code snippets was tiresome. CodeToHtml automated this for me");
  v.push_back("2010-04-10: version 1.1: cleaned up code, about 200 replacement entries");
  v.push_back("2010-05-07: version 1.2: about 650 replacement entries");
  v.push_back("2010-07-24: version 1.3: about 800 replacement entries");
  v.push_back("2010-07-24: version 1.4: made a GUI version of CodeToHtml");
  v.push_back("2010-07-25: version 1.5: added a save button, removed some useless code (like 'createCss'), improved visual appearance");
  v.push_back("2010-08-07: version 1.6: added the option to convert multiple C++ files to one single page");
  v.push_back("2010-08-09: version 1.7: also put the .pro files in the website generated from file. Also fix that long lines of (plaintext)code got multiplied in the HTML output");
  v.push_back("2010-09-24: version 1.8: added 'About' and 'What's New' screen, changed GUI, added posibility to convert text to HTML");
  v.push_back("2010-09-24: version 1.9: posibility to only convert text body");
  v.push_back("2010-10-02: version 1.10: added use of pictograms");
  v.push_back("2010-10-08: version 1.11: added important new links, renamed pictogram names");
  v.push_back("2010-11-18: version 1.12: obtain just-read version numbers of Qt and Ubuntu");
  v.push_back("2010-12-12: version 1.13: added creation of tool and music pages");
  v.push_back("2010-12-18: version 1.14: fixed error in calling sylesheet");
  v.push_back("2010-12-19: version 1.15: support of displaying multiple Qt Creator project files in project conversion");
  v.push_back("2010-12-22: version 1.16: display the number of text replacements in the About screen");
  v.push_back("2011-01-15: version 1.17: switched to C++0x standard, replaced DialogAbout");
  v.push_back("2011-01-30: version 1.18: 1900 replacement, added the Android, Maemo, Symbian, VirtualBox operating systems");
  v.push_back("2011-04-12: version 1.19: +2300 replacement, slightly improved code");
  v.push_back("2011-04-14: version 1.20: major architectural change for future Wt support and increased speed, changed OS to Lubuntu");
  v.push_back("2011-06-26: version 1.21: seperated \'Convert Project\' logic from GUI, also converts .sh files");
  v.push_back("2011-07-01: version 1.22: added all Wt classes");
  v.push_back("2011-07-11: version 1.23: added all C++0x algorithms");
  v.push_back("2011-09-11: version 1.24: added console version, major architectural change");
  return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlreplacements.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLREPLACEMENTS_H
#define CODETOHTMLREPLACEMENTS_H
//---------------------------------------------------------------------------
///\brief
///Contains all code replacements
///
///All code replacements have the following order:
///-m_initial_replacements: converts '&' to '&'
///-m_replacements: the replacements it is about
///-m_end_replacements: converts '&' back to '&'
///
///m_all_replacements contains all replacements as a single std::vector
struct CodeToHtmlReplacements
{
  CodeToHtmlReplacements(const std::vector<std::pair<std::string,std::string> >& replacements);

  ///All replacements
  const std::vector<std::pair<std::string,std::string> > m_all_replacements;

  private:
  ///The important replacements
  const std::vector<std::pair<std::string,std::string> > m_replacements;

  private:
  static const std::vector<std::pair<std::string,std::string> > CreateAllReplacements(
    const std::vector<std::pair<std::string,std::string> >& replacements);
  static const std::vector<std::pair<std::string,std::string> > CreateEndReplacements();
  static const std::vector<std::pair<std::string,std::string> > CreateInitialReplacements();
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLREPLACEMENTS_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlreplacements.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <iostream>
//---------------------------------------------------------------------------
#include "codetohtmlreplacements.h"
#include "trace.h"
//---------------------------------------------------------------------------
CodeToHtmlReplacements::CodeToHtmlReplacements(
  const std::vector<std::pair<std::string,std::string> >& replacements)
  : m_all_replacements(CreateAllReplacements(replacements))
{
  #ifndef NDEBUG
  {
    ///Warn the user for doublures in the input
    const auto end = replacements.end();
    for (auto i=replacements.begin();i!=end;++i)
    {
      for (auto j=replacements.begin();j!=end;++j)
      {
        if (i==j) continue;
        if ((*i).first == (*j).first)
        {
          std::cerr << "Element occurring twice: " << (*i).first << '\n';
        }
      }
    }
  }


  {
    ///Check against recurring replacements
    std::for_each(replacements.begin(),replacements.end(),
      [](const std::pair<std::string,std::string>& p)
      {
        assert(
          std::search(p.second.begin(),p.second.end(),p.first.begin(),p.first.end())
          == p.second.end());
      }
    );
  }

  {
    ///Check agains doublures in the processed input
    const auto end = m_replacements.end();
    for (auto i=m_replacements.begin();i!=end;++i)
    {
      std::clog << (*i).first << '\n';
      for (auto j=m_replacements.begin();j!=end;++j)
      {
        if (i==j) continue;
        if ((*i).first == (*j).first)
        {
          std::cerr << (*i).first << '\n';
        }
        assert((*i).first != (*j).first);
      }
    }
  }

  {
    ///Check nested processed input
    const auto end = m_replacements.end();
    for (auto i=m_replacements.begin();i!=end;++i)
    {
      const std::string s = (*i).second;
      //if (s.find("any")!=std::string::npos) { std::clog << "any_ found!\n"; }
      for (auto j=m_replacements.begin();j!=end;++j)
      {
        if (i==j) continue;
        const std::string t = (*j).first;
        //if (t == "any") { std::clog << "any found!\n"; }
        if (s.find(t) != std::string::npos)
        {
          std::cerr << "Error: "
            << s
            << " is nested by "
            << t
            << '\n';
        }
        assert(s.find(t) == std::string::npos);
      }
    }
  }

  #endif
}
//---------------------------------------------------------------------------
const std::vector<std::pair<std::string,std::string> >
  CodeToHtmlReplacements::CreateAllReplacements(
    const std::vector<std::pair<std::string,std::string> >& replacements)
{
  std::vector<std::pair<std::string,std::string> > v;
  //Initial
  {
    std::vector<std::pair<std::string,std::string> > w
      = CreateInitialReplacements();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  //Main
  {
    std::vector<std::pair<std::string,std::string> > w(replacements);

    //Sort to remove doublures
    std::sort(w.begin(),w.end());
    const auto new_end = std::unique(w.begin(),w.end());
    w.erase(new_end,w.end());

    //Sort from long strings to short, and alphabetically
    std::sort(w.begin(),w.end(),
      [](const std::pair<std::string,std::string>& lhs,const std::pair<std::string,std::string>& rhs)
      {
        if (lhs.first.size() > rhs.first.size()) return true;
        if (lhs.first.size() == rhs.first.size())
        {
          return lhs.first < rhs.first;
        }
        if (lhs.first.size() < rhs.first.size()) return false;
      }
    );
    std::copy(w.begin(),w.end(),std::back_inserter(v));

    std::for_each(w.begin(),w.end(),
      [](const std::pair<std::string,std::string>& p)
      {
        std::clog << p.first << '\n';
      }
    );
  }
  //End
  {
    std::vector<std::pair<std::string,std::string> > w
      = CreateEndReplacements();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}
//---------------------------------------------------------------------------
const std::vector<std::pair<std::string,std::string> > CodeToHtmlReplacements::CreateEndReplacements()
{
  //C++0x initializer list
  return
  {
  //2
    { "  ","&nbsp;&nbsp;" },
  //Remove the dollars
    { "$","" }, //IMPORTANT
  //Convert original ampersands and dollars back again
    { "&","&amp;" },
    { "$","$" },
    { "<","&lt;" },
    { ">","&gt;" }
  };
}
//---------------------------------------------------------------------------
const std::vector<std::pair<std::string,std::string> > CodeToHtmlReplacements::CreateInitialReplacements()
{
  //C++0x initializer list
  return
  {
    //symbol replacements that will mess up the markup if placed in bottom
    //First convert ampersands and dollars
    { "&","&" },
    { "$","$" },
    { "<","<" },
    { ">",">" }
  };
}
//---------------------------------------------------------------------------


 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlreplacementscpp.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlcontent.h"
//---------------------------------------------------------------------------
const std::vector<std::pair<std::string,std::string> > CodeToHtmlContent::CreateCppReplacements()
{
  std::vector<std::pair<std::string,std::string> > v = CodeToHtmlContent::CreateProReplacements();
  const std::vector<std::pair<std::string,std::string> > w =
  {
    //35
    { "<functional>","<<a href=\"CppFu$nctionalH.htm\">fu$nctional</a>>" },
    //34
    { "<algorithm>","[$LESS_THAN]<a href=\"CppAl$gorithmH.htm\">al$gorithm</a>>" },
    { "<exception>","[$LESS_THAN]<a href=\"CppEx$ceptionH.htm\">ex$ception</a>>" },
    { "<stdexcept>","[$LESS_THAN]<a href=\"CppSt$dexceptH.htm\">st$dexcept</a>>" },
    { "<streambuf>","[$LESS_THAN]<a href=\"CppSt$reambufH.htm\">st$reambuf</a>>" },
    { "<strstream>","[$LESS_THAN]<a href=\"CppSt$rstreamH.htm\">st$rstream</a>>" },
    //33
    { "<iostream>","<<a href=\"CppIo$streamH.htm\">io$s$tream</a>>" },
    { "<iterator>","<<a href=\"CppIt$eratorH.htm\">it$erator</a>>" },
    { "<valarray>","<<a href=\"CppVa$larrayH.htm\">va$larray</a>>" },
    { "<typeinfo>","<<a href=\"CppTy$peinfoH.htm\">ty$peinfo</a>>" },
    //32
    { "<cassert>","<<a href=\"CppCas$sertH.htm\">cas$sert</a>>" },
    { "<climits>","<<a href=\"CppCl$imitsH.htm\">cl$imits</a>>" },
    { "<clocale>","<<a href=\"CppClo$caleH.htm\">clo$cale</a>>" },
    { "<cstring>","<<a href=\"CppS$tringH.htm\">cs$tring</a>>" },
    { "<complex>","<<a href=\"CppCo$mplexH.htm\">co$mplex</a>>" },
    { "<cstdlib>","<<a href=\"CppCs$tdlibH.htm\">cs$tdlib</a>>" },
    { "<cwctype>","<<a href=\"CppCc$typeH.htm\">c$wct$ype</a>>" },
    { "<fstream>","<<a href=\"CppFs$treamH.htm\">fs$tream</a>>" },
    { "<iomanip>","<<a href=\"CppIo$manipH.htm\">i$o$m$anip</a>>" },
    { "<istream>","<<a href=\"CppIs$treamH.htm\">i$s$tream</a>>" },
    { "<numeric>","<<a href=\"CppNu$mericH.htm\">nu$meric</a>>" },
    { "<ostream>","<<a href=\"CppOs$treamH.htm\">os$tream</a>>" },
    { "<utility>","<<a href=\"CppUt$ilityH.htm\">ut$ility</a>>" },
    { "<sstream>","<<a href=\"CppSs$treamH.htm\">s$s$tream</a>>" },
    { "<stdio.h>","<<a href=\"CppStdioH.htm\">s$tdio.h</a>>" },
    { "CppHelloQtQtCreatorUbuntuSymbian","<a href=\"C$ppH$elloQ$tQ$tC$reatorU$buntuS$ymbian.htm\">C$ppH$elloQ$tQ$tC$reatorU$buntuS$ymbian</a>" },
    //31
    { "<bitset>","<<a href=\"CppBi$tsetH.htm\">bi$tset</a>>" },
    { "<cctype>","<<a href=\"CppCc$typeH.htm\">cct$ype</a>>" },
    { "<chrono>","<<a href=\"C$ppC$hronoH.htm\">c$hrono</a>>" },
    { "<cstdio>","<<a href=\"CppCs$tdioH.htm\">cs$tdio</a>>" },
    { "<iosfwd>","<<a href=\"CppIo$sfwdH.htm\">io$s$fwd</a>>" },
    { "<limits>","<<a href=\"CppLi$mitsH.htm\">li$mits</a>>" },
    { "<locale>","<<a href=\"CppLo$caleH.htm\">lo$cale</a>>" },
    { "<memory>","<<a href=\"CppMe$moryH.htm\">me$mory</a>>" },
    { "<string>","<<a href=\"CppSt$ringH.htm\">s$tring</a>>" },
    { "<thread>","<<a href=\"CppT$hreadH.htm\">t$hread</a>>" },
    { "<vector>","<<a href=\"CppVe$ctorH.htm\">ve$ctor</a>>" },
    //30
    { "<cmath>","<<a href=\"CppC$m$athH.htm\">cm$ath</a>>" },
    { "<ctime>","<<a href=\"CppC$t$imeH.htm\">ct$ime</a>>" },
    { "<deque>","<<a href=\"CppD$e$queH.htm\">de$que</a>>" },
    { "<regex>","<<a href=\"CppM$utexH.htm\">r$egex</a>>" },
    { "<queue>","<<a href=\"CppQ$ueueH.htm\">qu$eue</a>>" },
    { "<regex>","<<a href=\"CppR$egexH.htm\">r$egex</a>>" },
    { "<stack>","<<a href=\"CppS$tackH.htm\">s$t$ack</a>>" },
    { "<tuple>","<<a href=\"CppT$upleH.htm\">t$uple</a>>" },
    { "operator<<","<b><a href=\"CppOp$eratorStreamOut.htm\">o$perator[L$ESS_THAN][L$ESS_THAN]</a></b>" },
    { "QtMultipleChoiceQuestionDialog","<a href=\"C$ppQ$tM$ultipleC$hoiceQ$uestionD$ialog.htm\">Q$tM$ultipleC$hoiceQ$uestionD$ialog</a>" },
    { "WtMultipleChoiceQuestionDialog","<a href=\"C$ppW$tM$ultipleC$hoiceQ$uestionD$ialog.htm\">W$tM$ultipleC$hoiceQ$uestionD$ialog</a>" },
    //29
    { "<list>","<<a href=\"CppLi$stH.htm\">li$st</a>>" },
    { "Optical character recognition","<a href=\"CppO$cr.htm\">O$ptical c$haracter r$ecognition</a>" },
    { "optical character recognition","<a href=\"CppO$cr.htm\">o$ptical c$haracter r$ecognition</a>" },
    { "std::set_symmetric_difference","<a href=\"CppSet_symmetric_di$fference.htm\">st$d::set_symmetric_di$fference</a>" },
    { "Wt::WCombinedLocalizedStrings","<a href=\"CppW$C$ombinedL$ocalizedS$trings.htm\">W$t::W$C$ombinedL$ocalizedS$trings</a>" },
    //28
    { "boost::algorithm::find_first","<a href=\"CppFind_first.htm\">b$oost::a$lgorithm::f$ind_first</a>" },
    { "boost::filesystem::copy_file","<a href=\"CppCopy_file.htm\">b$oost::filesystem::copy_file</a>" },
    { "std::lexicographical_compare","<a href=\"CppLexicographical_compare.htm\">st$d::lexicographical_compare</a>" },
    { "CppHelloWorldQtCreatorUbuntu","<a href=\"C$ppH$elloW$orldQ$tC$reatorU$buntu.htm\">C$ppH$elloW$orldQ$tC$reatorU$buntu</a>" },
    { "MultipleChoiceQuestionDialog","<a href=\"C$ppM$ultipleC$hoiceQ$uestionD$ialog.htm\">M$ultipleC$hoiceQ$uestionD$ialog</a>" },
    { "TestSortedBinaryNewickVector","<a href=\"T$oolT$estS$ortedB$inaryN$ewickV$ector.htm\">T$estS$ortedB$inaryN$ewickV$ector</a>" },
    { "Wt::InvalidDateTimeException","<a href=\"CppI$nvalidD$ateT$imeE$xception.htm\">W$t::I$nvalidD$ateT$imeE$xception</a>" },
    { "Wt::WOverlayLoadingIndicator","<a href=\"CppW$OverlayL$oadingI$ndicator.htm\">W$t::W$O$verlayL$oadingI$ndicator</a>" },
    { "Wt::WDefaultLoadingIndicator","<a href=\"CppW$DefaultL$oadingI$ndicator.htm\">W$t::W$D$efaultL$oadingI$ndicator</a>" },
    //27
    { "boost::algorithm::trim_left","<a href=\"CppT$rim_left.htm\">b$oost::a$lgorithm::t$rim_left</a>" },
    { "boost::logic::indeterminate","<a href=\"CppIndeterminate.htm\">b$oost::l$ogic::i$ndeterminate</a>" },
    { "Flood::MultilayerPerceptron","<a href=\"CppFloodMultilayerPerceptron.htm\">F$lood::MultilayerPerceptron</a>" },
    //26
    { "explicit function defaults","<a href=\"C$ppE$xplicitF$unctionD$efault.htm\">e$xplicit f$unction d$efaults</a>" },
    { "implementation (.cpp) file","<a href=\"C$ppI$mplementationF$ile.htm\">i$mplementation (.c$pp) f$ile</a>" },
    { "std::recursive_timed_mutex","<a href=\"C$ppR$ecursive_t$imed_m$utex.htm\">s$td::r$ecursive_t$imed_m$utex</a>" },
    { "Explicit function defaults","<a href=\"C$ppE$xplicitF$unctionD$efault.htm\">E$xplicit f$unction d$efaults</a>" },
    { "GetCumulativeDensityNormal","<a href=\"CppGe$tCumulativeDensityNormal.htm\">Ge$tCumulativeDensityNormal</a>" },
    { "Wt::WMessageResourceBundle","<a href=\"CppW$M$essageR$esourceB$undle.htm\">W$t::W$MessageR$esourceB$undle</a>" },
    //25
    { "boost/program_options.hpp","<a href=\"C$ppP$rogram_o$ptions.htm\">b$oost/p$rogram_op$tions.hpp</a>" },
    { "boost::tuples::make_tuple","<a href=\"C$ppM$ake_t$uple.htm\">b$oost::t$uples::m$ake_t$uple</a>" },
    { "explicit function default","<a href=\"C$ppE$xplicitF$unctionD$efault.htm\">e$xplicit f$unction d$efault</a>" },
    { "CalcNumOfSymmetriesBinary","<a href=\"C$ppC$alcN$umO$fS$ymmetriesB$inary.htm\">C$alcN$umO$fS$ymmetriesB$inary</a>" },
    { "CppHelloQtQtCreatorUbuntu","<a href=\"C$ppH$elloQ$tQ$tC$reatorU$buntu.htm\">C$ppH$elloQ$tQ$tC$reatorU$buntu</a>" },
    { "DoPerfectElasticCollision","<a href=\"C$ppD$oPerfectElasticCollision.htm\">D$oPerfectElasticCollision</a>" },
    { "Explicit function default","<a href=\"C$ppE$xplicitF$unctionD$efault.htm\">E$xplicit f$unction d$efault</a>" },
    { "GetLubuntuVersionCodename","<a href=\"C$ppG$etLu$buntuV$ersionC$odename.htm\">G$etLu$buntuV$ersionC$odename</a>" },
    { "Wt::WSortFilterProxyModel","<a href=\"C$ppW$S$ortF$ilterP$roxyM$odel.htm\">W$t::W$S$ortF$ilterP$roxyM$odel</a>" },
    { "Wt::WAbstractToggleButton","<a href=\"C$ppW$A$bstractT$oggleB$utton.htm\">W$t::W$A$bstractT$oggleB$utton</a>" },
    { "Wt::WAbstractItemDelegate","<a href=\"C$ppW$A$bstractI$temD$elegate.htm\">W$t::W$A$bstractI$temD$elegate</a>" },
    { "WtTimedServerPusherClient","<a href=\"C$ppW$tT$imedS$erverP$usherC$lient.htm\">W$tT$imedS$erverP$usherC$lient</a>" },
    //24
    { "copy assignment operator","<a href=\"C$ppC$opyA$ssignmentO$perator.htm\">c$opy a$ssignment o$perator</a>" },
    { "std::adjacent_difference","<a href=\"C$ppAdjacent_di$fference.htm\">st$d::adj$acent_di$fference</a>" },
    { "Copy assignment operator","<a href=\"C$ppC$opyA$ssignmentO$perator.htm\">C$opy a$ssignment o$perator</a>" },
    { "GetUbuntuVersionCodename","<a href=\"C$ppG$etU$buntuV$ersionC$odename.htm\">G$etU$buntuV$ersionC$odename</a>" },
    { "RandomCodeDesktopConsole","<a href=\"T$oolR$andomC$ode.htm\">R$andomC$odeD$esktopC$onsole</a>" },
    { "SortedBinaryNewickVector","<a href=\"C$ppS$ortedB$inaryN$ewickV$ector.htm\">S$ortedB$inaryN$ewickV$ector</a>" },
    { "Wt::WBatchEditProxyModel","<a href=\"C$ppW$B$atchE$ditP$roxyM$odel.htm\">W$t::W$B$atchEditP$roxyM$odel</a>" },
    { "Wt::WAggregateProxyModel","<a href=\"C$ppW$A$ggregateP$roxyM$odel.htm\">W$t::W$A$ggregateP$roxyM$odel</a>" },
    { "Wt::InvalidTimeException","<a href=\"C$ppI$nvalidT$imeE$xception.htm\">W$t::I$nvalidT$imeE$xception</a>" },
    { "Wt::InvalidDateException","<a href=\"C$ppI$nvalidD$ateE$xception.htm\">W$t::I$nvalidD$ateE$xception</a>" },

  //23
    { "boost::algorithm::split","<a href=\"C$ppS$plit.htm\">b$oost::a$lgorithm::s$plit</a>" },
    { "boost::bad_lexical_cast","<a href=\"C$ppB$ad_lex$ical_c$ast.htm\">bo$ost::bad_lex$ical_cast</a>" },
    { "boost::signals2::signal","<a href=\"C$ppB$oostS$ignal.htm\">b$oost::s$ignals2::s$ignal</a>" },
    { "boost/logic/tribool.hpp","<a href=\"C$ppT$rib$ool.htm\">b$oost/l$ogic/t$rib$ool.h$pp</a>" },
    { "std::condition_variable","<a href=\"C$ppC$ondition_v$ariable.htm\">s$td::c$ondition_v$ariable</a>" },
    { "Wt::WItemSelectionModel","<a href=\"CppWI$temS$electionM$odel.htm\">W$t::W$I$temS$electionM$odel</a>" },
    { "Wt::WCssDecorationStyle","<a href=\"CppWCssDecorationStyle.htm\">W$t::W$CssDecorationStyle</a>" },
    { "Wt::WAbstractTableModel","<a href=\"CppWAbstractTableModel.htm\">W$t::W$AbstractTableModel</a>" },
    { "Wt::WAbstractProxyModel","<a href=\"CppWAbstractProxyModel.htm\">W$t::W$AbstractProxyModel</a>" },
    { "QtMobility::QSystemInfo","<a href=\"CppQ$S$ystemI$nfo.htm\">Q$tM$obility::Q$S$ystemI$nfo</a>" },
  //22
    { "boost::circular_buffer","<a href=\"C$ppC$ircular_b$uffer.htm\">b$oost::c$ircular_b$uffer</a>" },
    { "boost::program_options","<a href=\"C$ppP$rogram_o$ptions.htm\">b$oost::p$rogram_o$ptions</a>" },
    { "boost::signals::signal","<a href=\"C$ppB$oostS$ignal.htm\">b$oost::s$ignals::s$ignal</a>" },
    { "std::partial_sort_copy","<a href=\"C$ppP$artial_s$ort_c$opy.htm\">st$d::p$artial_s$ort_c$opy</a>" },
    { "MultipleChoiceQuestion","<a href=\"C$ppM$ultipleC$hoiceQ$uestion.htm\">M$ultipleC$hoiceQ$uestion</a>" },
    { "SetReadOnlyTableWidget","<a href=\"C$ppS$etR$eadO$nlyT$ableW$idget.htm\">S$etR$eadO$nlyT$ableW$idget</a>" },
    { "TestBinaryNewickVector","<a href=\"T$oolT$estB$inaryN$ewickV$ector.htm\">T$estB$inaryN$ewickV$ector</a>" },
    { "Wt::WStandardItemModel","<a href=\"CppW$S$tandardI$temM$odel.htm\">W$t::W$S$tandardI$temM$odel</a>" },
    { "Wt::WCanvasPaintDevice","<a href=\"CppW$C$anvasP$ai$ntD$evice.htm\">W$t::W$C$anvasP$ai$ntD$evice</a>" },
    { "Wt::WAbstractListModel","<a href=\"CppW$A$bstractL$istM$odel.htm\">W$t::W$A$bstractL$istM$odel</a>" },
    { "Wt::WAbstractItemModel","<a href=\"CppW$A$bstractI$temM$odel.htm\">W$t::W$A$bstractI$temM$odel</a>" },
    { "&&","<a href=\"CppOperatorLogicalAnd.htm\">$&amp;$&amp;</a>" },
  //21
    { "boost::adjacency_list","<a href=\"CppAdjacency_l$ist.htm\">b$oost::adjacency_l$ist</a>" },
    { "boost::checked_delete","<a href=\"CppChecked_del$ete.htm\">bo$ost::checked_del$ete</a>" },
    { "boost::logic::tribool","<a href=\"C$ppT$rib$ool.htm\">b$oost::l$ogic::t$rib$ool</a>" },
    { "boost::write_graphviz","<a href=\"CppWrite_graphviz.htm\">b$oost::write_graphviz</a>" },
    { "i686-pc-mingw32-qmake","<a href=\"CppI$686-p$c-m$ingw32-q$m$ake.htm\">i$686-p$c-m$ingw32-q$m$ake</a>" },
    { "rubiksclockmaindialog","<a href=\"G$ameR$ubiksC$lock.htm\">r$ubiksc$lockm$aind$ialog</a>" },
    { "std::invalid_argument","<a href=\"CppInvalid_argument.htm\">st$d::invalid_argument</a>" },
    { "std::istream_iterator","<a href=\"C$ppI$stream_i$terator.htm\">s$td::i$st$ream_i$te$rator</a>" },
    { "std::ostream_iterator","<a href=\"C$ppO$stream_i$terator.htm\">s$td::o$st$ream_i$te$rator</a>" },
    { "std::set_intersection","<a href=\"CppSet_in$tersection.htm\">st$d::set_in$tersection</a>" },
    { "std::stable_partition","<a href=\"CppStable_partition.htm\">st$d::stable_partition</a>" },
    { "std::stable_sort_copy","<a href=\"CppStable_sort_copy.htm\">st$d::stable_sort_copy</a>" },
    { "std::prev_permutation","<a href=\"CppPrev_permutation.htm\">st$d::prev_permutation</a>" },
    { "std::next_permutation","<a href=\"CppNext_permutation.htm\">st$d::next_permutation</a>" },
    { "CalcNumOfCombinations","<a href=\"CppC$alcNumOfCombinations.htm\">C$alcNumOfCombinations</a>" },
    { "CountNonZeroPositives","<a href=\"CppCo$untNonZeroPositives.htm\">Co$untNonZeroPositives</a>" },
    { "ReplaceNegativeByZero","<a href=\"CppRe$placeN$egativeB$yZ$ero.htm\">Re$placeN$egativeB$yZ$ero</a>" },
    { "ReplacePositiveByZero","<a href=\"CppRe$placeP$ositiveB$yZ$ero.htm\">Re$placeP$ositiveB$yZ$ero</a>" },
    { "RubiksClockMainDialog","<a href=\"G$ameR$ubiksC$lock.htm\">R$ubiksC$lockM$ainD$ialog</a>" },
    { "RubiksClockMenuDialog","<a href=\"G$ameR$ubiksC$lock.htm\">R$ubiksC$lockM$enuD$ialog</a>" },
    { "TestTimedServerPusher","<a href=\"T$oolT$estT$imedS$erverP$usher.htm\">T$estT$imedS$erverP$usher</a>" },
    { "Wt::WValidationStatus","<a href=\"CppW$V$alidationS$tatus.htm\">W$t::W$V$alidationS$tatus</a>" },
    { "Wt::WLocalizedStrings","<a href=\"CppW$L$ocalizedS$trings.htm\">W$t::W$L$ocalizedS$trings</a>" },
    { "Wt::WLoadingIndicator","<a href=\"CppW$L$oadingI$ndicator.htm\">W$t::W$L$oadingI$ndicator</a>" },
    { "Wt::WAbstractItemView","<a href=\"CppW$A$bstractI$temView.htm\">W$t::W$A$bstractI$temV$iew</a>" },
  //20
    { "boost::property_tree","<a href=\"C$ppP$roperty_t$ree.htm\">b$oost::property_t$ree</a>" },
    { "default construction","<a href=\"C$ppD$efaultC$ons$tructor.htm\">d$efault c$ons$truction</a>" },
    { "std::basic_streambuf ","<a href=\"C$ppB$asic_s$treambuf.htm\">s$td::ba$sic_streambuf</a> " },
    { "std::binary_function","<a href=\"C$ppB$inary_f$unction.htm\">s$td::bi$nary_fu$nction</a>" },
    { "std::is_sorted_until","<a href=\"C$ppI$s_s$orted_u$ntil.htm\">st$d::i$s_s$orted_u$ntil</a>" },
    { "std::recursive_mutex","<a href=\"C$ppR$ecursive_m$utex.htm\">s$td::r$ecursive_m$utex</a>" },
    { "std::replace_copy_if","<a href=\"CppReplace_copy_i$f.htm\">st$d::replace_copy_i$f</a>" },
    { "std::tr1::shared_ptr","<a href=\"CppS$hared_p$tr.htm\">s$td::t$r1::s$hared_p$tr</a>" },
    { "std::underflow_error","<a href=\"CppUnderflow_error.htm\">st$d::underflow_error</a>" },
    { "wtconnectthreewidget","<a href=\"C$ppW$tC$onnectT$hreeW$idget.htm\">w$tc$onnectt$hreew$idget</a>" },
    { "CreateInvalidNewicks","<a href=\"C$ppC$reateInvalidN$ewicks.htm\">C$reateInvalidN$ewicks</a>" },
    { "Default construction","<a href=\"CppD$efaultC$ons$tructor.htm\">D$efault c$ons$truction</a>" },
    { "GetHtmlFilesInFolder","<a href=\"C$ppG$etHtmlFilesInFolder.htm\">G$etHtmlFilesInFolder</a>" },
    { "GetSumProperDivisors","<a href=\"CppG$etSumProperDivisors.htm\">G$etSumProperDivisors</a>" },
    { "GetTextFilesInFolder","<a href=\"C$ppG$etT$extF$ilesI$nF$older.htm\">G$etT$extF$ilesI$nF$older</a>" },
    { "GetVirtualBoxVersion","<a href=\"CppG$etV$irtualB$oxV$ersion.htm\">G$etV$irtualB$oxV$ersion</a>" },
    { "InspectInvalidNewick","<a href=\"CppI$nspectInvalidN$ewick.htm\">I$nspectInvalidN$ewick</a>" },
    { "QtMobility::QContact","<a href=\"CppQ$C$ontact.htm\">Q$tM$obility::Q$C$ontact</a>" },
    { "QtOpenQuestionDialog","<a href=\"C$ppQ$tO$penQ$uestionD$ialog.htm\">Q$tO$penQ$uestionD$ialog</a>" },
    { "RandomCodeDesktopGui","<a href=\"T$oolR$andomC$ode.htm\">R$andomC$odeD$esktopG$ui</a>" },
    { "TestSelectFileDialog","<a href=\"T$oolT$estS$electF$ileD$ialog.htm\">T$estS$electF$ileD$ialog</a>" },
    { "Wt::WSuggestionPopup","<a href=\"CppW$S$uggestionP$opup.htm\">W$t::W$S$uggestionP$opup</a>" },
    { "Wt::WStringListModel","<a href=\"CppW$S$tringL$istM$odel.htm\">W$t::W$S$tringL$istM$odel</a>" },
    { "Wt::WStaticModelView","<a href=\"CppW$S$taticM$odelV$iew.htm\">W$t::W$S$taticM$odelV$iew</a>" },
    { "Wt::WRegExpValidator","<a href=\"CppW$R$egE$xpV$alidator.htm\">W$t::W$R$egE$xpV$alidator</a>" },
    { "Wt::WLengthValidator","<a href=\"CppW$L$engthV$alidator.htm\">W$t::W$L$engthV$alidator</a>" },
    { "Wt::WDoubleValidator","<a href=\"CppW$D$oubleV$alidator.htm\">W$t::W$D$oubleV$alidator</a>" },
    { "Wt::WCssTemplateRule","<a href=\"CppW$C$ssT$emplateR$ule.htm\">W$t::W$C$ssT$emplateR$ule</a>" },
    { "Wt::WContainerWidget","<a href=\"CppW$C$ontainerW$idget.htm\">W$t::W$C$ontainerW$idget</a>" },
    { "Wt::WCompositeWidget","<a href=\"CppW$C$ompositeW$idget.htm\">W$t::W$C$ompositeW$idget</a>" },
    { "Wt::WAccordionLayout","<a href=\"CppW$A$ccordionL$ayout.htm\">W$t::W$A$ccordionL$ayout</a>" },
    { "Wt::Boost_any_traits","<a href=\"C$ppB$oost_a$ny_t$raits.htm\">W$t::B$oost_a$ny_t$raits</a>" },
    { "WtOpenQuestionDialog","<a href=\"C$ppW$tO$penQ$uestionD$ialog.htm\">W$tO$penQ$uestionD$ialog</a>" },
    { "WtServerPusherClient","<a href=\"C$ppW$tS$erverP$usherC$lient.htm\">W$tS$erverP$usherC$lient</a>" },
  //19
    { "Abstract base class","<a href=\"C$ppA$bstractB$aseC$lass.htm\">A$bstract b$ase c$lass</a>" },
    { "Andrei Alexandrescu","<a href=\"CppAndreiAlexandrescu.htm\">A$ndrei Alexandrescu</a>" },
    { "boost/property_tree","<a href=\"C$ppP$roperty_t$ree.htm\">b$oost/p$roperty_t$ree</a>" },
    { "BOOST_STATIC_ASSERT","<a href=\"CppBO$OST_STATIC_ASSERT.htm\">BO$OST_STATIC_ASSERT</a>" },
    { "Boost.PropertyTree","<a href=\"C$ppP$ropertyT$ree.htm\">B$oost.P$ropertyT$ree</a>" },
    { "CalcNumOfSymmetries","<a href=\"CppC$alcNumOfSymmetries.htm\">C$alcNumOfSymmetries</a>" },
    { "Default constructor","<a href=\"CppD$efaultC$ons$tructor.htm\">D$efault c$ons$tructor</a>" },
    { "Forward declaration","<a href=\"CppF$orwardD$eclaration.htm\">F$orward d$eclaration</a>" },
    { "GetCppFilesInFolder","<a href=\"CppG$etCppFilesInFolder.htm\">G$etCppFilesInFolder</a>" },
    { "GetLastModifiedTime","<a href=\"CppG$etL$astM$odi$fiedT$ime.htm\">G$etL$astM$odi$fiedT$ime</a>" },
    { "GetQtCreatorVersion","<a href=\"CppG$etQ$tC$reatorV$ersion.htm\">G$etQ$tC$reatorV$ersion</a>" },
    { "Implementation file","<a href=\"CppI$mplementationF$ile.htm\">I$mplementation f$ile</a>" },
    { "QGraphicsPixmapItem","<a href=\"CppQGra$phicsP$ixmapI$tem.htm\">Q$G$ra$phicsP$ixmapI$tem</a>" },
    { "QtDialDisplayWidget","<a href=\"CppQ$tD$ialD$isplayW$idget.htm\">Q$tD$ialD$isplayW$idget</a>" },
    { "TrinaryNewickVector","<a href=\"CppT$rinaryN$ewickV$ector.htm\">T$rinaryN$ewickV$ector</a>" },
    { "Wt::EventSignalBase","<a href=\"CppEventS$ignalBase.htm\">W$t::EventS$ignalBase</a>" },
    { "Wt::WInteractWidget","<a href=\"C$ppW$I$nteractW$idget.htm\">W$t::W$I$nteractW$idget</a>" },
    { "Wt::WLayoutItemImpl","<a href=\"CppW$L$ayoutI$temI$mpl.htm\">W$t::W$L$ayoutI$temI$mpl</a>" },
    { "Wt::WMemoryResource","<a href=\"CppWM$emoryResource.htm\">W$t::W$M$emoryResource</a>" },
    { "Wt::WSocketNotifier","<a href=\"CppWSocketNoti$fier.htm\">W$t::W$SocketNoti$fier</a>" },
    { "__gnu_cxx::hash_set;","<a href=\"C$ppH$ash_s$et.htm\">_$_gnu_cxx::hash_set</a>;" },
    { "abstract base class","<a href=\"CppA$bstractB$aseC$lass.htm\">a$bstract b$ase c$lass</a>" },
    { "boost::accumulators","<a href=\"C$ppAccumulators.htm\">b$oost::accumulators</a>" },
    { "boost::bad_any_cast","<a href=\"C$ppB$ad_a$ny_c$ast.htm\">b$oost::b$ad_a$ny_c$ast</a>" },
    { "boost::lexical_cast","<a href=\"CppLexical_cast.htm\">bo$ost::l$exical_ca$st</a>" },
    { "boost::numeric_cast","<a href=\"CppNumeric_cast.htm\">bo$ost::numeric_ca$st</a>" },
    { "default constructor","<a href=\"CppD$efaultC$ons$tructor.htm\">d$efault c$ons$tructor</a>" },
    { "forward declaration","<a href=\"CppF$orwardD$eclaration.htm\">f$orward d$eclaration</a>" },
    { "implementation file","<a href=\"CppI$mplementationF$ile.htm\">i$mplementation f$ile</a>" },
    { "jpeg_io_private.hpp","jp$eg_i$o_pri$vate.hpp" },
    { "std::minmax_element","<a href=\"CppMi$nm$ax_e$lement.htm\">st$d::mi$nm$ax_el$ement</a>" },
    { "std::numeric_limits","<a href=\"CppNu$meric_limits.htm\">st$d::nu$meric_limits</a>" },
    { "std::overflow_error","<a href=\"CppOverflow_error.htm\">st$d::overflow_error</a>" },
    { "std::priority_queue","<a href=\"CppPriority_queue.htm\">st$d::priority_queue</a>" },
    { "std::random_shuffle","<a href=\"CppRa$nd$om_shuffle.htm\">st$d::ra$nd$om_shuffle</a>" },
    { "std::remove_copy_if","<a href=\"CppRemove_copy_i$f.htm\">st$d::remove_copy_i$f</a>" },
    { "std::set_difference","<a href=\"CppSet_di$fference.htm\">st$d::set_di$fference</a>" },
    { "std::unary_function","<a href=\"CppU$nary_f$unction.htm\">s$td::un$ary_fu$nction</a>" },
  //18
    { "boost::multi_array","<a href=\"CppM$ulti_ar$ray.htm\">bo$ost::m$ulti_a$rray</a>" },
    { "boost::noncopyable","<a href=\"CppN$onc$opyable.htm\">b$oost::n$onc$opyable</a>" },
    { "boost::regex_match","<a href=\"CppR$egex_m$atch.htm\">b$oost::r$egex_match</a>" },
    { "boost::tuples::tie","<a href=\"CppT$ie.htm\">b$oost::t$uples::t$ie</a>" },
    { "lambda expressions","<a href=\"CppL$ambdaE$xpression.htm\">l$ambda e$xpressions</a>" },
    { "mobile application","<a href=\"CppM$obileA$pplication.htm\">m$obile a$pplication</a>" },
    { "std::adjacent_find","<a href=\"CppAdjacent_find.htm\">s$td::ad$jacent_fi$nd</a>" },
    { "std::bad_exception","<a href=\"CppBad_exception.htm\">st$d::bad_exception</a>" },
    { "std::binary_search","<a href=\"CppBinary_search.htm\">st$d::binary_search</a>" },
    { "std::copy_backward","<a href=\"C$ppC$opy_b$ackward.htm\">st$d::c$opy_b$ackward</a>" },
    { "std::hash_multimap","<a href=\"CppHash_multimap.htm\">st$d::hash_multimap</a>" },
    { "std::hash_multiset","<a href=\"CppHash_multiset.htm\">st$d::hash_multiset</a>" },
    { "std::inplace_merge","<a href=\"CppInplace_merge.htm\">st$d::inplace_merge</a>" },
    { "std::back_inserter","<a href=\"CppBack_inserter.htm\">s$td::back_ins$erter</a>" },
    { "std::find_first_of","<a href=\"CppFind_first_of.htm\">s$td::fi$nd_first_of</a>" },
    { "std::greater_equal","<a href=\"CppGreater_equal.htm\">st$d::gre$ater_equal</a>" },
    { "std::inner_product","<a href=\"CppInner_product.htm\">st$d::i$nner_product</a>" },
    { "std::is_heap_until","<a href=\"C$ppI$s_h$eap_u$ntil.htm\">s$td::i$s_h$eap_u$ntil</a>" },
    { "std::istringstream","<a href=\"CppIstringstream.htm\">s$td::ist$ringstream</a>" },
    { "std::move_backward","<a href=\"CppMo$ve_b$ackward.htm\">s$td::mo$ve_b$ackward</a>" },
    { "std::ostringstream","<a href=\"CppOstringstream.htm\">s$td::ost$ringstream</a>" },
    { "std::runtime_error","<a href=\"CppR$unt$ime_e$rror.htm\">st$d::r$unt$ime_error</a>" },
    { "std::resetiosflags","<a href=\"CppR$esetiosflags.htm\">st$d::r$eseti$osf$lags</a>" },
    { "significance_level","signi$ficance_level" },
    { "testfunctionparser","<a href=\"T$oolT$estF$unctionP$arser.htm\">t$estf$unctionp$arser</a>" },
    { "BinaryNewickVector","<a href=\"CppB$inaryN$ewickV$ector.htm\">B$inaryN$ewickV$ector</a>" },
    { "CreateValidNewicks","<a href=\"CppC$reateValidN$ewicks.htm\">C$reateValidN$ewicks</a>" },
    { "DumbNewickToString","<a href=\"CppD$umbN$ewickToString.htm\">D$umbN$ewickToS$tring</a>" },
    { "GetFoldersInFolder","<a href=\"CppG$etF$oldersI$nF$older.htm\">G$etF$oldersI$nF$older</a>" },
    { "GetQuantLibVersion","<a href=\"CppG$etQ$uantL$ibV$ersion.htm\">G$etQ$uantL$ibV$ersion</a>" },
    { "Lambda expressions","<a href=\"CppL$ambdaE$xpression.htm\">L$ambda e$xpressions</a>" },
    { "Mobile application","<a href=\"CppM$obileA$pplication.htm\">M$obile a$pplication</a>" },
    { "OpenQuestionDialog","<a href=\"C$ppO$penQ$uestionD$ialog.htm\">O$penQ$uestionD$ialog</a>" },
    { "QtLedDisplayWidget","<a href=\"CppQ$tL$edD$isplayW$idget.htm\">Q$tL$edD$isplayW$idget</a>" },
    { "ReadDoubleFromFile","<a href=\"CppR$eadD$oubleFromFile.htm\">R$eadD$oubleFromFile</a>" },
    { "TestFunctionParser","<a href=\"T$oolT$estF$unctionP$arser.htm\">T$estF$unctionP$arser</a>" },
    { "Wt::WTreeTableNode","<a href=\"CppW$T$reeT$ableN$ode.htm\">W$t::W$T$reeT$ableN$ode</a>" },
    { "Wt::WStackedWidget","<a href=\"C$ppW$S$tackedW$idget.htm\">W$t::W$S$tackedW$idget</a>" },
    { "Wt::WPopupMenuItem","<a href=\"C$ppW$P$opupM$enuI$tem.htm\">W$t::W$P$opupM$enuI$tem</a>" },
    { "Wt::WPaintedWidget","<a href=\"C$ppW$P$ai$ntedW$idget.htm\">W$t::W$Pai$ntedW$idget</a>" },
    { "Wt::WGenericMatrix","<a href=\"C$ppW$G$enericM$atrix.htm\">W$t::W$G$enericM$atrix</a>" },
    { "Wt::WDefaultLayout","<a href=\"C$ppW$D$efaultL$ayout.htm\">W$t::W$D$efaultL$ayout</a>" },
    { "Wt::WDateValidator","<a href=\"C$ppW$D$ateV$alidator.htm\">W$t::W$D$ateV$alidator</a>" },
    { "Wt::WCssStyleSheet","<a href=\"C$ppW$C$ssS$tyleS$heet.htm\">W$t::W$C$ssS$tyleSheet</a>" },
    { "WtLedDisplayWidget","<a href=\"C$ppW$t$L$edD$isplayW$idget.htm\">W$tL$edD$isplayW$idget</a>" },
    { "WtShapeGroupWidget","<a href=\"C$ppW$tS$hapeG$roupW$idget.htm\">W$tS$hapeG$roupW$idget</a>" },
  //17
    { "boost::filesystem","<a href=\"CppFilesystem.htm\">b$oost::filesystem</a>" },
    { "boost::make_tuple","<a href=\"CppM$ake_t$uple.htm\">bo$ost::m$ake_t$uple</a>" },
    { "boost::shared_ptr","<a href=\"CppS$hared_p$tr.htm\">b$oost::s$hared_p$tr</a>" },
    { "boost::scoped_ptr","<a href=\"CppS$coped_ptr.htm\">b$oost::s$coped_p$tr</a>" },
    { "lambda expression","<a href=\"CppL$ambdaE$xpression.htm\">l$ambda e$xpression</a>" },
    { "n_with_this_value","n_with_th$is_value" },
    { "static_assert.hpp","sta$tic_as$sert.hpp" },
    { "template function","<a href=\"C$ppT$emplateF$unction.htm\">t$emplate f$unction</a>" },
    { "BigIntegerLibrary","<a href=\"CppB$igInt.htm\">B$igI$ntegerL$ibrary</a>" },
    { "Bjarne Stroustrup","<a href=\"CppBjarneStroustrup.htm\">Bja$rne Stroustrup</a>" },
    { "Flood::Perceptron","<a href=\"CppFloodPerceptron.htm\">F$lood::Perceptron</a>" },
    { "GetFactorialTerms","<a href=\"CppGe$tFa$ctorialTerms.htm\">Ge$tFa$ctorialTerms</a>" },
    { "GetSimplerNewicks","<a href=\"CppG$etSimplerN$ewicks.htm\">G$etSimplerN$ewicks</a>" },
    { "Lambda expression","<a href=\"CppL$ambdaE$xpression.htm\">L$ambda e$xpression</a>" },
    { "QGraphicsPathItem","<a href=\"CppQGra$phicsP$athI$tem.htm\">QGra$phicsP$athI$tem</a>" },
    { "Template function","<a href=\"C$ppT$emplateF$unction.htm\">T$emplate f$unction</a>" },
    { "Wt::WVirtualImage","<a href=\"CppW$V$irtualI$mage.htm\">W$t::W$V$irtualI$mage</a>" },
    { "Wt::WStandardItem","<a href=\"CppW$S$tandardI$tem.htm\">W$t::W$S$tandardI$tem</a>" },
    { "Wt::WSignalMapper","<a href=\"CppW$S$ignalM$apper.htm\">W$t::W$S$ignalM$apper</a>" },
    { "Wt::WSelectionBox","<a href=\"CppW$S$electionB$ox.htm\">W$t::W$S$electionB$ox</a>" },
    { "Wt::WItemDelegate","<a href=\"CppW$I$temD$elegate.htm\">W$t::W$I$temD$elegate</a>" },
    { "Wt::WIntValidator","<a href=\"CppW$I$ntV$alidator.htm\">W$t::W$I$ntV$alidator</a>" },
    { "Wt::WGestureEvent","<a href=\"CppW$G$estureE$vent.htm\">W$t::W$G$estureE$vent</a>" },
    { "Wt::WFileResource","<a href=\"CppW$F$ileR$esource.htm\">W$t::W$F$ileR$esource</a>" },
    { "Wt::WBorderLayout","<a href=\"CppW$B$orderL$ayout.htm\">W$t::W$B$orderL$ayout</a>" },
    { "Wt::WAbstractArea","<a href=\"CppW$A$bstractA$rea.htm\">W$t::W$A$bstractA$rea</a>" },
    { "Copy construction","<a href=\"CppC$opyC$ons$tructor.htm\">C$opy c$ons$truction</a>" },
    { "GetLubuntuVersion","<a href=\"CppG$etLu$buntuV$ersion.htm\">G$etLu$buntuV$ersion</a>" },
    { "copy construction","<a href=\"CppC$opyC$ons$tructor.htm\">c$opy c$ons$truction</a>" },
    { "std::not_equal_to","<a href=\"CppNot_equal_to.htm\">st$d::no$t_equ$al_t$o</a>" },
    { "std::domain_error","<a href=\"CppDoma$in_error.htm\">st$d::d$oma$in_e$rror</a>" },
    { "std::length_error","<a href=\"CppLength_error.htm\">st$d::l$ength_e$rror</a>" },
    { "std::setprecision","<a href=\"CppSetprecision.htm\">st$d::s$etp$recision</a>" },
    { "std::out_of_range","<a href=\"CppOut_of_range.htm\">st$d::o$ut_o$f_r$ange</a>" },
    { "std::partial_sort","<a href=\"CppP$artial_s$ort.htm\">st$d::p$artial_s$ort</a>" },
    { "std::replace_copy","<a href=\"CppR$eplace_c$opy.htm\">st$d::r$eplace_c$opy</a>" },
    { "std::reverse_copy","<a href=\"CppR$everse_c$opy.htm\">st$d::r$everse_c$opy</a>" },
    { "std::stringstream","<a href=\"CppS$trings$tream.htm\">s$td::st$rings$tream</a>" },
  //16
    { "AskUserForDouble","<a href=\"C$ppA$skU$serF$orD$ouble.htm\">A$skU$serF$orD$ouble</a>" },
    { "GetCurrentFolder","<a href=\"CppG$etCurrentFolder.htm\">G$etCurrentFolder</a>" },
    { "GetDistancesPath","<a href=\"CppG$etDistancesPath.htm\">G$etDistancesPath</a>" },
    { "GetFilesInFolder","<a href=\"CppG$etFilesInFolder.htm\">G$etFilesInFolder</a>" },
    { "RemoveDuplicates","<a href=\"CppRem$oveDuplicates.htm\">Rem$oveDuplicates</a>" },
    { "TestServerPusher","<a href=\"T$oolT$estS$erverP$usher.htm\">T$estS$erverP$usher</a>" },
    { "WContainerWidget","<a href=\"CppW$C$ontainerW$idget.htm\">W$C$ontainerW$idget</a>" },
    { "access violation","<a href=\"CppAccessViolation.htm\">access vi$olation</a>" },
    { "cln::cl_I_to_int","<a href=\"CppCl_I_to_int.htm\">c$ln::c$l_I_to_int</a>" },
    { "copy constructor","<a href=\"CppC$opyC$ons$tructor.htm\">c$opy c$ons$tructor</a>" },
    { "initializer list","<a href=\"CppI$nitializerL$ist.htm\">i$nitializer l$ist</a>" },
    { "reinterpret_cast","<b><a href=\"CppRe$in$terpret_cast.htm\">rein$t$erpret_cast</a></b>" },
    { "std::accumulate(","<a href=\"CppAc$cu$mulate.htm\">s$td::a$ccu$mulate</a>(" },
    { "std::accumulate ","<a href=\"CppAc$cu$mulate.htm\">s$td::a$ccu$mulate</a> " },
    { "std::equal_range","<a href=\"CppEqual_range.htm\">st$d::equal_range</a>" },
    { "std::find_if_not","<a href=\"C$ppF$ind_i$f_n$ot.htm\">s$td::fi$nd_i$f_n$ot</a>" },
    { "std::logic_error","<a href=\"CppLogic_error.htm\">st$d::logic_error</a>" },
    { "std::logical_and","<a href=\"CppLogical_and.htm\">st$d::lo$gical_and</a>" },
    { "std::logical_not","<a href=\"CppLogical_not.htm\">st$d::lo$gical_not</a>" },
    { "std::lower_bound","<a href=\"CppLower_bound.htm\">st$d::lower_bound</a>" },
    { "std::max_element","<a href=\"CppMa$x_element.htm\">st$d::ma$x_el$ement</a>" },
    { "std::mem_fun_ref","<a href=\"CppMem_fun.htm\">s$td::me$m_fu$n_re$f</a>" },
    { "std::min_element","<a href=\"CppMi$n_element.htm\">st$d::mi$n_el$ement</a>" },
    { "std::noboolalpha","<a href=\"CppNobo$olalpha.htm\">st$d::nobo$olalpha</a>" },
    { "std::noshowpoint","<a href=\"CppNoshowpoi$nt.htm\">st$d::noshowpoi$nt</a>" },
    { "std::nouppercase","<a href=\"CppNoupperca$se.htm\">st$d::noupperca$se</a>" },
    { "std::nth_element","<a href=\"CppNth_element.htm\">st$d::nth_element</a>" },
    { "std::partial_sum","<a href=\"CppPartial_sum.htm\">st$d::pa$rtial_sum</a>" },
    { "std::range_error","<a href=\"CppRange_error.htm\">st$d::range_error</a>" },
    { "std::regex_match","<a href=\"CppR$egex_m$atch.htm\">s$td::r$egex_match</a>" },
    { "std::remove_copy","<a href=\"CppRemove_copy.htm\">st$d::remove_copy</a>" },
    { "std::rotate_copy","<a href=\"CppR$otate_copy.htm\">st$d::rotate_copy</a>" },
    { "std::setiosflags","<a href=\"CppSetiosflags.htm\">st$d::setiosflags</a>" },
    { "std::stable_sort","<a href=\"C$ppStable_sort.htm\">st$d::stable_sort</a>" },
    { "std::swap_ranges","<a href=\"C$ppSwap_ranges.htm\">st$d::swap_ranges</a>" },
    { "std::this_thread","<a href=\"C$ppT$his_t$hread.htm\">s$td::t$his_t$hread</a>" },
    { "std::timed_mutex","<a href=\"C$ppT$imed_m$utex.htm\">s$td::t$imed_m$utex</a>" },
    { "std::unique_copy","<a href=\"C$ppU$nique_c$opy.htm\">s$td::u$nique_c$opy</a>" },
    { "std::unique_lock","<a href=\"C$ppU$nique_l$ock.htm\">s$td::u$nique_l$ock</a>" },
    { "std::upper_bound","<a href=\"CppUpper_bound.htm\">st$d::upper_bound</a>" },
    { "Access violation","<a href=\"CppAccessViolation.htm\">Access vi$olation</a>" },
    { "AskUserForString","<a href=\"CppAskUserForStr$ing.htm\">AskUserForStr$ing</a>" },
    { "Copy constructor","<a href=\"CppC$opyC$ons$tructor.htm\">C$opy c$ons$tructor</a>" },
    { "Copy Constructor","<a href=\"CppC$opyC$ons$tructor.htm\">C$opy C$ons$tructor</a>" },
    { "CreateSloppyMaze","<a href=\"CppC$reateSloppyMaze.htm\">C$reateSloppyMaze</a>" },
    { "GetMazeDistances","<a href=\"CppG$etMazeDistances.htm\">G$etMazeDistances</a>" },
    { "GetRandomUniform","<a href=\"CppG$etRa$nd$omUni$fo$rm.htm\">Ge$tRa$nd$omUni$fo$rm</a>" },
    { "GetUbuntuVersion","<a href=\"CppG$etU$buntuV$ersion.htm\">G$etU$buntuV$ersion</a>" },
    { "Initializer list","<a href=\"CppI$nitializerL$ist.htm\">I$nitializer l$ist</a>" },
    { "QCoreApplication","<a href=\"CppQCo$reAp$plication.htm\">QCo$reAp$plication</a>" },
    { "ReplaceZeroByOne","<a href=\"CppRe$plac$eZeroByOne.htm\">Re$plac$eZeroByOne</a>" },
    { "TestNewickVector","<a href=\"T$oolT$estN$ewickV$ector.htm\">T$estN$ewickV$ector</a>" },
    { "ThreeDigitNewick","<a href=\"CppT$hreeD$igitN$ewick.htm\">T$hreeD$igitN$ewick</a>" },
    { "TicTacToeLearner","<a href=\"T$oolT$icTacToeLearner.htm\">T$icTacToeLearner</a>" },
    { "Wt::WVectorImage","<a href=\"CppWV$ectorI$mage.htm\">W$t::W$V$ectorI$mage</a>" },
    { "Wt::WTableColumn","<a href=\"CppWT$ableC$olumn.htm\">W$t::W$T$ableC$olumn</a>" },
    { "Wt::WSubMenuItem","<a href=\"CppWS$ubMenuI$tem.htm\">W$t::W$S$ubMenuI$tem</a>" },
    { "Wt::WScrollEvent","<a href=\"CppWS$crollE$vent.htm\">W$t::W$S$crollE$vent</a>" },
    { "Wt::WRasterImage","<a href=\"C$ppWR$asterI$mage.htm\">W$t::W$R$asterI$mage</a>" },
    { "Wt::WRadioButton","<a href=\"C$ppWR$adioB$utton.htm\">W$t::W$R$adioB$utton</a>" },
    { "Wt::WProgressBar","<a href=\"CppWP$rogressB$ar.htm\">W$t::W$P$rogressB$ar</a>" },
    { "Wt::WPolygonArea","<a href=\"CppWP$olygonA$rea.htm\">W$t::W$P$olygonA$rea</a>" },
    { "Wt::WPainterPath","<a href=\"CppWP$ai$nterPath.htm\">W$t::W$P$ai$nterPath</a>" },
    { "Wt::WPaintDevice","<a href=\"CppWP$ai$ntDevice.htm\">W$t::W$P$ai$ntDevice</a>" },
    { "Wt::WInPlaceEdit","<a href=\"CppWI$nP$laceE$dit.htm\">W$t::W$I$nPlaceEdit</a>" },
    { "Wt::WFlashObject","<a href=\"CppWF$lashO$bject.htm\">W$t::W$F$lashObject</a>" },
    { "Wt::WEnvironment","<a href=\"C$ppW$E$nvironment.htm\">W$t::W$E$nvironment</a>" },
    { "Wt::WCssTextRule","<a href=\"CppWC$ssT$extR$ule.htm\">W$t::W$C$ssTextRule</a>" },
    { "Wt::WButtonGroup","<a href=\"C$ppW$B$uttonG$roup.htm\">W$t::W$B$uttonGroup</a>" },
    { "Wt::WApplication","<a href=\"CppW$A$pplication.htm\">W$t::W$A$pplication</a>" },
  //15
    { "circular_buffer","<a href=\"C$ppC$ircular_b$uffer.htm\">c$ircular_b$uffer</a>" },
    { "Design patterns","<a href=\"C$ppD$esignPattern.htm\">D$esign p$atterns</a>" },
    { "Function parser","<a href=\"C$ppF$unctionP$arser.htm\">F$unction p$arser</a>" },
    { "Function Parser","<a href=\"C$ppF$unctionP$arser.htm\">F$unction P$arser</a>" },
    { "FunctionPointer","F$unctionPoi$nter" },
    { "FunctorIncrease","<a href=\"CppFuncto$rIn$crease.htm\">Functo$rIn$crease</a>" },
    { "GetBoostVersion","<a href=\"CppG$etB$oostV$ersion.htm\">G$etB$oostV$ersion</a>" },
    { "GetRegexMatches","<a href=\"CppGetR$egexMatches.htm\">GetR$egexMatches</a>" },
    { "GetRootBranches","<a href=\"CppGetR$ootBranches.htm\">G$etRootBranches</a>" },
    { "IntToStrWithSep","<a href=\"CppI$ntToStrWithSep.htm\">I$ntToStrWithSep</a>" },
    { "IsPerfectNumber","<a href=\"CppI$sPerfectNumber.htm\">I$sPerfectNumber</a>" },
    { "MinElementAbove","<a href=\"CppMi$nElementAbove.htm\">Mi$nElementAbove</a>" },
    { "MaxElementAbove","<a href=\"CppMa$xElementAbove.htm\">Ma$xElementAbove</a>" },
    { "QHelpEngineCore","<a href=\"CppQ$H$elpE$ngineC$ore.htm\">Q$H$elpE$ngineC$ore</a>" },
    { "StripeAwayTerms","<a href=\"CppSt$ripeAwayTerms.htm\">St$ripeAwayTerms</a>" },
    { "TestGroupWidget","<a href=\"T$oolT$estG$roupW$idget.htm\">T$estG$roupW$idget</a>" },
    { "TestMultiVector","<a href=\"T$oolT$estM$ultiV$ector.htm\">T$estM$ultiV$ector</a>" },
    { "TicTacToeValuer","<a href=\"T$oolT$icTacToeValuer.htm\">T$icTacToeValuer</a>" },
    { "Web application","<a href=\"CppW$ebA$pplication.htm\">W$eb a$pplication</a>" },
    { "Wt::WWidgetItem","<a href=\"CppW$W$idgetI$tem.htm\">W$t::W$W$idgetI$tem</a>" },
    { "Wt::WViewWidget","<a href=\"CppW$V$iewW$idget.htm\">W$t::W$V$iewW$idget</a>" },
    { "Wt::WVBoxLayout","<a href=\"CppW$V$B$oxL$ayout.htm\">W$t::W$V$B$oxL$ayout</a>" },
    { "Wt::WTouchEvent","<a href=\"CppW$T$ouchE$vent.htm\">W$t::W$TouchE$vent</a>" },
    { "Wt::WScrollArea","<a href=\"CppW$S$crollA$rea.htm\">W$t::W$S$crollA$rea</a>" },
    { "Wt::WPushButton","<a href=\"CppW$P$ushB$utton.htm\">W$t::W$P$ushB$utton</a>" },
    { "Wt::WMouseEvent","<a href=\"CppW$M$ouseE$vent.htm\">W$t::W$M$ouseE$vent</a>" },
    { "Wt::WModelIndex","<a href=\"CppW$M$odelI$ndex.htm\">W$t::W$M$odelIndex</a>" },
    { "Wt::WMessageBox","<a href=\"CppW$M$essageB$ox.htm\">W$t::W$M$essageBox</a>" },
    { "Wt::WLayoutItem","<a href=\"CppW$L$ayoutI$tem.htm\">W$t::W$L$ayoutI$tem</a>" },
    { "Wt::WHTML5Video","<a href=\"CppW$H$TML5V$ideo.htm\">W$t::W$H$TML5Video</a>" },
    { "Wt::WHTML5Media","<a href=\"CppW$H$TML5M$edia.htm\">W$t::W$H$TML5Media</a>" },
    { "Wt::WHTML5Audio","<a href=\"CppW$H$TML5A$udio.htm\">W$t::W$H$TML5Audio</a>" },
    { "Wt::WHBoxLayout","<a href=\"CppW$H$B$oxL$ayout.htm\">W$t::W$H$B$oxL$ayout</a>" },
    { "Wt::WGridLayout","<a href=\"CppW$G$ridL$ayout.htm\">W$t::W$G$ridL$ayout</a>" },
    { "Wt::WFormWidget","<a href=\"CppW$F$ormW$idget.htm\">W$t::W$F$ormW$idget</a>" },
    { "Wt::WFileUpload","<a href=\"CppW$F$ileU$pload.htm\">W$t::W$F$ileU$pload</a>" },
    { "Wt::WDatePicker","<a href=\"CppW$D$ateP$icker.htm\">W$t::W$DatePicker</a>" },
    { "Wt::WCircleArea","<a href=\"CppW$C$ircleA$rea.htm\">W$t::W$CircleArea</a>" },
    { "Wt::EventSignal","<a href=\"CppE$ventS$ignal.htm\">W$t::E$ventS$ignal</a>" },
    { "boost::any_cast","<a href=\"CppA$ny_cast.htm\">b$oost::a$ny_cast</a>" },
    { "boost::function","<a href=\"C$ppF$unction.htm\">b$oost::f$unction</a>" },
    { "boost::hash_set","<a href=\"CppH$ash_set.htm\">b$oost::h$ash_set</a>" },
    { "boost::signals2","<a href=\"C$ppS$ignals2.htm\">b$oost::s$ignals2</a>" },
    { "boost::weak_ptr","<a href=\"CppW$eak_p$tr.htm\">b$oost::w$eak_ptr</a>" },
    { "design patterns","<a href=\"C$ppD$esignPattern.htm\">d$esign p$atterns</a>" },
    { "extern template","<b><a href=\"CppEx$ternT$emplate.htm\">ext$ern t$emplate</a></b>" },
    { "function parser","<a href=\"C$ppF$unctionP$arser.htm\">f$unction p$arser</a>" },
    { "std::accumulate","<a href=\"CppA$ccumulate.htm\">st$d::ac$cumulate</a>" },
    { "std::bad_typeid","<a href=\"CppB$ad_type$id.htm\">st$d::b$ad_type$id</a>" },
    { "std::bit_vector","<a href=\"CppB$it_vector.htm\">st$d::b$it_vector</a>" },
    { "std::generate_n","<a href=\"CppG$enerate_n.htm\">st$d::g$enerate_n</a>" },
    { "std::less_equal","<a href=\"CppL$ess_equal.htm\">st$d::le$ss_equal</a>" },
    { "std::localeconv","<a href=\"CppL$ocaleconv.htm\">st$d::l$ocaleconv</a>" },
    { "std::lock_guard","<a href=\"C$ppL$ock_g$uard.htm\">s$td::l$ock_g$uard</a>" },
    { "std::logical_or;","<a href=\"CppL$ogical_or.htm\">st$d::lo$gical_or</a>;" },
    { "std::multiplies","<a href=\"CppM$ultiplies.htm\">s$td::m$ultiplies</a>" },
    { "std::noshowbase","<a href=\"CppN$oshowbase.htm\">st$d::n$oshowbase</a>" },
    { "std::replace_if","<a href=\"CppR$eplace_i$f.htm\">st$d::r$eplace_i$f</a>" },
    { "std::scientific","<a href=\"CppS$cienti$fic.htm\">st$d::s$cienti$fic</a>" },
    { "std::shared_ptr","<a href=\"CppS$hared_p$tr.htm\">s$td::s$hared_p$tr</a>" },
    { "std::unique_ptr","<a href=\"CppU$nique_p$tr.htm\">st$d::u$nique_p$tr</a>" },    { "functionPointer","f$unctionPoi$nter" },
    { "testgroupwidget","<a href=\"T$oolT$estG$roupW$idget.htm\">t$estg$roupw$idget</a>" },
    { "web application","<a href=\"CppW$ebA$pplication.htm\">w$eb a$pplication</a>" },
  //14
    { " $&amp;&amp$; "," <a href=\"CppOperatorLogicalAnd.htm\">$&amp;&amp$;</a> " },
    { "boost::ptr_set","<a href=\"CppPtr_set.htm\">bo$ost::ptr_s$et</a>" },
    { "boost::signals","<a href=\"C$ppS$ignals.htm\">b$oost::s$ignals</a>" },
    { "boost::tribool","<a href=\"C$ppT$rib$ool.htm\">b$oost::t$rib$ool</a>" },
    { "const_iterator","co$nst_i$terator" },
    { "design pattern","<a href=\"C$ppD$esignPattern.htm\">d$esign p$attern</a>" },
    { "plain old data","<a href=\"CppP$od.htm\">p$lain o$ld d$ata</a>" },
    { "std::bad_alloc","<a href=\"C$ppB$ad_a$lloc.htm\">st$d::b$ad_a$lloc</a>" },
    { "std::boolalpha","<a href=\"C$ppB$oola$lpha.htm\">st$d::bo$olalpha</a>" },
    { "std::exception","<a href=\"C$ppE$xception.htm\">st$d::ex$ception</a>" },
    { "std::is_sorted","<a href=\"C$ppI$s_s$orted.htm\">st$d::i$s_s$orted</a>" },
    { "std::iswxdigit","<a href=\"C$ppI$swxdigit.htm\">st$d::i$swxdigit</a>" },
    { "std::iter_swap","<a href=\"C$ppI$ter_s$wap.htm\">st$d::i$ter_s$wap</a>" },
    { "std::localtime","<a href=\"CppL$ocalt$ime.htm\">st$d::l$ocalt$ime</a>" },
    { "std::make_heap","<a href=\"CppM$ake_heap.htm\">st$d::m$ake_heap</a>" },
    { "std::make_pair","<a href=\"C$ppM$ake_p$air.htm\">s$td::ma$ke_pair</a>" },
    { "std::mbsrtowcs","<a href=\"CppMbsrtowcs.htm\">st$d::mbsrtowcs</a>" },
    { "std::multi_map","<a href=\"C$ppM$ulti_m$ap.htm\">s$td::m$ulti_map</a>" },
    { "std::noshowpos","<a href=\"C$ppN$oshowpos.htm\">s$td::n$os$howp$os</a>" },
    { "std::once_flag","<a href=\"C$ppO$nce_f$lag.htm\">s$td::o$nce_f$lag</a>" },
    { "std::partition","<a href=\"CppPartition.htm\">st$d::partition</a>" },
    { "std::push_heap","<a href=\"CppPush_heap.htm\">st$d::push_heap</a>" },
    { "std::remove_if","<a href=\"CppRemove_i$f.htm\">st$d::remove_i$f</a>" },
    { "std::set_union","<a href=\"CppSet_un$ion.htm\">st$d::set_uni$on</a>" },
    { "std::setlocale","<a href=\"CppSetlocale.htm\">st$d::setlocale</a>" },
    { "std::showpoint","<a href=\"CppShowpoi$nt.htm\">st$d::showpoi$nt</a>" },
    { "std::sort_heap","<a href=\"CppSort_heap.htm\">st$d::sort_heap</a>" },
    { "std::to_string","<a href=\"C$ppT$o_s$tring.htm\">s$td::t$o_s$tring</a>" },
    { "std::towctrans","<a href=\"CppTowctrans.htm\">st$d::towctrans</a>" },
    { "std::transform","<a href=\"C$ppT$ransfo$rm.htm\">s$td::tra$nsfo$rm</a>" },
    { "std::uppercase","<a href=\"CppUpperca$se.htm\">st$d::upperca$se</a>" },
    { "std::vswprintf","<a href=\"CppVswprin$tf.htm\">st$d::vswpri$ntf</a>" },    { "random numbers","<a href=\"C$ppR$and$omN$umber.htm\">rand$om numbers</a>" },
    { "CalcComplexity","<a href=\"CppC$alcComplexity.htm\">C$alcComplexity</a>" },
    { "CanLexicalCast","<a href=\"CppCa$nL$exicalC$ast.htm\">C$anLe$xicalC$ast</a>" },
    { "CLOCKS_PER_SEC","<a href=\"CppCL$OCKS_PER_SEC.htm\">CL$OCKS_PER_SEC</a>" },
    { "shape_typeCompressNewick","shape_type<a href=\"CppC$ompressN$ewick.htm\">C$ompressN$ewick</a>" },
    { "CountNonZeroes","<a href=\"CppCo$untNonZeroes.htm\">Co$untNonZeroes</a>" },
    { "CreateGlossary","<a href=\"T$oolC$reateG$lossary.htm\">C$reateG$lossary</a>" },
    { "Design pattern","<a href=\"C$ppD$esignPattern.htm\">D$esign p$attern</a>" },
    { "Design Pattern","<a href=\"C$ppD$esignPattern.htm\">D$esign P$attern</a>" },
    { "FunctionParser","<a href=\"C$ppF$unctionP$arser.htm\">F$unctionP$arser</a>" },
    { "Fuzzy_equal_to","<a href=\"C$ppF$uzzy_e$qual_t$o.htm\">F$uzzy_e$qual_t$o</a>" },
    { "GetDateIso8601","<a href=\"CppG$etDateIso8601.htm\">G$etDateIso8601</a>" },
    { "GetNonDeadEnds","<a href=\"CppG$etNonDeadEnds.htm\">G$etNonDeadEnds</a>" },
    { "GetWineVersion","<a href=\"CppG$etW$ineV$ersion.htm\">G$etW$ineV$ersion</a>" },
    { "IntToBitString","<a href=\"CppIn$tToBitString.htm\">In$tToBitString</a>" },
    { "IsBinaryNewick","<a href=\"CppI$sBinaryN$ewick.htm\">I$sBinaryN$ewick</a>" },
    { "MysteryMachine","<a href=\"CppM$ysteryM$achine.htm\">M$ysteryM$achine</a>" },
    { "NewickToString","<a href=\"CppN$ewickToS$tring.htm\">N$ewickToS$tring</a>" },
    { "NewickToVector","<a href=\"CppN$ewickToV$ector.htm\">N$ewickToV$ector</a>" },
    { "Plain Old Data","<a href=\"CppP$od.htm\">P$lain O$ld D$ata</a>" },
    { "Plain old data","<a href=\"CppP$od.htm\">P$lain o$ld d$ata</a>" },
    { "QDesktopWidget","<a href=\"CppQD$esktopWi$dget.htm\">QD$esktopWi$dget</a>" },
    { "QGraphicsScene","<a href=\"CppQG$raphicsScene.htm\">QG$raphicsScene</a>" },
    { "QPlainTextEdit","<a href=\"CppQP$lainTextEdit.htm\">QP$lainTextEdit</a>" },
    { "QtToggleButton","<a href=\"C$ppQ$tT$oggleB$utton.htm\">Q$tT$oggleB$utton</a>" },
    { "QuestionDialog","<a href=\"C$ppQ$uestionD$ialog.htm\">Q$uestionD$ialog</a>" },
    { "Random numbers","<a href=\"CppRand$omNumber.htm\">Rand$om numbers</a>" },
    { "RandomizeTimer","<a href=\"CppR$a$nd$omizeT$imer.htm\">R$a$nd$omizeT$imer</a>" },
    { "SeperateString","<a href=\"CppSeperateStr$ing.htm\">SeperateStr$ing</a>" },
    { "SolveQuadratic","<a href=\"CppSo$lveQuadratic.htm\">So$lveQuadratic</a>" },
    { "StringToNewick","<a href=\"CppS$tringToN$ewick.htm\">S$tringToN$ewick</a>" },
    { "TwoDigitNewick","<a href=\"CppT$woD$igitN$ewick.htm\">T$woD$igitN$ewick</a>" },
    { "Wt::WWebWidget","<a href=\"C$ppW$W$ebW$idget.htm\">W$t::W$W$ebW$idget</a>" },
    { "Wt::WValidator","<a href=\"C$ppW$V$alidator.htm\">W$t::W$V$alidator</a>" },
    { "Wt::WTreeTable","<a href=\"C$ppW$T$reeT$able.htm\">W$t::W$T$reeT$able</a>" },
    { "Wt::WTransform","<a href=\"C$ppW$T$ransform.htm\">W$t::W$T$ransform</a>" },
    { "Wt::WTabWidget","<a href=\"C$ppW$T$abW$idget.htm\">W$t::W$T$abW$idget</a>" },
    { "Wt::WTableView","<a href=\"C$ppW$T$ableV$iew.htm\">W$t::W$T$ableV$iew</a>" },
    { "Wt::WTableCell","<a href=\"C$ppW$T$ableC$ell.htm\">W$t::W$T$ableC$ell</a>" },
    { "Wt::WScrollBar","<a href=\"C$ppW$S$crollB$ar.htm\">W$t::W$S$crollB$ar</a>" },
    { "WPaintedWidget","<a href=\"CppWP$ai$ntedW$idget.htm\">W$Pai$ntedW$idget</a>" },
    { "WStackedWidget","<a href=\"C$ppW$S$tackedW$idget.htm\">W$S$tackedW$idget</a>" },
    { "Wt::WPopupMenu","<a href=\"C$ppW$P$opupM$enu.htm\">W$t::W$P$opupM$enu</a>" },
    { "Wt::WMatrix4x4","<a href=\"C$ppW$M$atrix4x4.htm\">W$t::W$M$atrix4x4</a>" },
    { "Wt::WGoogleMap","<a href=\"C$ppW$G$oogleM$ap.htm\">W$t::W$G$oogleM$ap</a>" },
    { "Wt::WFitLayout","<a href=\"C$ppW$F$itL$ayout.htm\">W$t::W$F$itL$ayout</a>" },
    { "Wt::WDropEvent","<a href=\"C$ppW$D$ropE$vent.htm\">W$t::W$D$ropE$vent</a>" },
    { "Wt::WBoxLayout","<a href=\"C$ppW$B$oxL$ayout.htm\">W$t::W$B$oxL$ayout</a>" },
    { "Wt::SignalBase","<a href=\"CppS$ignalB$ase.htm\">W$t::S$ignalBase</a>" },
  //13
    { "AllAboutEqual","<a href=\"CppA$llA$boutE$qual.htm\">A$llA$boutE$qual</a>" },
    { "BOOST_FOREACH","<a href=\"CppB$OOST_FOREACH.htm\">B$OOST_FOREACH</a>" },
    { "Carbide.C/C++","<a href=\"CppC$arbideC$pp.htm\">C$arbide$.$C$/C$+$+</a>" },
    { "CountDeadEnds","<a href=\"CppC$ountDeadEnds.htm\">C$ountDeadEnds</a>" },
    { "CoutContainer","<a href=\"CppCo$utCon$tainer.htm\">Cou$tC$ontainer</a>" },
    { "DesignPattern","<a href=\"C$ppD$esignP$attern.htm\">D$esignP$attern</a>" },
    { "Documentation","<a href=\"CppD$ocumentation.htm\">D$ocumentation</a>" },
    { "Flood::Matrix","<a href=\"CppF$loodM$atrix.htm\">F$lood::M$atrix</a>" },
    { "Flood::Vector","<a href=\"CppF$loodV$ector.htm\">F$lood::V$ector</a>" },
    { "Free function","<a href=\"CppF$reeF$unction.htm\">F$ree f$unction</a>" },
    { "GetDifference","<a href=\"CppGetDi$fference.htm\">GetDi$fference</a>" },
    { "GetGccVersion","<a href=\"CppG$etG$ccV$ersion.htm\">G$etG$ccV$ersion</a>" },
    { "GetStlVersion","<a href=\"CppG$etS$tlV$ersion.htm\">G$etS$tlV$ersion</a>" },
    { "HtmlValidator","<a href=\"T$oolH$tmlValidator.htm\">H$tmlValidator</a>" },
    { "Include guard","<a href=\"CppI$ncludeG$uard.htm\">I$nclude g$uard</a>" },
    { "InsertionSort","<a href=\"CppI$nsertionSort.htm\">I$nsertionSort</a>" },
    { "QGraphicsView","<a href=\"CppQG$raphicsView.htm\">QG$raphicsView</a>" },
    { "Random number","<a href=\"CppRand$omNumber.htm\">Rand$om number</a>" },
    { "Replace_range","<a href=\"CppRe$place_range.htm\">Re$place_range</a>" },
    { "ReverseString","<a href=\"CppR$everseString.htm\">R$everseString</a>" },
    { "SaveContainer","<a href=\"CppSa$veC$ontainer.htm\">Sa$veC$ontainer</a>" },
    { "SecretMessage","<a href=\"T$oolS$ecretM$essage.htm\">S$ecretM$essage</a>" },
    { "SelectionSort","<a href=\"CppS$electionSort.htm\">S$electionSort</a>" },
    { "Smart pointer","<a href=\"CppSm$artPoi$nter.htm\">Smart poi$nter</a>" },
    { "SortContainer","<a href=\"CppS$ortC$ontainer.htm\">S$ortC$ontainer</a>" },
    { "WBorderLayout","<a href=\"CppW$B$orderL$ayout.htm\">W$B$orderL$ayout</a>" },
    { "WFileResource","<a href=\"CppW$F$ileR$esource.htm\">W$F$ileR$esource</a>" },
    { "Wt::WCalendar","<a href=\"CppW$C$alendar.htm\">W$t::W$C$alendar</a>" },
    { "Wt::WCheckBox","<a href=\"CppW$C$heckB$ox.htm\">W$t::W$C$heckBox</a>" },
    { "Wt::WComboBox","<a href=\"CppW$C$omboB$ox.htm\">W$t::W$C$omboBox</a>" },
    { "Wt::WDateTime","<a href=\"CppW$D$ateT$ime.htm\">W$t::W$D$ateT$ime</a>" },
    { "Wt::WGLWidget","<a href=\"CppW$G$LW$idget.htm\">W$t::W$G$LW$idget</a>" },
    { "Wt::WGroupBox","<a href=\"C$ppW$G$roupB$ox.htm\">W$t::W$G$roupB$ox</a>" },
    { "Wt::WIconPair","<a href=\"CppW$I$conP$air.htm\">W$t::W$I$conPair</a>" },
    { "Wt::WKeyEvent","<a href=\"C$ppW$K$eyE$vent.htm\">W$t::W$K$eyEvent</a>" },
    { "Wt::WLineEdit","<a href=\"CppW$L$ineE$dit.htm\">W$t::W$L$ineE$dit</a>" },
    { "Wt::WLogEntry","<a href=\"CppW$L$ogE$ntry.htm\">W$t::W$L$ogEntry</a>" },
    { "Wt::WMenuItem","<a href=\"C$ppW$M$enuI$tem.htm\">W$t::W$M$enuI$tem</a>" },
    { "Wt::WPdfImage","<a href=\"C$ppW$P$dfImage.htm\">W$t::W$P$dfImage</a>" },
    { "Wt::WRectArea","<a href=\"C$ppW$R$ectArea.htm\">W$t::W$R$ectArea</a>" },
    { "Wt::WResource","<a href=\"C$ppW$R$esource.htm\">W$t::W$R$esource</a>" },
    { "Wt::WSvgImage","<a href=\"C$ppW$S$vgImage.htm\">W$t::W$S$vgImage</a>" },
    { "Wt::WTableRow","<a href=\"C$ppW$T$ableRow.htm\">W$t::W$T$ableRow</a>" },
    { "Wt::WTemplate","<a href=\"C$ppW$T$emplate.htm\">W$t::W$T$emplate</a>" },
    { "Wt::WTextArea","<a href=\"C$ppW$T$extA$rea.htm\">W$t::W$T$extA$rea</a>" },
    { "Wt::WTextEdit","<a href=\"C$ppW$T$extE$dit.htm\">W$t::W$T$extE$dit</a>" },
    { "Wt::WTreeNode","<a href=\"C$ppW$T$reeN$ode.htm\">W$t::W$TreeNode</a>" },
    { "Wt::WTreeView","<a href=\"C$ppW$T$reeV$iew.htm\">W$t::W$TreeView</a>" },
    { "Wt::WVmlImage","<a href=\"C$ppW$V$mlI$mage.htm\">W$t::W$VmlImage</a>" },
    { "WtGroupWidget","<a href=\"C$ppW$tG$roupW$idget.htm\">W$tG$roupW$idget</a>" },
    { "<ios>","<<a href=\"CppIo$sH.htm\">i$o$s</a>>" },
    { "<map>","<<a href=\"CppMa$pH.htm\">m$a$p</a>>" },
    { "<new>","<<a href=\"CppNe$wH.htm\">ne$w</a>>" },
    { "<set>","<<a href=\"CppSe$tH.htm\">s$e$t</a>>" },
    { "accumulate_if","<a href=\"CppAc$cu$mulate_i$f.htm\">a$ccu$mulate_i$f</a>" },
    { "assigned_rank","assi$gned_rank" },
    { "boost::format","<a href=\"CppFormat.htm\">b$oost::format</a>" },
    { "boost::lambda","<a href=\"CppLambda.htm\">b$oost::lambda</a>" },
    { "boost::mem_fn","<a href=\"CppMem_fn.htm\">bo$ost::me$m_f$n</a>" },
    { "boost::regex_","b$oost::r$egex_" },
    { "boost::thread","<a href=\"C$ppT$hread.htm\">b$oost::t$hread</a>" },
    { "delete a file","<a href=\"CppD$eleteF$ile.htm\">d$elete a f$ile</a>" },
    { "documentation","<a href=\"CppD$ocumentation.htm\">d$ocumentation</a>" },
    { "free function","<a href=\"CppF$reeF$unction.htm\">f$ree f$unction</a>" },
    { "include guard","<a href=\"CppI$ncludeG$uard.htm\">i$nclude g$uard</a>" },
    { "indeterminate","<a href=\"CppIndeterminate.htm\">i$ndeterminate</a>" },
    { "long long int","<b><a href=\"CppL$ongL$ongI$nt.htm\">l$ong l$ong i$nt</a></b>" },
    { "operator<","<b><a href=\"CppOp$eratorLess.htm\">o$perator<</a></b>" },
    { "random number","<a href=\"CppRand$omNumber.htm\">rand$om number</a>" },
    { "smart pointer","<a href=\"CppSm$artPoi$nter.htm\">smart poi$nter</a>" },
    { "static_assert","<b><a href=\"CppS$tatic_a$ssert.htm\">s$tatic_a$ssert</a></b>" },
    { "std::auto_ptr","<a href=\"Cp$pAu$to_ptr.htm\">s$td::aut$o_ptr</a>" },
    { "std::bad_cast","<a href=\"CppBad_cast.htm\">st$d::bad_cast</a>" },
    { "std::clearerr","<a href=\"CppClearerr.htm\">st$d::clearerr</a>" },
    { "std::count_if","<a href=\"Cp$pCo$unt_i$f.htm\">s$td:$:co$unt_i$f</a>" },
    { "std::difftime","<a href=\"CppDi$f$ft$ime.htm\">st$d::di$fft$ime</a>" },
    { "std::distance","<a href=\"CppDistance.htm\">st$d::di$stance</a>" },
    { "std::equal_to","<a href=\"CppEqual_to.htm\">st$d::eq$ual_to</a>" },
    { "std::find_end","<a href=\"CppFind_e$nd.htm\">s$td::fi$nd_e$nd</a>" },
    { "std::for_each","<a href=\"CppFor_each.htm\">s$td:$:fo$r_each</a>" },
    { "std::fwprintf","<a href=\"CppFwpri$ntf.htm\">st$d::fwpri$ntf</a>" },
    { "std::generate","<a href=\"CppGenerate.htm\">st$d::generate</a>" },
    { "std::getwchar","<a href=\"CppGetwch$ar.htm\">st$d::getwch$ar</a>" },
    { "std::hash_map","<a href=\"CppHash_map.htm\">st$d::hash_map</a>" },
    { "std::hash_set","<a href=\"CppHash_set.htm\">st$d::hash_set</a>" },
    { "std::ifstream","<a href=\"CppIfstream.htm\">st$d::i$fstream</a>" },
    { "std::includes","<a href=\"CppIncludes.htm\">st$d::includes</a>" },
    { "std::internal","<a href=\"CppI$nternal.htm\">st$d::i$nternal</a>" },
    { "std::iswalnum","<a href=\"CppIswalnum.htm\">st$d::iswalnum</a>" },
    { "std::iswalpha","<a href=\"CppIswalpha.htm\">st$d::iswalpha</a>" },
    { "std::iswcntrl","<a href=\"CppIswcntrl.htm\">st$d::iswcntrl</a>" },
    { "std::iswctype","<a href=\"CppIswctype.htm\">st$d::iswctype</a>" },
    { "std::iswdigit","<a href=\"CppIswdigit.htm\">st$d::iswdigit</a>" },
    { "std::iswgraph","<a href=\"CppIswgraph.htm\">st$d::iswgraph</a>" },
    { "std::iswlower","<a href=\"CppIswlower.htm\">st$d::iswlower</a>" },
    { "std::iswpunct","<a href=\"CppIswpunct.htm\">st$d::iswpunct</a>" },
    { "std::iswspace","<a href=\"CppIswspace.htm\">st$d::iswspace</a>" },
    { "std::iswupper","<a href=\"CppIswupper.htm\">st$d::iswupper</a>" },
    { "std::isxdigit","<a href=\"CppIsxdigit.htm\">st$d::isxdigit</a>" },
    { "std::mbstowcs","<a href=\"CppMbstowcs.htm\">st$d::mbstowcs</a>" },
    { "std::mismatch","<a href=\"CppMismatch.htm\">st$d::mismatch</a>" },
    { "std::multimap","<a href=\"CppMultimap.htm\">st$d::multimap</a>" },
    { "std::multiset","<a href=\"CppMultiset.htm\">st$d::multiset</a>" },
    { "std::noskipws","<a href=\"CppNoskipws.htm\">st$d::noskipws</a>" },
    { "std::ofstream","<a href=\"CppOfstream.htm\">st$d::ofstream</a>" },
    { "std::pop_heap","<a href=\"CppPop_heap.htm\">st$d::pop_heap</a>" },
    { "std::putwchar","<a href=\"CppPutwch$ar.htm\">st$d::putwch$ar</a>" },
    { "std::search_n","<a href=\"CppSearch_n.htm\">st$d::search_n</a>" },
    { "std::showbase","<a href=\"CppShowbase.htm\">st$d::showbase</a>" },
    { "std::strerror","<a href=\"CppStrerror.htm\">st$d::strerror</a>" },
    { "std::strftime","<a href=\"CppStrft$ime.htm\">st$d::strft$ime</a>" },
    { "std::swprintf","<a href=\"CppSwpri$ntf.htm\">st$d::swpri$ntf</a>" },
    { "std::towlower","<a href=\"CppTowlower.htm\">st$d::towlower</a>" },
    { "std::towupper","<a href=\"CppTowupper.htm\">st$d::towupper</a>" },
    { "std::valarray","<a href=\"CppValarray.htm\">st$d::valarray</a>" },
    { "std::vfprintf","<a href=\"CppVfpri$ntf.htm\">st$d::vfpri$ntf</a>" },
    { "std::vfwprint","<a href=\"CppVfwpri$nt.htm\">st$d::vfwpri$nt</a>" },
    { "std::vsprintf","<a href=\"CppVspri$ntf.htm\">st$d::vspri$ntf</a>" },
    { "std::wcsrtomb","<a href=\"CppWcsrtomb.htm\">s$td::wc$srtomb</a>" },
    { "std::wcstombs","<a href=\"CppWcstombs.htm\">s$td::wc$stombs</a>" },
    { "std::weak_ptr","<a href=\"CppW$eak_p$tr.htm\">s$td::w$eak_ptr</a>" },
  //12
    { "_declaration","_d$eclaration" },
    { "(&exception)","(&amp;exception)" },
    { "AnsiIsDouble","<a href=\"CppA$nsiI$sD$ouble.htm\">A$nsiI$sD$ouble</a>" },
    { "AnsiToDouble","<a href=\"CppA$nsiT$oD$ouble.htm\">A$nsiT$oD$ouble</a>" },
    { "AreMeansSame","<a href=\"CppAr$eMe$ansSame.htm\">AreMe$ansSame</a>" },
    { "BOOST_ASSERT","<a href=\"CppBO$OST_AS$SERT.htm\">BO$OST_AS$SERT</a>" },
    { "Code snippet","<a href=\"CppCodeSnippets.htm\">Co$de snippet</a>" },
    { "CreateVector","<a href=\"CppCr$eateVec$tor.htm\">Cre$ateV$ector</a>" },
    { "Data members","<a href=\"CppD$ataM$ember.htm\">D$ata m$embers</a>" },
    { "FileToVector","<a href=\"CppFi$leT$oV$ector.htm\">Fi$leT$oV$ector</a>" },
    { "GetGrayCodes","<a href=\"CppGe$tG$rayC$odes.htm\">Ge$tG$rayC$odes</a>" },
    { "GetIpAddress","<a href=\"CppG$etI$pA$ddress.htm\">G$etI$pA$ddress</a>" },
    { "GetMaxDouble","<a href=\"CppGe$tMa$xD$ouble.htm\">Ge$tMa$xD$ouble</a>" },
    { "GetQtVersion","<a href=\"CppG$etQ$tV$ersion.htm\">G$etQ$tV$ersion</a>" },
    { "GetTimestamp","<a href=\"CppG$etT$imes$tamp.htm\">G$etT$imes$tamp</a>" },
    { "GetWtVersion","<a href=\"CppG$etW$tV$ersion.htm\">G$etW$tV$ersion</a>" },
    { "Introduction","In$troduction" },
    { "IntToWString","<a href=\"C$ppI$ntT$oW$S$tring.htm\">I$ntT$oW$S$tring</a>" },
    { "NewickVector","<a href=\"CppN$ewickV$ector.htm\">N$ewickV$ector</a>" },
    { "OpenQuestion","<a href=\"C$ppO$penQ$uestion.htm\">O$penQ$uestion</a>" },
    { "QApplication","<a href=\"CppQ$Ap$plication.htm\">Q$Ap$plication</a>" },
    { "QPainterPath","<a href=\"CppQ$Pai$nterPath.htm\">Q$Pai$nterPath</a>" },
    { "QResizeEvent","<a href=\"CppQR$esizeEvent.htm\">QR$esizeEvent</a>" },
    { "QTableWidget","<a href=\"C$ppQ$T$ableW$idget.htm\">Q$T$ableW$idget</a>" },
    { "QtDialWidget","<a href=\"CppQ$tD$ialW$idget.htm\">Q$tD$ialW$idget</a>" },
    { "SafeIntToCli","<a href=\"CppS$afeIntToCli.htm\">S$afeIntToCli</a>" },
    { "Scott Meyers","<a href=\"CppScottMeyers.htm\">S$cott Meyers</a>" },
    { "SumNegatives","<a href=\"CppSu$mNegatives.htm\">Su$mNegatives</a>" },
    { "SumPositives","<a href=\"CppSu$mPositives.htm\">Su$mPositives</a>" },
    { "TestQuestion","<a href=\"T$oolT$estQ$uestion.htm\">T$estQ$uestion</a>" },
    { "ToggleButton","<a href=\"C$ppT$oggleB$utton.htm\">T$oggleB$utton</a>" },
    { "Wt::WSpinBox","<a href=\"CppWSpinBox.htm\">W$t::W$SpinBox</a>" },
    { "Wt::WPainter","<a href=\"CppWP$ai$nter.htm\">W$t::W$P$ai$nter</a>" },
    { "Wt::WCssRule","<a href=\"CppWCssRule.htm\">W$t::W$CssRule</a>" },
    { "Wt::SyncLock","<a href=\"CppSyncLock.htm\">W$t::SyncLock</a>" },
    { "WPainterPath","<a href=\"CppWP$ai$nterPath.htm\">W$P$ai$nterPath</a>" },
    { "WApplication","<a href=\"CppW$A$pplication.htm\">W$A$pplication</a>" },
    { "WButtonGroup","<a href=\"C$ppW$B$uttonG$roup.htm\">W$ButtonGroup</a>" },
    { "WEnvironment","<a href=\"C$ppW$E$nvironment.htm\">W$E$nvironment</a>" },
    { "WPaintDevice","<a href=\"CppWP$ai$ntDevice.htm\">W$P$ai$ntDevice</a>" },
    { "WRadioButton","<a href=\"C$ppWR$adioB$utton.htm\">W$R$adioB$utton</a>" },
    { "WStringToInt","<a href=\"C$ppW$S$tringT$oI$nt.htm\">W$S$tringT$oI$nt</a>" },
    { "WtDialWidget","<a href=\"CppW$tD$ialW$idget.htm\">W$tD$ialW$idget</a>" },
    { "boost::regex","<a href=\"CppR$egex.htm\">bo$ost::r$egex</a>" },
    { "boost::tuple","<a href=\"CppT$uple.htm\">bo$ost::t$uple</a>" },
    { "boost::timer","<a href=\"CppT$imer.htm\">bo$ost::t$imer</a>" },
    { "bad_any_cast","<a href=\"C$ppB$ad_a$ny_c$ast.htm\">b$ad_a$ny_c$ast</a>" },
    { "code snippet","<a href=\"CppCodeSnippets.htm\">co$de snippet</a>" },
    { "data members","<a href=\"CppD$ataM$ember.htm\">d$ata m$embers</a>" },
    { "dynamic_cast","<b><a href=\"CppDy$namic_cast.htm\">dyna$mic_cast</a></b>" },
    { "introduction","in$troduction" },
    { "lexical_cast","<a href=\"CppLexical_cast.htm\">l$exical_ca$st</a>" },
    { "printMessage","pri$ntMessage" },
    { "significance","signi$ficance" },
    { "std::asctime","<a href=\"C$ppA$sct$ime.htm\">st$d::as$cti$me</a>" },
    { "std::bind1st","<a href=\"C$ppB$ind1st.htm\">s$td::bi$nd1st</a>" },
    { "std::bind2nd","<a href=\"C$ppB$ind2nd.htm\">s$td::bi$nd2nd</a>" },
    { "std::bsearch","<a href=\"C$ppB$search.htm\">s$td::bs$earch</a>" },
    { "std::clock_t","<a href=\"C$ppC$lock_t.htm\">s$td::cl$ock_t</a>" },
    { "std::copy_if","<a href=\"C$ppC$opy_i$f.htm\">s$td::co$py_i$f</a>" },
    { "std::divides","<a href=\"C$ppD$ivides.htm\">s$td::di$vides</a>" },
    { "std::fgetpos","<a href=\"C$ppF$getpos.htm\">s$td::fg$etpos</a>" },
    { "std::find_if","<a href=\"C$ppF$ind_i$f.htm\">s$td::fi$nd_i$f</a>" },
    { "std::fprintf","<a href=\"C$ppF$pri$ntf.htm\">s$td::fpri$ntf</a>" },
    { "std::freopen","<a href=\"C$ppF$reopen.htm\">s$td::fr$eopen</a>" },
    { "std::fstream","<a href=\"C$ppF$stream.htm\">st$d::fstream</a>" },
    { "std::fsetpos","<a href=\"C$ppF$setpos.htm\">s$td::fs$etpos</a>" },
    { "std::fwscanf","<a href=\"C$ppF$wscanf.htm\">s$td::fw$scanf</a>" },
    { "std::getchar","<a href=\"C$ppG$etch$ar.htm\">st$d::ge$tch$ar</a>" },
    { "std::getline","<a href=\"C$ppG$etline.htm\">st$d::ge$tline</a>" },
    { "std::greater","<a href=\"C$ppG$reater.htm\">st$d::gr$eater</a>" },
    { "std::is_heap","<a href=\"C$ppI$s_h$eap.htm\">s$td::i$s_h$eap</a>" },
    { "std::isalnum","<a href=\"C$ppI$salnum.htm\">s$td::is$alnum</a>" },
    { "std::isalpha","<a href=\"C$ppI$salpha.htm\">s$td::is$alpha</a>" },
    { "std::iscntrl","<a href=\"C$ppI$scntrl.htm\">s$td::is$cntrl</a>" },
    { "std::isdigit","<a href=\"C$ppI$sdigit.htm\">s$td::is$digit</a>" },
    { "std::isgraph","<a href=\"C$ppI$sgraph.htm\">s$td::is$graph</a>" },
    { "std::islower","<a href=\"C$ppI$slower.htm\">s$td::is$lower</a>" },
    { "std::isprint","<a href=\"C$ppI$spri$nt.htm\">s$td::is$pri$nt</a>" },
    { "std::ispunct","<a href=\"C$ppI$spunct.htm\">s$td::is$punct</a>" },
    { "std::isspace","<a href=\"C$ppI$sspace.htm\">s$td::is$space</a>" },
    { "std::istream","<a href=\"C$ppI$$s$tream.htm\">s$td::i$st$ream</a>" },
    { "std::isupper","<a href=\"C$ppI$supper.htm\">s$td::is$upper</a>" },
    { "std::iswprin","<a href=\"C$ppI$swprin.htm\">s$td::is$wprin</a>" },
    { "std::longjmp","<a href=\"C$ppL$ongjmp.htm\">s$td::lo$ngjmp</a>" },
    { "std::mbrtowc","<a href=\"C$ppM$brtowc.htm\">s$td::mb$rtowc</a>" },
    { "std::mbsinit","<a href=\"C$ppM$bsinit.htm\">s$td::mb$sinit</a>" },
    { "std::mem_fun","<a href=\"C$ppM$em_fun.htm\">s$td::me$m_fu$n</a>" },
    { "std::memmove","<a href=\"C$ppM$emmove.htm\">s$td::me$mmove</a>" },
    { "std::modulus","<a href=\"C$ppM$odulus.htm\">st$d::modulus</a>" },
    { "std::none_of","<a href=\"C$ppN$one_o$f.htm\">s$td::n$one_o$f</a>" },
    { "std::ostream","<a href=\"C$ppO$s$tream.htm\">s$td::o$st$ream</a>" },
    { "std::ptr_fun","<a href=\"C$ppP$tr_fun.htm\">s$td::p$tr_fun</a>" },
    { "std::putchar","<a href=\"C$ppP$u$tch$ar.htm\">s$td::pu$tch$ar</a>" },
    { "std::realloc","<a href=\"C$ppR$ealloc.htm\">s$td::re$alloc</a>" },
    { "std::replace","<a href=\"C$ppR$eplace.htm\">s$td::re$place</a>" },
    { "std::reverse","<a href=\"C$ppR$everse.htm\">s$td::re$verse</a>" },
    { "std::setbase","<a href=\"C$ppS$etbase.htm\">st$d::setbase</a>" },
    { "std::setfill","<a href=\"C$ppS$etfill.htm\">s$td::se$tfill</a>" },
    { "std::setvbuf","<a href=\"C$ppS$etvbuf.htm\">s$td::se$tvbuf</a>" },
    { "std::showpos","<a href=\"C$ppS$howpos.htm\">s$td::sh$owpos</a>" },
    { "std::sprintf","<a href=\"C$ppS$pri$ntf.htm\">s$td::sp$ri$ntf</a>" },
    { "std::strcoll","<a href=\"C$ppS$trcoll.htm\">s$td::st$rcoll</a>" },
    { "std::tolower","<a href=\"C$ppT$olower.htm\">s$td::t$olower</a>" },
    { "std::toupper","<a href=\"C$ppT$oupper.htm\">s$td::t$oupper</a>" },
    { "std::strcspn","<a href=\"C$ppS$trcspn.htm\">st$d::strcspn</a>" },
    { "std::strncat","<a href=\"C$ppS$trncat.htm\">st$d::s$trncat</a>" },
    { "std::strncmp","<a href=\"C$ppS$trncmp.htm\">st$d::strncmp</a>" },
    { "std::strncpy","<a href=\"C$ppS$trncpy.htm\">st$d::strncpy</a>" },
    { "std::strpbrk","<a href=\"C$ppS$trpbrk.htm\">st$d::strpbrk</a>" },
    { "std::strrchr","<a href=\"C$ppS$trrchr.htm\">st$d::strrchr</a>" },
    { "std::strtoul","<a href=\"C$ppS$trtoul.htm\">st$d::strtoul</a>" },
    { "std::strxfrm","<a href=\"C$ppS$trxfrm.htm\">st$d::strxfrm</a>" },
    { "std::swscanf","<a href=\"C$ppS$wscanf.htm\">st$d::swscanf</a>" },
    { "std::tmpfile","<a href=\"C$ppT$mpfile.htm\">st$d::tmpfile</a>" },
    { "std::ungetwc","<a href=\"C$ppU$ngetwc.htm\">st$d::ungetwc</a>" },
    { "std::vprintf","<a href=\"C$ppV$pri$ntf.htm\">st$d::vpri$ntf</a>" },
    { "std::vwprint","<a href=\"C$ppV$wpri$nt.htm\">st$d::vwpri$nt</a>" },
    { "std::wcsftim","<a href=\"C$ppW$csftim.htm\">s$td::wc$sftim</a>" },
    { "std::wcstomb","<a href=\"C$ppW$cstomb.htm\">s$td::wc$stomb</a>" },
    { "std::wmemmov","<a href=\"C$ppW$memmov.htm\">s$td::wmemmov</a>" },
    { "thread_local","<b><a href=\"C$ppT$hread_l$ocal.htm\">t$hread_l$ocal</a></b>" },
    { "&amp$;&amp$;","<a href=\"CppOperatorLogicalAnd.htm\">&amp$;$&amp$;</a>" },
  //11
    { "algorithm.h","<a href=\"CppAlg$orithmH.htm\">alg$orithm.h</a>" },
    { "application","<a href=\"CppA$pplication.htm\">a$pplication</a>" },
    { "befriending","<a href=\"CppF$riend.htm\">b$ef$riending</a>" },
    { "boost::asio","<a href=\"CppAsio.htm\">b$oost::a$sio</a>" },
    { "boost::bind","<a href=\"CppBi$nd.htm\">bo$ost::bi$nd</a>" },
    { "constructor","<a href=\"CppC$ons$tructor.htm\">c$ons$tructor</a>" },
    { "data member","<a href=\"CppD$ataM$ember.htm\">d$ata m$ember</a>" },
    { "declaration","<a href=\"CppD$eclaration.htm\">d$eclaration</a>" },
    { "dataPointer","dataPoi$nter" },
    { "definitions","<a href=\"CppDe$finition.htm\">de$fi$nitions</a>" },
    { "header file","<a href=\"CppH$eaderF$ile.htm\">h$eader f$ile</a>" },
    { "noncopyable","<a href=\"CppN$onc$opyable.htm\">n$onc$opyable</a>" },
    { "return type","<a href=\"CppR$eturnT$ype.htm\">r$eturn t$ype</a>" },
    { "static_cast","<b><a href=\"CppSt$atic_cast.htm\">sta$tic_ca$st</a></b>" },
    { "std::_lrand","<a href=\"Cpp_lr$and.htm\">s$td::_lr$and</a>" },
    { "std::all_of","<a href=\"CppA$ll_o$f.htm\">s$td::a$ll_o$f</a>" },
    { "std::any_of","<a href=\"CppA$ny_o$f.htm\">s$td::a$ny_o$f</a>" },
    { "std::atexit","<a href=\"CppA$te$xit.htm\">s$td::at$exit</a>" },
    { "std::atomic","<a href=\"CppA$tomic.htm\">s$td::at$omic</a>" },
    { "std::bitset","<a href=\"CppB$itset.htm\">s$td::bi$tset</a>" },
    { "std::calloc","<a href=\"CppC$alloc.htm\">s$td::ca$lloc</a>" },
    { "std::chrono","<a href=\"CppC$hrono.htm\">s$td::c$hrono</a>" },
    { "std::copy_n","<a href=\"C$ppC$opy_n.htm\">s$td::c$o$py_n</a>" },
    { "std::fclose","<a href=\"CppF$close.htm\">s$td::fc$lose</a>" },
    { "std::ferror","<a href=\"CppF$error.htm\">s$td::fe$rror</a>" },
    { "std::fflush","<a href=\"CppF$flush.htm\">s$td::ff$lush</a>" },
    { "std::fgetwc","<a href=\"CppF$getwc.htm\">s$td::fg$etwc</a>" },
    { "std::fgetws","<a href=\"CppF$getws.htm\">s$td::fg$etws</a>" },
    { "std::fputwc","<a href=\"CppF$putwc.htm\">s$td::fp$utwc</a>" },
    { "std::fputws","<a href=\"CppF$putws.htm\">s$td::fp$utws</a>" },
    { "std::fscanf","<a href=\"CppF$scanf.htm\">s$td::fs$canf</a>" },
    { "std::fwrite","<a href=\"CppF$write.htm\">s$td::fw$rite</a>" },
    { "std::getenv","<a href=\"CppG$etenv.htm\">s$td::ge$tenv</a>" },
    { "std::gmtime","<a href=\"CppG$mt$ime.htm\">s$td::gm$t$ime</a>" },
    { "std::malloc","<a href=\"CppM$alloc.htm\">s$td::ma$lloc</a>" },
    { "std::mbrlen","<a href=\"CppM$brlen.htm\">s$td::mb$rlen</a>" },
    { "std::mbtowc","<a href=\"CppM$btowc.htm\">s$td::mb$towc</a>" },
    { "std::memchr","<a href=\"CppM$emchr.htm\">s$td::me$mchr</a>" },
    { "std::memcmp","<a href=\"CppM$emcmp.htm\">s$td::me$mcmp</a>" },
    { "std::memcpy","<a href=\"CppM$emcpy.htm\">s$td::me$mcpy</a>" },
    { "std::memset","<a href=\"CppM$emset.htm\">s$td::me$mset</a>" },
    { "std::minmax","<a href=\"CppMi$nm$ax.htm\">st$d::mi$nm$ax</a>" },
    { "std::mktime","<a href=\"CppM$kt$ime.htm\">s$td::mk$t$ime</a>" },
    { "std::negate","<a href=\"CppN$egate.htm\">s$td::ne$gate</a>" },
    { "std::perror","<a href=\"CppP$error.htm\">s$td::pe$rror</a>" },
    { "std::printf","<a href=\"CppP$ri$ntf.htm\">s$td::pr$in$tf</a>" },
    { "std::remove","<a href=\"CppR$emove.htm\">s$td::re$move</a>" },
    { "std::rename","<a href=\"CppR$ename.htm\">s$td::re$name</a>" },
    { "std::rewind","<a href=\"CppR$ewind.htm\">s$td::re$wind</a>" },
    { "std::rotate","<a href=\"CppR$o$tate.htm\">s$td::ro$tate</a>" },
    { "std::search","<a href=\"CppS$earch.htm\">s$td::se$arch</a>" },
    { "std::setbuf","<a href=\"CppS$etbuf.htm\">s$td::se$tbuf</a>" },
    { "std::signal","<a href=\"CppS$tdS$ignal.htm\">s$td::si$gnal</a>" },
    { "std::size_t","<a href=\"CppS$i$ze_t.htm\">st$d::si$ze_t</a>" },
    { "std::skipws","<a href=\"CppS$kipws.htm\">s$td::sk$ipws</a>" },
    { "std::sscanf","<a href=\"CppS$scanf.htm\">s$td::ssc$anf</a>" },
    { "std::strcat","<a href=\"CppS$trcat.htm\">s$td::st$rcat</a>" },
    { "std::strchr","<a href=\"CppS$trchr.htm\">s$td::st$rchr</a>" },
    { "std::strcmp","<a href=\"CppS$trcmp.htm\">s$td::st$rcmp</a>" },
    { "std::strcpy","<a href=\"CppS$trcpy.htm\">s$td::st$rcpy</a>" },
    { "std::string","<a href=\"CppS$tring.htm\">s$td::st$ring</a>" },
    { "std::strlen","<a href=\"CppS$trlen.htm\">s$td::st$rlen</a>" },
    { "std::strspn","<a href=\"CppS$trspn.htm\">s$td::st$rspn</a>" },
    { "std::strstr","<a href=\"CppS$trstr.htm\">s$td::st$rstr</a>" },
    { "std::strtod","<a href=\"CppS$trtod.htm\">s$td::st$rtod</a>" },
    { "std::strtok","<a href=\"CppS$trtok.htm\">s$td::st$rtok</a>" },
    { "std::strtol","<a href=\"CppS$trtol.htm\">s$td::st$rtol</a>" },
    { "std::system","<a href=\"CppS$ystem.htm\">s$td::sy$stem</a>" },
    { "std::thread","<a href=\"C$ppT$hread.htm\">s$td::t$hread</a>" },
    { "std::time_t","<a href=\"CppT$$ime_t.htm\">s$td::ti$me_t</a>" },
    { "std::tmpnam","<a href=\"CppT$mpnam.htm\">s$td::tm$pnam</a>" },
    { "std::ungetc","<a href=\"CppU$ngetc.htm\">s$td::un$getc</a>" },
    { "std::unique","<a href=\"CppU$nique.htm\">s$td::un$ique</a>" },
    { "std::vector","<a href=\"CppV$ector.htm\">s$td::ve$ctor</a>" },
    { "std::wcrtom","<a href=\"CppWcrtom.htm\">s$td::wc$rtom</a>" },
    { "std::wcscol","<a href=\"CppWcscol.htm\">s$td::wc$scol</a>" },
    { "std::wcscsp","<a href=\"CppWcscsp.htm\">s$td::wc$scsp</a>" },
    { "std::wcsnca","<a href=\"CppWcsnca.htm\">s$td::wc$snca</a>" },
    { "std::wcsncm","<a href=\"CppWcsncm.htm\">s$td::wc$sncm</a>" },
    { "std::wcsncp","<a href=\"CppWcsncp.htm\">s$td::wc$sncp</a>" },
    { "std::wcspbr","<a href=\"CppWcspbr.htm\">s$td::wc$spbr</a>" },
    { "std::wcsrch","<a href=\"CppWcsrch.htm\">s$td::wc$srch</a>" },
    { "std::wcstou","<a href=\"CppWcstou.htm\">s$td::wc$stou</a>" },
    { "std::wcsxfr","<a href=\"CppWcsxfr.htm\">s$td::wc$sxfr</a>" },
    { "std::wctomb","<a href=\"CppWctomb.htm\">s$td::w$ctomb</a>" },
    { "std::wctran","<a href=\"CppWctran.htm\">s$td::wc$tran</a>" },
    { "std::wmemch","<a href=\"CppWmemch.htm\">s$td::wm$emch</a>" },
    { "std::wmemcm","<a href=\"CppWmemcm.htm\">s$td::wm$emcm</a>" },
    { "std::wmemcp","<a href=\"CppWmemcp.htm\">s$td::wm$emcp</a>" },
    { "std::wmemse","<a href=\"CppWmemse.htm\">s$td::wm$emse</a>" },
    { "std::wprint","<a href=\"CppWpri$nt.htm\">s$td::wp$ri$nt</a>" },
    { "signedRanks","si$gnedRanks" },
    { "significant","signi$ficant" },
    { "Android SDK","<a href=\"CppA$ndroidS$dk.htm\">A$ndroid S$D$K</a>" },
    { "AnsiToLower","<a href=\"CppA$nsiT$oL$ower.htm\">A$nsiT$oL$ower</a>" },
    { "AnsiToUpper","<a href=\"CppA$nsiT$oU$pper.htm\">A$nsiT$oU$pper</a>" },
    { "Application","<a href=\"CppA$pplication.htm\">A$pplication</a>" },
    { "Befriending","<a href=\"CppF$riend.htm\">B$ef$riending</a>" },
    { "BigUnsigned","BigUns$igned" },
    { "Boost.Regex","<a href=\"CppR$egex.htm\">B$oost.R$egex</a>" },
    { "C[PLUS][PLUS] Builder","<a href=\"C$ppB$uilder.htm\">C[PLUS][PLUS] B$uilder</a>" },
    { "C[PLUS][PLUS] builder","<a href=\"C$ppB$uilder.htm\">C[PLUS][PLUS] b$uilder</a>" },
    { "CheckNewick","<a href=\"CppC$heckN$ewick.htm\">C$heckN$ewick</a>" },
    { "Constructor","<a href=\"CppC$ons$tructor.htm\">C$ons$tructor</a>" },
    { "Data member","<a href=\"CppD$ataM$ember.htm\">D$ata m$ember</a>" },
    { "Declaration","<a href=\"CppD$eclaration.htm\">D$eclaration</a>" },
    { "Definitions","<a href=\"CppDe$finition.htm\">De$fi$nitions</a>" },
    { "DivideTerms","<a href=\"CppDi$videTerms.htm\">Di$videTerms</a>" },
    { "GetDeadEnds","<a href=\"CppG$etDeadEnds.htm\">G$etDeadEnds</a>" },
    { "GetDistance","<a href=\"CppG$etDistance.htm\">G$etDistance</a>" },
    { "GreaterThan","<a href=\"CppFunctorG$reaterThan.htm\">G$reaterThan</a>" },
    { "GroupWidget","<a href=\"C$ppG$roupW$idget.htm\">G$roupW$idget</a>" },
    { "Header file","<a href=\"CppH$eaderF$ile.htm\">H$eader f$ile</a>" },
    { "Hello Boost","<a href=\"CppH$elloB$oost.htm\">H$ello B$oost</a>" },
    { "Hello World","<a href=\"CppH$elloW$orld.htm\">H$ello W$orld</a>" },
    { "Herb Sutter","<a href=\"CppH$erbS$utter.htm\">H$erb Sutter</a>" },
    { "LexicalCast","<a href=\"CppL$exicalC$ast.htm\">L$exicalC$ast</a>" },
    { "PrimeExpert","<a href=\"CppP$rimeE$xpert.htm\">P$rimeE$xpert</a>" },
    { "PylosWidget","<a href=\"CppP$ylosW$idget.htm\">P$ylosW$idget</a>" },
    { "QHBoxLayout","<a href=\"CppQ$H$B$oxL$ayout.htm\">Q$H$B$oxL$ayout</a>" },
    { "QMainWindow","<a href=\"CppQ$Ma$inWind$ow.htm\">Q$Ma$inWind$ow</a>" },
    { "QMouseEvent","<a href=\"CppQM$ouseEvent.htm\">QM$ouseEvent</a>" },
    { "QPaintEvent","<a href=\"CppQ$Pai$ntEv$ent.htm\">Q$Pai$ntEv$ent</a>" },
    { "QPushButton","<a href=\"CppQP$ushButton.htm\">QP$ushButton</a>" },
    { "QSystemInfo","<a href=\"CppQ$S$ystemI$nfo.htm\">Q$S$ystemI$nfo</a>" },
    { "QVBoxLayout","<a href=\"CppQ$V$B$oxL$ayout.htm\">Q$V$B$oxL$ayout</a>" },
    { "ReplaceOnce","<a href=\"CppRe$placeOnce.htm\">Re$placeOnce</a>" },
    { "Return type","<a href=\"CppR$eturnT$ype.htm\">R$eturn t$ype</a>" },
    { "SetPixelClx","<a href=\"CppSetP$ixelClx.htm\">SetP$ixelClx</a>" },
    { "SetPixelVcl","<a href=\"CppSetP$ixelVcl.htm\">SetP$ixelVcl</a>" },
    { "Symbian SDK","<a href=\"CppS$ymbianS$dk.htm\">S$ymbian S$D$K</a>" },
    { "TestNdsmake","<a href=\"T$oolT$estN$dsm$ake.htm\">T$estN$dsm$ake</a>" },
    { "TestProFile","<a href=\"T$oolT$estP$roF$ile.htm\">T$estP$roF$ile</a>" },
    { "Wt::WWidget","<a href=\"CppW$W$idget.htm\">W$t::W$W$idget</a>" },
    { "Wt::WString","<a href=\"CppW$S$tring.htm\">W$t::W$S$tring</a>" },
    { "Wt::WSlider","<a href=\"CppW$S$lider.htm\">W$t::W$S$lider</a>" },
    { "Wt::WShadow","<a href=\"CppW$S$hadow.htm\">W$t::W$S$hadow</a>" },
    { "Wt::WServer","<a href=\"CppW$S$erver.htm\">W$t::W$S$erver</a>" },
    { "Wt::WPointF","<a href=\"CppW$P$ointF.htm\">W$t::W$P$ointF</a>" },
    { "Wt::WObject","<a href=\"CppW$O$bject.htm\">W$t::W$O$bject</a>" },
    { "Wt::WLogger","<a href=\"CppW$L$ogger.htm\">W$t::W$L$ogger</a>" },
    { "Wt::WLength","<a href=\"CppW$L$ength.htm\">W$t::W$L$ength</a>" },
    { "Wt::WLayout","<a href=\"CppW$L$ayout.htm\">W$t::W$L$ayout</a>" },
    { "Wt::WDialog","<a href=\"CppW$D$ialog.htm\">W$t::W$D$ialog</a>" },
    { "Wt::WBorder","<a href=\"CppW$B$order.htm\">W$t::W$B$order</a>" },
    { "Wt::WAnchor","<a href=\"CppW$A$nchor.htm\">W$t::W$A$nchor</a>" },
    { "Wt::JSignal","<a href=\"CppJS$ignal.htm\">W$t::JS$i$gnal</a>" },
    { "WWidgetItem","<a href=\"CppW$W$idgetI$tem.htm\">W$W$idgetI$tem</a>" },
    { "WViewWidget","<a href=\"CppW$V$iewW$idget.htm\">W$V$iewW$idget</a>" },
    { "WVBoxLayout","<a href=\"CppW$V$B$oxL$ayout.htm\">W$V$B$oxL$ayout</a>" },
    { "WTouchEvent","<a href=\"CppW$T$ouchE$vent.htm\">W$TouchE$vent</a>" },
    { "WScrollArea","<a href=\"CppW$S$crollA$rea.htm\">W$S$crollA$rea</a>" },
    { "WPushButton","<a href=\"CppW$P$ushB$utton.htm\">W$P$ushB$utton</a>" },
    { "WMouseEvent","<a href=\"CppW$M$ouseE$vent.htm\">W$M$ouseE$vent</a>" },
    { "WModelIndex","<a href=\"CppW$M$odelI$ndex.htm\">W$ModelIndex</a>" },
    { "WMessageBox","<a href=\"CppW$M$essageB$ox.htm\">W$MessageBox</a>" },
    { "WLayoutItem","<a href=\"CppW$L$ayoutI$tem.htm\">W$L$ayoutI$tem</a>" },
    { "WHTML5Video","<a href=\"CppW$H$TML5V$ideo.htm\">W$HTML5Video</a>" },
    { "WHTML5Media","<a href=\"CppW$H$TML5M$edia.htm\">W$HTML5Media</a>" },
    { "WHTML5Audio","<a href=\"CppW$H$TML5A$udio.htm\">W$HTML5Audio</a>" },
    { "WtLedWidget","<a href=\"CppW$tL$edW$idget.htm\">W$tL$edW$idget</a>" },
    { "WHBoxLayout","<a href=\"CppW$H$B$oxL$ayout.htm\">W$H$B$oxL$ayout</a>" },
    { "WGridLayout","<a href=\"CppW$G$ridL$ayout.htm\">W$G$ridL$ayout</a>" },
    { "WFormWidget","<a href=\"CppW$F$ormW$idget.htm\">W$F$ormW$idget</a>" },
    { "WFileUpload","<a href=\"CppW$F$ileU$pload.htm\">W$F$ileU$pload</a>" },
    { "WDatePicker","<a href=\"CppW$D$ateP$icker.htm\">W$D$ateP$icker</a>" },
    { "WCircleArea","<a href=\"CppW$C$ircleA$rea.htm\">W$C$ircleA$rea</a>" },
    { "EventSignal","<a href=\"CppE$ventS$ignal.htm\">E$ventS$ignal</a>" },
    { "XmlToPretty","<a href=\"C$ppX$mlT$oP$retty.htm\">X$mlT$oP$retty</a>" },
    { "<<=","<a href=\"CppOperatorBitShi$ftLeftAssign.htm\">$&l$t;$&l$t;=</a>" },
    { ">>=","<a href=\"CppOperatorBitShi$ftRightAssign.htm\">$&g$t;$&g$t;=</a>" },
  //10
    { "<<","<a href=\"CppOperatorStreamOut.htm\">$&l$t;$&l$t;</a>" },
    { ">>","<a href=\"CppOperatorStreamIn.htm\">$&g$t;$&g$t;</a>" },
    { "ActivePerl","<a href=\"CppA$ctiveP$erl.htm\">A$ctiveP$erl</a>" },
    { "AnsiString","<a href=\"CppA$nsiS$tring.htm\">A$nsiS$tring</a>" },
    { "AnsiToWide","<a href=\"CppA$nsiT$oW$ide.htm\">A$nsiT$oW$ide</a>" },
    { "Base class","<a href=\"CppB$aseC$lass.htm\">B$ase c$lass</a>" },
    { "BeerWanter","<a href=\"G$ameB$eerWanter.htm\">B$eerWanter</a>" },
    { "BigInteger","<a href=\"CppB$igInt.htm\">B$igI$nteger</a>" },
    { "BubbleSort","<a href=\"CppB$ubbleSort.htm\">B$ubbleSort</a>" },
    { "Cachegrind","<a href=\"C$ppC$acheg$rind.htm\">C$acheg$rind</a>" },
    { "CodeToHtml","<a href=\"T$oolC$odeToHtml.htm\">C$odeToHtml</a>" },
    { "CopySecond","<a href=\"CppC$opyS$econd.htm\">C$opyS$econd</a>" },
    { "CoutVector","<a href=\"CppCo$utVec$tor.htm\">Cou$tV$ector</a>" },
    { "CreateMaze","<a href=\"CppCr$eateMaze.htm\">Cr$eateMa$ze</a>" },
    { "Definition","<a href=\"CppDe$finition.htm\">De$fi$nition</a>" },
    { "DeleteFile","<a href=\"CppD$eleteF$ile.htm\">D$eleteF$ile</a>" },
    { "Destructor","<a href=\"CppD$estr$uctor.htm\">D$estr$uctor</a>" },
    { "Difference","Di$fference" },
    { "ExtractIds","<a href=\"C$ppE$xtractI$ds.htm\">E$xtractI$ds</a>" },
    { "FileExists","<a href=\"CppFi$leExists.htm\">Fi$leExists</a>" },
    { "HelloBoost","<a href=\"CppH$elloB$oost.htm\">H$elloB$oost</a>" },
    { "HelloWorld","<a href=\"CppH$elloW$orld.htm\">H$elloW$orld</a>" },
    { "Identifier","<a href=\"CppI$denti$fier.htm\">I$denti$fier</a>" },
    { "IntToQtStr","<a href=\"CppI$ntToQ$tStr.htm\">I$ntToQ$tStr</a>" },
    { "IP address","<a href=\"C$ppI$pA$ddress.htm\">I$P a$ddress</a>" },
    { "IP Address","<a href=\"C$ppI$pA$ddress.htm\">I$P A$ddress</a>" },
    { "MainWindow","M$ainWi$nd$ow" },
    { "MakeSquare","<a href=\"CppMak$eS$quare.htm\">Mak$eS$quare</a>" },
    { "MaxElement","<a href=\"CppMa$xElement.htm\">Ma$xElement</a>" },
    { "MinElement","<a href=\"CppMi$nElement.htm\">Mi$nElement</a>" },
    { "Mpz_tToStr","<a href=\"CppM$pz_tToStr.htm\">M$pz_tToStr</a>" },
    { "Profilin\'","<a href=\"CppP$rofiling.htm\">P$rofilin\'</a>" },
    { "Qt Creator","<a href=\"CppQ$tCreator.htm\">Q$t Creator</a>" },
    { "QtMobility","<a href=\"CppQ$tM$obility.htm\">Q$tM$obility</a>" },
    { "QTcpClient","<a href=\"CppQ$TcpClient.htm\">Q$TcpClient</a>" },
    { "QTcpServer","<a href=\"CppQ$TcpServer.htm\">Q$TcpServer</a>" },
    { "QTcpSocket","<a href=\"CppQ$TcpSocket.htm\">Q$TcpSocket</a>" },
    { "QtStrToInt","<a href=\"CppQ$tS$trT$oInt.htm\">Q$tS$trT$oInt</a>" },
    { "Reciprocal","<a href=\"CppRe$ciprocal.htm\">Re$ciprocal</a>" },
    { "ReplaceAll","<a href=\"CppRe$placeAll.htm\">Re$placeAll</a>" },
    { "SortNewick","<a href=\"CppS$ortN$ewick.htm\">S$ortN$ewick</a>" },
    { "SortVector","<a href=\"CppS$ortV$ector.htm\">S$ortV$ector</a>" },
    { "Stopwatch","<a href=\"CppS$topwatch.htm\">S$topwatch</a>" },
    { "StrToLower","<a href=\"CppSt$rToL$ower.htm\">St$rToL$ower</a>" },
    { "StrToUpper","<a href=\"CppSt$rToU$pper.htm\">St$rToU$pper</a>" },
    { "ToolPause","<a href=\"T$oolP$ause.htm\">T$oolP$ause</a>" },
    { "TestPylos","<a href=\"T$oolT$estP$ylos.htm\">T$estP$ylos</a>" },
    { "Unassigned","Unass$igned" },
    { "Unregister","Unr$egister" },
    { "VirtualBox","<a href=\"CppV$irtualB$ox.htm\">V$irtualB$ox</a>" },
    { "WideString","<a href=\"CppW$ideS$tring.htm\">W$ideS$tring</a>" },
    { "Wt::WTimer","<a href=\"CppW$T$imer.htm\">W$t::W$T$imer</a>" },
    { "Wt::WTable","<a href=\"CppW$T$able.htm\">W$t::W$T$able</a>" },
    { "Wt::WSound","<a href=\"CppW$S$ound.htm\">W$t::W$S$ound</a>" },
    { "Wt::WRectF","<a href=\"CppW$R$ectF.htm\">W$t::W$R$ectF</a>" },
    { "Wt::WPoint","<a href=\"CppW$P$oint.htm\">W$t::W$P$oi$nt</a>" },
    { "Wt::WPanel","<a href=\"CppW$P$anel.htm\">W$t::W$P$anel</a>" },
    { "Wt::WLineF","<a href=\"CppW$L$ineF.htm\">W$t::W$L$ineF</a>" },
    { "Wt::WLabel","<a href=\"CppW$L$abel.htm\">W$t::W$L$abel</a>" },
    { "Wt::WImage","<a href=\"CppW$I$mage.htm\">W$t::W$I$mage</a>" },
    { "Wt::WColor","<a href=\"CppW$C$olor.htm\">W$t::W$C$olor</a>" },
    { "Wt::WBrush","<a href=\"CppW$B$rush.htm\">W$t::W$B$rush</a>" },
    { "Wt::WBreak","<a href=\"CppW$B$reak.htm\">W$t::W$B$reak</a>" },
    { "Wt::Signal","<a href=\"CppW$tS$ignal.htm\">W$t::S$ignal</a>" },
    { "base class","<a href=\"CppB$aseC$lass.htm\">b$ase c$lass</a>" },
    { "boost::any","<a href=\"CppAny.htm\">b$oost::a$ny</a>" },
    { "boost::get","<a href=\"CppGet.htm\">b$oost::g$et</a>" },
    { "const_cast","<b><a href=\"CppCo$nst_cast.htm\">co$nst_cast</a></b>" },
    { "definition","<a href=\"CppDe$finition.htm\">de$fi$nition</a>" },
    { "destructor","<a href=\"CppDestr$uctor.htm\">destr$uctor</a>" },
    { "difference","di$fference" },
    { "enum class","<b><a href=\"CppE$numC$lass.htm\">e$num c$lass</a></b>" },
    { "http://www","http:/$/www" },
    { "identifier","<a href=\"CppI$denti$fier.htm\">i$denti$fier</a>" },
    { "lock_guard","<a href=\"C$ppL$ock_g$uard.htm\">l$ock_g$uard</a>" },
    { "m_instance","<a href=\"CppIn$stance.htm\">m$_i$nstance</a>" },
    { "mainwindow","ma$inwind$ow" }, //Remove 'main' and 'do'
    { "operator()","<b><a href=\"CppOp$eratorF$unctionCall.htm\">op$erato$r()</a></b>" },
    { "operator==","<b><a href=\"CppOp$eratorEq$ual.htm\">op$erato$r=$=$</a></b>" },
    { "operator!=","<b><a href=\"CppOp$eratorN$otEq$ual.htm\">op$erato$r!$=$</a></b>" },
    { "operator++","<b><a href=\"CppOp$eratorIn$crement.htm\">op$erato$r+$+$</a></b>" },
    { "operator--","<b><a href=\"CppOp$eratorDe$crement.htm\">op$erato$r-$-$</a></b>" },
    { "operator->","<b><a href=\"CppOp$eratorMemberByP$oi$nter.htm\">op$erato$r-></a></b>" },
    { "paintEvent","pai$ntEvent" },
    { "profilin\'","<a href=\"CppP$rofiling.htm\">p$rofilin\'</a>" },
    { "scoped_ptr","<a href=\"CppS$coped_ptr.htm\">s$coped_p$tr</a>" },
    { "shared_ptr","<a href=\"CppS$hared_p$tr.htm\">s$hared_p$tr</a>" },
    { "std::abort","<a href=\"CppAbort.htm\">s$td::abo$rt</a>" },
    { "std::btowc","<a href=\"CppBtowc.htm\">s$td::bt$owc</a>" },
    { "std::clock","<a href=\"CppC$lock.htm\">s$td::cl$ock</a>" },
    { "std::ctime","<a href=\"CppC$t$ime.htm\">s$td::ct$ime</a>" },
    { "std::count","<a href=\"CppCount.htm\">s$td::co$unt</a>" },
    { "std::deque","<a href=\"CppDeque.htm\">s$td::de$que</a>" },
    { "std::equal","<a href=\"CppEqual.htm\">s$td::eq$ual</a>" },
    { "std::fgetc","<a href=\"CppFgetc.htm\">s$td::fge$tc</a>" },
    { "std::fgets","<a href=\"CppFgets.htm\">s$td::fge$ts</a>" },
    { "std::fixed","<a href=\"CppFixed.htm\">s$td::fi$xed</a>" },
    { "std::floor","<a href=\"CppFloor.htm\">s$td::fl$o$or</a>" },
    { "std::flush","<a href=\"CppFlush.htm\">s$td::fl$ush</a>" },
    { "std::fopen","<a href=\"CppFopen.htm\">s$td::fo$pen</a>" },
    { "std::fputc","<a href=\"CppFputc.htm\">s$td::fp$utc</a>" },
    { "std::fputs","<a href=\"CppFputs.htm\">s$td::fp$uts</a>" },
    { "std::fread","<a href=\"CppFread.htm\">s$td::fr$ead</a>" },
    { "std::frexp","<a href=\"CppFrexp.htm\">s$td::fr$ex$p</a>" },
    { "std::fseek","<a href=\"CppFseek.htm\">s$td::fs$eek</a>" },
    { "std::ftell","<a href=\"CppFtell.htm\">s$td::ft$ell</a>" },
    { "std::fwide","<a href=\"CppFwide.htm\">s$td::fw$ide</a>" },
    { "std::getwc","<a href=\"CppGetwc.htm\">s$td::ge$twc</a>" },
    { "std::ldexp","<a href=\"CppL$de$xp.htm\">s$td::lde$xp</a>" },
    { "std::mblen","<a href=\"CppM$bl$en.htm\">s$td::mbl$en</a>" },
    { "std::merge","<a href=\"CppM$erge.htm\">s$td::me$rge</a>" },
    { "std::minus","<a href=\"CppM$inus.htm\">s$td::mi$nus</a>" },
    { "std::mutex","<a href=\"CppM$utex.htm\">s$td::m$utex</a>" },
    { "std::putwc","<a href=\"CppP$utwc.htm\">s$td::pu$twc</a>" },
    { "std::qsort","<a href=\"CppQ$s$ort.htm\">s$td::qso$rt</a>" },
    { "std::queue","<a href=\"CppQ$ueue.htm\">s$td::qu$eue</a>" },
    { "std::regex","<a href=\"CppR$egex.htm\">s$td::r$egex</a>" },
    { "std::raise","<a href=\"CppR$ai$se.htm\">s$td::ra$ise</a>" },
    { "std::right","<a href=\"CppR$ight.htm\">s$td::ri$ght</a>" },
    { "std::scanf","<a href=\"CppS$canf.htm\">s$td::sc$anf</a>" },
    { "std::slist","<a href=\"CppS$l$ist.htm\">s$td::sli$st</a>" },
    { "std::srand","<a href=\"CppS$ra$nd.htm\">s$td::sra$nd</a>" },
    { "std::stack","<a href=\"CppS$tack.htm\">s$td::sta$ck</a>" },
    { "std::tuple","<a href=\"CppT$uple.htm\">s$td::t$uple</a>" },
    { "std::wcout","<a href=\"CppW$c$out.htm\">s$td::w$c$out</a>" },
    { "std::wcsca","<a href=\"CppW$csca.htm\">s$td::w$csca</a>" },
    { "std::wcsch","<a href=\"CppW$csch.htm\">s$td::w$csch</a>" },
    { "std::wcscm","<a href=\"CppW$cscm.htm\">s$td::w$cscm</a>" },
    { "std::wcscp","<a href=\"CppW$cscp.htm\">s$td::w$cscp</a>" },
    { "std::wcsle","<a href=\"CppW$csle.htm\">s$td::w$csle</a>" },
    { "std::wcssp","<a href=\"CppW$cssp.htm\">s$td::w$cssp</a>" },
    { "std::wcsst","<a href=\"CppW$csst.htm\">s$td::w$csst</a>" },
    { "std::wcsto","<a href=\"CppW$csto.htm\">s$td::w$csto</a>" },
    { "std::wctom","<a href=\"CppW$ctom.htm\">s$td::w$ctom</a>" },
    { "std::wctyp","<a href=\"CppW$ctyp.htm\">s$td::w$ctyp</a>" },
    { "std::wscan","<a href=\"CppW$s$can.htm\">s$td::w$scan</a>" },
    { "unassigned","unass$igned" },
    { "unregister","unr$egister" },
  //9
    { "::nrand48","<a href=\"CppN$r$and48.htm\">::n$r$and48</a>" },
    { "Algorithm","<a href=\"CppAlg$orithm.htm\">Alg$orithm</a>" },
    { "AnsiIsInt","<a href=\"CppA$nsiI$sInt.htm\">A$nsiI$sInt</a>" },
    { "AnsiToInt","<a href=\"CppA$nsiT$oI$nt.htm\">A$nsiT$oI$nt</a>" },
    { "AnsiToStr","<a href=\"CppA$nsiT$oS$tr.htm\">A$nsiT$oS$tr</a>" },
    { "Ascii art","<a href=\"CppA$sciiA$rt.htm\">A$scii a$rt</a>" },
    { "Ascii Art","<a href=\"CppA$sciiA$rt.htm\">A$scii A$rt</a>" },
    { "Assembler","<a href=\"CppA$ssembler.htm\">A$ssembler</a>" },
    { "Character","<a href=\"CppC$har.htm\">C$haracter</a>" },
    { "Component","<a href=\"CppC$omponent.htm\">C$omponent</a>" },
    { "Construct","<a href=\"CppC$ons$tructor.htm\">C$ons$truct</a>" },
    { "Container","<a href=\"CppC$ontainer.htm\">C$ontainer</a>" },
    { "CopyFirst","<a href=\"CppC$opyF$irst.htm\">C$opyF$irst</a>" },
    { "Debugging","<a href=\"CppD$eb$ug.htm\">D$eb$ugging</a>" },
    { "DevkitARM","<a href=\"CppD$evkitArm.htm\">D$evkitARM</a>" },
    { "DevkitPro","<a href=\"CppD$evkitPro.htm\">D$evkitPro</a>" },
    { "DrawGlobe","<a href=\"CppD$rawGlobe.htm\">D$rawGlobe</a>" },
    { "Factorial","<a href=\"CppFa$ctorial.htm\">Fa$ctorial</a>" },
    { "GetMaxInt","<a href=\"CppGe$tMa$xIn$t.htm\">Ge$tMa$xIn$t</a>" },
    { "GetStdDev","<a href=\"CppGe$tStdDev.htm\">Ge$tStdDev</a>" },
    { "GrayToInt","<a href=\"CppGr$ayT$oInt.htm\">GrayT$oI$nt</a>" },
    { "Interface","<a href=\"CppI$nterface.htm\">In$terface</a>" },
    { "IpAddress","<a href=\"C$ppI$pA$ddress.htm\">I$pA$ddress</a>" },
    { "Maemo SDK","<a href=\"CppM$aemoS$dk.htm\">M$aemo S$D$K</a>" },
    { "WMenuItem","<a href=\"C$ppW$M$enuI$tem.htm\">W$M$enuI$tem</a>" },
    { "NeuralNet","<a href=\"CppN$euralNet.htm\">N$euralNet</a>" },
    { "Ovi Suite","<a href=\"CppO$viS$uite.htm\">O$vi S$uite</a>" },
    { "PicToCode","<a href=\"T$oolP$icT$oC$ode.htm\">P$icT$oC$ode</a>" },
    { "Predicate","<a href=\"CppP$redicate.htm\">P$redicate</a>" },
    { "Profiling","<a href=\"CppP$rofiling.htm\">P$rofiling</a>" },
    { "QuickSort","<a href=\"C$ppQ$uickS$ort.htm\">Q$uickS$ort</a>" },
    { "Quicksort","<a href=\"C$ppQ$uickS$ort.htm\">Q$uicks$ort</a>" },
    { "Remainder","Rem$ainder" },
    { "Singleton","<a href=\"C$ppD$esignP$atternS$ingleton.htm\">S$ingleton</a>" },
    { "SolveMaze","<a href=\"CppS$olveM$aze.htm\">S$olveM$aze</a>" },
    { "StrToWStr","<a href=\"C$ppS$trT$oW$Str.htm\">S$trT$oW$Str</a>" },
    { "StrToAnsi","<a href=\"CppS$trT$oA$nsi.htm\">S$trT$oA$nsi</a>" },
    { "SumSecond","<a href=\"CppS$umS$econd.htm\">S$umS$econd</a>" },
    { "Therefore","Therefo$re" },
    { "TimeToStr","<a href=\"CppT$imeToStr.htm\">T$imeToStr</a>" },
    { "WideToInt","<a href=\"CppW$ideT$oInt.htm\">W$ideT$oI$nt</a>" },
    { "WLineEdit","<a href=\"CppW$L$ineE$dit.htm\">W$L$ineE$dit</a>" },
    { "Wt::JSlot","<a href=\"CppJ$S$lot.htm\">W$t::J$S$lot</a>" },
    { "Wt::Touch","<a href=\"CppT$o$uch.htm\">W$t::T$o$uch</a>" },
    { "Wt::WDate","<a href=\"CppW$D$ate.htm\">W$t::W$D$ate</a>" },
    { "Wt::WFont","<a href=\"CppW$F$ont.htm\">W$t::W$F$ont</a>" },
    { "Wt::WMenu","<a href=\"CppW$M$enu.htm\">W$t::W$M$enu</a>" },
    { "Wt::WText","<a href=\"CppW$T$ext.htm\">W$t::W$T$ext</a>" },
    { "Wt::WTime","<a href=\"CppW$T$ime.htm\">W$t::W$T$ime</a>" },
    { "Wt::WTree","<a href=\"CppW$T$ree.htm\">W$t::W$T$ree</a>" },
    { "WGroupBox","<a href=\"C$ppW$G$roupB$ox.htm\">W$G$roupB$ox</a>" },
    { "WResource","<a href=\"C$ppW$R$esource.htm\">W$R$esource</a>" },
    { "WStrToStr","<a href=\"C$ppW$S$trT$oS$tr.htm\">W$S$trT$oS$tr</a>" },
    { "WTextArea","<a href=\"C$ppW$T$extA$rea.htm\">W$T$extA$rea</a>" },
    { "WtWebsite","<a href=\"P$rojectW$tW$ebsite.htm\">W$tW$ebsite</a>" },
    { "_function","_$f$unction" },
    { "algorithm","<a href=\"CppAlg$orithm.htm\">alg$orithm</a>" },
    { "ascii art","<a href=\"CppA$sciiA$rt.htm\">a$scii a$rt</a>" },
    { "assembler","<a href=\"CppA$ssembler.htm\">a$ssembler</a>" },
    { "asserting","<a href=\"CppA$ssert.htm\">a$ss$erting</a>" },
    { "automatic","aut$omatic" },
    { "character","<a href=\"CppC$har.htm\">c$haracter</a>" },
    { "cln::cl_I","<a href=\"CppCl_I.htm\">c$ln::c$l_I</a>" },
    { "compilers","<a href=\"CppC$ompiler.htm\">c$ompilers</a>" },
    { "component","<a href=\"CppC$omponent.htm\">c$omponent</a>" },
    { "constexpr","<b><a href=\"CppCo$nste$xpr.htm\">co$nste$xpr</a></b>" },
    { "construct","<a href=\"CppC$ons$tructor.htm\">c$ons$truct</a>" },
    { "container","<a href=\"CppC$ontainer.htm\">c$ontainer</a>" },
    { "debugging","<a href=\"CppD$eb$ug.htm\">d$eb$ugging</a>" },
    { "devkitARM","<a href=\"CppD$evkitArm.htm\">d$evkitARM</a>" },
    { "devkitPro","<a href=\"CppD$evkitPro.htm\">d$evkitPro</a>" },
    { "instances","<a href=\"CppIn$stance.htm\">in$stances</a>" },
    { "interface","<a href=\"CppI$nterface.htm\">in$terface</a>" },
    { "namespace","<b><a href=\"CppNa$mespace.htm\">name$space</a></b>" },
    { "numeric.h","<a href=\"CppNu$mericH.htm\">nu$meric.h</a>" },
    { "operator%","<b><a href=\"CppOp$eratorMo$dulus.htm\">op$erato$r%</a></b>" },
    { "operator*","<b><a href=\"CppOp$eratorMu$ltiply.htm\">op$erato$r*</a></b>" },
    { "operator+","<b><a href=\"CppOp$eratorPl$us.htm\">op$erato$r+</a></b>" },
    { "operator-","<b><a href=\"CppOp$eratorMi$nus.htm\">op$erato$r-</a></b>" },
    { "operator/","<b><a href=\"CppOp$eratorDi$vide.htm\">op$erato$r/</a></b>" },
    { "operators","<a href=\"CppOp$erator.htm\">ope$rators</a>" },
    { "predicate","<a href=\"CppP$redicate.htm\">p$redicate</a>" },
    { "profiling","<a href=\"CppP$rofiling.htm\">p$rofiling</a>" },
    { "protected","<b><a href=\"CppPr$otected.htm\">prot$ected</a></b>" },
    { "quicksort","<a href=\"C$ppQ$uickS$ort.htm\">q$uicks$ort</a>" },
    { "std::acos","<a href=\"C$ppA$cos.htm\">s$td::ac$os</a>" },
    { "std::asin","<a href=\"C$ppA$sin.htm\">s$td::as$in</a>" },
    { "std::atan","<a href=\"C$ppA$tan.htm\">s$td::at$an</a>" },
    { "std::atof","<a href=\"C$ppA$tof.htm\">s$td::at$of</a>" },
    { "std::atoi","<a href=\"C$ppA$toi.htm\">s$td::at$oi</a>" },
    { "std::atol","<a href=\"C$ppA$tol.htm\">s$td::at$ol</a>" },
    { "std::ceil","<a href=\"C$ppC$eil.htm\">s$td::ce$il</a>" },
    { "std::cerr","<a href=\"C$ppC$err.htm\">s$td::c$err</a>" },
    { "std::clog","<a href=\"C$ppC$log.htm\">s$td::c$log</a>" },
    { "std::copy","<a href=\"C$ppC$opy.htm\">s$td::c$o$py</a>" },
    { "std::cosh","<a href=\"C$ppC$osh.htm\">s$td::c$osh</a>" },
    { "std::cout","<a href=\"C$ppC$out.htm\">s$td::c$out</a>" },
    { "std::endl","<a href=\"C$ppE$ndl.htm\">s$td::e$ndl</a>" },
    { "std::ends","<a href=\"C$ppE$nds.htm\">s$td::e$nds</a>" },
    { "std::exit","<a href=\"C$ppE$xit.htm\">s$td::e$xit</a>" },
    { "std::fabs","<a href=\"C$ppF$abs.htm\">s$td::fa$bs</a>" },
    { "std::feof","<a href=\"C$ppF$eof.htm\">s$td::fe$of</a>" },
    { "std::fill","<a href=\"C$ppF$ill.htm\">s$td::fi$ll</a>" },
    { "std::find","<a href=\"C$ppF$ind.htm\">s$td::fi$nd</a>" },
    { "std::fmod","<a href=\"C$ppF$mod.htm\">s$td::fm$od</a>" },
    { "std::free","<a href=\"C$ppF$ree.htm\">s$td::fr$ee</a>" },
    { "std::getc","<a href=\"C$ppG$etc.htm\">s$td::ge$tc</a>" },
    { "std::gets","<a href=\"C$ppG$ets.htm\">s$td::ge$ts</a>" },
    { "std::iota","<a href=\"C$ppI$ota.htm\">s$td::io$ta</a>" },
    { "std::labs","<a href=\"C$ppL$abs.htm\">s$td::la$bs</a>" },
    { "std::ldiv","<a href=\"C$ppL$div.htm\">s$td::ld$iv</a>" },
    { "std::left","<a href=\"C$ppL$eft.htm\">s$td::le$ft</a>" },
    { "std::less","<a href=\"C$ppL$ess.htm\">s$td::l$ess</a>" },
    { "std::list","<a href=\"C$ppL$ist.htm\">s$td::li$st</a>" },
    { "std::modf","<a href=\"C$ppM$odf.htm\">s$td::mo$df</a>" },
    { "std::move","<a href=\"CppMo$ve.htm\">s$td::mo$ve</a>" },
    { "std::not1","<a href=\"CppNo$t1.htm\">s$td::n$ot1</a>" },
    { "std::not2","<a href=\"CppNo$t2.htm\">s$td::n$ot2</a>" },
    { "std::pair","<a href=\"CppPair.htm\">s$td::p$air</a>" },
    { "std::plus","<a href=\"CppPlus.htm\">s$td::p$lus</a>" },
    { "std::putc","<a href=\"CppPutc.htm\">s$td::p$utc</a>" },
    { "std::puts","<a href=\"CppPuts.htm\">s$td::p$uts</a>" },
    { "std::rand","<a href=\"CppRand.htm\">s$td::ra$nd</a>" },
    { "std::rope","<a href=\"CppRope.htm\">s$td::ro$pe</a>" },
    { "std::setw","<a href=\"CppSetw.htm\">s$td::se$tw</a>" },
    { "std::sinh","<a href=\"CppSinh.htm\">s$td::si$nh</a>" },
    { "std::sort","<a href=\"CppSo$rt.htm\">s$td::so$rt</a>" },
    { "std::sqrt","<a href=\"CppSqrt.htm\">s$td::sq$rt</a>" },
    { "std::stod","<a href=\"CppS$tod.htm\">s$td::st$od</a>" },
    { "std::stoi","<a href=\"CppS$toi.htm\">s$td::st$oi</a>" },
    { "std::swap","<a href=\"CppSw$ap.htm\">s$td::s$wap</a>" },
    { "std::tanh","<a href=\"CppTanh.htm\">s$td::ta$nh</a>" },
    { "std::time","<a href=\"CppT$ime.htm\">s$td::ti$me</a>" },
    { "std::wcto","<a href=\"CppW$cto.htm\">s$td::w$cto</a>" },
    { "templates","<a href=\"CppTe$mplate.htm\">tem$plates</a>" },
    { "therefore","therefo$re" },
    { "wtwebsite","<a href=\"P$rojectW$tW$ebsite.htm\">w$tw$ebsite</a>" },
  //8
    { "__thread","<b><a href=\"C$pp_$_T$hread.htm\">_$_t$hread</a></b>" },
    { "#include","<a href=\"CppInclude.htm\">#inc$lude</a>" },
    { ".Rotate(",".R$otate(" },
    { "Befriend","<a href=\"CppF$riend.htm\">B$ef$riend</a>" },
    { "Big four","<a href=\"C$ppB$igF$our.htm\">B$ig f$our</a>" },
    { "Big Four","<a href=\"C$ppB$igF$our.htm\">B$ig F$our</a>" },
    { "CliToInt","<a href=\"CppC$liT$oInt.htm\">C$liT$oInt</a>" },
    { "CliToStr","<a href=\"CppC$liToStr.htm\">C$liToStr</a>" },
    { "Compiler","<a href=\"CppC$ompiler.htm\">C$ompiler</a>" },
    { "Converts","<a href=\"CppC$onvert.htm\">C$onverts</a>" },
    { "CopyFile","<a href=\"CppC$opyFile.htm\">C$opyFile</a>" },
    { "CppWMenu","<a href=\"C$ppW$M$enu.htm\">C$ppW$M$enu</a>" },
    { "Deadlock","<a href=\"C$ppD$eadl$ock.htm\">D$eadl$ock</a>" },
    { "Destruct","<a href=\"C$ppD$estr$uctor.htm\">D$estr$uct</a>" },
    { "Emulator","<a href=\"CppE$mulator.htm\">E$mulator</a>" },
    { "Function","<a href=\"CppF$unction.htm\">F$unction</a>" },
    { "GetAngle","<a href=\"CppGe$tAngle.htm\">Ge$tAngle</a>" },
    { "GetEmail","<a href=\"CppG$etE$mail.htm\">G$etE$mail</a>" },
    { "GetPixel","<a href=\"CppGe$tPixel.htm\">Ge$tPixel</a>" },
    { "GetSizes","<a href=\"CppGe$tSizes.htm\">Ge$tSizes</a>" },
    { "Helgrind","<a href=\"C$ppH$elg$rind.htm\">H$elg$rind</a>" },
    { "Hello Qt","<a href=\"CppH$elloQ$t.htm\">H$ello Q$t</a>" },
    { "In_regex","<a href=\"CppI$n_regex.htm\">I$n_regex</a>" },
    { "Increase","<a href=\"CppFuncto$rIn$crease.htm\">In$crease</a>" },
    { "IntPower","<a href=\"CppIn$tPo$wer.htm\">In$tPo$wer</a>" },
    { "IntToStr","<a href=\"CppIn$tToS$tr.htm\">In$tToS$tr</a>" },
    { "Iterates","<a href=\"CppI$terator.htm\">I$terates</a>" },
    { "Iterator","<a href=\"CppI$terator.htm\">I$terator</a>" },
    { "IsDouble","<a href=\"CppI$sD$ouble.htm\">I$sD$ouble</a>" },
    { "IsNewick","<a href=\"CppIsN$ewick.htm\">I$sN$ewick</a>" },
    { "IsSorted","<a href=\"CppI$sS$orted.htm\">I$sS$orted</a>" },
    { "IsSquare","<a href=\"CppI$sS$quare.htm\">I$sS$quare</a>" },
    { "Makefile","<a href=\"CppM$akef$ile.htm\">M$akef$ile</a>" },
    { "Memcheck","<a href=\"CppM$emc$heck.htm\">M$emc$heck</a>" },
    { "Modified","Modi$fied" },
    { "Multiply","<a href=\"CppMult$iply.htm\">Mult$iply</a>" },
    { "Profiler","<a href=\"CppP$rofiler.htm\">P$rofiler</a>" },
    { "QPainter","<a href=\"CppQ$Pai$nter.htm\">Q$Pai$nter</a>" },
    { "QPointer","<a href=\"CppQ$Poi$nter.htm\">Q$Poi$nter</a>" },
    { "Question","<a href=\"C$ppQ$uestion.htm\">Q$uestion</a>" },
    { "Q_OBJECT","<a href=\"CppQ$_OBJECT.htm\">Q$_OBJECT</a>" },
    { "RAND_MAX","<a href=\"CppRA$ND_MA$X.htm\">RA$ND_MA$X</a>" },
    { "RoundOff","<a href=\"CppRo$undOff.htm\">Ro$undOff</a>" },
    { "Specific","Speci$fic" },
    { "SplitXml","<a href=\"C$ppS$plitX$ml.htm\">S$plitX$ml</a>" },
    { "StrToInt","<a href=\"CppSt$rToI$nt.htm\">St$rToI$nt</a>" },
    { "SumFirst","<a href=\"CppS$umF$irst.htm\">S$umF$irst</a>" },
    { "TestDial","<a href=\"T$oolT$estD$ial.htm\">T$estD$ial</a>" },
    { "TimePoll","<a href=\"T$oolT$imeP$oll.htm\">T$imeP$oll</a>" },
    { "ToDouble","<a href=\"CppToD$ouble.htm\">ToD$ouble</a>" },
    { "Tracin\'","<a href=\"CppT$race.htm\">T$racin\'</a>" },
    { "Trigraph","<a href=\"CppT$rig$raph.htm\">T$rig$raph</a>" },
    { "Unsigned","<a href=\"CppUn$si$gned.htm\">Un$si$gned</a>" },
    { "Wt::WPen","<a href=\"C$ppW$P$en.htm\">W$t::W$P$en</a>" },
    { "WPainter","<a href=\"CppWP$ai$nter.htm\">W$P$ai$nter</a>" },
    { "-address","-a$ddress" },
    { "__func__","<a href=\"Cpp_$_f$unc__.htm\">_$_f$unc__</a>" },
    { "_address","_a$ddress" },
    { "_default","_d$efault" },
    { "befriend","<a href=\"CppF$riend.htm\">b$ef$riend</a>" },
    { "big four","<a href=\"C$ppB$igF$our.htm\">b$ig f$our</a>" },
    { "char16_t","<b><a href=\"CppCh$ar16_t.htm\">ch$ar16_t</a></b>" },
    { "char32_t","<b><a href=\"CppCh$ar32_t.htm\">ch$ar32_t</a></b>" },
    { "compiler","<a href=\"CppC$ompiler.htm\">c$ompiler</a>" },
    { "continue","<b><a href=\"CppCo$ntinue.htm\">cont$inue</a></b>" },
    { "converts","<a href=\"CppC$onvert.htm\">c$onverts</a>" },
    { "deadlock","<a href=\"C$ppD$eadl$ock.htm\">d$eadl$ock</a>" },
    { "debuggin\'","<a href=\"CppD$eb$ug.htm\">d$eb$uggin\'</a>" },
    { "default_","d$efault_" },
    { "destruct","<a href=\"C$ppD$estr$uctor.htm\">d$estr$uct</a>" },
    { "endpoint","endp$oi$nt" },
    { "emulator","<a href=\"CppE$mulator.htm\">e$mulator</a>" },
    { "explicit","<b><a href=\"CppEx$plicit.htm\">expl$icit</a></b>" },
    { "function","<a href=\"CppF$unction.htm\">f$unction</a>" },
    { "h this p","h t$his p" },
    { "instance","<a href=\"CppIn$stance.htm\">in$stance</a>" },
    { "interval","in$terval" },
    { "iterates","<a href=\"CppI$terator.htm\">i$terates</a>" },
    { "iterator","<a href=\"CppI$terator.htm\">i$terator</a>" },
    { "makefile","<a href=\"CppM$akef$ile.htm\">m$akef$ile</a>" },
    { "memcheck","<a href=\"CppM$emc$heck.htm\">m$emc$heck</a>" },
    { "mglPoint","mglPoi$nt" },
    { "noexcept","<b><a href=\"C$ppN$oe$xcept.htm\">n$oe$xcept</a></b>" },
    { "operator","<b><a href=\"CppOp$erator.htm\">ope$rator</a></b>" },
    { "profiler","<a href=\"CppP$rofiler.htm\">p$rofiler</a>" },
    { "register","<b><a href=\"CppRe$gister.htm\">reg$ister</a></b>" },
    { "signals2","<a href=\"C$ppS$ignals2.htm\">s$ignals2</a>" },
    { "specific","speci$fic" },
    { "std::abs","<a href=\"CppAb$s.htm\">s$td::a$bs</a>" },
    { "std::cin","<a href=\"CppCi$n.htm\">s$td::c$in</a>" },
    { "std::cos","<a href=\"CppCo$s.htm\">s$td::c$os</a>" },
    { "std::dec","<a href=\"CppDe$c.htm\">s$td::d$ec</a>" },
    { "std::div","<a href=\"CppDi$v.htm\">s$td::d$iv</a>" },
    { "std::exp","<a href=\"CppE$xp.htm\">s$td::e$xp</a>" },
    { "std::get","<a href=\"CppG$et.htm\">s$td::g$et</a>" },
    { "std::hex","<a href=\"CppH$ex.htm\">s$td::h$ex</a>" },
    { "std::log","<a href=\"CppL$og.htm\">s$td::l$og</a>" },
    { "std::map","<a href=\"CppMa$p.htm\">s$td::m$ap</a>" },
    { "std::max","<a href=\"CppMa$x.htm\">s$td::m$ax</a>" },
    { "std::min","<a href=\"CppMi$n.htm\">s$td::m$in</a>" },
    { "std::not","<a href=\"CppNo$t.htm\">s$td::n$ot</a>" },
    { "std::oct","<a href=\"CppOc$t.htm\">s$td::oc$t</a>" },
    { "std::pow","<a href=\"CppPo$w.htm\">s$td::p$ow</a>" },
    { "std::ref","<a href=\"C$ppR$ef.htm\">st$d::r$ef</a>" },
    { "std::set","<a href=\"CppSe$t.htm\">s$td::s$et</a>" },
    { "std::sin","<a href=\"CppSi$n.htm\">s$td::s$in</a>" },
    { "std::tan","<a href=\"CppTa$n.htm\">s$td::ta$n</a>" },
    { "std::tr1","<a href=\"CppTr$1.htm\">s$td::t$r1</a>" },
    { "template","<b><a href=\"CppTe$mplate.htm\">tem$plate</a></b>" },
    { "tracin\'","<a href=\"CppT$race.htm\">t$racin\'</a>" },
    { "trigraph","<a href=\"CppT$rig$raph.htm\">t$rig$raph</a>" },
    { "typename","<b><a href=\"CppTy$pename.htm\">typ$ename</a></b>" },
    { "unsigned","<b><a href=\"CppUn$si$gned.htm\">un$si$gned</a></b>" },
    { "volatile","<b><a href=\"CppVo$latile.htm\">vol$atile</a></b>" },
  //7
    { "#define","<a href=\"CppDefine.htm\">#de$fine</a>" },
    { "#ifndef","<a href=\"CppIfndef.htm\">#i$fndef</a>" },
    { "#pragma","<a href=\"CppPragma.htm\">#$pragma</a>" },
    { "Address","<a href=\"CppAd$dress.htm\">Ad$dress</a>" },
    { "Android","<a href=\"CppA$ndroid.htm\">A$ndroid</a>" },
    { "CanCast","<a href=\"CppCa$nCast.htm\">Ca$nCast</a>" },
    { "Carbide","<a href=\"CppC$arbideC$pp.htm\">C$arbide</a>" },
    { "Compile","<a href=\"CppC$ompile.htm\">C$ompile</a>" },
    { "Convert","<a href=\"CppC$onvert.htm\">C$onvert</a>" },
    { "Counter","<a href=\"C$ppC$ounter.htm\">C$ounter</a>" },
    { "Emitted","<a href=\"CppE$mit.htm\">E$mitted</a>" },
    { "GetMean","<a href=\"CppG$etMean.htm\">G$etMean</a>" },
    { "GetPath","<a href=\"CppG$etPath.htm\">G$etPath</a>" },
    { "GetTime","<a href=\"CppG$etT$ime.htm\">G$etT$ime</a>" },
    { "HelloQt","<a href=\"CppH$elloQ$t.htm\">H$elloQ$t</a>" },
    { "Integer","<a href=\"CppIn$t.htm\">I$nteger</a>" },
    { "IsPrime","<a href=\"CppI$sPrime.htm\">I$s$Prime</a>" },
    { "Iterate","<a href=\"CppI$terator.htm\">I$terate</a>" },
    { "Library","<a href=\"CppL$ibrary.htm\">L$ibrary</a>" },
    { "MakeAbs","<a href=\"CppM$akeA$bs.htm\">M$akeA$bs</a>" },
    { "Ndsmake","<a href=\"CppN$dsm$ake.htm\">N$dsm$ake</a>" },
    { "NewickV","N$ewickV" },
    { "Nrand48","<a href=\"CppN$r$and48.htm\">N$r$and48</a>" },
    { "Pointer","<a href=\"CppPo$in$ter.htm\">Poi$nter</a>" },
    { "Product","<a href=\"CppPr$oduct.htm\">Pr$oduct</a>" },
    { "QBitmap","<a href=\"CppQB$itmap.htm\">QB$itmap</a>" },
    { "QCanvas","<a href=\"CppQC$anvas.htm\">QC$anvas</a>" },
    { "QDialog","<a href=\"CppQD$ialog.htm\">QD$ialog</a>" },
    { "QLayout","<a href=\"CppQL$ayout.htm\">QL$ayout</a>" },
    { "QObject","<a href=\"CppQ$Object.htm\">Q$Object</a>" },
    { "QPixmap","<a href=\"CppQ$Pixm$ap.htm\">Q$Pixm$ap</a>" },
    { "QPointF","<a href=\"CppQPoi$ntF.htm\">QPoi$ntF</a>" },
    { "QString","<a href=\"CppQS$tring.htm\">QS$tring</a>" },
    { "QWidget","<a href=\"CppQ$Widg$et.htm\">Q$Widg$et</a>" },
    { "Symbian","<a href=\"CppS$ymbian.htm\">S$ymbian</a>" },
    { "TestLed","<a href=\"T$oolT$estL$ed.htm\">T$estL$ed</a>" },
    { "Tracing","<a href=\"CppT$race.htm\">T$racing</a>" },
    { "Version","<a href=\"CppV$ersion.htm\">V$ersion</a>" },
    { "Windows","<a href=\"CppW$ind$ows.htm\">W$ind$ows</a>" },
    { "WObject","<a href=\"CppW$O$bject.htm\">W$O$bject</a>" },
    { "WServer","<a href=\"CppW$S$erver.htm\">W$S$erver</a>" },
    { "WSlider","<a href=\"CppW$S$lider.htm\">W$Slider</a>" },
    { "WWidget","<a href=\"CppW$W$idget.htm\">W$W$idget</a>" },
    { "_delete","_d$elete" },
    { "_signal","_s$ignal" },
    { "_struct","_s$truct" },
    { "address","<a href=\"CppAd$dress.htm\">ad$dress</a>" },
    { "adelete","ad$elete" },
    { "asignal","as$ignal" },
    { "astruct","as$truct" },
    { "bdelete","bd$elete" },
    { "bsignal","bs$ignal" },
    { "bstruct","bs$truct" },
    { "cdelete","cd$elete" },
    { "classes","<b><a href=\"CppCl$ass.htm\">cl$asses</a></b>" },
    { "compile","<a href=\"CppC$ompile.htm\">c$ompile</a>" },
    { "convert","<a href=\"CppC$onvert.htm\">c$onvert</a>" },
    { "country","count$ry" },
    { "csignal","cs$ignal" },
    { "cstruct","cs$truct" },
    { "ddelete","dd$elete" },
    { "default","<b><a href=\"CppDe$fault.htm\">defa$ult</a></b>" },
    { "delete_","d$elete_" },
    { "deletea","d$eletea" },
    { "deleteb","d$eleteb" },
    { "deletec","d$eletec" },
    { "deleted","d$eleted" },
    { "deletee","d$eletee" },
    { "deletef","d$eletef" },
    { "deleteg","d$eleteg" },
    { "deleteh","d$eleteh" },
    { "deletei","d$eletei" },
    { "deletej","d$eletej" },
    { "deletek","d$eletek" },
    { "deletel","d$eletel" },
    { "deletem","d$eletem" },
    { "deleten","d$eleten" },
    { "deleteo","d$eleteo" },
    { "deletep","d$eletep" },
    { "deleteq","d$eleteq" },
    { "deleter","d$eleter" },
    { "deletes","d$eletes" },
    { "deletet","d$eletet" },
    { "deleteu","d$eleteu" },
    { "deletev","d$eletev" },
    { "deletew","d$eletew" },
    { "deletex","d$eletex" },
    { "deletey","d$eletey" },
    { "deletez","d$eletez" },
    { "dsignal","ds$ignal" },
    { "dstruct","ds$truct" },
    { "e for m","e f$or m" },
    { "edelete","ed$elete" },
    { "emitted","<a href=\"CppE$mit.htm\">e$mitted</a>" },
    { "esignal","es$ignal" },
    { "estruct","es$truct" },
    { "fdelete","fd$elete" },
    { "foreach","<a href=\"CppB$OOST_FOREACH.htm\">f$oreach</a>" },
    { "freedom","freed$om" },
    { "fsignal","fs$ignal" },
    { "fstruct","fs$truct" },
    { "gdelete","gd$elete" },
    { "gsignal","gs$ignal" },
    { "gstruct","gs$truct" },
    { "hdelete","hd$elete" },
    { "hsignal","hs$ignal" },
    { "hstruct","hs$truct" },
    { "http://","http:/$/$" },
    { "idelete","id$elete" },
    { "integer","<a href=\"CppIn$t.htm\">i$nteger</a>" },
    { "isignal","is$ignal" },
    { "istruct","is$truct" },
    { "iterate","<a href=\"CppI$terator.htm\">i$terate</a>" },
    { "jdelete","jd$elete" },
    { "jsignal","js$ignal" },
    { "jstruct","js$truct" },
    { "kdelete","kd$elete" },
    { "ksignal","ks$ignal" },
    { "kstruct","ks$truct" },
    { "ldelete","ld$elete" },
    { "library","<a href=\"CppL$ibrary.htm\">l$ibrary</a>" },
    { "lsignal","ls$ignal" },
    { "lstruct","ls$truct" },
    { "mdelete","md$elete" },
    { "msignal","ms$ignal" },
    { "mstruct","ms$truct" },
    { "mutable","<b><a href=\"CppMu$table.htm\">mut$able</a></b>" },
    { "ndelete","nd$elete" },
    { "ndsmake","<a href=\"T$oolN$dsm$ake.htm\">n$dsm$ake</a>" },
    { "nrand48","<a href=\"CppN$r$and48.htm\">n$r$and48</a>" },
    { "nsignal","ns$ignal" },
    { "nstruct","ns$truct" },
    { "nullptr","<b><a href=\"CppN$ullp$tr.htm\">n$ullp$tr</a></b>" },
    { "odelete","od$elete" },
    { "osignal","os$ignal" },
    { "ostruct","os$truct" },
    { "painter","pain$ter" },
    { "pdelete","pd$elete" },
    { "perform","perfo$rm" },
    { "pointer","<a href=\"CppPo$in$ter.htm\">poi$nter</a>" },
    { "private","<b><a href=\"CppPr$ivate.htm\">pri$vate</a></b>" },
    { "psignal","ps$ignal" },
    { "pstruct","ps$truct" },
    { "qdelete","qd$elete" },
    { "qsignal","qs$ignal" },
    { "qstruct","qs$truct" },
    { "rdelete","rd$elete" },
    { "returns","<a href=\"CppR$eturn.htm\">r$eturns</a>" },
    { "rsignal","rs$ignal" },
    { "rstruct","rs$truct" },
    { "sdelete","sd$elete" },
    { "signal_","s$ignal_" },
    { "signala","s$ignala" },
    { "signalb","s$ignalb" },
    { "signalc","s$ignalc" },
    { "signald","s$ignald" },
    { "signale","s$ignale" },
    { "signalf","s$ignalf" },
    { "signalg","s$ignalg" },
    { "signalh","s$ignalh" },
    { "signali","s$ignali" },
    { "signalj","s$ignalj" },
    { "signalk","s$ignalk" },
    { "signall","s$ignall" },
    { "signalm","s$ignalm" },
    { "signaln","s$ignaln" },
    { "signalo","s$ignalo" },
    { "signalp","s$ignalp" },
    { "signalq","s$ignalq" },
    { "signalr","s$ignalr" },
    { "signals","<b><a href=\"CppQ$tS$ignals.htm\">s$ignals</a></b>" },
    { "signalt","s$ignalt" },
    { "signalu","s$ignalu" },
    { "signalv","s$ignalv" },
    { "signalw","s$ignalw" },
    { "signalx","s$ignalx" },
    { "signaly","s$ignaly" },
    { "signalz","s$ignalz" },
    { "sprintf","<a href=\"CppS$pri$ntf.htm\">spri$ntf</a>" },
    { "ssignal","ss$ignal" },
    { "sstruct","ss$truct" },
    { "std::tm","<a href=\"CppTm.htm\">s$td::t$m</a>" },
    { "std::ws","<a href=\"CppWs.htm\">s$td::w$s</a>" },
    { "strncat","<a href=\"CppStrncat.htm\">st$rncat</a>" },
    { "struct_","s$truct_" },
    { "structa","s$tructa" },
    { "structb","s$tructb" },
    { "structc","s$tructc" },
    { "structd","s$tructd" },
    { "structe","s$tructe" },
    { "structf","s$tructf" },
    { "structg","s$tructg" },
    { "structh","s$tructh" },
    { "structi","s$tructi" },
    { "structj","s$tructj" },
    { "structk","s$tructk" },
    { "structl","s$tructl" },
    { "structm","s$tructm" },
    { "structn","s$tructn" },
    { "structo","s$tructo" },
    { "structp","s$tructp" },
    { "structq","s$tructq" },
    { "structr","s$tructr" },
    { "structs","s$tructs" },
    { "structt","s$tructt" },
    { "structu","s$tructu" },
    { "structv","s$tructv" },
    { "structw","s$tructw" },
    { "structx","s$tructx" },
    { "structy","s$tructy" },
    { "structz","s$tructz" },
    { "tdelete","td$elete" },
    { "tribool","<a href=\"C$ppT$rib$ool.htm\">t$rib$ool</a>" },
    { "tsignal","ts$ignal" },
    { "tstruct","ts$truct" },
    { "typedef","<b><a href=\"CppTy$pedef.htm\">typ$edef</a></b>" },
    { "udelete","ud$elete" },
    { "usignal","us$ignal" },
    { "ustruct","us$truct" },
    { "vdelete","vd$elete" },
    { "version","<a href=\"CppV$ersion.htm\">v$ersion</a>" },
    { "virtual","<b><a href=\"CppVi$rtual.htm\">vir$tual</a></b>" },
    { "vsignal","vs$ignal" },
    { "vstruct","vs$truct" },
    { "wchar_t","<b><a href=\"CppWc$har_t.htm\">wc$har_t</a></b>" },
    { "wdelete","wd$elete" },
    { "wsignal","ws$ignal" },
    { "wstruct","ws$truct" },
    { "xdelete","xd$elete" },
    { "xsignal","xs$ignal" },
    { "xstruct","xs$truct" },
    { "ydelete","yd$elete" },
    { "ysignal","ys$ignal" },
    { "ystruct","ys$truct" },
    { "zdelete","zd$elete" },
    { "zsignal","zs$ignal" },
    { "zstruct","zs$truct" },
  //6
    { "#endif","<a href=\"CppEn$di$f.htm\">#e$ndi$f</a>" },
    { "#ifdef","<a href=\"CppIfdef.htm\">#i$fd$ef</a>" },
    { "#undef","<a href=\"CppUndef.htm\">#u$nd$ef</a>" },
    { "AddOne","<a href=\"C$ppAd$dOne.htm\">Ad$dOne</a>" },
    { "AddTwo","<a href=\"C$ppAd$dTwo.htm\">Ad$dTwo</a>" },
    { "Append","<a href=\"C$ppApp$end.htm\">App$end</a>" },
    { "Cygwin","<a href=\"C$ppC$ygwin.htm\">C$ygwin</a>" },
    { "Double","<a href=\"C$ppDo$uble.htm\">D$ouble</a>" },
    { "GetAbs","<a href=\"C$ppGe$tA$bs.htm\">Ge$tA$bs</a>" },
    { "GetSum","<a href=\"C$ppGe$tS$um.htm\">Ge$tS$um</a>" },
    { "Gossip","<a href=\"C$ppG$ossip.htm\">G$ossip</a>" },
    { "Inform","Inf$orm" },
    { "Linker","<a href=\"CppL$inker.htm\">L$inker</a>" },
    { "Memory","<a href=\"CppMe$mory.htm\">Me$mory</a>" },
    { "Modify","Modi$fy" },
    { "NDEBUG","<a href=\"CppND$EBUG.htm\">ND$EBUG</a>" },
    { "Newick","<a href=\"CppN$ewick.htm\">N$ewick</a>" },
    { "QColor","<a href=\"CppQC$olor.htm\">QC$olor</a>" },
    { "QEvent","<a href=\"CppQ$Ev$ent.htm\">Q$Ev$ent</a>" },
    { "QImage","<a href=\"CppQIm$age.htm\">QIm$age</a>" },
    { "QLabel","<a href=\"CppQ$La$bel.htm\">Q$La$bel</a>" },
    { "QPoint","<a href=\"CppQPoi$nt.htm\">QPoi$nt</a>" },
    { "QTimer","<a href=\"CppQ$Ti$mer.htm\">Q$Ti$mer</a>" },
    { "Random","Rand$om" },
    { "Rotate","<a href=\"C$ppR$otate.htm\">R$otate</a>" },
    { "SIGNAL","<a href=\"C$ppS$IGNAL.htm\">S$IGNAL</a>" },
    { "Signal","<a href=\"C$ppS$ignal.htm\">S$ignal</a>" },
    { "TColor","TC$olor" },
    { "Thread","<a href=\"C$ppT$hread.htm\">T$hread</a>" },
    { "TImage","<a href=\"CppTI$mage.htm\">TI$mage</a>" },
    { "TPoint","TPoi$nt" },
    { "Triple","<a href=\"CppTr$iple.htm\">Tr$iple</a>" },
    { "Ubuntu","<a href=\"CppU$buntu.htm\">U$buntu</a>" },
    { "Uint16","Ui$nt16" },
    { "WBreak","<a href=\"C$ppW$B$reak.htm\">W$B$reak</a>" },
    { "WEvent","<a href=\"C$ppW$E$vent.htm\">W$E$vent</a>" },
    { "Window","Wind$ow" },
    { "WImage","<a href=\"CppW$I$mage.htm\">W$I$mage</a>" },
    { "WLabel","<a href=\"CppW$L$abel.htm\">W$L$abel</a>" },
    { "WTimer","<a href=\"CppW$T$imer.htm\">W$T$imer</a>" },
    { "_about","_a$bout" },
    { "_class","_c$lass" },
    { "_const","_c$onst" },
    { "_float","_f$loat" },
    { "_mutex","_m$utex" },
    { "_short","_s$hort" },
    { "about_","a$bout_" },
    { "aconst","ac$onst" },
    { "afloat","af$loat" },
    { "ashort","as$hort" },
    { "bconst","bc$onst" },
    { "before","befo$re" },
    { "bfloat","bf$loat" },
    { "bshort","bs$hort" },
    { "cconst","cc$onst" },
    { "cfloat","cf$loat" },
    { "chrono","<a href=\"CppC$hrono.htm\">c$hrono</a>" },
    { "classi","c$lassi" },
    { "const_","c$onst_" },
    { "consta","c$onsta" },
    { "constb","c$onstb" },
    { "constc","c$onstc" },
    { "constd","c$ons$td" },
    { "conste","c$onste" },
    { "constf","c$onstf" },
    { "constg","c$onstg" },
    { "consth","c$onsth" },
    { "consti","c$onsti" },
    { "constj","c$onstj" },
    { "constk","c$onstk" },
    { "constl","c$onstl" },
    { "constm","c$onstm" },
    { "constn","c$onstn" },
    { "consto","c$onsto" },
    { "constp","c$onstp" },
    { "constq","c$onstq" },
    { "constr","c$onstr" },
    { "consts","c$onsts" },
    { "constt","c$onstt" },
    { "constu","c$onstu" },
    { "constv","c$onstv" },
    { "constw","c$onstw" },
    { "constx","c$onstx" },
    { "consty","c$onsty" },
    { "constz","c$onstz" },
    { "cshort","cs$hort" },
    { "dconst","dc$onst" },
    { "delete","<b><a href=\"CppDe$lete.htm\">del$ete</a></b>" },
    { "dfloat","df$loat" },
    { "differ","di$ffer" },
    { "double","<b><a href=\"CppDo$uble.htm\">d$o$uble</a></b>" },
    { "dshort","ds$hort" },
    { "econst","ec$onst" },
    { "efloat","ef$loat" },
    { "eshort","es$hort" },
    { "export","<b><a href=\"CppEx$port.htm\">ex$port</a></b>" },
    { "extern","<b><a href=\"CppEx$tern.htm\">ext$ern</a></b>" },
    { "fconst","fc$onst" },
    { "ffloat","ff$loat" },
    { "float_","f$loat_" },
    { "floata","f$loata" },
    { "floatb","f$loatb" },
    { "floatc","f$loatc" },
    { "floatd","f$loatd" },
    { "floate","f$loate" },
    { "floatf","f$loatf" },
    { "floatg","f$loatg" },
    { "floath","f$loath" },
    { "floati","f$loati" },
    { "floatj","f$loatj" },
    { "floatk","f$loatk" },
    { "floatl","f$loatl" },
    { "floatm","f$loatm" },
    { "floatn","f$loatn" },
    { "floato","f$loato" },
    { "floatp","f$loatp" },
    { "floatq","f$loatq" },
    { "floatr","f$loatr" },
    { "floats","f$loats" },
    { "floatt","f$loatt" },
    { "floatu","f$loatu" },
    { "floatv","f$loatv" },
    { "floatw","f$loatw" },
    { "floatx","f$loatx" },
    { "floaty","f$loaty" },
    { "floatz","f$loatz" },
    { "format","fo$rmat" },
    { "friend","<b><a href=\"CppFr$iend.htm\">fri$end</a></b>" },
    { "fshort","fs$hort" },
    { "gconst","gc$onst" },
    { "gfloat","gf$loat" },
    { "gshort","gs$hort" },
    { "hconst","hc$onst" },
    { "hfloat","hf$loat" },
    { "hshort","hs$hort" },
    { "iconst","ic$onst" },
    { "ifloat","i$f$loat" },
    { "inline","<b><a href=\"CppIn$line.htm\">in$l$ine</a></b>" },
    { "ishort","is$hort" },
    { "jconst","jc$onst" },
    { "jfloat","jf$loat" },
    { "jshort","js$hort" },
    { "kconst","kc$onst" },
    { "kfloat","kf$loat" },
    { "kshort","ks$hort" },
    { "lconst","lc$onst" },
    { "lfloat","lf$loat" },
    { "libnds","<a href=\"CppLibnds.htm\">l$ibnds</a>" },
    { "linker","<a href=\"CppL$inker.htm\">l$inker</a>" },
    { "lshort","ls$hort" },
    { "mconst","mc$onst" },
    { "memcpy","<a href=\"CppM$emcpy.htm\">m$emcpy</a>" },
    { "memory","<a href=\"CppMe$mory.htm\">me$mory</a>" },
    { "mfloat","mf$loat" },
    { "modify","modi$fy" },
    { "mshort","ms$hort" },
    { "nconst","nc$onst" },
    { "nfloat","nf$loat" },
    { "nshort","ns$hort" },
    { "oconst","oc$onst" },
    { "ofloat","of$loat" },
    { "oshort","os$hort" },
    { "pconst","pc$onst" },
    { "pfloat","pf$loat" },
    { "pshort","ps$hort" },
    { "public","<b><a href=\"CppPu$blic.htm\">pub$lic</a></b>" },
    { "qconst","qc$onst" },
    { "qfloat","qf$loat" },
    { "qshort","qs$hort" },
    { "random","ra$nd$om" },
    { "rconst","rc$onst" },
    { "return","<b><a href=\"CppRe$turn.htm\">ret$urn</a></b>" },
    { "rfloat","rf$loat" },
    { "rshort","rs$hort" },
    { "sconst","sc$onst" },
    { "sfloat","sf$loat" },
    { "short_","s$hort_" },
    { "shorta","s$horta" },
    { "shortb","s$hortb" },
    { "shortc","s$hortc" },
    { "shortd","s$hortd" },
    { "shorte","s$horte" },
    { "shortf","s$hortf" },
    { "shortg","s$hortg" },
    { "shorth","s$horth" },
    { "shorti","s$horti" },
    { "shortj","s$hortj" },
    { "shortk","s$hortk" },
    { "shortl","s$hortl" },
    { "shortm","s$hortm" },
    { "shortn","s$hortn" },
    { "shorto","s$horto" },
    { "shortp","s$hortp" },
    { "shortq","s$hortq" },
    { "shortr","s$hortr" },
    { "shorts","s$horts" },
    { "shortt","s$hortt" },
    { "shortu","s$hortu" },
    { "shortv","s$hortv" },
    { "shortw","s$hortw" },
    { "shortx","s$hortx" },
    { "shorty","s$horty" },
    { "shortz","s$hortz" },
    { "signal","<a href=\"CppS$ignal.htm\">s$ignal</a>" },
    { "signed","<b><a href=\"CppSi$gned.htm\">si$gned</a></b>" },
    { "size_t","<b><a href=\"CppSi$ze_t.htm\">si$ze_t</a></b>" },
    { "sizeof","<b><a href=\"CppSi$zeof.htm\">si$zeof</a></b>" },
    { "sshort","ss$hort" },
    { "static","<b><a href=\"CppSt$atic.htm\">sta$tic</a></b>" },
    { "stdDev","st$dDev" },
    { "stddev","st$ddev" },
    { "strlen","<a href=\"CppS$trlen.htm\">s$trlen</a>" },
    { "struct","<b><a href=\"CppSt$ruct.htm\">str$uct</a></b>" },
    { "switch","<b><a href=\"CppSw$itch.htm\">swi$tch</a></b>" },
    { "tAbout","tA$bout" },
    { "tconst","tc$onst" },
    { "tfloat","tf$loat" },
    { "thread","<a href=\"C$ppT$hread.htm\">t$hread</a>" },
    { "tshort","ts$hort" },
    { "typeid","<b><a href=\"CppTy$peid.htm\">typ$eid</a></b>" },
    { "uconst","uc$onst" },
    { "ufloat","uf$loat" },
    { "ushort","us$hort" },
    { "vconst","vc$onst" },
    { "vfloat","vf$loat" },
    { "vshort","vs$hort" },
    { "wconst","wc$onst" },
    { "wfloat","wf$loat" },
    { "window","wind$ow" },
    { "wshort","ws$hort" },
    { "xconst","xc$onst" },
    { "xfloat","xf$loat" },
    { "xshort","xs$hort" },
    { "yconst","yc$onst" },
    { "yfloat","yf$loat" },
    { "yshort","ys$hort" },
    { "zconst","zc$onst" },
    { "zfloat","zf$loat" },
    { "zshort","zs$hort" },
  //5
    { "#else","<a href=\"CppPreElse.htm\">#el$se</a>" },
    { "Avoid","Av$oid" },
    { "Boost","<a href=\"CppB$oost.htm\">Bo$ost</a>" },
    { "C++0x","<a href=\"Cpp0x.htm\">C$+$+0x</a>" },
    { "C++98","<a href=\"Cpp98.htm\">C$+$+98</a>" },
    { "ChatA","C$hatA" },
    { "ChatB","C$hatB" },
    { "ChatC","C$hatC" },
    { "ChatD","C$hatD" },
    { "ChatE","C$hatE" },
    { "ChatF","C$hatF" },
    { "ChatG","C$hatG" },
    { "ChatH","C$hatH" },
    { "ChatI","C$hatI" },
    { "ChatJ","C$hatJ" },
    { "ChatK","C$hatK" },
    { "ChatL","C$hatL" },
    { "ChatM","C$hatM" },
    { "ChatN","C$hatN" },
    { "ChatO","C$hatO" },
    { "ChatP","C$hatP" },
    { "ChatQ","C$hatQ" },
    { "ChatR","C$hatR" },
    { "ChatS","C$hatS" },
    { "ChatT","C$hatT" },
    { "ChatU","C$hatU" },
    { "ChatV","C$hatV" },
    { "ChatW","C$hatW" },
    { "ChatX","C$hatX" },
    { "ChatY","C$hatY" },
    { "ChatZ","C$hatZ" },
    { "Chata","C$hata" },
    { "Chatb","C$hatb" },
    { "Chatc","C$hatc" },
    { "Chatd","C$hatd" },
    { "Chate","C$hate" },
    { "Chatf","C$hatf" },
    { "Chatg","C$hatg" },
    { "Chath","C$hath" },
    { "Chati","C$hati" },
    { "Chatj","C$hatj" },
    { "Chatk","C$hatk" },
    { "Chatl","C$hatl" },
    { "Chatm","C$hatm" },
    { "Chatn","C$hatn" },
    { "Chato","C$hato" },
    { "Chatp","C$hatp" },
    { "Chatq","C$hatq" },
    { "Chatr","C$hatr" },
    { "Chats","C$hats" },
    { "Chatt","C$hatt" },
    { "Chatu","C$hatu" },
    { "Chatv","C$hatv" },
    { "Chatw","C$hatw" },
    { "Chatx","C$hatx" },
    { "Chaty","C$haty" },
    { "Chatz","C$hatz" },
    { "Debug","<a href=\"CppD$eb$ug.htm\">D$eb$ug</a>" },
    { "Dial_","D$ial_" },
    { "Diala","D$iala" },
    { "Dialb","D$ialb" },
    { "Dialc","D$ialc" },
    { "Diald","D$iald" },
    { "Diale","D$iale" },
    { "Dialf","D$ialf" },
    { "Dialg","D$ialg" },
    { "Dialh","D$ialh" },
    { "Diali","D$iali" },
    { "Dialj","D$ialj" },
    { "Dialk","D$ialk" },
    { "Diall","D$iall" },
    { "Dialm","D$ialm" },
    { "Dialn","D$ialn" },
    { "Dialo","D$ialo" },
    { "Dialp","D$ialp" },
    { "Dialq","D$ialq" },
    { "Dialr","D$ialr" },
    { "Dials","D$ials" },
    { "Dialt","D$ialt" },
    { "Dialu","D$ialu" },
    { "Dialv","D$ialv" },
    { "Dialw","D$ialw" },
    { "Dialx","D$ialx" },
    { "Dialy","D$ialy" },
    { "Dialz","D$ialz" },
    { "Emit_","E$mit_" },
    { "Emita","E$mita" },
    { "Emitb","E$mitb" },
    { "Emitc","E$mitc" },
    { "Emitd","E$mitd" },
    { "Emite","E$mite" },
    { "Emitf","E$mitf" },
    { "Emitg","E$mitg" },
    { "Emith","E$mith" },
    { "Emiti","E$miti" },
    { "Emitj","E$mitj" },
    { "Emitk","E$mitk" },
    { "Emitl","E$mitl" },
    { "Emitm","E$mitm" },
    { "Emitn","E$mitn" },
    { "Emito","E$mito" },
    { "Emitp","E$mitp" },
    { "Emitq","E$mitq" },
    { "Emitr","E$mitr" },
    { "Emits","E$mits" },
    { "Emitt","E$mitt" },
    { "Emitu","E$mitu" },
    { "Emitv","E$mitv" },
    { "Emitw","E$mitw" },
    { "Emitx","E$mitx" },
    { "Emity","E$mity" },
    { "Emitz","E$mitz" },
    { "Halve","<a href=\"CppHa$lve.htm\">Ha$lve</a>" },
    { "IsInt","<a href=\"CppI$sInt.htm\">I$sInt</a>" },
    { "Linux","<a href=\"CppL$inux.htm\">L$inux</a>" },
    { "Maemo","<a href=\"CppM$aemo.htm\">M$aemo</a>" },
    { "Paint","<a href=\"CppP$ai$nt.htm\">P$ai$nt</a>" },
    { "Pause","<a href=\"T$oolP$ause.htm\">P$ause</a>" },
    { "Point","<a href=\"CppPo$in$ter.htm\">Poi$nt</a>" },
    { "Pylos","<a href=\"CppP$ylos.htm\">P$ylos</a>" },
    { "QFile","<a href=\"C$ppQ$F$ile.htm\">Q$F$ile</a>" },
    { "QRect","<a href=\"CppQR$ect.htm\">QR$ect</a>" },
    { "Regex","<a href=\"CppR$egex.htm\">R$egex</a>" },
    { "Scope","<a href=\"CppS$cope.htm\">S$cope</a>" },
    { "Shift","Shi$ft" },
    { "State","<a href=\"C$ppS$tate.htm\">S$tate</a>" },
    { "ToInt","<a href=\"CppT$oI$nt.htm\">T$oI$nt</a>" },
    { "WMenu","<a href=\"CppW$M$enu.htm\">W$M$enu</a>" },
    { "WText","<a href=\"CppW$T$ext.htm\">W$T$ext</a>" },
    { ">=","<a href=\"CppOperatorGreaterEqual.htm\">>$=</a>" },
    { "<=","<a href=\"CppOperatorLessEqual.htm\"><$=</a>" },
    { "_Dial","_D$ial" },
    { "_dial","_d$ial" },
    { "_emit","_e$mit" },
    { "_long","_l$ong" },
    { "_main","_m$ain" },
    { "_this","_t$his" },
    { "aDial","aD$ial" },
    { "adial","ad$ial" },
    { "aemit","ae$mit" },
    { "along","al$ong" },
    { "amain","am$ain" },
    { "avoid","av$oid" },
    { "bDial","bD$ial" },
    { "bdial","bd$ial" },
    { "bemit","be$mit" },
    { "blong","bl$ong" },
    { "bmain","bm$ain" },
    { "boost","<a href=\"CppB$oost.htm\">bo$ost</a>" },
    { "break","<b><a href=\"CppBr$eak.htm\">br$eak</a></b>" },
    { "cDial","cD$ial" },
    { "catch","<b><a href=\"CppCa$tch.htm\">ca$tch</a></b>" },
    { "cdial","cd$ial" },
    { "cemit","ce$mit" },
    { "char_","c$har_" },
    { "chat_","c$hat_" },
    { "chatt","c$hatt" },
    { "class","<b><a href=\"CppCl$ass.htm\">cl$ass</a></b>" },
    { "cln::","<a href=\"CppCln.htm\">c$ln</a>::" },
    { "clong","cl$ong" },
    { "cmain","cm$ain" },
    { "const","<b><a href=\"CppCo$nst.htm\">co$nst</a></b>" },
    { "dDial","dD$ial" },
    { "ddial","dd$ial" },
    { "debug","<a href=\"CppD$eb$ug.htm\">d$eb$ug</a>" },
    { "demit","de$mit" },
    { "dial_","d$ial_" },
    { "diala","d$iala" },
    { "dialb","d$ialb" },
    { "dialc","d$ialc" },
    { "diald","d$iald" },
    { "diale","d$iale" },
    { "dialf","d$ialf" },
    { "dialg","d$ialg" },
    { "dialh","d$ialh" },
    { "diali","d$iali" },
    { "dialj","d$ialj" },
    { "dialk","d$ialk" },
    { "diall","d$iall" },
    { "dialm","d$ialm" },
    { "dialn","d$ialn" },
    { "dialp","d$ialp" },
    { "dialq","d$ialq" },
    { "dialr","d$ialr" },
    { "dials","d$ials" },
    { "dialt","d$ialt" },
    { "dialu","d$ialu" },
    { "dialv","d$ialv" },
    { "dialw","d$ialw" },
    { "dialx","d$ialx" },
    { "dialy","d$ialy" },
    { "dialz","d$ialz" },
    { "dlong","dl$ong" },
    { "dmain","dm$ain" },
    { "eDial","eD$ial" },
    { "edial","ed$ial" },
    { "eemit","ee$mit" },
    { "elong","el$ong" },
    { "emain","em$ain" },
    { "emit_","e$mit_" },
    { "emita","e$mita" },
    { "emitb","e$mitb" },
    { "emitc","e$mitc" },
    { "emitd","e$mitd" },
    { "emite","e$mite" },
    { "emitf","e$mitf" },
    { "emitg","e$mitg" },
    { "emith","e$mith" },
    { "emiti","e$miti" },
    { "emitj","e$mitj" },
    { "emitk","e$mitk" },
    { "emitl","e$mitl" },
    { "emitm","e$mitm" },
    { "emitn","e$mitn" },
    { "emito","e$mito" },
    { "emitp","e$mitp" },
    { "emitq","e$mitq" },
    { "emitr","e$mitr" },
    { "emits","e$mits" },
    { "emitt","e$mitt" },
    { "emitu","e$mitu" },
    { "emitv","e$mitv" },
    { "emitw","e$mitw" },
    { "emitx","e$mitx" },
    { "emity","e$mity" },
    { "emitz","e$mitz" },
    { "fDial","fD$ial" },
    { "false","<b><a href=\"CppFa$lse.htm\">fal$se</a></b>" },
    { "fdial","fd$ial" },
    { "femit","fe$mit" },
    { "float","<b><a href=\"CppFl$oat.htm\">fl$oat</a></b>" },
    { "flong","fl$ong" },
    { "fmain","fm$ain" },
    { "gDial","gD$ial" },
    { "gdial","gd$ial" },
    { "gemit","ge$mit" },
    { "glong","gl$ong" },
    { "gmain","gm$ain" },
    { "hDial","hD$ial" },
    { "hdial","hd$ial" },
    { "hemit","he$mit" },
    { "hlong","hl$ong" },
    { "hmain","hm$ain" },
    { "iDial","iD$ial" },
    { "idial","id$ial" },
    { "iemit","ie$mit" },
    { "ilong","il$ong" },
    { "imain","im$ain" },
    { "inter","i$nter" },
    { "jDial","jD$ial" },
    { "jdial","jd$ial" },
    { "jemit","je$mit" },
    { "jlong","jl$ong" },
    { "jmain","jm$ain" },
    { "kDial","kD$ial" },
    { "kdial","kd$ial" },
    { "kemit","ke$mit" },
    { "klong","kl$ong" },
    { "kmain","km$ain" },
    { "lDial","lD$ial" },
    { "ldial","ld$ial" },
    { "lemit","le$mit" },
    { "llong","ll$ong" },
    { "lmain","lm$ain" },
    { "long_","l$ong_" },
    { "longa","l$onga" },
    { "longb","l$ongb" },
    { "longc","l$ongc" },
    { "longd","l$ongd" },
    { "longe","l$onge" },
    { "longf","l$ongf" },
    { "longg","l$ongg" },
    { "longh","l$ongh" },
    { "longi","l$ongi" },
    { "longj","l$ongj" },
    { "longk","l$ongk" },
    { "longl","l$ongl" },
    { "longm","l$ongm" },
    { "longn","l$ongn" },
    { "longo","l$ongo" },
    { "longp","l$ongp" },
    { "longq","l$ongq" },
    { "longr","l$ongr" },
    { "longs","l$ongs" },
    { "longt","l$ongt" },
    { "longu","l$ongu" },
    { "longv","l$ongv" },
    { "longw","l$ongw" },
    { "longx","l$ongx" },
    { "longy","l$ongy" },
    { "longz","l$ongz" },
    { "mDial","mD$ial" },
    { "main_","m$ain_" },
    { "maina","m$aina" },
    { "mainb","m$ainb" },
    { "mainc","m$ainc" },
    { "maind","m$aind" },
    { "maine","m$aine" },
    { "mainf","m$ainf" },
    { "maing","m$aing" },
    { "mainh","m$ainh" },
    { "maini","m$aini" },
    { "mainj","m$ainj" },
    { "maink","m$aink" },
    { "mainl","m$ainl" },
    { "mainm","m$ainm" },
    { "mainn","m$ainn" },
    { "maino","m$aino" },
    { "mainp","m$ainp" },
    { "mainq","m$ainq" },
    { "mainr","m$ainr" },
    { "mains","m$ains" },
    { "maint","m$aint" },
    { "mainu","m$ainu" },
    { "mainv","m$ainv" },
    { "mainw","m$ainw" },
    { "mainx","m$ainx" },
    { "mainy","m$ainy" },
    { "mainz","m$ainz" },
    { "mdial","md$ial" },
    { "memit","me$mit" },
    { "mlong","ml$ong" },
    { "mmain","mm$ain" },
    { "mutex","<a href=\"CppM$utex.htm\">m$utex</a>" },
    { "nDial","nD$ial" },
    { "ndial","nd$ial" },
    { "nemit","ne$mit" },
    { "nlong","nl$ong" },
    { "nmain","nm$ain" },
    { "oDial","oD$ial" },
    { "odial","od$ial" },
    { "oemit","oe$mit" },
    { "olong","ol$ong" },
    { "omain","om$ain" },
    { "pDial","pD$ial" },
    { "paint","pai$nt" },
    { "pdial","pd$ial" },
    { "pemit","pe$mit" },
    { "plong","pl$ong" },
    { "pmain","pm$ain" },
    { "point","<a href=\"CppPo$in$ter.htm\">poi$nt</a>" },
    { "qDial","qD$ial" },
    { "qdial","qd$ial" },
    { "qemit","qe$mit" },
    { "qlong","ql$ong" },
    { "qmain","qm$ain" },
    { "rDial","rD$ial" },
    { "rdial","rd$ial" },
    { "remit","re$mit" },
    { "rlong","rl$ong" },
    { "rmain","rm$ain" },
    { "sDial","sD$ial" },
    { "scope","<a href=\"CppS$cope.htm\">s$cope</a>" },
    { "sdial","sd$ial" },
    { "semit","se$mit" },
    { "short","<b><a href=\"CppSh$ort.htm\">sh$ort</a></b>" },
    { "slong","sl$ong" },
    { "slots","<b><a href=\"CppSl$ots.htm\">sl$ots</a></b>" },
    { "smain","sm$ain" },
    { "tDial","tD$ial" },
    { "tdial","td$ial" },
    { "temit","te$mit" },
    { "throw","<b><a href=\"CppTh$row.htm\">th$row</a></b>" },
    { "tlong","tl$ong" },
    { "tmain","tm$ain" },
    { "tools","<a href=\"T$ools.htm\">t$ools</a>" },
    { "tuple","<a href=\"CppT$uple.htm\">t$uple</a>" },
    { "uDial","uD$ial" },
    { "udial","ud$ial" },
    { "uemit","ue$mit" },
    { "ulong","ul$ong" },
    { "umain","um$ain" },
    { "union","<b><a href=\"CppUn$ion.htm\">un$ion</a></b>" },
    { "using","<b><a href=\"CppUs$ing.htm\">us$ing</a></b>" },
    { "vDial","vD$ial" },
    { "vdial","vd$ial" },
    { "vemit","ve$mit" },
    { "vlong","vl$ong" },
    { "vmain","vm$ain" },
    { "wDial","wD$ial" },
    { "wdial","wd$ial" },
    { "wemit","we$mit" },
    { "while","<b><a href=\"CppWh$ile.htm\">wh$ile</a></b>" },
    { "wlong","wl$ong" },
    { "wmain","wm$ain" },
    { "xDial","xD$ial" },
    { "xdial","xd$ial" },
    { "xemit","xe$mit" },
    { "xlong","xl$ong" },
    { "xmain","xm$ain" },
    { "yDial","yD$ial" },
    { "ydial","yd$ial" },
    { "yemit","ye$mit" },
    { "ylong","yl$ong" },
    { "ymain","ym$ain" },
    { "zDial","zD$ial" },
    { "zdial","zd$ial" },
    { "zemit","ze$mit" },
    { "zlong","zl$ong" },
    { "zmain","zm$ain" },
  //4
    { "Chat","<a href=\"C$ppC$hat.htm\">C$hat</a>" },
    { "Dial","<a href=\"C$ppD$ial.htm\">D$ial</a>" },
    { "Emit","<a href=\"C$ppE$mit.htm\">E$mit</a>" },
    { "Fmod","<a href=\"C$ppF$mod.htm\">Fm$od</a>" },
    { "GTST","<a href=\"P$rojectG$tst.htm\">G$TST</a>" },
    { "Led_","L$ed_" },
    { "Leda","L$eda" },
    { "Ledb","L$edb" },
    { "Ledc","L$edc" },
    { "Ledd","L$edd" },
    { "Lede","L$ede" },
    { "Ledf","L$edf" },
    { "Ledg","L$edg" },
    { "Ledh","L$edh" },
    { "Ledi","L$edi" },
    { "Ledj","L$edj" },
    { "Ledk","L$edk" },
    { "Ledl","L$edl" },
    { "Ledm","L$edm" },
    { "Ledn","L$edn" },
    { "Ledo","L$edo" },
    { "Ledp","L$edp" },
    { "Ledq","L$edq" },
    { "Ledr","L$edr" },
    { "Leds","L$eds" },
    { "Ledt","L$edt" },
    { "Ledu","L$edu" },
    { "Ledv","L$edv" },
    { "Ledw","L$edw" },
    { "Ledx","L$edx" },
    { "Ledy","L$edy" },
    { "Ledz","L$edz" },
    { "Link","<a href=\"CppL$ink.htm\">L$ink</a>" },
    { "M_PI","<a href=\"CppM$_PI.htm\">M$_PI</a>" },
    { "NULL","<a href=\"CppN$ULL.htm\">N$ULL</a>" },
    { "SLOT","<a href=\"CppS$LOT.htm\">S$LOT</a>" },
    { "Time","<a href=\"CppT$ime.htm\">T$ime</a>" },
    { "Tool","<a href=\"T$ools.htm\">T$ool</a>" },
    { "Trim","<a href=\"C$ppT$rim.htm\">T$rim</a>" },
    { "UNIX","<a href=\"CppU$nix.htm\">U$NIX</a>" },
    { "Ui::","<a href=\"CppU$i.htm\">Ui</a>::" },
    { "Wine","<a href=\"CppW$ine.htm\">W$ine</a>" },
    { "Wt::","<a href=\"CppW$t.htm\">W$t</a>::" },
    { "Led","L$ed" },
    { "_asm","_a$sm" },
    { "_for","_f$or" },
    { "_int","_i$nt" },
    { "_led","_l$ed" },
    { "_new","_n$ew" },
    { "_try","_t$ry" },
    { "aasm","aa$sm" },
    { "afor","af$or" },
    { "aint","ai$nt" },
    { "aled","al$ed" },
    { "anew","an$ew" },
    { "argc","<a href=\"CppAr$gc.htm\">ar$gc</a>" },
    { "argv","<a href=\"CppAr$gc.htm\">ar$gv</a>" },
    { "asm_","a$sm_" },
    { "asma","a$sma" },
    { "asmb","a$smb" },
    { "asmc","a$smc" },
    { "asmd","a$smd" },
    { "asme","a$sme" },
    { "asmf","a$smf" },
    { "asmg","a$smg" },
    { "asmh","a$smh" },
    { "asmi","a$smi" },
    { "asmj","a$smj" },
    { "asmk","a$smk" },
    { "asml","a$sml" },
    { "asmm","a$smm" },
    { "asmn","a$smn" },
    { "asmo","a$smo" },
    { "asmp","a$smp" },
    { "asmq","a$smq" },
    { "asmr","a$smr" },
    { "asms","a$sms" },
    { "asmt","a$smt" },
    { "asmu","a$smu" },
    { "asmv","a$smv" },
    { "asmw","a$smw" },
    { "asmx","a$smx" },
    { "asmy","a$smy" },
    { "asmz","a$smz" },
    { "atoi","<a href=\"CppA$toi.htm\">a$toi</a>" },
    { "atry","at$ry" },
    { "auto","<b><a href=\"CppAu$to.htm\">au$to</a></b>" },
    { "basm","ba$sm" },
    { "bfor","bf$or" },
    { "bint","bi$nt" },
    { "bled","bl$ed" },
    { "bnew","bn$ew" },
    { "bool","<b><a href=\"CppBo$ol.htm\">bo$ol</a></b>" },
    { "btry","bt$ry" },
    { "case","<b><a href=\"CppCa$se.htm\">ca$se</a></b>" },
    { "casm","ca$sm" },
    { "cfor","cf$or" },
    { "char","<b><a href=\"CppCh$ar.htm\">ch$ar</a></b>" },
    { "chat","<a href=\"CppC$hat.htm\">c$hat</a>" },
    { "cint","ci$nt" },
    { "cled","cl$ed" },
    { "cnew","cn$ew" },
    { "ctry","ct$ry" },
    { "dasm","da$sm" },
    { "dfor","df$or" },
    { "dint","di$nt" },
    { "dled","dl$ed" },
    { "dnew","dn$ew" },
    { "dtry","dt$ry" },
    { "easm","ea$sm" },
    { "efor","ef$or" },
    { "eint","ei$nt" },
    { "eled","el$ed" },
    { "else","<b><a href=\"CppE$lse.htm\">el$se</a></b>" },
    { "emit","<b><a href=\"CppE$mit.htm\">e$mit</a></b>" },
    { "enew","en$ew" },
    { "enum","<b><a href=\"CppE$num.htm\">en$um</a></b>" },
    { "etry","et$ry" },
    { "fasm","fa$sm" },
    { "ffor","ff$or" },
    { "fint","fi$nt" },
    { "fled","fl$ed" },
    { "fnew","fn$ew" },
    { "for_","f$or_" },
    { "fora","f$ora" },
    { "forb","f$orb" },
    { "forc","f$orc" },
    { "ford","f$ord" },
    { "fore","f$ore" },
    { "forf","f$orf" },
    { "forg","f$org" },
    { "forh","f$orh" },
    { "fori","f$ori" },
    { "forj","f$orj" },
    { "fork","<a href=\"CppF$ork.htm\">f$ork</a>" },
    { "forl","f$orl" },
    { "form","f$orm" },
    { "forn","f$orn" },
    { "foro","f$oro" },
    { "forp","f$orp" },
    { "forq","f$orq" },
    { "forr","f$orr" },
    { "fors","f$ors" },
    { "fort","f$ort" },
    { "foru","f$oru" },
    { "forv","f$orv" },
    { "forw","f$orw" },
    { "forx","f$orx" },
    { "fory","f$ory" },
    { "forz","f$orz" },
    { "ftry","ft$ry" },
    { "gasm","ga$sm" },
    { "gfor","gf$or" },
    { "gint","gi$nt" },
    { "gled","gl$ed" },
    { "gnew","gn$ew" },
    { "goto","<b><a href=\"CppGo$to.htm\">go$to</a></b>" },
    { "gtry","gt$ry" },
    { "hasm","ha$sm" },
    { "hfor","hf$or" },
    { "hint","hi$nt" },
    { "hled","hl$ed" },
    { "hnew","hn$ew" },
    { "htry","ht$ry" },
    { "i$for","i$f$or" },
    { "iasm","ia$sm" },
    { "iint","ii$nt" },
    { "iled","il$ed" },
    { "inew","in$ew" },
    { "int_","i$nt_" },
    { "inta","i$nta" },
    { "intb","i$ntb" },
    { "intc","i$ntc" },
    { "intd","i$ntd" },
    { "inte","i$nte" },
    { "intf","i$ntf" },
    { "intg","i$ntg" },
    { "inth","i$nth" },
    { "inti","i$nti" },
    { "intj","i$ntj" },
    { "intk","i$ntk" },
    { "intl","i$ntl" },
    { "intm","i$ntm" },
    { "intn","i$ntn" },
    { "into","i$nto" },
    { "intp","i$ntp" },
    { "intq","i$ntq" },
    { "intr","i$ntr" },
    { "ints","i$nts" },
    { "intt","i$ntt" },
    { "intu","i$ntu" },
    { "intv","i$ntv" },
    { "intw","i$ntw" },
    { "intx","i$ntx" },
    { "inty","i$nty" },
    { "intz","i$ntz" },
    { "itry","it$ry" },
    { "jasm","ja$sm" },
    { "jfor","jf$or" },
    { "jint","ji$nt" },
    { "jled","jl$ed" },
    { "jnew","jn$ew" },
    { "jtry","jt$ry" },
    { "kasm","ka$sm" },
    { "kfor","kf$or" },
    { "kint","ki$nt" },
    { "kled","kl$ed" },
    { "knew","kn$ew" },
    { "ktry","kt$ry" },
    { "lasm","la$sm" },
    { "led_","l$ed_" },
    { "leda","l$eda" },
    { "ledb","l$edb" },
    { "ledc","l$edc" },
    { "ledd","l$edd" },
    { "lede","l$ede" },
    { "ledf","l$edf" },
    { "ledg","l$edg" },
    { "ledh","l$edh" },
    { "ledi","l$edi" },
    { "ledj","l$edj" },
    { "ledk","l$edk" },
    { "ledl","l$edl" },
    { "ledm","l$edm" },
    { "ledn","l$edn" },
    { "ledo","l$edo" },
    { "ledp","l$edp" },
    { "ledq","l$edq" },
    { "ledr","l$edr" },
    { "leds","l$eds" },
    { "ledt","l$edt" },
    { "ledu","l$edu" },
    { "ledv","l$edv" },
    { "ledw","l$edw" },
    { "ledx","l$edx" },
    { "ledy","l$edy" },
    { "ledz","l$edz" },
    { "lfor","lf$or" },
    { "link","<a href=\"CppL$ink.htm\">l$ink</a>" },
    { "lint","li$nt" },
    { "lled","ll$ed" },
    { "lnew","ln$ew" },
    { "long","<b><a href=\"CppLo$ng.htm\">lo$ng</a></b>" },
    { "ltry","lt$ry" },
    { "make","<a href=\"CppM$ake.htm\">m$ake</a>" },
    { "masm","ma$sm" },
    { "mfor","mf$or" },
    { "mint","mi$nt" },
    { "mled","ml$ed" },
    { "mnew","mn$ew" },
    { "mtry","mt$ry" },
    { "nasm","na$sm" },
    { "new_","n$ew_" },
    { "newa","n$ewa" },
    { "newb","n$ewb" },
    { "newc","n$ewc" },
    { "newd","n$ewd" },
    { "newe","n$ewe" },
    { "newf","n$ewf" },
    { "newg","n$ewg" },
    { "newh","n$ewh" },
    { "newi","n$ewi" },
    { "newj","n$ewj" },
    { "newk","n$ewk" },
    { "newl","n$ewl" },
    { "newm","n$ewm" },
    { "newn","n$ewn" },
    { "newo","n$ewo" },
    { "newp","n$ewp" },
    { "newq","n$ewq" },
    { "newr","n$ewr" },
    { "news","n$ews" },
    { "newt","n$ewt" },
    { "newu","n$ewu" },
    { "newv","n$ewv" },
    { "neww","n$eww" },
    { "newx","n$ewx" },
    { "newy","n$ewy" },
    { "newz","n$ewz" },
    { "nfor","nf$or" },
    { "nint","ni$nt" },
    { "nled","nl$ed" },
    { "nnew","nn$ew" },
    { "ntry","nt$ry" },
    { "oasm","oa$sm" },
    { "ofor","of$or" },
    { "oint","oi$nt" },
    { "oled","ol$ed" },
    { "onew","on$ew" },
    { "otry","ot$ry" },
    { "pasm","pa$sm" },
    { "pfor","pf$or" },
    { "pint","pi$nt" },
    { "pled","pl$ed" },
    { "pnew","pn$ew" },
    { "ptry","pt$ry" },
    { "qasm","qa$sm" },
    { "qfor","qf$or" },
    { "qint","qi$nt" },
    { "qled","ql$ed" },
    { "qnew","qn$ew" },
    { "qtry","qt$ry" },
    { "rasm","ra$sm" },
    { "rfor","rf$or" },
    { "rint","ri$nt" },
    { "rled","rl$ed" },
    { "rnew","rn$ew" },
    { "rtry","rt$ry" },
    { "sasm","sa$sm" },
    { "sfor","sf$or" },
    { "sint","si$nt" },
    { "sled","sl$ed" },
    { "snew","sn$ew" },
    { "stry","st$ry" },
    { "tasm","ta$sm" },
    { "tfor","tf$or" },
    { "this","<b><a href=\"CppTh$is.htm\">th$is</a></b>" },
    { "time","<a href=\"CppT$ime.htm\">t$ime</a>" },
    { "tint","ti$nt" },
    { "tled","tl$ed" },
    { "tnew","tn$ew" },
    { "tool","<a href=\"T$ools.htm\">t$ool</a>" },
    { "true","<b><a href=\"CppTr$ue.htm\">tr$ue</a></b>" },
    { "try_","t$ry_" },
    { "trya","t$rya" },
    { "tryb","t$ryb" },
    { "tryc","t$ryc" },
    { "tryd","t$ryd" },
    { "trye","t$rye" },
    { "tryf","t$ryf" },
    { "tryg","t$ryg" },
    { "tryh","t$ryh" },
    { "tryi","t$ryi" },
    { "tryj","t$ryj" },
    { "tryk","t$ryk" },
    { "tryl","t$ryl" },
    { "trym","t$rym" },
    { "tryn","t$ryn" },
    { "tryo","t$ryo" },
    { "tryp","t$ryp" },
    { "tryq","t$ryq" },
    { "tryr","t$ryr" },
    { "trys","t$rys" },
    { "tryt","t$ryt" },
    { "tryu","t$ryu" },
    { "tryv","t$ryv" },
    { "tryw","t$ryw" },
    { "tryx","t$ryx" },
    { "tryy","t$ryy" },
    { "tryz","t$ryz" },
    { "ttry","tt$ry" },
    { "uasm","ua$sm" },
    { "ufor","uf$or" },
    { "uint","ui$nt" },
    { "uled","ul$ed" },
    { "unew","un$ew" },
    { "utry","ut$ry" },
    { "vasm","va$sm" },
    { "vfor","vf$or" },
    { "vint","vi$nt" },
    { "vled","vl$ed" },
    { "vnew","vn$ew" },
    { "void","<b><a href=\"CppVo$id.htm\">vo$id</a></b>" },
    { "vtry","vt$ry" },
    { "wasm","wa$sm" },
    { "wfor","wf$or" },
    { "wint","wi$nt" },
    { "wled","wl$ed" },
    { "wnew","wn$ew" },
    { "wtry","wt$ry" },
    { "xasm","xa$sm" },
    { "xfor","xf$or" },
    { "xint","xi$nt" },
    { "xled","xl$ed" },
    { "xnew","xn$ew" },
    { "xtry","xt$ry" },
    { "yasm","ya$sm" },
    { "yfor","yf$or" },
    { "yint","yi$nt" },
    { "yled","yl$ed" },
    { "ynew","yn$ew" },
    { "ytry","yt$ry" },
    { "zasm","za$sm" },
    { "zfor","zf$or" },
    { "zint","zi$nt" },
    { "zled","zl$ed" },
    { "znew","zn$ew" },
    { "ztry","zt$ry" },
  //3
    { "#if","<a href=\"CppPreIf.htm\">#i$f</a>" },
    { "---","$-$-$-$" },
    { "Add","<a href=\"CppAd$d.htm\">Ad$d</a>" },
    { "Bug","<a href=\"CppB$ug.htm\">B$ug</a>" },
    { "C++","<a href=\"Cpp.htm\">C$+$+$</a>" },
    { "CLN","<a href=\"CppC$ln.htm\">C$LN</a>" },
    { "DRD","<a href=\"CppD$rd.htm\">D$RD</a>" },
    { "E32","<a href=\"CppE$3$2$.htm\">E$3$2</a>" },
    { "GMP","<a href=\"CppG$mp.htm\">G$MP</a>" },
    { "LED","<a href=\"CppL$ed.htm\">L$ED</a>" },
    { "Led","<a href=\"CppL$ed.htm\">L$ed</a>" },
    { "NDS","<a href=\"CppN$ds.htm\">N$DS</a>" },
    { "OCR","<a href=\"CppO$cr.htm\">O$CR</a>" },
    { "POD","<a href=\"CppP$od.htm\">P$OD</a>" },
    { "Pod","<a href=\"CppP$od.htm\">P$od</a>" },
    { "SDK","<a href=\"CppS$dk.htm\">S$D$K</a>" },
    { "SIS","<a href=\"CppS$is.htm\">S$I$S</a>" },
    { "TR1","<a href=\"CppT$r1.htm\">T$R$1</a>" },
    { "TR2","<a href=\"CppT$r2.htm\">T$R$2</a>" },
    { "TRK","<a href=\"CppT$rk.htm\">T$R$K</a>" },
    { "WtA","W$tA" },
    { "WtB","W$tB" },
    { "WtC","W$tC" },
    { "WtD","W$tD" },
    { "WtE","W$tE" },
    { "WtF","W$tF" },
    { "WtG","W$tG" },
    { "WtH","W$tH" },
    { "WtI","W$tI" },
    { "WtJ","W$tJ" },
    { "WtK","W$tK" },
    { "WtL","W$tL" },
    { "WtM","W$tM" },
    { "WtN","W$tN" },
    { "WtO","W$tO" },
    { "WtP","W$tP" },
    { "WtQ","W$tQ" },
    { "WtR","W$tR" },
    { "WtS","W$tS" },
    { "WtT","W$tT" },
    { "WtU","W$tU" },
    { "WtV","W$tV" },
    { "WtW","W$tW" },
    { "WtX","W$tX" },
    { "WtY","W$tY" },
    { "WtZ","W$tZ" },
    { "Wt_","W$t_" },
    { "Wta","W$ta" },
    { "Wtb","W$tb" },
    { "Wtc","W$tc" },
    { "Wtd","W$td" },
    { "Wte","W$te" },
    { "Wtf","W$tf" },
    { "Wtg","W$tg" },
    { "Wth","W$th" },
    { "Wti","W$ti" },
    { "Wtj","W$tj" },
    { "Wtk","W$tk" },
    { "Wtl","W$tl" },
    { "Wtm","W$tm" },
    { "Wtn","W$tn" },
    { "Wto","W$to" },
    { "Wtp","W$tp" },
    { "Wtq","W$tq" },
    { "Wtr","W$tr" },
    { "Wts","W$ts" },
    { "Wtt","W$tt" },
    { "Wtu","W$tu" },
    { "Wtv","W$tv" },
    { "Wtw","W$tw" },
    { "Wtx","W$tx" },
    { "Wty","W$ty" },
    { "Wtz","W$tz" },
    { "XML","<a href=\"C$ppX$ml.htm\">X$ML</a>" },
    { "_do","_d$o" },
    { "_if","_i$f" },
    { "ado","ad$o" },
    { "aif","ai$f" },
    { "any","<a href=\"C$ppA$ny.htm\">a$ny</a>" },
    { "asm","<b><a href=\"CppAs$m.htm\">as$m</a></b>" },
    { "bdo","bd$o" },
    { "bif","bi$f" },
    { "bug","<a href=\"CppB$ug.htm\">b$ug</a>" },
    { "cdo","cd$o" },
    { "cif","ci$f" },
    { "ddo","dd$o" },
    { "dif","di$f" },
    { "do_","d$o_" },
    { "doa","d$oa" },
    { "dob","d$ob" },
    { "doc","d$oc" },
    { "dod","d$od" },
    { "doe","d$oe" },
    { "dof","d$of" },
    { "dog","d$og" },
    { "doh","d$oh" },
    { "doi","d$oi" },
    { "doj","d$oj" },
    { "dok","d$ok" },
    { "dol","d$ol" },
    { "dom","d$om" },
    { "don","d$on" },
    { "doo","d$oo" },
    { "dop","d$op" },
    { "doq","d$oq" },
    { "dor","d$or" },
    { "dos","d$os" },
    { "dot","d$ot" },
    { "dou","d$ou" },
    { "dov","d$ov" },
    { "dow","d$ow" },
    { "dox","d$ox" },
    { "doy","d$oy" },
    { "doz","d$oz" },
    { "edo","ed$o" },
    { "eif","ei$f" },
    { "fdo","fd$o" },
    { "fif","fi$f" },
    { "for","<b><a href=\"CppFo$r.htm\">f$o$r</a></b>" },
    { "gdo","gd$o" },
    { "gif","gi$f" },
    { "hdo","hd$o" },
    { "hif","hi$f" },
    { "ido","id$o" },
    { "if_","i$f_" },
    { "ifa","i$fa" },
    { "ifb","i$fb" },
    { "ifc","i$fc" },
    { "ifd","i$fd" },
    { "ife","i$fe" },
    { "iff","i$ff" },
    { "ifg","i$fg" },
    { "ifh","i$fh" },
    { "ifi","i$fi" },
    { "ifj","i$fj" },
    { "ifk","i$fk" },
    { "ifl","i$fl" },
    { "ifm","i$fm" },
    { "ifn","i$fn" },
    { "ifo","i$fo" },
    { "ifp","i$fp" },
    { "ifq","i$fq" },
    { "ifr","i$fr" },
    { "ifs","i$fs" },
    { "ift","i$ft" },
    { "ifu","i$fu" },
    { "ifv","i$fv" },
    { "ifw","i$fw" },
    { "ifx","i$fx" },
    { "ify","i$fy" },
    { "ifz","i$fz" },
    { "iif","ii$f" },
    { "int","<b><a href=\"CppIn$t.htm\">i$nt</a></b>" },
    { "jdo","jd$o" },
    { "jif","ji$f" },
    { "kdo","kd$o" },
    { "kif","ki$f" },
    { "ldo","ld$o" },
    { "lif","li$f" },
    { "mdo","md$o" },
    { "mif","mi$f" },
    { "ndo","nd$o" },
    { "new","<b><a href=\"CppNe$w.htm\">n$ew</a></b>" },
    { "nif","ni$f" },
    { "odo","od$o" },
    { "oif","oi$f" },
    { "pdo","pd$o" },
    { "pif","pi$f" },
    { "qdo","qd$o" },
    { "qif","qi$f" },
    { "rdo","rd$o" },
    { "rif","ri$f" },
    { "sdo","sd$o" },
    { "sif","si$f" },
    { "std","<a href=\"CppS$td.htm\">s$td</a>" },
    { "tdo","td$o" },
    { "tif","ti$f" },
    { "tr1","<a href=\"CppTr$1.htm\">t$r1</a>" },
    { "try","<b><a href=\"CppTr$y.htm\">t$ry</a></b>" },
    { "udo","ud$o" },
    { "uif","ui$f" },
    { "vdo","vd$o" },
    { "vif","vi$f" },
    { "wdo","wd$o" },
    { "wif","wi$f" },
    { "xdo","xd$o" },
    { "xif","xi$f" },
    { "ydo","yd$o" },
    { "yif","yi$f" },
    { "zdo","zd$o" },
    { "zif","zi$f" },
  //2
    { "!=","<a href=\"CppOperatorNotEqual.htm\">!$=</a>" },
    { "%=","<a href=\"CppOperatorModulusAssign.htm\">%$=</a>" },
  //v.push_back(std::make_pair("&,","&amp;," },
    { "*/","<a href=\"CppComment.htm\">$*$/$</a>" },
    { "*=","<a href=\"CppOperatorMultiplyAssign.htm\">*$=</a>" },
    { "++","<a href=\"CppOperatorIncrement.htm\">+$+</a>" },
    { "+=","<a href=\"CppOperatorPlusAssign.htm\">+$=</a>" },
    { "--","<a href=\"CppOperatorDecrement.htm\">-$-</a>" },
    { "-=","<a href=\"CppOperatorMinusAssign.htm\">-$=</a>" },
    { "/*","<a href=\"CppComment.htm\">$/$*$</a>" },
    { "//","<a href=\"CppComment.htm\">$/$/$</a>" },
    { "/=","<a href=\"CppOperatorDivideAssign.htm\">/$=</a>" },
    { "==","<a href=\"CppOperatorEqual.htm\">=$=</a>" },
    { "Qt","<a href=\"CppQ$t.htm\">Q$t</a>" },
    { "Wt","<a href=\"CppW$t.htm\">W$t</a>" },
    { "^=","<a href=\"CppOperatorBitwiseXorAssign.htm\">^$=</a>" },
    { "do","<b><a href=\"CppD$o.htm\">d$o</a></b>" },
    { "if","<b><a href=\"CppI$f$.htm\">i$f</a></b>" },
    { "||","<a href=\"CppOperatorLogicalOr.htm\">|$|</a>" },
  //1
    { " %"," <a href=\"CppOperatorModulus.htm\">$%</a>" },
    { " +"," <a href=\"CppOperatorPlus.htm\">$+</a>" },
    { " -"," <a href=\"CppOperatorMinus.htm\">$-</a>" },
    { " /"," <a href=\"CppOperatorDivide.htm\">$/</a>" },
    { " ="," <a href=\"CppOperatorAssign.htm\">$=</a>" },
    { "% ","<a href=\"CppOperatorModulus.htm\">%$</a> " },
    { "+ ","<a href=\"CppOperatorPlus.htm\">+$</a> " },
    { "- ","<a href=\"CppOperatorMinus.htm\">-$</a> " },
    { "/ ","<a href=\"CppOperatorDivide.htm\">/$</a> " },
    { "= ","<a href=\"CppOperatorAssign.htm\">=$</a> " }
};
std::copy(w.begin(),w.end(),std::back_inserter(v));
return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlreplacementspro.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "codetohtmlcontent.h"
//---------------------------------------------------------------------------
///CreateProFileReplacements creates the replacements when
///a Qt project file is converted to HTML
const std::vector<std::pair<std::string,std::string> > CodeToHtmlContent::CreateProReplacements()
{
  //C++0x initializer list
  return
  {
    //Desired replacements
    //33
    { "CppQtMultipleChoiceQuestionDialog","<a href=\"C$ppQ$tM$ultipleC$hoiceQ$uestionD$ialog.htm\">C$ppQ$tM$ultipleC$hoiceQ$uestionD$ialog</a>" },
    { "CppWtMultipleChoiceQuestionDialog","<a href=\"C$ppW$tM$ultipleC$hoiceQ$uestionD$ialog.htm\">C$ppW$tM$ultipleC$hoiceQ$uestionD$ialog</a>" },
    //32

    //31
    { "CppMultipleChoiceQuestionDialog","<a href=\"C$ppM$ultipleC$hoiceQ$uestionD$ialog.htm\">C$ppM$ultipleC$hoiceQ$uestionD$ialog</a>" },
    //30
    { "qtmultiplechoicequestiondialog","<a href=\"C$ppQ$tM$ultipleC$hoiceQ$uestionD$ialog.htm\">q$tm$ultiplec$hoiceq$uestiond$ialog</a>" },
    { "wtmultiplechoicequestiondialog","<a href=\"C$ppW$tM$ultipleC$hoiceQ$uestionD$ialog.htm\">w$tm$ultiplec$hoiceq$uestiond$ialog</a>" },
    //28
    { "multiplechoicequestiondialog","<a href=\"C$ppM$ultipleC$hoiceQ$uestionD$ialog.htm\">m$ultiplec$hoiceq$uestiond$ialog</a>" },
    //27
    { "CppSortedBinaryNewickVector","<a href=\"C$ppS$ortedB$inaryN$ewickV$ector.htm\">C$ppS$ortedB$inaryN$ewickV$ector</a>" },
    //26

    //25
    { "CppMultipleChoiceQuestion","<a href=\"C$ppM$ultipleC$hoiceQ$uestion.htm\">C$ppM$ultipleC$hoiceQ$uestion</a>" },
    { "ToolTestTimedServerPusher","<a href=\"T$oolT$estT$imedS$erverP$usher.htm\">T$oolT$estT$imedS$erverP$usher</a>" },
    { "wttimedserverpusherclient","<a href=\"C$ppW$tT$imedS$erverP$usherC$lient.htm\">w$tt$imeds$erverp$usherc$lient</a>" },

    //24
    { "ToolTestSelectFileDialog","<a href=\"T$oolT$estS$electF$ileD$ialog.htm\">T$oolT$estS$electF$ileD$ialog</a>" },

    //23
    { "CppQtConnectThreeWidget","<a href=\"C$ppQ$tC$onnectT$hreeW$idget.htm\">C$ppQ$tC$onnectT$hreeW$idget</a>" },
    { "CppQtOpenQuestionDialog","<a href=\"C$ppQ$tO$penQ$uestionD$ialog.htm\">C$ppQ$tO$penQ$uestionD$ialog</a>" },
    { "CppWtOpenQuestionDialog","<a href=\"C$ppW$tO$penQ$uestionD$ialog.htm\">C$ppW$tO$penQ$uestionD$ialog</a>" },
    { "CppWtConnectThreeWidget","<a href=\"C$ppW$tC$onnectT$hreeW$idget.htm\">C$ppW$tC$onnectT$hreeW$idget</a>" },
    { "CppWtToggleButtonWidget","<a href=\"C$ppW$tT$oggleB$uttonW$idget.htm\">C$ppW$tT$oggleB$uttonW$idget</a>" },
    { "ToolTestBroadcastServer","<a href=\"T$oolT$estB$roadc$astS$erver.htm\">T$oolT$estB$roadcastS$erver</a>" },
    { "WtBroadcastServerClient","<a href=\"C$ppW$tB$roadc$astS$erverC$lient.htm\">W$tB$roadc$astS$erverC$lient</a>" },
    { "wtbroadcastserverclient","<a href=\"C$ppW$tB$roadc$astS$erverC$lient.htm\">w$tb$roadc$asts$erverc$lient</a>" },
    { "wtrubiksclockmaindialog","<a href=\"G$ameR$ubiksC$lock.htm\">w$tr$ubiksc$lockm$aind$ialog</a>" },
    { "wtrubiksclockmenudialog","<a href=\"G$ameR$ubiksC$lock.htm\">w$tr$ubiksc$lockm$enud$ialog</a>" },

  //22
    { "multiplechoicequestion","<a href=\"C$ppM$ultipleC$hoiceQ$uestion.htm\">m$ultiplec$hoiceq$uestion</a>" },
    { "CppWtRubiksClockWidget","<a href=\"C$ppW$tR$ubiksC$lockW$idget.htm\">C$ppW$tR$ubiksC$lockW$idget</a>" },
    { "CppWtTimedServerPusher","<a href=\"C$ppW$tT$imedS$erverP$usher.htm\">C$ppW$tT$imedS$erverP$usher</a>" },
    { "ToolTestFunctionParser","<a href=\"T$oolT$estF$unctionP$arser.htm\">T$oolT$estF$unctionP$arser</a>" },
    { "ToolTestTwoDigitNewick","<a href=\"T$oolT$estT$woD$igitN$ewick.htm\">T$oolT$estT$woD$igitN$ewick</a>" },
  //21
    { "CppBinaryNewickVector","<a href=\"C$ppB$inaryN$ewickV$ector.htm\">C$ppB$inaryN$ewickV$ector</a>" },
    { "CppConnectThreeWidget","<a href=\"C$ppC$onnectT$hreeW$idget.htm\">C$ppC$onnectT$hreeW$idget</a>" },
    { "CppOpenQuestionDialog","<a href=\"C$ppO$penQ$uestionD$ialog.htm\">C$ppO$penQ$uestionD$ialog</a>" },
    { "CppWtSelectFileDialog","<a href=\"CppW$tS$electF$ileD$ialog.htm\">C$ppW$tS$electF$ileD$ialog</a>" },
    { "CppWtShapeGroupWidget","<a href=\"C$ppW$tS$hapeG$roupW$idget.htm\">C$ppW$tS$hapeG$roupW$idget</a>" },
    { "rubiksclockmenudialog","<a href=\"G$ameR$ubiksC$lock.htm\">r$ubiksc$lockm$enud$ialog</a>" },
    { "testtimedserverpusher","<a href=\"T$oolT$estT$imedS$erverP$usher.htm\">t$estt$imeds$erverp$usher</a>" },
  //20
    { "CppQtTicTacToeWidget","<a href=\"C$ppQ$tT$icTacToeW$idget.htm\">C$ppQ$tT$icTacToeW$idget</a>" },
    { "CppRubiksClockWidget","<a href=\"C$ppR$ubiksC$lockW$idget.htm\">C$ppR$ubiksC$lockW$idget</a>" },
    { "CppWtBroadcastServer","<a href=\"C$ppW$tB$roadc$astS$erver.htm\">C$ppW$tB$roadc$astS$erver</a>" },
    { "CppWtTicTacToeWidget","<a href=\"C$ppW$tT$icTacToeW$idget.htm\">C$ppW$tT$icTacToeW$idget</a>" },
    { "QtConnectThreeWidget","<a href=\"C$ppQ$tC$onnectT$hreeW$idget.htm\">Q$tC$onnectT$hreeW$idget</a>" },
    { "ToolTestToggleButton","<a href=\"T$oolT$estT$oggleButton.htm\">T$oolT$estT$oggleButton</a>" },
    { "ToolTestNewickVector","<a href=\"T$oolT$estN$ewickV$ector.htm\">T$oolT$estN$ewickV$ector</a>" },
    { "ToolTestServerPusher","<a href=\"T$oolT$estS$erverP$usher.htm\">T$oolT$estS$erverP$usher</a>" },
    { "WtConnectThreeWidget","<a href=\"C$ppW$tC$onnectT$hreeW$idget.htm\">W$tC$onnectT$hreeW$idget</a>" },
    { "wttogglebuttonwidget","<a href=\"C$ppW$tT$oggleB$uttonW$idget.htm\">w$tt$oggleb$uttonw$idget</a>" },
    { "qtopenquestiondialog","<a href=\"C$ppQ$tO$penQ$uestionD$ialog.htm\">q$to$penq$uestiond$ialog</a>" },
    { "testselectfiledialog","<a href=\"T$oolT$estS$electF$ileD$ialog.htm\">t$ests$electf$il$ed$ialog</a>" },
    { "wtopenquestiondialog","<a href=\"C$ppW$tO$penQ$uestionD$ialog.htm\">w$to$penq$uestiond$ialog</a>" },
    { "wtserverpusherclient","<a href=\"C$ppW$tS$erverP$usherC$lient.htm\">w$ts$erverp$usherc$lient</a>" },

  //19
    { "CppQtQuestionDialog","<a href=\"C$ppQ$tQ$uestionD$ialog.htm\">C$ppQ$tQ$uestionD$ialog</a>" },
    { "CppWtQuestionDialog","<a href=\"C$ppW$tQ$uestionD$ialog.htm\">C$ppW$tQ$uestionD$ialog</a>" },
    { "TestBroadcastServer","<a href=\"T$oolT$estB$roadc$astS$erver.htm\">T$estB$roadcastS$erver</a>" },
    { "ToolTestGroupWidget","<a href=\"T$oolT$estG$roupW$idget.htm\">T$oolT$estG$roupW$idget</a>" },
    { "WtRubiksClockWidget","<a href=\"C$ppW$tR$ubiksC$lockW$idget.htm\">W$tR$ubiksC$lockW$idget</a>" },
    { "WtTimedServerPusher","<a href=\"C$ppW$tT$imedS$erverP$usher.htm\">W$tT$imedS$erverP$usher</a>" },
    { "wtrubiksclockwidget","<a href=\"C$ppW$tR$ubiksC$lockW$idget.htm\">w$tr$ubiksc$lockw$idget</a>" },
    { "wttimedserverpusher","<a href=\"C$ppW$tT$imedS$erverP$usher.htm\">w$tt$imeds$erverp$usher</a>" },
  //18
    { "ConnectThreeWidget","<a href=\"C$ppC$onnectT$hreeW$idget.htm\">C$onnectT$hreeW$idget</a>" },
    { "CppManyDigitNewick","<a href=\"C$ppM$a$nyD$igitN$ewick.htm\">C$ppM$a$nyD$igitN$ewick</a>" },
    { "ToolTestAsciiArter","<a href=\"T$oolT$estA$sciiA$rter.htm\">T$oolT$estA$sciiA$rter</a>" },
    { "TestTwoDigitNewick","<a href=\"T$oolT$estT$woD$igitN$ewick.htm\">T$estT$woD$igitN$ewick</a>" },
    { "WtSelectFileDialog","<a href=\"CppW$tS$electF$ileD$ialog.htm\">W$tS$electF$ileD$ialog</a>" },
    { "openquestiondialog","<a href=\"C$ppO$penQ$uestionD$ialog.htm\">o$penq$uestiond$ialog</a>" },
    { "wtselectfiledialog","<a href=\"CppW$tS$electF$ileD$ialog.htm\">w$ts$electf$il$ed$ialog</a>" },
    { "wtshapegroupwidget","<a href=\"C$ppW$tS$hapeG$roupW$idget.htm\">w$ts$hapeg$roupw$idget</a>" },


  //17
    { "CppFuzzy_equal_to","<a href=\"C$ppF$uzzy_e$qual_t$o.htm\">C$ppF$uzzy_e$qual_t$o</a>" },
    { "CppQtQuestionDialog","<a href=\"C$ppQ$tQ$uestionD$ialog.htm\">C$ppQ$tQ$uestionD$ialog</a>" },
    { "CppTwoDigitNewick","<a href=\"C$ppT$woD$igitN$ewick.htm\">C$ppT$woD$igitN$ewick</a>" },
    { "CppWtServerPusher","<a href=\"C$ppW$tS$erverP$usher.htm\">C$ppW$tS$erverP$usher</a>" },
    { "QtTicTacToeWidget","<a href=\"C$ppQ$tT$icTacToeW$idget.htm\">Q$tT$icTacToeW$idget</a>" },
    { "RubiksClockWidget","<a href=\"C$ppR$ubiksC$lockW$idget.htm\">R$ubiksC$lockW$idget</a>" },
    { "ToolTestEncranger","<a href=\"T$oolT$estE$ncranger.htm\">T$oolT$estE$ncranger</a>" },
    { "ToolTestNeuralNet","<a href=\"T$oolT$estN$euralNet.htm\">T$oolT$estN$euralNet</a>" },
    { "ToolTestStopwatch","<a href=\"T$oolTestS$topwatch.htm\">T$oolTestS$topwatch</a>" },
    { "ToolTestTicTacToe","<a href=\"T$oolT$estT$icTacToe.htm\">T$oolT$estT$icTacToe</a>" },
    { "WtBroadcastServer","<a href=\"C$ppW$tB$roadc$astS$erver.htm\">W$tB$roadc$astS$erver</a>" },
    { "WtTicTacToeWidget","<a href=\"C$ppW$tT$icTacToeW$idget.htm\">W$tT$icTacToeW$idget</a>" },
    { "qttictactoewidget","<a href=\"C$ppQ$tT$icTacToeW$idget.htm\">q$tt$ictactoew$idget</a>" },
    { "rubiksclockwidget","<a href=\"C$ppR$ubiksC$lockW$idget.htm\">r$ubiksc$lockw$idget</a>" },
    { "wtbroadcastserver","<a href=\"C$ppW$tB$roadc$astS$erver.htm\">w$tb$roadc$asts$erver</a>" },
    { "wttictactoewidget","<a href=\"C$ppW$tT$icTacToeW$idget.htm\">w$tt$ictactoew$idget</a>" },

  //16
    { "CppDesignPattern","<a href=\"C$ppD$esignP$attern.htm\">C$ppD$esignP$attern</a>" },
    { "CppQtAboutDialog","<a href=\"C$ppQ$tA$boutD$ialog.htm\">C$ppQ$tA$boutD$ialog</a>" },
    { "CppQtShapeWidget","<a href=\"C$ppQ$tS$hapeW$idget.htm\">C$ppQ$tS$hapeW$idget</a>" },
    { "CppWtAboutDialog","<a href=\"C$ppW$tA$boutD$ialog.htm\">C$ppW$tA$boutD$ialog</a>" },
    { "CppWtGroupWidget","<a href=\"C$ppW$tG$roupW$idget.htm\">C$ppW$tG$roupW$idget</a>" },
    { "CppWtShapeWidget","<a href=\"C$ppW$tS$hapeW$idget.htm\">C$ppW$tS$hapeW$idget</a>" },
    { "GameConnectThree","<a href=\"G$ameC$onnectT$hree.htm\">G$ameC$onnectT$hree</a>" },
    { "ProjectWtWebsite","<a href=\"P$rojectW$t$W$ebsite.htm\">P$rojectW$t$W$ebsite</a>" },
    { "ToolTestQuestion","<a href=\"T$oolT$estQ$uestion.htm\">T$oolT$estQ$uestion</a>" },
    { "TestToggleButton","<a href=\"T$oolT$estT$oggleButton.htm\">T$estT$oggleButton</a>" },
    { "qtquestiondialog","<a href=\"C$ppQ$tQ$uestionD$ialog.htm\">q$tq$uestiond$ialog</a>" },
    { "testtogglebutton","<a href=\"T$oolT$estT$oggleB$utton.htm\">t$estt$oggleb$utton</a>" },
    { "testserverpusher","<a href=\"T$oolT$estS$erverP$usher.htm\">t$ests$erverp$usher</a>" },
    { "wtquestiondialog","<a href=\"C$ppW$tQ$uestionD$ialog.htm\">w$tq$uestiond$ialog</a>" },

  //15
    { "CppConnectThree","<a href=\"C$ppC$onnectT$hree.htm\">CppC$onnectT$hree</a>" },
    { "CppNewickVector","<a href=\"C$ppN$ewickV$ector.htm\">C$ppN$ewickV$ector</a>" },
    { "CppOpenQuestion","<a href=\"C$ppO$penQ$uestion.htm\">CppO$penQ$uestion</a>" },
    { "CppQtDialWidget","<a href=\"C$ppQ$tD$ialW$idget.htm\">C$ppQ$tD$ialW$idget</a>" },
    { "CppToggleButton","<a href=\"C$ppT$oggleB$utton.htm\">C$ppT$oggleB$utton</a>" },
    { "CppWtAutoConfig","<a href=\"C$ppW$tA$utoC$onfig.htm\">C$ppW$tA$utoC$onfig</a>" },
    { "CppWtDialWidget","<a href=\"C$ppW$tD$ialW$idget.htm\">C$ppW$tD$ialW$idget</a>" },
    { "GameRubiksClock","<a href=\"G$ameR$ubiksC$lock.htm\">G$ameR$ubiksC$lock</a>" },
  //14
    { "CppMultiVector","<a href=\"C$ppM$ultiV$ector.htm\">C$ppM$ultiV$ector</a>" },
    { "CppQtLedWidget","<a href=\"C$ppQ$tL$edW$idget.htm\">C$ppQ$tL$edW$idget</a>" },
    { "CppRubiksClock","<a href=\"C$ppR$ubiksC$lock.htm\">C$ppR$ubiksC$lock</a>" },
    { "CppShapeWidget","<a href=\"C$ppS$hapeW$idget.htm\">C$ppS$hapeW$idget</a>" },
    { "CppWtLedWidget","<a href=\"C$ppW$tL$edW$idget.htm\">C$ppW$tL$edW$idget</a>" },
    { "CppWtSafeTimer","<a href=\"C$ppW$tS$afeT$imer.htm\">C$ppW$tS$afeT$imer</a>" },
    { "ToolRandomCode","<a href=\"T$oolR$andomC$ode.htm\">T$oolR$andomC$ode</a>" },
    { "TestAsciiArter","<a href=\"T$oolT$estA$sciiA$rter.htm\">T$estA$sciiA$rter</a>" },
    { "fuzzy_equal_to","<a href=\"C$ppF$uzzy_e$qual_t$o.htm\">f$uzzy_e$qual_t$o</a>" },
    { "questiondialog","<a href=\"C$ppQ$uestionD$ialog.htm\">q$uestiond$ialog</a>" },
    { "testasciiarter","<a href=\"T$oolT$estA$sciiA$rter.htm\">t$esta$sciia$rter</a>" },
    { "WtServerPusher","<a href=\"C$ppW$tS$erverP$usher.htm\">W$tS$erverP$usher</a>" },
    { "WtToggleButton","<a href=\"C$ppW$tT$oggleB$utton.htm\">W$tT$oggleB$utton</a>" },
    { "wttogglebutton","<a href=\"C$ppW$tT$oggleB$utton.htm\">w$tt$oggleb$utton</a>" },
    { "wtserverpusher","<a href=\"C$ppW$tS$erverP$usher.htm\">w$ts$erverp$usher</a>" },



  //13
    { "CppAsciiArter","<a href=\"CppA$sciiA$rter.htm\">C$ppA$sciiA$rter</a>" },
    { "CppDialWidget","<a href=\"CppD$ialW$idget.htm\">CppD$ialW$idget</a>" },
    { "CppLoopReader","<a href=\"CppL$oopR$eader.htm\">C$ppL$oopR$eader</a>" },
    { "CppRandomCode","<a href=\"CppR$andomC$ode.htm\">C$ppR$andomC$ode</a>" },
    { "GameTicTacToe","<a href=\"GameT$icTacToe.htm\">GameT$icTacToe</a>" },
    { "QtAboutDialog","<a href=\"C$ppQ$tA$boutD$ialog.htm\">Q$tA$boutD$ialog</a>" },
    { "QtShapeWidget","<a href=\"C$ppQ$tS$hapeW$idget.htm\">Q$tS$hapeW$idget</a>" },
    { "TestEncranger","<a href=\"T$oolT$estE$ncranger.htm\">T$estE$ncranger</a>" },
    { "TestNeuralNet","<a href=\"T$oolT$estN$euralNet.htm\">T$estN$euralNet</a>" },
    { "TestStopwatch","<a href=\"T$oolTestS$topwatch.htm\">TestS$topwatch</a>" },
    { "TestTicTacToe","<a href=\"T$oolT$estT$icTacToe.htm\">T$estT$icTacToe</a>" },
    { "ToolTestShape","<a href=\"T$oolT$estS$hape.htm\">T$oolT$estS$hape</a>" },
    { "WtAboutDialog","<a href=\"C$ppW$tA$boutD$ialog.htm\">W$tA$boutD$ialog</a>" },
    { "WtShapeWidget","<a href=\"C$ppW$tS$hapeW$idget.htm\">W$tS$hapeW$idget</a>" },
    { "qtaboutdialog","<a href=\"C$ppQ$tA$boutD$ialog.htm\">q$ta$boutd$ialog</a>" },
    { "qtshapewidget","<a href=\"C$ppQ$tS$hapeW$idget.htm\">q$ts$hapew$idget</a>" },
    { "testencranger","<a href=\"T$oolT$estE$ncranger.htm\">t$este$ncranger</a>" },
    { "testneuralnet","<a href=\"T$oolT$estN$euralNet.htm\">t$estn$euralnet</a>" },
    { "teststopwatch","<a href=\"T$oolTestS$topwatch.htm\">tests$topwatch</a>" },
    { "testtictactoe","<a href=\"T$oolT$estT$icTacToe.htm\">t$estt$ictactoe</a>" },
    { "wtaboutdialog","<a href=\"C$ppW$tA$boutD$ialog.htm\">w$ta$boutd$ialog</a>" },
    { "wtgroupwidget","<a href=\"C$ppW$tG$roupW$idget.htm\">w$tg$roupw$idget</a>" },
    { "wtshapewidget","<a href=\"C$ppW$tS$hapeW$idget.htm\">w$ts$hapew$idget</a>" },


  //12
    { "connectthree","<a href=\"C$ppC$onnectT$hree.htm\">c$onnectt$hree</a>" },
    { "openquestion","<a href=\"C$ppO$penQ$uestion.htm\">o$penq$uestion</a>" },
    { "qtdialwidget","<a href=\"C$ppQ$tD$ialW$idget.htm\">q$td$ialw$idget</a>" },
    { "qtcodetohtml","<a href=\"T$oolC$odeToH$tml.htm\">q$tc$odet$oh$tml</a>" },
    { "testquestion","<a href=\"T$oolT$estQ$uestion.htm\">t$estq$uestion</a>" },
    { "togglebutton","<a href=\"C$ppT$oggleB$utton.htm\">t$oggleb$utton</a>" },
    { "wtautoconfig","<a href=\"C$ppW$tA$utoC$onfig.htm\">w$ta$utoc$onfig</a>" },
    { "wtdialwidget","<a href=\"C$ppW$tD$ialW$idget.htm\">w$td$ialw$idget</a>" },
    { "wtcodetohtml","<a href=\"T$oolC$odeToH$tml.htm\">w$tc$odet$oh$tml</a>" },
    { "CppEncranger","<a href=\"CppE$ncranger.htm\">C$ppE$ncranger</a>" },
    { "CppIpAddress","<a href=\"C$ppI$pA$ddress.htm\">C$ppI$pA$ddress</a>" },
    { "CppLedWidget","<a href=\"CppL$edW$idget.htm\">CppL$edW$idget</a>" },
    { "CppRectangle","<a href=\"C$ppR$ectangle.htm\">C$ppR$ectangle</a>" },
    { "CppStopwatch","<a href=\"C$ppS$topw$atch.htm\">C$ppS$topw$atch</a>" },
    { "CppTicTacToe","<a href=\"C$ppT$icTacToe.htm\">C$ppT$icTacToe</a>" },
    { "ConnectThree","<a href=\"C$ppC$onnectT$hree.htm\">C$onnectT$hree</a>" },
    { "ToolTestDial","<a href=\"T$oolT$estD$ial.htm\">T$oolT$estD$ial</a>" },
    { "ToolTimePoll","<a href=\"T$oolT$imeP$oll.htm\">T$oolT$imeP$oll</a>" },
    { "WtAutoConfig","<a href=\"C$ppW$tA$utoC$onfig.htm\">W$tA$utoC$onfig</a>" },

  //11
    { "multivector","<a href=\"C$ppM$ultiV$ector.htm\">m$ultiv$ector</a>" },
    { "qtledwidget","<a href=\"CppQ$tL$edW$idget.htm\">q$tl$edw$idget</a>" },
    { "rubiksclock","<a href=\"C$ppR$ubiksC$lock.htm\">r$ubiksc$lock</a>" },
    { "shapewidget","<a href=\"C$ppS$hapeW$idget.htm\">s$hapew$idget</a>" },
    { "wtledwidget","<a href=\"CppW$tL$edW$idget.htm\">w$tl$edw$idget</a>" },
    { "wtsafetimer","<a href=\"C$ppW$tS$afeT$imer.htm\">w$ts$afet$imer</a>" },
    { "CppQuestion","<a href=\"C$ppQ$uestion.htm\">C$ppQ$uestion</a>" },
    { "MultiVector","<a href=\"C$ppM$ultiV$ector.htm\">M$ultiV$ector</a>" },
    { "ProjectGtst","<a href=\"P$rojectG$tst.htm\">P$rojectG$tst</a>" },
    { "QtLedWidget","<a href=\"CppQ$tL$edW$idget.htm\">Q$tL$edW$idget</a>" },
    { "RubiksClock","<a href=\"C$ppR$ubiksC$lock.htm\">R$ubiksC$lock</a>" },
    { "ShapeWidget","<a href=\"C$ppS$hapeW$idget.htm\">S$hapeW$idget</a>" },
    { "ToolTestLed","<a href=\"T$oolT$estL$ed.htm\">T$oolT$estL$ed</a>" },
    { "WtSafeTimer","<a href=\"C$ppW$tS$afeT$imer.htm\">W$tS$afeT$imer</a>" },
  //10
    { "asciiarter","<a href=\"CppA$sciiA$rter.htm\">a$sciia$rter</a>" },
    { "cachegrind","<a href=\"C$ppC$acheg$rind.htm\">c$acheg$rind</a>" },
    { "codetohtml","<a href=\"T$oolC$odeToH$tml.htm\">c$odet$oh$tml</a>" },
    { "dialwidget","<a href=\"CppD$ialW$idget.htm\">d$ialw$idget</a>" },
    { "loopreader","<a href=\"CppL$oopR$eader.htm\">l$oopr$eader</a>" },
    { "randomcode","<a href=\"CppR$andomC$ode.htm\">r$andomc$ode</a>" },
    { "AsciiArter","<a href=\"CppA$sciiA$rter.htm\">A$sciiA$rter</a>" },
    { "CppCopy_if","<a href=\"CppCo$py_i$f.htm\">C$ppCo$py_i$f</a>" },
    { "CppCounter","<a href=\"C$ppC$ounter.htm\">C$ppC$ounter</a>" },
    { "CppProFile","<a href=\"CppP$roF$ile.htm\">C$ppP$roF$ile</a>" },
    { "CppRainbow","<a href=\"CppR$ainbow.htm\">CppR$ainbow</a>" },
    { "DialWidget","<a href=\"CppD$ialW$idget.htm\">D$ialW$idget</a>" },
    { "LoopReader","<a href=\"CppL$oopR$eader.htm\">L$oopR$eader</a>" },
    { "RandomCode","<a href=\"CppR$andomC$ode.htm\">R$andomC$ode</a>" },
  //9
    { "CppAssert","<a href=\"C$ppA$ssert.htm\">C$ppA$ssert</a>" },
    { "CppNewick","<a href=\"C$ppN$ewick.htm\">C$ppN$ewick</a>" },
    { "CppSurvey","<a href=\"C$ppS$urvey.htm\">C$ppS$urvey</a>" },
    { "CppWidget","<a href=\"C$ppW$idget.htm\">C$ppW$idget</a>" },
    { "Encranger","<a href=\"CppE$ncranger.htm\">E$ncranger</a>" },
    { "LedWidget","<a href=\"CppL$edW$idget.htm\">L$edW$idget</a>" },
    { "Libraries","<a href=\"C$ppL$ibrary.htm\">L$ibraries</a>" },
    { "QtCreator","<a href=\"CppQ$tC$reator.htm\">Q$tC$reator</a>" },
    { "Rectangle","<a href=\"C$ppR$ectangle.htm\">R$ectangle</a>" },
    { "TestShape","<a href=\"T$oolT$estS$hape.htm\">T$estS$hape</a>" },
    { "TicTacToe","<a href=\"C$ppT$icTacToe.htm\">T$icT$acT$oe</a>" },
    { "encranger","<a href=\"CppE$ncranger.htm\">e$ncranger</a>" },
    { "ipaddress","<a href=\"C$ppI$pa$ddress.htm\">i$pa$ddress</a>" },
    { "rectangle","<a href=\"C$ppR$ectangle.htm\">r$ectangle</a>" },
    { "stopwatch","<a href=\"C$ppS$topw$atch.htm\">s$topw$atch</a>" },
    { "testshape","<a href=\"T$oolT$estS$hape.htm\">t$ests$hape</a>" },
    { "tictactoe","<a href=\"C$ppT$icTacToe.htm\">t$ict$act$oe</a>" },

  //8
    { "helgrind","<a href=\"C$ppH$elg$rind.htm\">h$elg$rind</a>" },
    { "htmlpage","<a href=\"C$ppH$tmlP$age.htm\">h$tmlp$age</a>" },
    { "quantlib","<a href=\"C$ppQ$uantL$ib.htm\">q$uantl$ib</a>" },
    { "question","<a href=\"C$ppQ$uestion.htm\">q$uestion</a>" },
    { "testdial","<a href=\"T$oolT$estD$ial.htm\">t$es$td$ial</a>" },
    { "timepoll","<a href=\"T$oolT$imeP$oll.htm\">t$imep$oll</a>" },
    { "valgrind","<a href=\"C$ppV$alg$rind.htm\">v$alg$rind</a>" },
    { "CppAbout","<a href=\"C$ppA$bout.htm\">C$ppA$bout</a>" },
    { "CppShape","<a href=\"C$ppS$hape.htm\">C$ppS$hape</a>" },
    { "CppTrace","<a href=\"C$ppT$race.htm\">C$ppT$race</a>" },
    { "HtmlPage","<a href=\"C$ppH$tmlP$age.htm\">H$tmlP$age</a>" },
    { "Projects","<a href=\"P$rojects.htm\">P$rojects</a>" },
    { "QuantLib","<a href=\"C$ppQ$uantL$ib.htm\">Q$uantL$ib</a>" },
    { "Valgrind","<a href=\"C$ppV$alg$rind.htm\">V$alg$rind</a>" },

  //7
    { "Classes","<a href=\"C$ppC$lass.htm\">C$lasses</a>" },
    { "Copy_if","<a href=\"CppCo$py_i$f.htm\">Co$py_i$f</a>" },
    { "CppDial","<a href=\"C$ppD$ial.htm\">C$ppD$ial</a>" },
    { "ProFile","<a href=\"CppP$roF$ile.htm\">P$roF$ile</a>" },
    { "Rainbow","<a href=\"CppR$ainbow.htm\">R$ainbow</a>" },
    { "copy_if","<a href=\"CppCo$py_i$f.htm\">co$py_i$f</a>" },
    { "counter","<a href=\"C$ppC$ounter.htm\">c$ounter</a>" },
    { "rainbow","<a href=\"CppR$ainbow.htm\">r$ainbow</a>" },
    { "testled","<a href=\"T$oolT$estL$ed.htm\">t$estl$ed</a>" },
  //6
    { "Assert","<a href=\"C$ppA$ssert.htm\">A$ssert</a>" },
    { "assert","<a href=\"C$ppA$ssert.htm\">a$ss$ert</a>" },
    { "newick","<a href=\"C$ppN$ewick.htm\">n$ewick</a>" },
    { "survey","<a href=\"C$ppS$urvey.htm\">s$urvey</a>" },
    { "CppLed","<a href=\"C$ppL$ed.htm\">C$ppL$ed</a>" },
    { "Survey","<a href=\"C$ppS$urvey.htm\">S$urvey</a>" },
    { "Widget","<a href=\"C$ppW$idget.htm\">W$idget</a>" },
    { "widget","<a href=\"C$ppW$idget.htm\">w$idget</a>" },
  //5
    { "about","<a href=\"C$ppA$bout.htm\">a$bout</a>" },
    { "c++0x","<a href=\"C$pp0$x.htm\">c$+$+$0$x</a>" },
    { "dialo","d$ialo" },
    { "gprof","<a href=\"C$ppG$p$rof.htm\">g$p$rof</a>" },
    { "shape","<a href=\"C$ppS$hape.htm\">s$hape</a>" },
    { "trace","<a href=\"CppT$race.htm\">t$race</a>" },
    { "About","<a href=\"C$ppA$bout.htm\">A$bout</a>" },
    { "Games","<a href=\"G$ames.htm\">G$ames</a>" },
    { "Gprof","<a href=\"C$ppG$p$rof.htm\">G$p$rof</a>" },
    { "Shape","<a href=\"C$ppS$hape.htm\">S$hape</a>" },
    { "Trace","<a href=\"CppT$race.htm\">T$race</a>" },
    { "TRACE","<a href=\"CppT$RACE.htm\">T$RACE</a>" },
    { "Tools","<a href=\"T$ools.htm\">T$ools</a>" },
  //4
    { "dial","<a href=\"C$ppD$ial.htm\">d$ial</a>" },
    { "main","<a href=\"CppMa$in.htm\">m$ain</a>" },
  //3
    { "led","<a href=\"C$ppL$ed.htm\">l$ed</a>" }
  };
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmltechnicalinfo.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLTECHNICALINFO_H
#define CODETOHTMLTECHNICALINFO_H
//---------------------------------------------------------------------------
#include <set>
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include "codetohtml.h"
//---------------------------------------------------------------------------
///Defines the header of the resulting HTML page
struct CodeToHtmlTechnicalInfo
{
  enum ApplicationType { desktop, mobile, web };
  enum Compiler { gpp, bcc32 };
  enum Ide { command_line, cpp_builder, qt_creator };
  enum Library { big_int, boost, cln, libnds, qt, stl, vcl, wt };
  enum OperatingSystem { android,cygwin,lubuntu,meamo,nds,symbian,ubuntu,windows,wine };
  enum ProjectType { console, gui };
  enum Standard { cpp98, cpp0x };

  CodeToHtmlTechnicalInfo();

  const std::vector<std::string> ToHtml() const;


  std::set<ApplicationType> m_application_types;
  std::set<Compiler> m_compilers;
  std::set<Ide> m_ides;
  std::set<Library> m_libraries;
  std::set<OperatingSystem> m_operating_systems;
  std::set<ProjectType> m_project_types;
  std::set<Standard> m_standards;
};
//---------------------------------------------------------------------------
#endif // CODETOHTMLTECHNICALINFO_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmltechnicalinfo.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmltechnicalinfo.h"
#include "codetohtmlversion.h"
//---------------------------------------------------------------------------
CodeToHtmlTechnicalInfo::CodeToHtmlTechnicalInfo()
{

}
//---------------------------------------------------------------------------
const std::vector<std::string> CodeToHtmlTechnicalInfo::ToHtml() const
{
  std::vector<std::string> v;
  v.push_back("<h2>Technical facts</h2>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p><a href=\"CppApplication.htm\">Application type(s)</a></p>");
  v.push_back("<ul>");

  v.push_back("  <li><img src=\"PicDesktop.png\" alt=\"Desktop\"/> <a href=\"CppDesktopApplication.htm\">Desktop application</a></li>");
  v.push_back("  <li><img src=\"PicMobile.png\" alt=\"Mobile\"/> <a href=\"CppMobileApplication.htm\">Mobile application</a></li>");
  v.push_back("  <li><img src=\"PicWeb.png\" alt=\"Web\"/> <a href=\"CppWebApplication.htm\">Web application</a></li>");
  v.push_back("</ul>");
  v.push_back("<p><a href=\"CppOs.htm\">Operating system(s) or programming environment(s)</a></p>");
  v.push_back("<ul>");
  v.push_back("  <li><img src=\"PicAndroid.png\" alt=\"Android\"/> <a href=\"CppAndroid.htm\">Android</a></li>");
  //v.push_back("  <li><img src=\"PicCygwin.png\" alt=\"Cygwin\"/> <a href=\"CppCygwin.htm\">Cygwin</a> 1.7.7</li>");
  v.push_back("  <li><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/> <a href=\"CppLubuntu.htm\">Lubuntu</a> "+ Version::GetLubuntuVersion()+" ("+Version::GetLubuntuVersionCodename()+")</li>");
  v.push_back("  <li><img src=\"PicMaemo.png\" alt=\"Maemo\"/> <a href=\"CppMaemo.htm\">Maemo</a></li>");
  v.push_back("  <li><img src=\"PicNds.png\" alt=\"NDS\"/> <a href=\"CppNds.htm\">NDS</a></li>");
  v.push_back("  <li><img src=\"PicSymbian.png\" alt=\"Symbian\"/> <a href=\"CppSymbian.htm\">Symbian</a></li>");
  //v.push_back("  <li><img src=\"PicUbuntu.png\" alt=\"Ubuntu\"/> <a href=\"CppUbuntu.htm\">Ubuntu</a> "+ Version::GetUbuntuVersion()+" ("+Version::GetUbuntuVersionCodename()+")</li>");
  //v.push_back("  <li><img src=\"PicVirtualBox.png\" alt=\"VirtualBox\"/> <a href=\"CppVirtualBox.htm\">VirtualBox</a> " + Version::GetVirtualBoxVersion() + "</li>");
  v.push_back("  <li><img src=\"PicWindows.png\" alt=\"Windows\"/> <a href=\"CppWindows.htm\">Windows</a> XP</li>");
  //v.push_back("  <li><img src=\"PicWine.png\" alt=\"Wine\"/> <a href=\"CppWine.htm\">Wine</a> " + Version::GetWineVersion() + "</li>");
  v.push_back("</ul>");
  v.push_back("<p><a href=\"CppIde.htm\">IDE(s)</a>:</p>");
  v.push_back("<ul>");
  v.push_back("  <li><img src=\"PicCl.png\" alt=\"Command line\"/> command line</li>");
  v.push_back("  <li><img src=\"PicCppBuilder.png\" alt=\"C[PLUS][PLUS] Builder\"/> <a href=\"CppBuilder.htm\">C[PLUS][PLUS] Builder</a> 6.0 Enterprise edition</li>");
  v.push_back("  <li><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/> <a href=\"CppQtCreator.htm\">Qt Creator</a> 2.3.0</li>");
  //v.push_back("  <li><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/> <a href=\"CppQtCreator.htm\">Qt Creator</a> " + Version::GetQtCreatorVersion() + "</li>");
  v.push_back("</ul>");
  v.push_back("<p><a href=\"CppQtProjectType.htm\">Project type</a>:</p>");
  v.push_back("<ul>");
  v.push_back("  <li><img src=\"PicConsole.png\" alt=\"console\"/> <a href=\"CppConsoleApplication.htm\">Console application</a></li>");
  v.push_back("  <li><img src=\"PicGui.png\" alt=\"GUI\"/> <a href=\"CppGuiApplication.htm\">GUI application</a></li>");
  v.push_back("</ul>");
  v.push_back("<p><a href=\"CppStandard.htm\">C++ standard</a>:</p>");
  v.push_back("<ul>");
  v.push_back("  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/> <a href=\"Cpp98.htm\">C++98</a></li>");
  v.push_back("  <li><img src=\"PicCpp0x.png\" alt=\"C++0x\"/> <a href=\"Cpp0x.htm\">C++0x</a></li>");
  v.push_back("</ul>");
  v.push_back("<p><a href=\"CppCompiler.htm\">Compiler(s)</a>:</p>");
  v.push_back("<ul>");
  v.push_back("  <li><a href=\"CppGpp.htm\">G++</a> "+Version::GetGccVersion()+"</li>");
  v.push_back("  <li>Borland <a href=\"CppBcc32Exe.htm\">BCC32.EXE</a> version 6.0.10.157</li>");
  v.push_back("</ul>");
  v.push_back("<p><a href=\"CppLibrary.htm\">Libraries</a> used:</p>");
  v.push_back("<ul>");
  //v.push_back("  <li><img src=\"PicBigInt.png\" alt=\"BigInt\"/> <a href=\"CppBigInt.htm\">BigInteger</a>: version 2010.04.30</li>");
  v.push_back("  <li><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppBoost.htm\">Boost</a>: version "+Version::GetBoostVersion()+"</li>");
  //v.push_back("  <li><img src=\"PicCln.png\" alt=\"CLN\"/> <a href=\"CppCln.htm\">CLN</a>: version 1.3.1</li>");
  //v.push_back("  <li><img src=\"PicLibnds.png\" alt=\"libnds\"/> <a href=\"CppLibnds.htm\">libnds</a>: version 1.4.7</li>");
  //v.push_back("  <li><img src=\"PicQuantLib.png\" alt=\"QuantLib\"/> <a href=\"CppQuantLib.htm\">QuantLib</a>: version "+Version::GetQuantLibVersion()+"</li>");
  v.push_back("  <li><img src=\"PicQt.png\" alt=\"Qt\"/> <a href=\"CppQt.htm\">Qt</a>: version "+Version::GetQtVersion()+" (32 bit)</li>");
  v.push_back("  <li><img src=\"PicStl.png\" alt=\"STL\"/> <a href=\"CppStl.htm\">STL</a>: GNU ISO C++ Library, version "+Version::GetStlVersion()+"</li>");
  //v.push_back("  <li><img src=\"PicVcl.png\" alt=\"VCL\"/> <a href=\"CppVcl.htm\">VCL</a>: supplied with <a href=\"CppBuilder.htm\">C[PLUS][PLUS] Builder</a> 6.0 Enterprise edition");
  v.push_back("  <li><img src=\"PicWt.png\" alt=\"Wt\"/> <a href=\"CppWt.htm\">Wt</a>: version "+Version::GetWtVersion()+"</li>");
  v.push_back("</ul>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  return v;
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlversion.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef VERSION_H
#define VERSION_H
//---------------------------------------------------------------------------
#include <string>
//---------------------------------------------------------------------------
namespace Version
{
//---------------------------------------------------------------------------
///GetBoostVersion returns the version of the current Boost library.
///From http://www.richelbilderbeek.nl/CppGetBoostVersion.htm
const std::string GetBoostVersion();
//---------------------------------------------------------------------------
///GetLubuntuVersion returns the version number of the Lubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetLubuntuVersion.htm
const std::string GetLubuntuVersion();
//---------------------------------------------------------------------------
///GetLubuntuVersionCodename returns the codename of the Lubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetLubuntuVersionCodename.htm
const std::string GetLubuntuVersionCodename();
//---------------------------------------------------------------------------
///GetGccVersion returns the version number of GCC currently installed.
///From http://www.richelbilderbeek.nl/CppGetGccVersion.htm
const std::string GetGccVersion();
//---------------------------------------------------------------------------
/*
///GetQuantLibVersion returns the version of the QuantLib library installed.
///From http://www.richelbilderbeek.nl/CppGetQuantLibVersion.htm
const std::string GetQuantLibVersion();
*/
//---------------------------------------------------------------------------
///GetQtVersion returns the version of the Qt library installed.
///From http://www.richelbilderbeek.nl/CppGetQtVersion.htm
const std::string GetQtVersion();
//---------------------------------------------------------------------------
/*
///GetQtCreatorVersion returns the version Qt Creator currently installed.
///From http://www.richelbilderbeek.nl/CppGetQtCreatorVersion.htm
const std::string GetQtCreatorVersion();
*/
//---------------------------------------------------------------------------
///GetStlVersion returns the version number of the GCC STL currently installed.
///From http://www.richelbilderbeek.nl/CppGetStlVersion.htm
const std::string GetStlVersion();
//---------------------------------------------------------------------------
///GetUbuntuVersion returns the version number of the Ubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetUbuntuVersion.htm
const std::string GetUbuntuVersion();
//---------------------------------------------------------------------------
///GetUbuntuVersionCodename returns the codename of the Ubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetUbuntuVersionCodename.htm
const std::string GetUbuntuVersionCodename();
//---------------------------------------------------------------------------
///GetVirtualBoxVersion returns the version of the currently installed VirtualBox
///From http://www.richelbilderbeek.nl/CppGetVirtualBoxVersion.htm
const std::string GetVirtualBoxVersion();
//---------------------------------------------------------------------------
///GetWineVersion returns the version of the currently installed Wine
///From http://www.richelbilderbeek.nl/CppGetWineVersion.htm
const std::string GetWineVersion();
//---------------------------------------------------------------------------
///GetWtVersion returns the version of the currently installed Wt library
///From http://www.richelbilderbeek.nl/CppGetWtVersion.htm
const std::string GetWtVersion();
//---------------------------------------------------------------------------
}
//---------------------------------------------------------------------------
#endif // VERSION_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/codetohtmlversion.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/foreach.hpp>
#include <boost/version.hpp>
//---------------------------------------------------------------------------
#include <QFile>
//---------------------------------------------------------------------------
#include <Wt/WConfig.h>
//---------------------------------------------------------------------------
#include "codetohtmlversion.h"
//---------------------------------------------------------------------------
namespace Version
{
//---------------------------------------------------------------------------
///GetBoostVersion returns the version of the current Boost library.
///From http://www.richelbilderbeek.nl/CppGetBoostVersion.htm
const std::string GetBoostVersion()
{
  std::string s = BOOST_LIB_VERSION;
  std::replace(s.begin(),s.end(),'_','.');
  return s;
}
//---------------------------------------------------------------------------
///GetGccVersion returns the version number of GCC currently installed.
///From http://www.richelbilderbeek.nl/CppGetGccVersion.htm
const std::string GetGccVersion()
{
  return
      std::to_string(__GNUC__)
    + std::string(".")
    + std::to_string(__GNUC_MINOR__)
    + std::string(".")
    + std::to_string(__GNUC_PATCHLEVEL__);
}
//---------------------------------------------------------------------------
///GetLubuntuVersion returns the version number of the Lubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetLubuntuVersion.htm
const std::string GetLubuntuVersion()
{
  const std::string filename = "tmp.txt";
  //Save info to tmp.txt
  {
    const std::string cmd
      = std::string("cat /etc/*-release > ")
      + filename;
    const int error_code = std::system(cmd.c_str());
    if (error_code) throw std::runtime_error(
      std::string("Command ")
      + cmd
      + std::string("failed"));
  }
  //Read info to std::vector
  std::vector<std::string> v;
  {
    std::ifstream f(filename.c_str());
    std::string s;
    for (int i=0; !f.eof(); ++i)
    {
      std::getline(f,s);
      v.push_back(s);
    }
  }
  //Analyze std::vector
  BOOST_FOREACH(const std::string& s,v)
  {
    if (s.size() > 15
      && s.substr(0,15)=="DISTRIB_RELEASE")
    {
      const int i = s.find_last_of("=");
      return s.substr(i+1,s.size()-(i+1));
    }
  }
  std::remove(filename.c_str());
  return "";
}
//---------------------------------------------------------------------------
///GetLubuntuVersionCodename returns the codename of the Lubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetLubuntuVersionCodename.htm
const std::string GetLubuntuVersionCodename()
{
  const std::string filename = "tmp.txt";
  //Save info to tmp.txt
  {
    const std::string cmd
      = std::string("cat /etc/*-release > ")
      + filename;
    const int error_code = std::system(cmd.c_str());
    if (error_code) throw std::runtime_error(
      std::string("Command ")
      + cmd
      + std::string("failed"));
  }
  //Read info to std::vector
  std::vector<std::string> v;
  {
    std::ifstream f("tmp.txt");
    std::string s;
    for (int i=0; !f.eof(); ++i)
    {
      std::getline(f,s);
      v.push_back(s);
    }
  }
  //Analyze std::vector
  BOOST_FOREACH(const std::string& s,v)
  {
    if (s.size() > 16
      && s.substr(0,16)=="DISTRIB_CODENAME")
    {
      const int i = s.find_last_of("=");
      return s.substr(i+1,s.size()-(i+1));
    }
  }
  return "";
}
//---------------------------------------------------------------------------
/*
///GetQuantLibVersion returns the version number of QuantLib currently installed.
///From http://www.richelbilderbeek.nl/CppGetQuantLibVersion.htm
const std::string GetQuantLibVersion()
{
  return QL_LIB_VERSION;
}
*/
//---------------------------------------------------------------------------
///GetQtVersion returns the version of the Qt library installed.
///From http://www.richelbilderbeek.nl/CppGetQtVersion.htm
const std::string GetQtVersion()
{
  return QT_VERSION_STR;
}
//---------------------------------------------------------------------------
///GetQtCreatorVersion returns the version number of the Qt Creator distribution installed.
///From http://www.richelbilderbeek.nl/CppGetQtCreatorVersion.htm
///DOES NOT WORK: 'qtcreator -version > tmp.txt'
///does not create an output file :-(
/*
const std::string GetQtCreatorVersion()
{
  const std::string qt_creator_path
    = "/home/richel/qtsdk-2010.04/bin/Projects/NokiaQtSdk/QtCreator/bin/qtcreator";
  const std::string filename = "tmp.txt";
  //Save info to tmp.txt
  {
    const std::string cmd
      = qt_creator_path
      + std::string(" -version > ")
      + filename;
    std::system(cmd.c_str());
  }
  //Read info to std::vector
  std::vector<std::string> v;
  {
    std::ifstream f(filename.c_str());
    assert(f);
    std::string s;
    for (int i=0; !f.eof(); ++i)
    {
      std::getline(f,s);
      v.push_back(s);
    }
  }
  //Analyze std::vector
  BOOST_FOREACH(const std::string& s,v)
  {
    if (s.size() > 16
      && s.substr(0,10)=="Qt Creator")
    {
      std::remove(filename.c_str());
      return s.substr(11,5);
    }
  }
  return "(unknown)";
}
*/
//---------------------------------------------------------------------------
///GetStlVersion returns the version number of the GCC STL currently installed.
///From http://www.richelbilderbeek.nl/CppGetStlVersion.htm
const std::string GetStlVersion()
{
  return __VERSION__;
}
//---------------------------------------------------------------------------
///GetUbuntuVersion returns the version number of the Ubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetUbuntuVersion.htm
const std::string GetUbuntuVersion()
{
  const std::string filename = "tmp.txt";
  //Save info to tmp.txt
  {
    const std::string cmd
      = std::string("cat /etc/*-release > ")
      + filename;
    const int error_code = std::system(cmd.c_str());
    if (error_code) throw std::runtime_error(
      std::string("Command ")
      + cmd
      + std::string("failed"));
  }
  //Read info to std::vector
  std::vector<std::string> v;
  {
    std::ifstream f(filename.c_str());
    std::string s;
    for (int i=0; !f.eof(); ++i)
    {
      std::getline(f,s);
      v.push_back(s);
    }
  }
  //Analyze std::vector
  BOOST_FOREACH(const std::string& s,v)
  {
    if (s.size() > 15
      && s.substr(0,15)=="DISTRIB_RELEASE")
    {
      const int i = s.find_last_of("=");
      return s.substr(i+1,s.size()-(i+1));
    }
  }
  std::remove(filename.c_str());
  return "";
}
//---------------------------------------------------------------------------
///GetUbuntuVersionCodename returns the codename of the Ubuntu distribution currently installed.
///From http://www.richelbilderbeek.nl/CppGetUbuntuVersionCodename.htm
const std::string GetUbuntuVersionCodename()
{
  //Save info to tmp.txt
  {
    const std::string cmd = "cat /etc/*-release > tmp.txt";
    const int error_code = std::system(cmd.c_str());
    if (error_code) throw std::runtime_error(
      std::string("Command ")
      + cmd
      + std::string("failed"));
  }
  //Read info to std::vector
  std::vector<std::string> v;
  {
    std::ifstream f("tmp.txt");
    std::string s;
    for (int i=0; !f.eof(); ++i)
    {
      std::getline(f,s);
      v.push_back(s);
    }
  }
  //Analyze std::vector
  BOOST_FOREACH(const std::string& s,v)
  {
    if (s.size() > 16
      && s.substr(0,16)=="DISTRIB_CODENAME")
    {
      const int i = s.find_last_of("=");
      return s.substr(i+1,s.size()-(i+1));
    }
  }
  return "";
}
//---------------------------------------------------------------------------
///GetVirtualBoxVersion returns the version of the currently installed VirtualBox
///From http://www.richelbilderbeek.nl/CppGetVirtualBoxVersion.htm
const std::string GetVirtualBoxVersion()
{
  const std::string filename = "tmp.txt";
  //Save info to temporary file
  {
    const std::string cmd
      = std::string("vboxmanage --version > ")
      + filename;
    const int error_code = std::system(cmd.c_str());
    if (error_code) throw std::runtime_error(
      std::string("Command ")
      + cmd
      + std::string("failed"));
  }
  {
    std::ifstream f(filename.c_str());
    std::string version;
    f >> version;
    //Delete temporary file
    std::remove(filename.c_str());
    return version;
  }
}
//---------------------------------------------------------------------------
///GetWineVersion returns the version of the currently installed Wine
///From http://www.richelbilderbeek.nl/CppGetWineVersion.htm
const std::string GetWineVersion()
{
  const std::string filename = "tmp.txt";
  //Save info to temporary file
  {
    const std::string cmd
      = std::string("wine --version > ")
      + filename;
    const int error_code = std::system(cmd.c_str());
    if (error_code) throw std::runtime_error(
      std::string("Command ")
      + cmd
      + std::string("failed"));
  }
  {
    std::ifstream f(filename.c_str());
    std::string version;
    //Reads wine-x.y.z
    f >> version;
    //Remove 'wine-' prefix
    version = version.substr(5,version.size() - 5);
    //Delete temporary file
    std::remove(filename.c_str());
    return version;
  }
}
//---------------------------------------------------------------------------
///GetWtVersion returns the version of the currently installed Wt library
///From http://www.richelbilderbeek.nl/CppGetWtVersion.htm
const std::string GetWtVersion()
{
  return WT_VERSION_STR;
}
//---------------------------------------------------------------------------
} //~namespace Version
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/main.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <fstream>
#include <iostream>
//---------------------------------------------------------------------------
#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>
//---------------------------------------------------------------------------
#include "codetohtml.h"
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppGetPath.htm
const std::string GetPath(const std::string& filename)
{
  return boost::filesystem::path(filename).parent_path().string();
}
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppGetCurrentFolder.htm
const std::string GetCurrentFolder(const std::string& s)
{
  return GetPath(s);
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
  // Declare the supported options.
  boost::program_options::options_description d("Allowed options for CodeToHtmlConsole");

  //std::string source = GetCurrentFolder(argv[0]) + "/../ToolCodeToHtml/main.cpp";
  //std::string source = GetCurrentFolder(argv[0]) + "/../ToolCodeToHtml";
  std::string source = GetCurrentFolder(argv[0]) + "/../ToolCodeToHtml/ToolCodeToHtmlConsole.pro";

  d.add_options()
      ("help",
        "produce this help message")
      ("source",
         boost::program_options::value<std::string>(&source),
         "File or folder to convert to HTML")
       ;

  boost::program_options::variables_map m;
  boost::program_options::store(
    boost::program_options::parse_command_line(
      argc, argv, d), m);
  boost::program_options::notify(m);

  //If one of the options is set to 'help'...
  if (m.count("help"))
  {
    //Display the options_description
    std::cout << d << "\n";
    return 0;
  }

  std::cout << "Source: " << source << "\n";
  if (!boost::filesystem::exists(source))
  {
    std::cout << "Source exists: no\n";
    std::cout << "Specify an existing file or folder\n";
    return 0;
  }
  std::cout << "Source exists: yes\n";
  if (boost::filesystem::is_directory(source))
  {
    std::cout << "Source is directory: yes\n";
  }
  else
  {
    std::cout << "Source is directory: no\n";
  }
  CodeToHtml c;
  const std::string output_filename = boost::filesystem::basename(source) + ".htm";
  if (boost::filesystem::is_directory(source))
  {
    const std::vector<std::string> v = c.ConvertFolder(source);
    std::ofstream f(output_filename.c_str());
    std::copy(v.begin(),v.end(),
      std::ostream_iterator<std::string>(f,"\n"));

  }
  else
  {
    const std::vector<std::string> v = c.ConvertFile(source);
    std::ofstream f(output_filename.c_str());
    std::copy(v.begin(),v.end(),
      std::ostream_iterator<std::string>(f,"\n"));
  }
}

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlconvertcodedialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef QTCODETOHTMLCONVERTCODEDIALOG_H
#define QTCODETOHTMLCONVERTCODEDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/regex.hpp>
//---------------------------------------------------------------------------
#include <QDialog>
//---------------------------------------------------------------------------
#include "about.h"
#include "codetohtml.h"
//---------------------------------------------------------------------------
struct QPlainTextEdit;
//---------------------------------------------------------------------------
namespace Ui {
  class QtCodeToHtmlConvertCodeDialog;
}
//---------------------------------------------------------------------------
class QtCodeToHtmlConvertCodeDialog : public QDialog
{
  Q_OBJECT

public:
  explicit QtCodeToHtmlConvertCodeDialog(QWidget *parent = 0);
  ~QtCodeToHtmlConvertCodeDialog();

protected:
  void changeEvent(QEvent *e);

private:
  Ui::QtCodeToHtmlConvertCodeDialog *ui;
  std::vector<std::string> m_html;

  std::vector<std::string> readCode() const;
  void writeHtml(const std::vector<std::string>& v);

  CodeToHtml::PageType GetPageType() const;

  private slots:
  void on_button_close_clicked();
  void on_button_save_clicked();
  void onSourceChange();
};
//---------------------------------------------------------------------------
#endif // QTCODETOHTMLCONVERTCODEDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlconvertcodedialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <regex>
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/filesystem.hpp>
#include <boost/version.hpp>
//---------------------------------------------------------------------------
#include <QDesktopWidget>
#include <QFile>
#include <QPixmap>
#include <QTextBlock>
#include <QTextDocument>
//---------------------------------------------------------------------------
#include "qtcodetohtmlconvertcodedialog.h"
#include "codetohtml.h"
#include "codetohtmlconvertcodedialog.h"
#include "qtaboutdialog.h"
#include "ui_qtcodetohtmlconvertcodedialog.h"
#include "codetohtmlversion.h"
//---------------------------------------------------------------------------
QtCodeToHtmlConvertCodeDialog::QtCodeToHtmlConvertCodeDialog(QWidget *parent) :
    QDialog(parent,Qt::Window),
    ui(new Ui::QtCodeToHtmlConvertCodeDialog)
{
  ui->setupUi(this);
  QObject::connect(ui->edit_source,SIGNAL(textChanged()),this,SLOT(onSourceChange()));
  QObject::connect(ui->radio_cpp,SIGNAL(clicked()),this,SLOT(onSourceChange()));
  QObject::connect(ui->radio_text,SIGNAL(clicked()),this,SLOT(onSourceChange()));

  //Put this dialog in the screen center
  const QRect scr = QApplication::desktop()->screenGeometry();
  move( scr.center() - rect().center() );

  onSourceChange();
}
//---------------------------------------------------------------------------
QtCodeToHtmlConvertCodeDialog::~QtCodeToHtmlConvertCodeDialog()
{
  delete ui;
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertCodeDialog::changeEvent(QEvent *e)
{
  QDialog::changeEvent(e);
  switch (e->type()) {
  case QEvent::LanguageChange:
    ui->retranslateUi(this);
    break;
  default:
    break;
  }
}
//---------------------------------------------------------------------------
CodeToHtml::PageType QtCodeToHtmlConvertCodeDialog::GetPageType() const
{

  if (ui->radio_cpp->isChecked()) return CodeToHtml::cpp;
  if (ui->radio_text->isChecked()) return CodeToHtml::text;
  assert(!"Should not get here");
}
//---------------------------------------------------------------------------
std::vector<std::string> QtCodeToHtmlConvertCodeDialog::readCode() const
{
  std::vector<std::string> v;

  const QTextDocument * const doc = ui->edit_source->document();
  if (!doc) return v;
  const int n_lines = doc->lineCount();
  std::clog << "Source text contains " << n_lines << " line(s)\n";
  for (int i=0; i!=n_lines; ++i)
  {
    const QTextBlock block = doc->findBlockByNumber(i);
    if (!block.isValid())
    {
      std::clog << "block #" << i << " is not valid and is skipped...\n";
      continue;
    }
    assert(block.isValid());
    const QString line = block.text();
    std::clog << "Line " << i << "/" << n_lines
      << " has text '" << line.toStdString() << "'\n";
    v.push_back(line.toStdString());
  }
  return v;
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertCodeDialog::writeHtml(const std::vector<std::string>& v)
{
  QString text;
  std::for_each(v.begin(),v.end(),
    [&text](std::string s)
    {
      text += QString(s.c_str()) + '\n';
    } );
  ui->webView->setHtml(text);
  ui->edit_html->setPlainText(text);
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertCodeDialog::on_button_save_clicked()
{
  std::ofstream f("target.htm");
  std::copy(m_html.begin(),m_html.end(),std::ostream_iterator<std::string>(f,"\n"));
  std::clog << "File target.htm saved\n";
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertCodeDialog::onSourceChange()
{
  const std::vector<std::string> code = readCode();
  CodeToHtmlConvertCodeDialog d(code,GetPageType());
  m_html = d.ToHtml();
  writeHtml(m_html);
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertCodeDialog::on_button_close_clicked()
{
  close();
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlconvertfolderdialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef QTCODETOHTMLCONVERTFOLDERDIALOG_H
#define QTCODETOHTMLCONVERTFOLDERDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/scoped_ptr.hpp>
//---------------------------------------------------------------------------
#include <QDialog>
//---------------------------------------------------------------------------
namespace Ui {
  class QtCodeToHtmlConvertFolderDialog;
}
//---------------------------------------------------------------------------
struct CodeToHtmlConvertFolderDialog;
//---------------------------------------------------------------------------
///Qt GUI of CodeToHtmlConvertFolderDialog
class QtCodeToHtmlConvertFolderDialog : public QDialog
{
  Q_OBJECT

public:
  explicit QtCodeToHtmlConvertFolderDialog(QWidget *parent = 0);
  ~QtCodeToHtmlConvertFolderDialog();

protected:
  void changeEvent(QEvent *e);

private:
  Ui::QtCodeToHtmlConvertFolderDialog *ui;
  boost::scoped_ptr<CodeToHtmlConvertFolderDialog> m_dialog;

  static const std::string GetCurrentFolder();
  void writeHtml(const std::vector<std::string>& v);

  private slots:
  void on_edit_folder_textChanged(QString );
  void on_button_convert_files_clicked();
  void on_button_save_clicked();
};
//---------------------------------------------------------------------------
#endif // QTCODETOHTMLCONVERTFOLDERDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlconvertfolderdialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <fstream>
#include <iostream>
//---------------------------------------------------------------------------
#include <QDesktopWidget>
#include <QFile>
#include <QPixmap>
#include <QTextBlock>
#include <QTextDocument>
//---------------------------------------------------------------------------
#include "codetohtmlconvertfolderdialog.h"
#include "qtaboutdialog.h"
#include "qtcodetohtmlconvertfolderdialog.h"
#include "codetohtml.h"
#include "codetohtmlconvertfolderdialog.h"
#include "ui_qtcodetohtmlconvertfolderdialog.h"
#include "codetohtmlversion.h"
//---------------------------------------------------------------------------
QtCodeToHtmlConvertFolderDialog::QtCodeToHtmlConvertFolderDialog(QWidget *parent) :
    QDialog(parent,Qt::Window),
    ui(new Ui::QtCodeToHtmlConvertFolderDialog)
{
  ui->setupUi(this);

  QObject::connect(ui->edit_folder,SIGNAL(textEdited(QString)),this,SLOT(on_edit_folder_textChanged(QString)));

  //Put this dialog in the screen center
  const QRect scr = QApplication::desktop()->screenGeometry();
  move( scr.center() - rect().center() );

  on_edit_folder_textChanged(QString());
}
//---------------------------------------------------------------------------
QtCodeToHtmlConvertFolderDialog::~QtCodeToHtmlConvertFolderDialog()
{
  delete ui;
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertFolderDialog::changeEvent(QEvent *e)
{
  QDialog::changeEvent(e);
  switch (e->type()) {
  case QEvent::LanguageChange:
    ui->retranslateUi(this);
    break;
  default:
    break;
  }
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertFolderDialog::on_edit_folder_textChanged(QString )
{
  const std::string folder = ui->edit_folder->text().toStdString();
  const std::vector<std::string> v
    = CodeToHtml::SortFiles(
        CodeToHtml::FilterFiles(
          CodeToHtml::GetFilesInFolder(folder)));

  if (v.empty())
  {
    ui->edit_files_found->clear();
    ui->edit_files_found->appendPlainText("Folder does not exist");
    return;
  }

  ui->edit_files_found->clear();

  std::for_each(v.begin(), v.end(),
    [&ui](const std::string& s)
    {
      ui->edit_files_found->appendPlainText(QString(s.c_str()));
    });
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertFolderDialog::on_button_convert_files_clicked()
{
  const std::string folder = ui->edit_folder->text().toStdString();
  if (!m_dialog || m_dialog->GetFolder() != folder)
  {
    m_dialog.reset(new CodeToHtmlConvertFolderDialog(folder));
    const std::vector<std::string> v = m_dialog->ToHtml();
    writeHtml(v);
  }
}
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppGetCurrentFolder.htm
const std::string QtCodeToHtmlConvertFolderDialog::GetCurrentFolder()
{
  QString s = QApplication::applicationDirPath();
  return s.toStdString();
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertFolderDialog::writeHtml(const std::vector<std::string>& v)
{
  QString text;
  std::for_each(v.begin(),v.end(),
    [&text](std::string s)
  {
    text += QString(s.c_str()) + '\n';
  } );
  ui->webView->setHtml(text);
  ui->edit_html->setPlainText(text);
}
//---------------------------------------------------------------------------
void QtCodeToHtmlConvertFolderDialog::on_button_save_clicked()
{
  std::ofstream f("target.htm");
  const std::string s = ui->edit_html->document()->toPlainText().toStdString();
  f << s;
  std::clog << "File target.htm saved\n";
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlcreateemptypagedialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef QTCODETOHTMLCREATEEMPTYPAGEDIALOG_H
#define QTCODETOHTMLCREATEEMPTYPAGEDIALOG_H
//---------------------------------------------------------------------------
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/regex.hpp>
//---------------------------------------------------------------------------
#include <QDialog>
//---------------------------------------------------------------------------
#include "about.h"
#include "codetohtml.h"
//---------------------------------------------------------------------------
struct QPlainTextEdit;
//---------------------------------------------------------------------------
namespace Ui {
  class QtCodeToHtmlCreateEmptyPageDialog;
}
//---------------------------------------------------------------------------
class QtCodeToHtmlCreateEmptyPageDialog : public QDialog
{
  Q_OBJECT

public:
  explicit QtCodeToHtmlCreateEmptyPageDialog(QWidget *parent = 0);
  ~QtCodeToHtmlCreateEmptyPageDialog();

protected:
  void changeEvent(QEvent *e);

private:
  Ui::QtCodeToHtmlCreateEmptyPageDialog *ui;

  std::vector<std::string> m_html;
  void writeHtml(const std::vector<std::string>& v);

  private slots:
  void on_button_close_clicked();
  void on_button_save_clicked();
  void on_box_technical_info_clicked();
};
//---------------------------------------------------------------------------
#endif // QTCODETOHTMLCREATEEMPTYPAGEDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlcreateemptypagedialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <regex>
#include <string>
#include <vector>
//---------------------------------------------------------------------------
#include <boost/filesystem.hpp>
#include <boost/version.hpp>
//---------------------------------------------------------------------------
#include <QDesktopWidget>
#include <QFile>
#include <QPixmap>
#include <QTextBlock>
#include <QTextDocument>
//---------------------------------------------------------------------------
#include "qtcodetohtmlcreateemptypagedialog.h"
#include "codetohtml.h"
#include "codetohtmlcreateemptypagedialog.h"
#include "qtaboutdialog.h"
#include "ui_qtcodetohtmlcreateemptypagedialog.h"
#include "codetohtmlversion.h"
//---------------------------------------------------------------------------
QtCodeToHtmlCreateEmptyPageDialog::QtCodeToHtmlCreateEmptyPageDialog(QWidget *parent) :
    QDialog(parent,Qt::Window),
    ui(new Ui::QtCodeToHtmlCreateEmptyPageDialog)
{
  ui->setupUi(this);

  //Put this dialog in the screen center
  const QRect scr = QApplication::desktop()->screenGeometry();
  move( scr.center() - rect().center() );

  on_box_technical_info_clicked();
}
//---------------------------------------------------------------------------
QtCodeToHtmlCreateEmptyPageDialog::~QtCodeToHtmlCreateEmptyPageDialog()
{
  delete ui;
}
//---------------------------------------------------------------------------
void QtCodeToHtmlCreateEmptyPageDialog::changeEvent(QEvent *e)
{
  QDialog::changeEvent(e);
  switch (e->type()) {
  case QEvent::LanguageChange:
    ui->retranslateUi(this);
    break;
  default:
    break;
  }
}
//---------------------------------------------------------------------------
void QtCodeToHtmlCreateEmptyPageDialog::writeHtml(const std::vector<std::string>& v)
{
  QString text;
  std::for_each(v.begin(),v.end(),
    [&text](std::string s)
    {
      text += QString(s.c_str()) + '\n';
    } );
  ui->webView->setHtml(text);
  ui->edit_html->setPlainText(text);
}
//---------------------------------------------------------------------------
void QtCodeToHtmlCreateEmptyPageDialog::on_button_save_clicked()
{
  std::ofstream f("target.htm");
  std::copy(m_html.begin(),m_html.end(),std::ostream_iterator<std::string>(f,"\n"));
  std::clog << "File target.htm saved\n";
}
//---------------------------------------------------------------------------
void QtCodeToHtmlCreateEmptyPageDialog::on_button_close_clicked()
{
  close();
}
//---------------------------------------------------------------------------
void QtCodeToHtmlCreateEmptyPageDialog::on_box_technical_info_clicked()
{
  CodeToHtmlCreateEmptyPageDialog d(ui->box_technical_info->isChecked());
  m_html = d.ToHtml();
  writeHtml(m_html);
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlmenudialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef QTCODETOHTMLMENUDIALOG_H
#define QTCODETOHTMLMENUDIALOG_H
//---------------------------------------------------------------------------
#include <QDialog>
//---------------------------------------------------------------------------
namespace Ui {
  class QtCodeToHtmlMenuDialog;
}
//---------------------------------------------------------------------------
class QtCodeToHtmlMenuDialog : public QDialog
{
  Q_OBJECT

public:
  explicit QtCodeToHtmlMenuDialog(QWidget *parent = 0);
  ~QtCodeToHtmlMenuDialog();

protected:
  void changeEvent(QEvent *e);

private:
  Ui::QtCodeToHtmlMenuDialog *ui;

private slots:
  void on_button_quit_clicked();
  void on_button_about_clicked();
  void on_button_convert_code_clicked();
  void on_button_convert_folder_clicked();
  void on_button_create_empty_page_clicked();
};
//---------------------------------------------------------------------------
#endif // QTCODETOHTMLMENUDIALOG_H

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtcodetohtmlmenudialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlmenudialog.h"
#include "qtaboutdialog.h"
#include "qtcodetohtmlconvertcodedialog.h"
#include "qtcodetohtmlconvertfolderdialog.h"
#include "qtcodetohtmlcreateemptypagedialog.h"
#include "qtcodetohtmlmenudialog.h"
#include "ui_qtcodetohtmlmenudialog.h"
//---------------------------------------------------------------------------
QtCodeToHtmlMenuDialog::QtCodeToHtmlMenuDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::QtCodeToHtmlMenuDialog)
{
  ui->setupUi(this);
}
//---------------------------------------------------------------------------
QtCodeToHtmlMenuDialog::~QtCodeToHtmlMenuDialog()
{
  delete ui;
}
//---------------------------------------------------------------------------
void QtCodeToHtmlMenuDialog::changeEvent(QEvent *e)
{
  QDialog::changeEvent(e);
  switch (e->type()) {
  case QEvent::LanguageChange:
    ui->retranslateUi(this);
    break;
  default:
    break;
  }
}
//---------------------------------------------------------------------------
void QtCodeToHtmlMenuDialog::on_button_convert_code_clicked()
{
  QtCodeToHtmlConvertCodeDialog d;
  this->hide();
  d.exec();
  this->show();
}
//---------------------------------------------------------------------------
void QtCodeToHtmlMenuDialog::on_button_convert_folder_clicked()
{
  QtCodeToHtmlConvertFolderDialog d;
  this->hide();
  d.exec();
  this->show();
}
//---------------------------------------------------------------------------
void QtCodeToHtmlMenuDialog::on_button_about_clicked()
{
  QtAboutDialog d(CodeToHtmlMenuDialog::GetAbout());
  this->hide();
  d.exec();
  this->show();
}
//---------------------------------------------------------------------------
void QtCodeToHtmlMenuDialog::on_button_quit_clicked()
{
  close();
}
//---------------------------------------------------------------------------
void QtCodeToHtmlMenuDialog::on_button_create_empty_page_clicked()
{
  QtCodeToHtmlCreateEmptyPageDialog d;
  this->hide();
  d.exec();
  this->show();
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/qtmain.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2011  Richel Bilderbeek

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 3 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, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include <QtGui/QApplication>
#include "qtcodetohtmlmenudialog.h"
#include "trace.h"
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
  QApplication a(argc, argv);
  { START_TRACE(); }
  QtCodeToHtmlMenuDialog w;
  w.show();
  return a.exec();
}
//---------------------------------------------------------------------------

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/crosscompiletowindows.sh

 

#!/bin/sh
#From http://richelbilderbeek.nl/CppQtCrosscompileToWindowsExample15.htm

echo "Cross compiling to Windows"

echo "1/2: Creating Windows makefile"
i686-pc-mingw32-qmake ToolCodeToHtml.pro

echo "2/2: making makefile"

make

echo "Done"

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/memcheck.sh

 

#!/bin/sh
valgrind --leak-check=full -v --track-origins=yes --show-reachable=yes --log-file=memcheck.txt ../ToolCodeToHtml-build-desktop/./ToolCodeToHtml

 

 

 

 

 

/home/richel/Projects/Tools/ToolCodeToHtml/zip.sh

 

#!/bin/sh
#zip packs all the files to port into a single .zip file,
#minicking the same folder structure
#Folder structure
# *
#  * Classes
#    * CppAbout
#    * CppQtAboutDialog
#    * CppProFile
#  * Tools
#    * ToolCodeToHtml

echo "Creating a sloccount file"
sloccount ../ProjectCodeToHtml > sloccount.txt

echo "Creating documentation"
doxygen doxygen_config.txt

echo "Removing user information"
rm *.user

echo "Removing possible CodeToHtml temp file"
rm copy.txt
rm tmp.txt

echo "Mimicking file structure"
mkdir temp_zip
mkdir temp_zip/Classes
mkdir temp_zip/Classes/CppAbout
mkdir temp_zip/Classes/CppQtAboutDialog
mkdir temp_zip/Classes/CppProFile
mkdir temp_zip/Tools
mkdir temp_zip/Tools/ToolCodeToHtml

echo "Copying files"
cp ../../Classes/CppAbout/*.* temp_zip/Classes/CppAbout
cp ../../Classes/CppQtAboutDialog/*.* temp_zip/Classes/CppQtAboutDialog
cp ../../Classes/CppProFile/*.* temp_zip/Classes/CppProFile
cp ../../Tools/ToolCodeToHtml/*.* temp_zip/Tools/ToolCodeToHtml

FILENAME=ToolCodeToHtmlSource_1_24
ZIP_FILENAME=$FILENAME".zip"

#echo "Compressing files"
cd temp_zip
zip -r $FILENAME Classes
#zip -r $FILENAME Games
#zip -r $FILENAME Libraries
#zip -r $FILENAME Projects
zip -r $FILENAME Tools
cd ..
cp "temp_zip/"$ZIP_FILENAME $ZIP_FILENAME


echo "Cleaning up"
rm temp_zip/Classes/CppAbout/*.*
rm temp_zip/Classes/CppQtAboutDialog/*.*
rm temp_zip/Classes/CppProFile/*.*

rmdir temp_zip/Classes/CppAbout
rmdir temp_zip/Classes/CppQtAboutDialog
rmdir temp_zip/Classes/CppProFile
rmdir temp_zip/Classes

rm temp_zip/Tools/ToolCodeToHtml/*.*
rmdir temp_zip/Tools/ToolCodeToHtml
rmdir temp_zip/Tools
rm temp_zip/*.*
rmdir temp_zip
echo "Done"

 

 

 

 

 

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

 

Valid XHTML 1.0 Strict