PasDoc's autodoc

Class TDocGenerator

Description
Hierarchy
Fields
Methods
Properties

Unit

PasDoc_Gen

Declaration

type TDocGenerator = class(TComponent)

Description

basic documentation generator object

This abstract object will do the complete process of writing documentation files. It will be given the collection of units that was the result of the parsing process and a configuration object that was created from default values and program parameters. Depending on the output format, one or more files may be created (HTML will create several, Tex only one).

Hierarchy

Overview

Fields

Protected FLanguage: TPasDocLanguages;
Protected FClassHierarchy: TStringCardinalTree;
Protected FUnits: TPasUnits;

Methods

Protected procedure DoError(const AMessage: string; const AArguments: array of const; const AExitCode: Word);
Protected procedure DoMessage(const AVerbosity: Cardinal; const MessageType: TPasDocMessageType; const AMessage: string; const AArguments: array of const);
Protected procedure CreateClassHierarchy;
Protected function MakeItemLink(const Item: TBaseItem; const LinkCaption: string; const LinkContext: TLinkContext): string; virtual;
Protected procedure WriteCodeWithLinksCommon(const Item: TPasItem; const Code: string; WriteItemLink: boolean; const NameLinkBegin, NameLinkEnd: string);
Protected procedure CloseStream;
Protected function CodeString(const s: string): string; virtual; abstract;
Protected function ConvertString(const s: string): string; virtual; abstract;
Protected function ConvertChar(c: char): string; virtual; abstract;
Protected function CreateLink(const Item: TBaseItem): string; virtual;
Protected function CreateStream(const AName: string): Boolean;
Protected function ExtractEmailAddress(s: string; out S1, S2, EmailAddress: string): Boolean;
Protected function FixEmailaddressWithoutMailTo(const PossibleEmailAddress: String): String;
Protected function ExtractWebAddress(s: string; out S1, S2, WebAddress: string): Boolean;
Protected function FindGlobal(const NameParts: TNameParts): TBaseItem;
Protected function FindGlobalPasItem(const NameParts: TNameParts): TPasItem; overload;
Protected function FindGlobalPasItem(const ItemName: String): TPasItem; overload;
Protected function GetClassDirectiveName(Directive: TClassDirective): string;
Protected function GetCIOTypeName(MyType: TCIOType): string;
Protected procedure LoadDescriptionFile(n: string);
Protected function SearchItem(s: string; const Item: TBaseItem; WarningIfNotSplittable: boolean): TBaseItem;
Protected function SearchLink(s: string; const Item: TBaseItem; const LinkDisplay: string; const WarningIfLinkNotFound: boolean; out FoundItem: TBaseItem): string; overload;
Protected function SearchLink(s: string; const Item: TBaseItem; const LinkDisplay: string; const WarningIfLinkNotFound: boolean): string; overload;
Protected procedure StoreDescription(ItemName: string; var t: string);
Protected procedure WriteConverted(const s: string; Newline: boolean); overload;
Protected procedure WriteConverted(const s: string); overload;
Protected procedure WriteConvertedLine(const s: string);
Protected procedure WriteDirect(const t: string; Newline: boolean); overload;
Protected procedure WriteDirect(const t: string); overload;
Protected procedure WriteDirectLine(const t: string);
Protected procedure WriteUnit(const HL: integer; const U: TPasUnit); virtual; abstract;
Protected procedure WriteUnits(const HL: integer);
Protected procedure WriteStartOfCode; virtual;
Protected procedure WriteEndOfCode; virtual;
Protected procedure WriteGVUses;
Protected procedure WriteGVClasses;
Protected procedure StartSpellChecking(const AMode: string);
Protected procedure CheckString(const AString: string; const AErrors: TObjectVector);
Protected procedure EndSpellChecking;
Protected function FormatPascalCode(const Line: string): string; virtual;
Protected function FormatNormalCode(AString: string): string; virtual;
Protected function FormatComment(AString: string): string; virtual;
Protected function FormatHex(AString: string): string; virtual;
Protected function FormatNumeric(AString: string): string; virtual;
Protected function FormatFloat(AString: string): string; virtual;
Protected function FormatString(AString: string): string; virtual;
Protected function FormatKeyWord(AString: string): string; virtual;
Protected function FormatCompilerComment(AString: string): string; virtual;
Protected function Paragraph: string; virtual;
Protected function ShortDash: string; virtual;
Protected function EnDash: string; virtual;
Protected function EmDash: string; virtual;
Protected function HtmlString(const S: string): string; virtual;
Protected function LatexString(const S: string): string; virtual;
Protected function LineBreak: string; virtual;
Protected function URLLink(const URL: string): string; overload; virtual;
Protected function URLLink(const URL, LinkDisplay: string): string; overload; virtual;
Protected procedure WriteExternal(const ExternalItem: TExternalItem; const Id: TTranslationID);
Protected procedure WriteExternalCore(const ExternalItem: TExternalItem; const Id: TTranslationID); virtual; abstract;
Protected procedure WriteConclusion;
Protected procedure WriteIntroduction;
Protected procedure WriteAdditionalFiles;
Protected function FormatSection(HL: integer; const Anchor: string; const Caption: string): string; virtual; abstract;
Protected function FormatAnchor(const Anchor: string): string; virtual; abstract;
Protected function FormatBold(const Text: string): string; virtual;
Protected function FormatItalic(const Text: string): string; virtual;
Protected function FormatWarning(const Text: string): string; virtual;
Protected function FormatNote(const Text: string): string; virtual;
Protected function FormatPreformatted(const Text: string): string; virtual;
Protected function FormatImage(FileNames: TStringList): string; virtual;
Protected function FormatList(ListData: TListData): string; virtual; abstract;
Protected function FormatTable(Table: TTableData): string; virtual; abstract;
Protected function FormatTableOfContents(Sections: TStringPairVector): string; virtual;
Public procedure BuildLinks; virtual;
Public procedure ExpandDescriptions;
Public function GetFileExtension: string; virtual; abstract;
Public procedure LoadDescriptionFiles(const c: TStringVector);
Public procedure WriteDocumentation; virtual;
Public constructor Create(AOwner: TComponent); override;
Public destructor Destroy; override;
Public procedure ParseAbbreviationsFile(const AFileName: string);

