// Created: 06/01/99
// RCS-ID: $Id$
// Copyright: (c) 1999 VZ
-// Licence: GPL
+// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
/*
// headers
// -----------------------------------------------------------------------------
-// wxWindows
+// wxWidgets
#include "wx/wxprec.h"
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
+#if wxUSE_UNICODE
+ #error "HelpGen doesn't build in Unicode mode"
+#endif
+
#ifndef WX_PRECOMP
#include "wx/string.h"
#include "wx/log.h"
#include "wx/dynarray.h"
+ #include "wx/app.h"
#endif // WX_PRECOMP
#include "wx/file.h"
#include <stdio.h>
#include <time.h>
-// argh, Windows defines this
-#ifdef GetCurrentTime
-#undef GetCurrentTime
-#endif
-
// -----------------------------------------------------------------------------
// private functions
// -----------------------------------------------------------------------------
// return the label for the given function name (i.e. argument of \label)
-static wxString MakeLabel(const char *classname, const char *funcname = NULL);
+static wxString MakeLabel(const wxChar *classname, const wxChar *funcname = NULL);
// return the whole \helpref{arg}{arg_label} string
-static wxString MakeHelpref(const char *argument);
+static wxString MakeHelpref(const wxChar *argument);
// [un]quote special TeX characters (in place)
static void TeXFilter(wxString* str);
// get the string with current time (returns pointer to static buffer)
// timeFormat is used for the call of strftime(3)
-static const char *GetCurrentTime(const char *timeFormat);
+static const char *GetCurrentTimeFormatted(const char *timeFormat);
// get the string containing the program version
static const wxString GetVersionString();
return 1;
}
- wxString dtorname = wxString('~') + classname;
+ wxString dtorname = wxString(_T("~")) + classname;
// there is only one dtor, so the logic here is simpler
if ( (*pp1)->name == dtorname ) {
}
// two normal methods
- return strcmp((*pp1)->name, (*pp2)->name);
+ return wxStrcmp((*pp1)->name, (*pp2)->name);
}
}
bool FlushAll()
{
if ( m_text.empty() )
- return TRUE;
+ return true;
if ( !Write(m_text) ) {
- wxLogError("Failed to output generated documentation.");
+ wxLogError(_T("Failed to output generated documentation."));
- return FALSE;
+ return false;
}
m_text.clear();
- return TRUE;
+ return true;
}
private:
// already have)
bool AddNamesFromFile(const wxString& filename);
- // return TRUE if we ignore this function
+ // return true if we ignore this function
bool IgnoreMethod(const wxString& classname,
const wxString& funcname) const
{
if ( IgnoreClass(classname) )
- return TRUE;
+ return true;
IgnoreListEntry ignore(classname, funcname);
return m_ignore.Index(&ignore) != wxNOT_FOUND;
}
- // return TRUE if we ignore this class entirely
+ // return true if we ignore this class entirely
bool IgnoreClass(const wxString& classname) const
{
- IgnoreListEntry ignore(classname, "");
+ IgnoreListEntry ignore(classname, _T(""));
return m_ignore.Index(&ignore) != wxNOT_FOUND;
}
IgnoreListEntry *second);
// for efficiency, let's sort it
+public: // FIXME: macro requires it
WX_DEFINE_SORTED_ARRAY(IgnoreListEntry *, ArrayNamesToIgnore);
+protected:
ArrayNamesToIgnore m_ignore;
private:
wxTeXFile m_file; // file we're writing to now
// state variables
- bool m_inClass, // TRUE after file successfully opened
+ bool m_inClass, // true after file successfully opened
m_inTypesSection, // enums & typedefs go there
m_inMethodSection, // functions go here
m_isFirstParam; // first parameter of current function?
DocManager(bool checkParamNames);
~DocManager();
- // returns FALSE on failure
+ // returns false on failure
bool ParseTeXFile(const wxString& filename);
- // returns FALSE if there were any differences
+ // returns false if there were any differences
bool DumpDifferences(spContext *ctxTop) const;
// get our `ignore' object
// returns the length of 'match' if the string 'str' starts with it or 0
// otherwise
- static size_t TryMatch(const char *str, const char *match);
+ static size_t TryMatch(const wxChar *str, const wxChar *match);
// skip spaces: returns pointer to first non space character (also
// updates the value of m_line)
}
// skips characters until the next 'c' in '*pp' unless it ends before in
- // which case FALSE is returned and pp points to '\0', otherwise TRUE is
+ // which case false is returned and pp points to '\0', otherwise true is
// returned and pp points to 'c'
bool SkipUntil(const char **pp, char c);
// the same as SkipUntil() but only spaces are skipped: on first non space
- // character different from 'c' the function stops and returns FALSE
+ // character different from 'c' the function stops and returns false
bool SkipSpaceUntil(const char **pp, char c);
// extract the string between {} and modify '*pp' to point at the
wxString m_type;
};
+ friend class ParamInfo; // for access to TypeInfo
+
// info abotu a function parameter
class ParamInfo
{
wxString m_value; // default value
};
- WX_DEFINE_ARRAY(ParamInfo *, ArrayParamInfo);
+public: // FIXME: macro requires it
+ WX_DEFINE_ARRAY_PTR(ParamInfo *, ArrayParamInfo);
// info about a function
struct MethodInfo
ArrayParamInfo m_params;
};
- WX_DEFINE_ARRAY(MethodInfo *, ArrayMethodInfo);
- WX_DEFINE_ARRAY(ArrayMethodInfo *, ArrayMethodInfos);
+ WX_DEFINE_ARRAY_PTR(MethodInfo *, ArrayMethodInfo);
+ WX_DEFINE_ARRAY_PTR(ArrayMethodInfo *, ArrayMethodInfos);
+private:
// first array contains the names of all classes we found, the second has a
// pointer to the array of methods of the given class at the same index as
// the class name appears in m_classes
wxInitializer initializer;
if ( !initializer )
{
- fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
+ fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
return -1;
}
wxArrayString filesH, filesTeX;
wxString directoryOut, // directory for 'dmup' output
ignoreFile; // file with classes/functions to ignore
- bool overwrite = FALSE, // overwrite existing files during 'dump'?
- paramNames = FALSE; // check param names during 'diff'?
+ bool overwrite = false, // overwrite existing files during 'dump'?
+ paramNames = false; // check param names during 'diff'?
for ( int current = 1; current < argc ; current++ ) {
// all options have one letter
case 'q':
// be quiet
- wxLog::GetActiveTarget()->SetVerbose(FALSE);
+ wxLog::GetActiveTarget()->SetVerbose(false);
continue;
case 'H':
break;
}
- paramNames = TRUE;
+ paramNames = true;
continue;
case 'f':
break;
}
- overwrite = TRUE;
+ overwrite = true;
continue;
case 'o':
}
directoryOut = argv[current];
- if ( !!directoryOut ) {
+ if ( !directoryOut.IsEmpty() ) {
// terminate with a '/' if it doesn't have it
switch ( directoryOut.Last() ) {
case '/':
// create a parser object and a visitor derivation
CJSourceParser parser;
HelpGenVisitor visitor(directoryOut, overwrite);
- if ( !!ignoreFile && mode == Mode_Dump )
+ if ( !ignoreFile.IsEmpty() && mode == Mode_Dump )
visitor.GetIgnoreHandler().AddNamesFromFile(ignoreFile);
spContext *ctxTop = NULL;
wxLogError("Can't complete diff.");
// failure
- return FALSE;
+ return false;
}
DocManager docman(paramNames);
}
}
- if ( !!ignoreFile )
+ if ( !ignoreFile.IsEmpty() )
docman.GetIgnoreHandler().AddNamesFromFile(ignoreFile);
docman.DumpDifferences(ctxTop);
{
m_inClass =
m_inTypesSection =
- m_inMethodSection = FALSE;
+ m_inMethodSection = false;
m_classname =
m_funcName =
void HelpGenVisitor::InsertDataStructuresHeader()
{
if ( !m_inTypesSection ) {
- m_inTypesSection = TRUE;
+ m_inTypesSection = true;
m_file.WriteVerbatim("\\wxheading{Data structures}\n\n");
}
void HelpGenVisitor::InsertMethodsHeader()
{
if ( !m_inMethodSection ) {
- m_inMethodSection = TRUE;
+ m_inMethodSection = true;
m_file.WriteVerbatim( "\\latexignore{\\rtfignore{\\wxheading{Members}}}\n\n");
}
void HelpGenVisitor::CloseClass()
{
- CloseFunction();
+ CloseFunction();
- if ( m_inClass ) {
+ if ( m_inClass )
+ {
size_t count = m_arrayFuncDocs.GetCount();
- if ( count ) {
- size_t n;
+ if ( count )
+ {
+ size_t n;
FunctionDocEntry::classname = m_classname;
m_arrayFuncDocs.Sort(FunctionDocEntry::Compare);
- // Now examine each first line and if it's been seen, cut it
- // off (it's a duplicate \membersection)
- wxHashTable membersections(wxKEY_STRING);
+ // Now examine each first line and if it's been seen, cut it
+ // off (it's a duplicate \membersection)
+ wxHashTable membersections(wxKEY_STRING);
for ( n = 0; n < count; n++ )
- {
+ {
wxString section(m_arrayFuncDocs[n].text);
- // Strip leading whitespace
- int pos = section.Find("\\membersection");
- if (pos > -1)
- {
- section = section.Mid(pos);
- }
-
- wxString ms(section.BeforeFirst(wxT('\n')));
- if (membersections.Get(ms))
- {
- m_arrayFuncDocs[n].text = section.AfterFirst(wxT('\n'));
- }
- else
- {
- membersections.Put(ms, & membersections);
- }
+ // Strip leading whitespace
+ int pos = section.Find("\\membersection");
+ if (pos > -1)
+ {
+ section = section.Mid(pos);
+ }
+
+ wxString ms(section.BeforeFirst(wxT('\n')));
+ if (membersections.Get(ms))
+ {
+ m_arrayFuncDocs[n].text = section.AfterFirst(wxT('\n'));
+ }
+ else
+ {
+ membersections.Put(ms, & membersections);
+ }
}
for ( n = 0; n < count; n++ ) {
m_arrayFuncDocs.Empty();
}
- m_inClass = FALSE;
+ m_inClass = false;
m_classname.clear();
}
- m_file.FlushAll();
+ m_file.FlushAll();
}
void HelpGenVisitor::EndVisit()
m_fileHeader.Empty();
m_file.FlushAll();
- if (m_file.IsOpened())
- {
- m_file.Flush();
- m_file.Close();
- }
+ if (m_file.IsOpened())
+ {
+ m_file.Flush();
+ m_file.Close();
+ }
wxLogVerbose("%s: finished generating for the current file.",
- GetCurrentTime("%H:%M:%S"));
+ GetCurrentTimeFormatted("%H:%M:%S"));
}
void HelpGenVisitor::VisitFile( spFile& file )
{
m_fileHeader = file.mFileName;
wxLogVerbose("%s: started generating docs for classes from file '%s'...",
- GetCurrentTime("%H:%M:%S"), m_fileHeader.c_str());
+ GetCurrentTimeFormatted("%H:%M:%S"), m_fileHeader.c_str());
}
void HelpGenVisitor::VisitClass( spClass& cl )
{
CloseClass();
- if (m_file.IsOpened())
- {
- m_file.Flush();
- m_file.Close();
- }
+ if (m_file.IsOpened())
+ {
+ m_file.Flush();
+ m_file.Close();
+ }
wxString name = cl.GetName();
}
m_inMethodSection =
- m_inTypesSection = FALSE;
+ m_inTypesSection = false;
wxLogInfo("Created new file '%s' for class '%s'.",
filename.c_str(), name.c_str());
"\\section{\\class{%s}}\\label{%s}\n\n",
GetVersionString().c_str(),
m_fileHeader.c_str(),
- GetCurrentTime("%d/%b/%y %H:%M:%S"),
+ GetCurrentTimeFormatted("%d/%b/%y %H:%M:%S"),
name.c_str(),
wxString(name).MakeLower().c_str());
// if the header includes other headers they must be related to it... try to
// automatically generate the "See also" clause
if ( !m_headers.IsEmpty() ) {
- // correspondence between wxWindows headers and class names
+ // correspondence between wxWidgets headers and class names
static const char *headers[] = {
"object",
"defs",
derived << "No base class";
}
else {
- bool first = TRUE;
+ bool first = true;
for ( StrListT::const_iterator i = baseClasses.begin();
i != baseClasses.end();
i++ ) {
derived << "\\\\\n";
}
else {
- first = FALSE;
+ first = false;
}
wxString baseclass = *i;
InsertTypedefDocs();
InsertEnumDocs();
- //m_file.Flush();
+ //m_file.Flush();
}
void HelpGenVisitor::VisitEnumeration( spEnumeration& en )
// save state info
m_funcName = funcname;
- m_isFirstParam = TRUE;
+ m_isFirstParam = true;
m_textStoredFunctionComment = GetAllComments(op);
// check for the special case of dtor
wxString dtor;
- if ( (funcname[0] == '~') && (m_classname == funcname.c_str() + 1) ) {
+ if ( (funcname[0u] == '~') && (m_classname == funcname.c_str() + 1) ) {
dtor.Printf("\\destruct{%s}", m_classname.c_str());
funcname = dtor;
}
- m_textFunc.Printf("\n"
- "\\membersection{%s::%s}\\label{%s}\n",
- m_classname.c_str(), funcname.c_str(),
- MakeLabel(m_classname, funcname).c_str());
+ m_textFunc.Printf("\n"
+ "\\membersection{%s::%s}\\label{%s}\n",
+ m_classname.c_str(), funcname.c_str(),
+ MakeLabel(m_classname, funcname).c_str());
- wxString func;
- func.Printf("\n"
+ wxString func;
+ func.Printf("\n"
"\\%sfunc{%s%s}{%s}{",
op.mIsConstant ? "const" : "",
op.mIsVirtual ? "virtual " : "",
op.mRetType.c_str(),
funcname.c_str());
- m_textFunc += func;
+ m_textFunc += func;
}
void HelpGenVisitor::VisitParameter( spParameter& param )
return;
if ( m_isFirstParam ) {
- m_isFirstParam = FALSE;
+ m_isFirstParam = false;
}
else {
m_textFunc << ", ";
wxFile file(m_filename, wxFile::read);
if ( !file.IsOpened() )
- return FALSE;
+ return false;
off_t len = file.Length();
if ( len == wxInvalidOffset )
- return FALSE;
+ return false;
char *buf = new char[len + 1];
buf[len] = '\0';
if ( file.Read(buf, len) == wxInvalidOffset ) {
delete [] buf;
- return FALSE;
+ return false;
}
// reinit everything
m_line = 1;
wxLogVerbose("%s: starting to parse doc file '%s'.",
- GetCurrentTime("%H:%M:%S"), m_filename.c_str());
+ GetCurrentTimeFormatted("%H:%M:%S"), m_filename.c_str());
// the name of the class from the last "\membersection" command: we assume
// that the following "\func" or "\constfunc" always documents a method of
- // this class (and it should always be like that in wxWindows documentation)
+ // this class (and it should always be like that in wxWidgets documentation)
wxString classname;
for ( const char *current = buf; current - buf < len; current++ ) {
TeXUnfilter(&returnType);
current++;
- if ( !SkipSpaceUntil(¤t, '{') ) {
+ if ( !SkipSpaceUntil(¤t, '{') ) {
wxLogWarning("file %s(%d): '{' expected after return type",
m_filename.c_str(), m_line);
current = funcEnd + 1;
// trim spaces from both sides
- funcName.Trim(FALSE);
- funcName.Trim(TRUE);
+ funcName.Trim(false);
+ funcName.Trim(true);
// special cases: '$...$' may be used for LaTeX inline math, remove the
// '$'s
wxArrayString paramNames, paramTypes, paramValues;
- bool isVararg = FALSE;
+ bool isVararg = false;
current++; // skip '\\'
lenMatch = TryMatch(current, "void");
// vararg function?
wxString paramText = ExtractStringBetweenBraces(¤t);
if ( paramText == "..." ) {
- isVararg = TRUE;
+ isVararg = true;
}
else {
wxLogWarning("Parameters of '%s::%s' are in "
delete [] buf;
wxLogVerbose("%s: finished parsing doc file '%s'.\n",
- GetCurrentTime("%H:%M:%S"), m_filename.c_str());
+ GetCurrentTimeFormatted("%H:%M:%S"), m_filename.c_str());
- return TRUE;
+ return true;
}
bool DocManager::DumpDifferences(spContext *ctxTop) const
{
typedef MMemberListT::const_iterator MemberIndex;
- bool foundDiff = FALSE;
+ bool foundDiff = false;
// flag telling us whether the given class was found at all in the header
size_t nClass, countClassesInDocs = m_classes.GetCount();
bool *classExists = new bool[countClassesInDocs];
for ( nClass = 0; nClass < countClassesInDocs; nClass++ ) {
- classExists[nClass] = FALSE;
+ classExists[nClass] = false;
}
// ctxTop is normally an spFile
int index = m_classes.Index(nameClass);
if ( index == wxNOT_FOUND ) {
if ( !m_ignoreNames.IgnoreClass(nameClass) ) {
- foundDiff = TRUE;
+ foundDiff = true;
wxLogError("Class '%s' is not documented at all.",
nameClass.c_str());
continue;
}
else {
- classExists[index] = TRUE;
+ classExists[index] = true;
}
// array of method descriptions for this class
// flags telling if we already processed given function
bool *methodExists = new bool[countMethods];
for ( nMethod = 0; nMethod < countMethods; nMethod++ ) {
- methodExists[nMethod] = FALSE;
+ methodExists[nMethod] = false;
}
wxArrayString aOverloadedMethods;
if ( aMethodsWithSameName.IsEmpty() && ctxMethod->IsPublic() ) {
if ( !m_ignoreNames.IgnoreMethod(nameClass, nameMethod) ) {
- foundDiff = TRUE;
+ foundDiff = true;
wxLogError("'%s::%s' is not documented.",
nameClass.c_str(),
}
else if ( aMethodsWithSameName.GetCount() == 1 ) {
index = (size_t)aMethodsWithSameName[0u];
- methodExists[index] = TRUE;
+ methodExists[index] = true;
if ( m_ignoreNames.IgnoreMethod(nameClass, nameMethod) )
continue;
const ParamInfo& param = method.GetParam(nParam);
if ( m_checkParamNames &&
(param.GetName() != ctxParam->mName) ) {
- foundDiff = TRUE;
+ foundDiff = true;
wxLogError("Parameter #%d of '%s::%s' should be "
"'%s' and not '%s'.",
}
if ( param.GetType() != ctxParam->mType ) {
- foundDiff = TRUE;
+ foundDiff = true;
wxLogError("Type of parameter '%s' of '%s::%s' "
"should be '%s' and not '%s'.",
// mark all methods with this name as existing
for ( nMethod = 0; nMethod < countMethods; nMethod++ ) {
if ( methods[nMethod]->GetName() == nameMethod )
- methodExists[nMethod] = TRUE;
+ methodExists[nMethod] = true;
}
aOverloadedMethods.Add(nameMethod);
if ( !methodExists[nMethod] ) {
const wxString& nameMethod = methods[nMethod]->GetName();
if ( !m_ignoreNames.IgnoreMethod(nameClass, nameMethod) ) {
- foundDiff = TRUE;
+ foundDiff = true;
wxLogError("'%s::%s' is documented but doesn't exist.",
nameClass.c_str(),
// check that all classes we found in the docs really exist
for ( nClass = 0; nClass < countClassesInDocs; nClass++ ) {
if ( !classExists[nClass] ) {
- foundDiff = TRUE;
+ foundDiff = true;
wxLogError("Class '%s' is documented but doesn't exist.",
m_classes[nClass].c_str());
{
wxFile file(filename, wxFile::read);
if ( !file.IsOpened() )
- return FALSE;
+ return false;
off_t len = file.Length();
if ( len == wxInvalidOffset )
- return FALSE;
+ return false;
char *buf = new char[len + 1];
buf[len] = '\0';
if ( file.Read(buf, len) == wxInvalidOffset ) {
delete [] buf;
- return FALSE;
+ return false;
}
wxString line;
delete [] buf;
- return TRUE;
+ return true;
}
// -----------------------------------------------------------------------------
static void TeXFilter(wxString* str)
{
// TeX special which can be quoted (don't include backslash nor braces as
- // we generate them
+ // we generate them
static wxRegEx reNonSpecialSpecials("[#$%&_]"),
reAccents("[~^]");
static void TeXUnfilter(wxString* str)
{
// FIXME may be done much more quickly
- str->Trim(TRUE);
- str->Trim(FALSE);
+ str->Trim(true);
+ str->Trim(false);
// undo TeXFilter
static wxRegEx reNonSpecialSpecials("\\\\([#$%&_{}])"),
wxString comment = (*i)->GetText();
// don't take comments like "// ----------" &c
- comment.Trim(FALSE);
+ comment.Trim(false);
if ( !!comment &&
comment == wxString(comment[0u], comment.length() - 1) + '\n' )
comments << "\n";
return comments;
}
-static const char *GetCurrentTime(const char *timeFormat)
+static const char *GetCurrentTimeFormatted(const char *timeFormat)
{
static char s_timeBuffer[128];
time_t timeNow;
/*
$Log$
+ Revision 1.35 2004/12/12 11:03:31 VZ
+ give an error message if we're built in Unicode mode (in response to bug 1079224)
+
+ Revision 1.34 2004/11/23 09:53:31 JS
+ Changed GPL to wxWindows Licence
+
+ Revision 1.33 2004/11/12 03:30:07 RL
+
+ Cruft cleanup from MJW, strip the tabs out of sound.cpp
+
+ Revision 1.32 2004/11/10 21:02:58 VZ
+ new set of fixes for problems due to huge files support: drop wxFileSize_t, use wxFileOffset only, make wxInvalidOffset an int (main part of the patch 1063498)
+
+ Revision 1.31 2004/10/05 15:38:29 ABX
+ Warning fixes found under hardest mode of OpenWatcom. Seems clean in Borland, MinGW and DMC.
+
+ Revision 1.30 2004/06/18 19:25:50 ABX
+ Small step in making HelpGen up to date unicode application.
+
+ Revision 1.29 2004/06/17 19:00:22 ABX
+ Warning fixes. Code cleanup. Whitespaces and tabs removed.
+
+ Revision 1.28 2004/05/25 11:19:57 JS
+ More name changes
+
+ Revision 1.27 2003/10/13 17:21:30 MBN
+ Compilation fixes.
+
+ Revision 1.26 2003/09/29 15:18:35 MBN
+ (Blind) compilation fix for Sun compiler.
+
+ Revision 1.25 2003/09/03 17:39:27 MBN
+ Compilation fixes.
+
Revision 1.24 2003/08/13 22:59:37 VZ
compilation fix
date: 1999/01/08 17:45:55; author: VZ; state: Exp;
HelpGen is a prototype of the tool for automatic generation of the .tex files
- for wxWindows documentation from C++ headers
+ for wxWidgets documentation from C++ headers
*/
/* vi: set tw=80 et ts=4 sw=4: */
projects / wxWidgets.git / blobdiff