class TDocParser: public TObject

 Constructor called for parsing class sources

 constructor called for parsing text files with Convert()

 destructor, checking whether all methods have been found for gDebug > 3

 Add accessible (i.e. non-private) methods of base class bc
 and its base classes' methods to methodNames.
 If bc==0, we add fCurrentClass's methods (and also private functions).

 Add data members of fCurrentClass and of bc to datamembers, recursively.
 Real data members are in idx 0..2 (public, protected, private access),
 enum constants in idx 3..5.

 Create an anchor from the given line, by hashing it and
 convertig the hash into a custom base64 string.

 Parse text file "in", add links etc, and write output to "out".
 If "isCode", "in" is assumed to be C++ code.

 Expand keywords in text, writing to out.

 Find keywords in line and create URLs around them. Escape characters with a
 special meaning for HTML. Protect "Begin_Html"/"End_Html" pairs, and set the
 parsing context. Evaluate sequences like a::b->c.
 Skip regions where directives are active.

 reduce method count for method called name,
 removing it from fMethodCounts once the count reaches 0.

 Delete output generated by prior runs of all known directives;
 the output file names might have changes.

 Expand preprocessor statements


 Input: line - line containing the CPP statement,
        pos  - position of '#'

  NOTE: Looks for the #include statements and
        creates link to the corresponding file
        if such file exists

 Return the name of module for which sources are currently parsed.

 Process directives to the documentation engine, like "Begin_Html" / "End_Html",
 "Begin_Macro" / "End_Macro", and "Begin_Latex" / "End_Latex".

 checks whether we are in a parse context, return the entry closest
 to the current context.
 If context is a EParseContextFlag just look for the first match in
 the flags

 fill C++ keywords into fgKeywords

 return whether word at line's pos is a valid directive, and returns its
 TDocDirective's TClass object, or 0 if it's not a directive. Set begin
 to kTRUE for "Begin_..."
 You can implement your own handlers by implementing a class deriving
 from TDocHandler, and calling it TDocTagDirective for "BEGIN_TAG",
 "END_TAG" blocks.

 Check if c is a valid C++ name character


  Input: c - a single character

 Output: TRUE if c is a valid C++ name character
         and FALSE if it's not.

   NOTE: Valid name characters are [a..zA..Z0..9_~],

 Check if c is a valid first character for C++ name


  Input: c - a single character

 Output: TRUE if c is a valid first character for C++ name,
         and FALSE if it's not.

   NOTE: Valid first characters are [a..zA..Z_~]

 Search for a method starting at posMethodName, and return its return type,
 its name, and its arguments. If the end of arguments is not found in the
 current line, get a new line from sourceFile, beautify it to srcOut, creating
 an anchor as necessary. When this function returns, posMethodName points to the
 end of the function declaration, i.e. right after the arguments' closing bracket.
 If posMethodName == kNPOS, we look for the first matching method in fMethodCounts.

 Locate methods, starting in the source file, then inline, then
 immediately inside the class declaration. While doing that also
 find the class description and special tags like the macro tag etc.

 Collect methods from the source or header file called filename.
 It generates a beautified version of the source file on the fly;
 the output file is given by the fCurrentClass's name, and sourceExt.
 Documentation is extracted to out.
   lookForSourceInfo: if set, author, lastUpdate, and copyright are
     extracted (i.e. the values contained in fSourceInfo)
   useDocxxStyle: if set, documentation can be in front of the method
     name, not only inside the method. Useful doc Doc++/Doxygen style,
     and inline methods.
   lookForClassDescr: if set, the first line matching the class description
     rules is assumed to be the class description for fCurrentClass; the
     description is written to out.
   methodPattern: if set, methods have to be prepended by this tag. Usually
     the class name + "::". In header files, looking for in-place function
     definitions, this should be 0. In that case, only functions in
     fMethodCounts are searched for.

 Given fCurrentClass, look for methods in its source file,
 and extract documentation to out, while beautifying the source
 file in parallel.

 Given fCurrentClass, look for methods in its header file,
 and extract documentation to out.

 Given fCurrentClass, look for methods in its header file's
 class declaration block, and extract documentation to out,
 while beautifying the header file in parallel.

 Parse the current line as a comment, handling directives and re-formatting
 the comment: remove "/*", "*/", "//", similar characters surrounding lines,
 etc.

 Return kFALSE if the line is not a comment.

 remove the top-most comment context that matches cxxcomment,

 strips ' ', tabs, and newlines from both sides of str

 Write the class description depending (among others) on fClassDocState.

 Write a method, forwarding to TClassDocOutput

 Write fLineSource to out.
 Adjust relative paths first.