Properties

Protected property CurrentStream: TStream read FCurrentStream;
Public property Units: TPasUnits read FUnits write FUnits;
Public property Introduction: TExternalItem read FIntroduction write FIntroduction;
Public property Conclusion: TExternalItem read FConclusion write FConclusion;
Public property AdditionalFiles: TExternalItemList read FAdditionalFiles write FAdditionalFiles;
Public property OnMessage: TPasDocMessageEvent read FOnMessage write FOnMessage;
Published property Language: TLanguageID read GetLanguage write SetLanguage default DEFAULT_LANGUAGE;
Published property ProjectName: string read FProjectName write FProjectName;
Published property ExcludeGenerator: Boolean read FExcludeGenerator write FExcludeGenerator default false;
Published property IncludeCreationTime: Boolean read FIncludeCreationTime write FIncludeCreationTime default false;
Published property UseLowercaseKeywords: Boolean read FUseLowercaseKeywords write FUseLowercaseKeywords default false;
Published property Title: string read FTitle write FTitle;
Published property DestinationDirectory: string read FDestDir write SetDestDir;
Published property OutputGraphVizUses: boolean read FGraphVizUses write FGraphVizUses default false;
Published property OutputGraphVizClassHierarchy: boolean read FGraphVizClasses write FGraphVizClasses default false;
Published property LinkGraphVizUses: string read FLinkGraphVizUses write FLinkGraphVizUses;
Published property LinkGraphVizClasses: string read FLinkGraphVizClasses write FLinkGraphVizClasses;
Published property Abbreviations: TStringList read FAbbreviations write SetAbbreviations;
Published property CheckSpelling: boolean read FCheckSpelling write FCheckSpelling default false;
Published property AspellLanguage: string read FAspellLanguage write FAspellLanguage;
Published property SpellCheckIgnoreWords: TStringList read FSpellCheckIgnoreWords write SetSpellCheckIgnoreWords;
Published property AutoAbstract: boolean read FAutoAbstract write FAutoAbstract default false;
Published property LinkLook: TLinkLook read FLinkLook write FLinkLook default llDefault;
Published property WriteUsesClause: boolean read FWriteUsesClause write FWriteUsesClause default false;
Published property AutoLink: boolean read FAutoLink write FAutoLink default false;
Published property AutoLinkExclude: TStringList read FAutoLinkExclude;
Published property ExternalClassHierarchy: TStrings read FExternalClassHierarchy write SetExternalClassHierarchy stored StoredExternalClassHierarchy;
Published property Markdown: boolean read FMarkdown write FMarkdown default false;

