There are needed special comments to point out special things as constants,methods,etc.
These comments have to be used others will be ignored.
Because PasDoc was written to create docs of units the code has to be an unit file.

overview:
{U    *unit history
{S    *constants
{T    *types
{C    *variables
{O    *objects
{I     -inherited 
{F     -fields
{C     -constructors
{D     -destructors
{M     -methods
{H     -object history

To show the history many programmers write a short history overview in their files.

With {U a unit-history comment is introduced.
After this you can write as much lines as you like about unit history.
The comment finishs with an normal end comment }
sample:

{U Version 1.0 }

{U
Version 1.0 (1 April 2000)
* ...
* ...
Version 0.9 (21 January 2000)
* ...
* ...
}

Programmers often use constants to make the code more readable because a $AA656798
dos not really say anything about the sense. A constant like const_FileIsInvalid says much more.

The constant-comment is introduced by {S and ends with }.
IMPORTANT!: The constant declaration has to follow the comment on the next line.
sample:

{S invalid file format}
const_InvalidFileFormat=$AA00;

{S
set of chars representing comment introducing chars
char meaning
S    comment for constants
F    comment for fields
C    comment for constructors
}
commentCHARS:set of char=['s','S','f','F','c','C'];

There are three possible types of type declarations.
The first is the declaration of a type using standard types or arrays. These are named here
"normal types". The second type are record declaraions which are here also named as 
"record types". The third and last are object which have an own comment declaration.

1.normal types
Normal types are commented like global consts only the comment char is here "T".
The type-comment is introduced by {T and ends with }.
IMPORTANT!: The type declaration has to follow the comment on the next line.
sample:
{T just a pointer to a string}
PString=^String;

2.record types
Record types consist normally of more than one field. For this each of the fied can be described
seperately. The type-comment is introduced by {T and ends with }.
For the field description each field can be access by >
IMPORTANT!: The type declaration has to follow the comment on the next line.
sample:
{T
record to store date/time informations
>the year
>the month
>the day
>the weekday
>the hours
>the minutes
>the seconds
>the milliseconds
}
DateTimeRec=record
    Y:word;
    M:byte;
    D:byte;
    W:byte;
    H:byte;
    M:byte;
    S:byte;
    MS:byte;
end;

In some cases global variables are used in unit for example to count the number of accesses on the
unit. Therefor also variable-comments are supported. They are uses like the constant-comment only
with {V as comment char.
IMPORTANT!: The variable declaration has to follow the comment on the next line.
sample:
{V counts the accesses on the unit}
accessCount:word;

The main reason PasDoc was written was to comment objects their fields and methods.
For this many comment-chars are available to describe objects.
The main object comment is in {O ... }
After this follows optional a comment for inherited fields/methods with {I ... }
Then the normal object declaration follows.
In this fields can be described by {F ... }, constructors by {C ... },destructors by {D ... }, 
methods by {M ... } and the object history by {H ... }.
In constructor, destructor and method comments the parameters can be described by > and the return
values by <
IMPORTANT!: The object declaration has to follow the {O ... } [{I ... }] comment on the next line.
sample:
{O a circle object }
{I inherits from object point the fields X and Y}
Circle=object(Point)
    {F the radius of the circle}
    R:word;
    {C initializes the fields of the circle
    > the x-coordinate 
    > the y-coordinate
    > the radius
    }
    constructor Init(iX,iY,iR:word);
    {M
    function to get the current radius
    < the current radius
    }
    function GetRadius:integer;
    {H
    - Version 2.0
    ...
    - Version 1.0
    ...
    }
end;