Description

Fields

Protected FLanguage: TPasDocLanguages;

the (human) output language of the documentation file(s)

Protected FClassHierarchy: TStringCardinalTree;
 
Protected FUnits: TPasUnits;

list of all units that were successfully parsed

Methods

Protected procedure DoError(const AMessage: string; const AArguments: array of const; const AExitCode: Word);
 
Protected procedure DoMessage(const AVerbosity: Cardinal; const MessageType: TPasDocMessageType; const AMessage: string; const AArguments: array of const);
 
Protected procedure CreateClassHierarchy;
 
Protected function MakeItemLink(const Item: TBaseItem; const LinkCaption: string; const LinkContext: TLinkContext): string; virtual;

Return a link to item Item which will be displayed as LinkCaption. Returned string may be directly inserted inside output documentation. LinkCaption will be always converted using ConvertString before writing, so don't worry about doing this yourself when calling this method.

LinkContext may be used in some descendants to present the link differently, see TLinkContext for it's meaning.

If some output format doesn't support this feature, it can return simply ConvertString(LinkCaption). This is the default implementation of this method in this class.

Protected procedure WriteCodeWithLinksCommon(const Item: TPasItem; const Code: string; WriteItemLink: boolean; const NameLinkBegin, NameLinkEnd: string);

This writes Code as a Pascal code. Links inside the code are resolved from Item. If WriteItemLink then Item.Name is made a link. Item.Name is printed between NameLinkBegin and NameLinkEnd.

Protected procedure CloseStream;

If field CurrentStream is assigned, it is disposed and set to nil.

Protected function CodeString(const s: string): string; virtual; abstract;

Makes a String look like a coded String, i.e. <CODE>TheString</CODE> in Html.

Parameters
s
is the string to format
Returns

the formatted string

Protected function ConvertString(const s: string): string; virtual; abstract;

Converts for each character in S, thus assembling a String that is returned and can be written to the documentation file.

The @ character should not be converted, this will be done later on.

Protected function ConvertChar(c: char): string; virtual; abstract;

Converts a character to its converted form. This method should always be called to add characters to a string.

@ should also be converted by this routine.

Protected function CreateLink(const Item: TBaseItem): string; virtual;

This function is supposed to return a reference to an item, that is the name combined with some linking information like a hyperlink element in HTML or a page number in Tex.

Protected function CreateStream(const AName: string): Boolean;

Open output stream in the destination directory. If CurrentStream still exists (<> nil), it is closed. Then, a new output stream in the destination directory is created and assigned to CurrentStream. The file is overwritten if exists.

Use this only for text files that you want to write using WriteXxx methods of this class (like WriteConverted). There's no point to use if for other files.

Returns True if creation was successful, False otherwise. When it returns False, the error message was already shown by DoMessage.

Protected function ExtractEmailAddress(s: string; out S1, S2, EmailAddress: string): Boolean;

Searches for an email address in String S. Searches for first appearance of the @ character

Protected function FixEmailaddressWithoutMailTo(const PossibleEmailAddress: String): String;

Searches for an email address in PossibleEmailAddress and appends mailto: if it's an email address and mailto: wasn't provided. Otherwise it simply returns the input.

Needed to link email addresses properly which doesn't start with mailto:

Protected function ExtractWebAddress(s: string; out S1, S2, WebAddress: string): Boolean;

Searches for a web address in String S. It must either contain a http:// or start with www.

Protected function FindGlobal(const NameParts: TNameParts): TBaseItem;

Searches all items in all units (given by field Units) for item with NameParts. Returns a pointer to the item on success, nil otherwise.

Protected function FindGlobalPasItem(const NameParts: TNameParts): TPasItem; overload;

Find a Pascal item, searching global namespace. Returns Nil if not found.

Protected function FindGlobalPasItem(const ItemName: String): TPasItem; overload;

Find a Pascal item, searching global namespace. Assumes that Name is only one component (not something with dots inside). Returns Nil if not found.

Protected function GetClassDirectiveName(Directive: TClassDirective): string;

GetClassDirectiveName returns ' abstract', or ' sealed' for classes that abstract or sealed respectively. GetClassDirectiveName is used by TTexDocGenerator and TGenericHTMLDocGenerator in writing the declaration of the class.

Protected function GetCIOTypeName(MyType: TCIOType): string;

GetCIOTypeName writes a translation of MyType based on the current language. However, 'record' and 'packed record' are not translated.

Protected procedure LoadDescriptionFile(n: string);

Loads descriptions from file N and replaces or fills the corresponding comment sections of items.

Protected function SearchItem(s: string; const Item: TBaseItem; WarningIfNotSplittable: boolean): TBaseItem;

Searches for item with name S.

If S is not splittable by SplitNameParts, returns nil. If WarningIfNotSplittable, additionally does DoMessage with appropriate warning.

Else (if S is "splittable"), seeks for S (first trying Item.FindName, if Item is not nil, then trying FindGlobal). Returns nil if not found.

Protected function SearchLink(s: string; const Item: TBaseItem; const LinkDisplay: string; const WarningIfLinkNotFound: boolean; out FoundItem: TBaseItem): string; overload;

Searches for an item of name S which was linked in the description of Item. Starts search within item, then does a search on all items in all units using FindGlobal. Returns a link as String on success.

If S is not splittable by SplitNameParts, it always does DoMessage with appropriate warning and returns something like 'UNKNOWN' (no matter what is the value of WarningIfLinkNotFound). FoundItem will be set to nil in this case.

When item will not be found then:

  • if WarningIfLinkNotFound is true then it returns CodeString(ConvertString(S)) and makes DoMessage with appropriate warning.

  • else it returns '' (and does not do any DoMessage)

If LinkDisplay is not '', then it specifies explicite the display text for link. Else how exactly link does look like is controlled by LinkLook property.

Parameters
FoundItem
is the found item instance or nil if not found.
Protected function SearchLink(s: string; const Item: TBaseItem; const LinkDisplay: string; const WarningIfLinkNotFound: boolean): string; overload;

Just like previous overloaded version, but this doesn't return FoundItem (in case you don't need it).

Protected procedure StoreDescription(ItemName: string; var t: string);
 
Protected procedure WriteConverted(const s: string; Newline: boolean); overload;

Writes S to CurrentStream, converting it using ConvertString. Then optionally writes LineEnding.

Protected procedure WriteConverted(const s: string); overload;

Writes S to CurrentStream, converting it using ConvertString. No LineEnding at the end.

Protected procedure WriteConvertedLine(const s: string);

Writes S to CurrentStream, converting it using ConvertString. Then writes LineEnding.

Protected procedure WriteDirect(const t: string; Newline: boolean); overload;

Simply writes T to CurrentStream, with optional LineEnding.

Protected procedure WriteDirect(const t: string); overload;

Simply writes T to CurrentStream.

Protected procedure WriteDirectLine(const t: string);

Simply writes T followed by LineEnding to CurrentStream.

Protected procedure WriteUnit(const HL: integer; const U: TPasUnit); virtual; abstract;

Abstract method that writes all documentation for a single unit U to output, starting at heading level HL. Implementation must be provided by descendant objects and is dependent on output format.

Protected procedure WriteUnits(const HL: integer);

Writes documentation for all units, calling WriteUnit for each unit.

Protected procedure WriteStartOfCode; virtual;
 
Protected procedure WriteEndOfCode; virtual;
 
Protected procedure WriteGVUses;

output graphviz uses tree

Protected procedure WriteGVClasses;

output graphviz class tree

Protected procedure StartSpellChecking(const AMode: string);

starts the spell checker

Protected procedure CheckString(const AString: string; const AErrors: TObjectVector);

If CheckSpelling and spell checking was successfully started, this will run FAspellProcess.CheckString and will report all errors using DoMessage with mtWarning.

Otherwise this just clears AErrors, which means that no errors were found.

Protected procedure EndSpellChecking;

closes the spellchecker

Protected function FormatPascalCode(const Line: string): string; virtual;

FormatPascalCode will cause Line to be formatted in the way that Pascal code is formatted in Delphi. Note that given Line is taken directly from what user put inside 




, it is not even processed by ConvertString. You should process it with ConvertString if you want.









Protected
function FormatNormalCode(AString: string): string; virtual;






This will cause AString to be formatted in the way that normal Pascal statements (not keywords, strings, comments, etc.) look in Delphi.









Protected
function FormatComment(AString: string): string; virtual;






FormatComment will cause AString to be formatted in the way that comments other than compiler directives are formatted in Delphi. See: FormatCompilerComment.









Protected
function FormatHex(AString: string): string; virtual;






FormatHex will cause AString to be formatted in the way that Hex are formatted in Delphi.









Protected
function FormatNumeric(AString: string): string; virtual;






FormatNumeric will cause AString to be formatted in the way that Numeric are formatted in Delphi.









Protected
function FormatFloat(AString: string): string; virtual;






FormatFloat will cause AString to be formatted in the way that Float are formatted in Delphi.









Protected
function FormatString(AString: string): string; virtual;






FormatString will cause AString to be formatted in the way that strings are formatted in Delphi.









Protected
function FormatKeyWord(AString: string): string; virtual;






FormatKeyWord will cause AString to be formatted in the way that reserved words are formatted in Delphi.









Protected
function FormatCompilerComment(AString: string): string; virtual;






FormatCompilerComment will cause AString to be formatted in the way that compiler directives are formatted in Delphi.









Protected
function Paragraph: string; virtual;






This is paragraph marker in output documentation.


Default implementation in this class simply returns ' ' (one space).









Protected
function ShortDash: string; virtual;






See TTagManager.ShortDash. Default implementation in this class returns '-'.









Protected
function EnDash: string; virtual;






See TTagManager.EnDash. Default implementation in this class returns '--'.









Protected
function EmDash: string; virtual;






See TTagManager.EmDash. Default implementation in this class returns '---'.









Protected
function HtmlString(const S: string): string; virtual;






S is guaranteed (guaranteed by the user) to be correct html content, this is taken directly from parameters of tag. Override this function to decide what to put in output on such thing.


Note that S is not processed in any way, even with ConvertString. So you're able to copy user's input inside @html() verbatim to the output.


The default implementation is this class simply discards it, i.e. returns always ''. Generators that know what to do with HTML can override this with simple "Result := S".









Protected
function LatexString(const S: string): string; virtual;






This is equivalent of HtmlString for @latex tag.


The default implementation is this class simply discards it, i.e. returns always ''. Generators that know what to do with raw LaTeX markup can override this with simple "Result := S".









Protected
function LineBreak: string; virtual;






This returns markup that forces line break in given output format (e.g. '<br>' in html or '\\' in LaTeX).






It is used on 
 tag (but may also be used on other occasions in the future).


In this class it returns '', because it's valid for an output generator to simply ignore 
 tags if linebreaks can't be expressed in given output format.









Protected
function URLLink(const URL: string): string; overload; virtual;






This should return markup upon finding URL in description. E.g. HTML generator will want to wrap this in <a href="...">...</a>.


Note that passed here URL is not processed by ConvertString (because sometimes it could be undesirable). If you want you can process URL with ConvertString when overriding this method.


Default implementation in this class simply returns ConvertString(URL). This is good if your documentation format does not support anything like URL links.









Protected
function URLLink(const URL, LinkDisplay: string): string; overload; virtual;






This returns the Text which will be shown for an URL tag.


URL is a link to a website or e-mail address. LinkDisplay is an optional parameter which will be used as the display name of the URL.









Protected
procedure WriteExternal(const ExternalItem: TExternalItem; const Id: TTranslationID);






WriteExternal is used to write the introduction and conclusion of the project.









Protected
procedure WriteExternalCore(const ExternalItem: TExternalItem; const Id: TTranslationID); virtual; abstract;






This is called from WriteExternal when ExternalItem.Title and ShortTitle are already set, message about generating appropriate item is printed etc. This should write ExternalItem, including ExternalItem.DetailedDescription, ExternalItem.Authors, ExternalItem.Created, ExternalItem.LastMod.









Protected
procedure WriteConclusion;






WriteConclusion writes a conclusion for the project. See WriteExternal.









Protected
procedure WriteIntroduction;






WriteIntroduction writes an introduction for the project. See WriteExternal.









Protected
procedure WriteAdditionalFiles;






WriteAdditionalFiles writes the other files for the project. See WriteExternal.









Protected
function FormatSection(HL: integer; const Anchor: string; const Caption: string): string; virtual; abstract;






FormatSection writes a section heading and a link-anchor;









Protected
function FormatAnchor(const Anchor: string): string; virtual; abstract;






FormatAnchor writes a link-anchor;









Protected
function FormatBold(const Text: string): string; virtual;






This returns Text formatted using bold font.


Given Text is already in the final output format (with characters converted using ConvertString, @-tags expanded etc.).


Implementation of this method in this class simply returns Result := Text. Output generators that can somehow express bold formatting (or at least emphasis of some text) should override this.




See also



  
FormatItalic

  
This returns Text formatted using italic font.











Protected
function FormatItalic(const Text: string): string; virtual;






This returns Text formatted using italic font. Analogous to FormatBold.









Protected
function FormatWarning(const Text: string): string; virtual;






This returns Text using bold font by calling FormatBold(Text).









Protected
function FormatNote(const Text: string): string; virtual;






This returns Text using italic font by calling FormatItalic(Text).









Protected
function FormatPreformatted(const Text: string): string; virtual;






This returns Text preserving spaces and line breaks. Note that Text passed here is not yet converted with ConvertString. The implementation of this method in this class just returns ConvertString(Text).









Protected
function FormatImage(FileNames: TStringList): string; virtual;






Return markup to show an image. FileNames is a list of possible filenames of the image. FileNames always contains at least one item (i.e. FileNames.Count >= 1), never contains empty lines (i.e. Trim(FileNames[I]) <> ''), and contains only absolute filenames.


E.g. HTML generator will want to choose the best format for HTML, then somehow copy the image from FileNames[Chosen] and wrap this in <img src="...">.


Implementation of this method in this class simply shows FileNames[0]. Output generators should override this.









Protected
function FormatList(ListData: TListData): string; virtual; abstract;






Format a list from given ListData.









Protected
function FormatTable(Table: TTableData): string; virtual; abstract;






This should return appropriate content for given Table. It's guaranteed that the Table passed here will have at least one row and in each row there will be at least one cell, so you don't have to check it within descendants.









Protected
function FormatTableOfContents(Sections: TStringPairVector): string; virtual;






Override this if you want to insert something on @tableOfContents tag. As a parameter you get already prepared tree of sections that your table of contents should show. Each item of Sections is a section on the level 1. Item's Name is section name, item's Value is section caption, item's Data is a TStringPairVector instance that describes subsections (on level 2) below this section. And so on, recursively.


Sections given here are never nil, and item's Data is never nil. But of course they may contain 0 items, and this should be a signal to you that given section doesn't have any subsections.


Default implementation of this method in this class just returns empty string.









Public
procedure BuildLinks; virtual;






Creates anchors and links for all items in all units.









Public
procedure ExpandDescriptions;






Expands description for each item in each unit of Units. "Expands description" means that TTagManager.Execute is called, and item's DetailedDescription, AbstractDescription, AbstractDescriptionWasAutomatic (and many others, set by @-tags handlers) properties are calculated.









Public
function GetFileExtension: string; virtual; abstract;






Abstract function that provides file extension for documentation format. Must be overwritten by descendants.









Public
procedure LoadDescriptionFiles(const c: TStringVector);






Assumes C contains file names as PString variables. Calls LoadDescriptionFile with each file name.









Public
procedure WriteDocumentation; virtual;






Must be overwritten, writes all documentation. Will create either a single file or one file for each unit and each class, interface or object, depending on output format.









Public
constructor Create(AOwner: TComponent); override;




 







Public
destructor Destroy; override;




 







Public
procedure ParseAbbreviationsFile(const AFileName: string);




 




Properties





Protected
property CurrentStream: TStream read FCurrentStream;




 







Public
property Units: TPasUnits read FUnits write FUnits;




 







Public
property Introduction: TExternalItem read FIntroduction
      write FIntroduction;




 







Public
property Conclusion: TExternalItem read FConclusion write FConclusion;




 







Public
property AdditionalFiles: TExternalItemList read FAdditionalFiles write FAdditionalFiles;




 







Public
property OnMessage: TPasDocMessageEvent read FOnMessage write FOnMessage;






Callback receiving messages from generator.


This is usually used internally by TPasDoc class, that assigns it's internal callback here when using this generator. Also, for the above reason, do not make this published.


See TPasDoc.OnMessage for something more useful for final programs.









Published
property Language: TLanguageID read GetLanguage write SetLanguage
      default DEFAULT_LANGUAGE;






the (human) output language of the documentation file(s)









Published
property ProjectName: string read FProjectName write FProjectName;






Name of the project to create.









Published
property ExcludeGenerator: Boolean
      read FExcludeGenerator write FExcludeGenerator default false;






"Generator info" are things that can change with each invocation of pasdoc, with different pasdoc binary etc.


This includes 



    
  
  • pasdoc's compiler name and version,
    • 
  
  • pasdoc's version and time of compilation
    • 




 See [https://github.com/pasdoc/pasdoc/wiki/ExcludeGeneratorOption]. Default value is false (i.e. show them), as this information is generally considered useful.


Setting this to true is useful for automatically comparing two versions of pasdoc's output (e.g. when trying to automate pasdoc's tests).









Published
property IncludeCreationTime: Boolean
      read FIncludeCreationTime write FIncludeCreationTime default false;






Show creation time in the output.









Published
property UseLowercaseKeywords: Boolean
      read FUseLowercaseKeywords write FUseLowercaseKeywords default false;






Setting to define how literal tag keywords should appear in documentaion.









Published
property Title: string read FTitle write FTitle;






Title of the documentation, supplied by user. May be empty. See TPasDoc.Title.









Published
property DestinationDirectory: string read FDestDir write SetDestDir;






Destination directory for documentation. Must include terminating forward slash or backslash so that valid file names can be created by concatenating DestinationDirectory and a pathless file name.









Published
property OutputGraphVizUses: boolean read FGraphVizUses write FGraphVizUses
      default false;






generate a GraphViz diagram for the units dependencies









Published
property OutputGraphVizClassHierarchy: boolean
      read FGraphVizClasses write FGraphVizClasses default false;






generate a GraphViz diagram for the Class hierarchy









Published
property LinkGraphVizUses: string read FLinkGraphVizUses write FLinkGraphVizUses;






link the GraphViz uses diagram









Published
property LinkGraphVizClasses: string read FLinkGraphVizClasses write FLinkGraphVizClasses;






link the GraphViz classes diagram









Published
property Abbreviations: TStringList read FAbbreviations write SetAbbreviations;




 







Published
property CheckSpelling: boolean read FCheckSpelling write FCheckSpelling
      default false;




 







Published
property AspellLanguage: string read FAspellLanguage write FAspellLanguage;




 







Published
property SpellCheckIgnoreWords: TStringList
      read FSpellCheckIgnoreWords write SetSpellCheckIgnoreWords;




 







Published
property AutoAbstract: boolean read FAutoAbstract write FAutoAbstract default false;






The meaning of this is just like --auto-abstract command-line option. It is used in ExpandDescriptions.









Published
property LinkLook: TLinkLook read FLinkLook write FLinkLook default llDefault;






This controls SearchLink behavior, as described in [https://github.com/pasdoc/pasdoc/wiki/LinkLookOption].









Published
property WriteUsesClause: boolean
      read FWriteUsesClause write FWriteUsesClause default false;




 







Published
property AutoLink: boolean
      read FAutoLink write FAutoLink default false;






This controls auto-linking, see [https://github.com/pasdoc/pasdoc/wiki/AutoLinkOption]









Published
property AutoLinkExclude: TStringList read FAutoLinkExclude;




 







Published
property ExternalClassHierarchy: TStrings
      read FExternalClassHierarchy write SetExternalClassHierarchy
      stored StoredExternalClassHierarchy;




 







Published
property Markdown: boolean
      read FMarkdown write FMarkdown default false;




 




Generated by PasDoc 0.16.0.