This is Info file gpc.info, produced by Makeinfo version 1.68 from the
input file /usr/local/src/gcc-2.8.1/p/doc/gpc.texi.

   This file documents the use and the internals of the GNU Pascal
compiler.

   Copyright (C) 1988, 1996 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License," "Funding for
Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License," "Funding for Free Software," and "Protect Your Freedom--Fight
`Look And Feel'", and this permission notice, may be included in
translations approved by the Free Software Foundation instead of in the
original English.


File: gpc.info,  Node: How to Contribute,  Next: GPC notes,  Prev: Support,  Up: Top

How you can contribute to GNU Pascal
************************************

   Below you can find a list of jobs which should be done for GNU
Pascal.  In cases where somebody is already working on it, the name of
that person is written behind the job's description together with the
status of the project; e-mail addresses are given below.

   If there is already a name behind a job, this does *not* mean that
you shouldn't do that but just that you should get in contact with that
person if you would like to contribute to that field.

   Don't forget to join the GPC mailing list, `gpc@hut.fi'.  To
subscribe, write to `gpc-request@hut.fi'.

   Welcome to the GNU Pascal development team!

List of jobs
============

     Overall coordination                    Peter           works ;-)
     Coordination with GCC developers        JanJaap          ?
     Merge into GCC main distribution        JanJaap         90%
     
     ISO 7185 Standard Pascal                Juki, Peter     works
     ISO 10206 Extended Pascal               Juki, Peter     90%
     Object Pascal                            ?
     Borland Pascal 7.0                      Peter           90%
     Delphi                                  Peter           2%
     Pascal-SC                               Peter           please help!
     
     Windows 95/NT version                   JanJaap         new port started
     
     Find all bugs                            ?              please help!
     Improve the documentation               JanJaap, Peter  please help!
     
     More strict type checking               Juki, Peter     20%
     Objects: C++ code compatibility         Peter            ?
     Objects: Interfaces                     Peter           planned
     PXSC module syntax                      Peter           planned
     Procedure overloading                   Peter           planned
     
     Run time system                         Juki, JanJaap   works
     I/O error handling                       ?
     Borland compatible System               Peter, Chief    works on DJGPP, EMX
     Borland compatible DOS                  Chief
     Borland compatible CRT                  Peter           works on DJGPP, EMX
     Borland compatible Graph                Sven            works on DJGPP, Linux
     Turbo Vision compatible library         JanJaap          ?
     POSIX library (replacement for DOS)     Berend          to be ported
     NCurses Unit                            Ken              ?
     Replacement for (parts of) CRT          Peter           beta (BO5)
     Replacement for Graph                   Sven             ?
     Replacement for Graph                   Peter           planned (BO5)
     Replacement for Turbo Vision            Peter           planned (BO5)
     
     Adaption of the XWPE IDE (for UNIX)      ?
     Pascal mode for GDB, the GNU Debugger   JanJaap         planned

List of done jobs :-)
=====================

     Documentation                           JanJaap, Peter  existing ;-)
     EMX version (DOS and OS/2)              Peter           works
     DJ version (DOS)                        JanJaap         works
     Cross compilers                         JanJaap         works
     Adaption of the RHIDE                   Robert          works
     
     Automatic make                          Peter           works
     Precompiled module interfaces           Peter           works
     Compiler options to force one standard  Peter           works
     
     Installation instructions               JanJaap, Peter  done

List of contributors (in alphabetical order)
============================================

     Berend              Berend de Boer, Nederlands
                         <berend@pobox.com>
     
     Chief               Abimbola A. Olowofoyeku, Great Britain
                         <laa12@cc.keele.ac.uk>
     
     JanJaap             Jan-Jaap van der Heijden, Nederlands
                         <j.j.vanderheijden@student.utwente.nl>
     
     Juki                Jukka Virtanen, Finland
                         <jtv@hut.fi>
     
     Ken                 Kennith Linder, USA
                         <klinder@lucky.hn.com>
     
     Peter               Peter Gerwinski, Germany
                         <peter@gerwinski.de>
     
     Robert              Robert Hoehne, Germany
                         <robert.hoehne@mathematik.tu-chemnitz.de>
     
     Sven                Sven Hilscher, Germany
                         <sven@rufus.central.de>


File: gpc.info,  Node: GPC notes,  Next: PVS,  Prev: How to Contribute,  Up: Top

GPC--Gnu Pascal Random Notes
****************************

   * a bison parser for GPC

     (the parser is a ISO 7185 standard pascal parser with extensions
     (like casts, type of, address of vars, inline, return, break,
     continue, otherwise and so on...)

   * code (glue) that can be used to convert the Pascal way of defining
     things to use routines in a modified `c-decl.c'.  This mainly does
     re-ordering of the data structures. The glue lives in
     `gpc-parser.y' or in `gpc-util.c'.

   * VAR parameters for Pascal routines

     Now done with REFERENCE_TYPE. Until the REFERENCE_TYPE is
     implemented as in C++, I just get rid of this type as soon as
     possible by converting it to POINTER_TYPE in as few places as
     possible. Currently affects `gpc-parse.y', `actualparameterlist()'
     and `default_conversion()'.

   * redeclaration of standard identifiers (NOT reserved words) This
     requires a change in `tree.def' sometime in the future; currently
     I am mis-using Tiemann's FRIEND_DECL TREECODE which looks exactly
     like my KNOWNID_DECL would look like.  So maybe there is no need
     to add it at all for Pascal.

   * run time system & routines that generate calls to the rts.  The
     old one Antti Louko & I originally wrote back in -85 when I ported
     another Pascal compiler (Pax) to BSD Vax.  Pax compiler is written
     in Pascal, and it runs on Twenex and Unix. (Very good error
     reporting capabilities.)  More info on request.

   * WITH statement should work properly. No information of WITH is
     currently given to the debugger.

   * variant records

     These should work. Added routine find_field() that returns a chain
     of TREE_LIST nodes and modified build_component_ref() to work as
     follows: When `gpc-parse.y' builds a variant record, it constructs
     an unnamed RECORD_TYPE containing the possible variant selector
     field and an unnamed UNION_TYPE node. `When find_field()' sees
     unnamed RECORD_TYPE or UNION_TYPE nodes implicitely propagates to
     the inner layer of the definition. It then returns the TREE_LIST
     chain of this propagation and this is modified to a series of
     build(COMPONENT_REF,...) for all propagated RECORD_TYPE nodes,
     which the rest of gcc will handle. This does NOT YET check variant
     access errors...  When thinking about it, it does not check very
     many other things either, so maybe no one will notice this :-)

   * Arrays with non-zero lower bound

     Required some changes to `expr.c.'


File: gpc.info,  Node: PVS,  Next: Set types,  Prev: GPC notes,  Up: Top

PVS Conformance Test Results
****************************

   This is a list of failed Pascal Validation Suite Conformance tests
by GPC-1.2 (GCC-2.7.2)

   Last modified: Sun Dec 10 00:58:14 1995
Run by: Juki <jtv@hut.fi>

   Number of validation suite tests run: 199 Only LEVEL-0 tests run (no
conformant arrays).

   All programs have been named as `pDDD.pas' (DDD = three digits)
Otherwise my naming convention does not mean anything.

   All tests run with and without `-g' and with/without `-O' and
with/without `-O6' Only the tests that fail are mentioned, otherwise
they all pass.

     	TEST	WHAT HAPPENS
     	----    ------------
     i486	Mach 3 (CMU UX): 	All conformance tests pass.
     
     rs-6000 Aix 3.2.5: 		All conformance tests pass.
     
     mips	Ultrix 4.3:		All conformance tests pass.
     				*** Tested with gpc 2.5.7 only
     
     alpha:	OSF 1/V3.2c:		All conformace tests pass.
     
     	Important: DO NOT USE -O switch with the alpha GPC
     		   until the problems are fixed!!!
     
     	*** With -O the following FAIL
     	*** This is ridiculous!!! They worked before...
     	p004	FAIL
     	p029	FAIL
     	p069	FAIL
     	p072	FAIL
     	p075	FAIL
     	p076	FAIL
     	p098	FAIL
     	p108	FAIL
     	p110	FAIL
     	p111	FAIL
     	p113	FAIL
     	p128	FAIL
     	p136	FAIL
     	p142	runtime error
     	p157	FAIL
     	p164	FAIL
     	p167	FAIL
     	p171	FAIL
     
     	*** But with -O6 the following are compiled incorrectly.
     	*** (i.e. they compile but produce incorrect results).
     	*** Don't use -O6 on alpha until the bugs are fixed.
     	*** These have never worked.
     	*** I have not checked the reason for these:
     	p029	FAIL
     	p095	FAIL
     	p110	FAIL
     	p111	FAIL
     	p117	Loops
     	p157	FAIL
     
     sparc	Solaris 2.3:		*** Tested with gpc 2.6.3 only
     	003	Signal 11 received by the compiler when -O (optimized)
     
     HP-PA:	HP-UX 9.03 / --with-gnu-as
     	All other tests pass, except 003:
     
     	003	Compiler: Unrecognized insn. Compiler abort().
     		(PASS with -O6)
     
     		p003.pas:262: internal error--unrecognizable insn:
     		(jump_insn 730 728 732 (set (pc)
     		        (if_then_else (gt (const_int 0)
     		                (reg:SI 259))
     		            (label_ref 766)
     		            (pc))) -1 (nil)
     		    (nil))
     		p003.pas:262: internal gcc abort
     		p003.pas did not compile
     
     		This looks more like a generic GNU compiler bug than
     		a bug in GPC code...
     
     		003 is the PVS test 6.1.1-3.


File: gpc.info,  Node: Set types,  Next: GPC index,  Prev: PVS,  Up: Top

Implementation of Set Types in GPC
**********************************

   Information of the SET_TYPE implementation in GPC.
Juki `jtv@hut.fi'
Last modified: Wed Sep 22 11:47:27 1993

   * Memory format

     `Set of T' type nodes are represented as bit vectors, one bit for
     each element. The SET_TYPE objects contain only the bits necessary
     to represent the set type PLUS the padding to align the objects to
     the nearest word boundary. Thus, there may be unused bits in front
     and after the end of otherwise contiquous bit vector that
     represents all the elements of the set.

   * Sparse sets are not implemented

     there is no concept of "sparse sets", which I thought might be
     nice for things like `[ -maxint, maxint ]' to work. Maybe someone
     implements this later, e.g. with a list of set fragments or a list
     of set elements.

   * Negative bounds for sets do not work

     Perhaps this could be done by subtracting the low bound from all
     set elements before storing them to bitvectors.  (This might cause
     complications with set constructors in expressions?)

   * Set of integer

     This is a problem currently.  It should be dynamic, but currently
     the bounds are always set to 0..255 for an unlimited integer set.

     First aid:  We implemented a switch that specifies the bounds of
     such sets. The value should be passed to `setop.c' in some
     language independend way. (Global variables :-)

   * Set operations:

     With a massive hack attack I converted all set operations to
     inline code.  It is not perfect yet, but now it passes all set
     tests I have.  Yet, the code contains unimplemented parts (see
     `setop.c').

   * List of set operations:

     CARD_EXPR:      returns the number of set elements currently in the set
                     Extended Pascal.
     
     UNION           SETC := SETA + SETB; union of the sets
     BIT_OR_EXPR
     
     DIFF            SETC := SETA - SETB; If in A, but not in B.
     BIT_ANDTC_EXPR  (and `tc_optab' has vanished from gcc-2, so this
                     will be done ``SETA and (not (SETB))'')
     
     INTERSECTION    SETC := SETA * SETB; If in A and in B
     BIT_AND_EXPR
     
     SYMDIFF         SETC := SETA >< SETB; set symmetric difference
     BIT_XOR_EXPR    (C if only in A or only in B (Boolean `XOR')
                     Extended Pascal.
     
     SEARCH_EXPR:    in a set iteration, yields each member of the set
                     in some implementation dependend order.
                     Extended Pascal (this is not yet implemented in gpc).
     
     Rest of the operands result in boolean values.
     
     =, <>           Equality comparisons
     
     <=              `LE_EXPR'
                     SETA <= SETB denotes the inclusion of SETA in SETB
     
     >=              Implemented with `LE_EXPR', like above
                     SETA >= SETB denotes the inclusion of SETB in SETA


File: gpc.info,  Node: GPC index,  Prev: Set types,  Up: Top

Index
*****

* Menu:

* -gpc-main:                             Importing from other languages.
* -lgcc, use with -nodefaultlibs:        Link Options.
* -lgcc, use with -nostdlib:             Link Options.
* -nodefaultlibs and unresolved references: Link Options.
* -nostdlib and unresolved references:   Link Options.
* abs:                                   abs.
* absolute:                              absolute.
* addr:                                  addr.
* alignment <1>:                         AlignOf.
* alignment:                             alignment.
* AlignOf:                               AlignOf.
* all:                                   all.
* Alpha OSF/1:                           Alpha OSF/1.
* AMD29K options:                        AMD29K Options.
* and:                                   and.
* and then:                              and then.
* and_then:                              and_then.
* AnsiChar:                              AnsiChar.
* append:                                append.
* arctan:                                arctan.
* arg:                                   arg.
* arguments in frame (88k):              M88K Options.
* ARM options:                           ARM Options.
* array:                                 array.
* asm:                                   asm.
* asmname <1>:                           asmname.
* asmname:                               Importing from other languages.
* assembler syntax, 88k:                 M88K Options.
* Assign:                                Assign.
* assigned:                              assigned.
* attribute:                             attribute.
* AutoMake internals:                    AutoMake.
* Bar:                                   Schemata.
* begin:                                 begin.
* binary distributions, installing:      binary distributions.
* Bind:                                  Bind.
* bindable:                              bindable.
* Binding:                               Binding.
* BindingType:                           BindingType.
* Bison parser generator:                Installation.
* bit shift overflow (88k):              M88K Options.
* bits:                                  BitSizeOf.
* BitSizeOf:                             BitSizeOf.
* BlockRead:                             BlockRead.
* BlockWrite:                            BlockWrite.
* Boolean:                               Boolean.
* break:                                 break.
* bugs in GPC:                           GPC bugs.
* Byte:                                  Byte.
* byte writes (29k):                     AMD29K Options.
* ByteBool:                              ByteBool.
* ByteCard:                              ByteCard.
* ByteInt:                               ByteInt.
* C <1>:                                 C.
* C <2>:                                 Importing from other languages.
* C:                                     Other languages.
* C language:                            Importing from other languages.
* C_INCLUDE_PATH:                        Environment Variables.
* C_Language <1>:                        C_Language.
* C_Language:                            Importing from other languages.
* Card:                                  Card.
* Cardinal:                              Cardinal.
* case:                                  case.
* Char:                                  Char.
* ChDir:                                 ChDir.
* chr:                                   chr.
* close:                                 close.
* cmplx:                                 cmplx.
* code generation conventions:           Code Gen Options.
* command options:                       Invoking GPC.
* Comp:                                  Comp.
* compiler version, specifying:          Target Options.
* COMPILER_PATH:                         Environment Variables.
* Complex:                               Complex.
* Concat:                                Concat.
* configuration dependent compilation notes: compilation notes.
* conformant arrays:                     Parameter passing.
* conjugate:                             conjugate.
* Const:                                 Const.
* Constructor:                           Constructor.
* continue:                              continue.
* contributors:                          Contributors.
* Convex options:                        Convex Options.
* Copy:                                  Copy.
* cos:                                   cos.
* CPLUS_INCLUDE_PATH:                    Environment Variables.
* cross compiling:                       Target Options.
* cross-compilers:                       cross-compilers.
* CString:                               CString.
* CString2String:                        CString2String.
* Date:                                  Date.
* debugging information options:         Debugging Options.
* debugging, 88k OCS:                    M88K Options.
* dec:                                   dec.
* default:                               default.
* DefineSize:                            DefineSize.
* Delete:                                Delete.
* dependencies for make as output:       Environment Variables.
* dependencies, make:                    Preprocessor Options.
* DEPENDENCIES_OUTPUT:                   Environment Variables.
* Destructor:                            Destructor.
* dialect options:                       Pascal Dialect Options.
* directory options:                     Directory Options.
* Dispose:                               Dispose.
* div:                                   div.
* divide instruction, 88k:               M88K Options.
* djgpp:                                 DJGPP.
* do:                                    do.
* DOS, MS- <1>:                          EMX.
* DOS, MS-:                              DJGPP.
* Double:                                Double.
* downto:                                downto.
* DW bit (29k):                          AMD29K Options.
* else:                                  else.
* empty:                                 empty.
* EMX:                                   EMX.
* end:                                   end.
* endianness:                            endianness.
* environment variables:                 Environment Variables.
* eof:                                   eof.
* eoln:                                  eoln.
* EpsReal:                               EpsReal.
* eq:                                    eq.
* erase:                                 erase.
* Exit:                                  Exit.
* exp:                                   exp.
* Export:                                Export.
* extend:                                extend.
* Extended:                              Extended.
* extern <1>:                            extern.
* extern:                                Importing from other languages.
* external <1>:                          external.
* external:                              Importing from other languages.
* false:                                 false.
* far:                                   far.
* File:                                  File.
* file name suffix:                      Overall Options.
* file names:                            Link Options.
* FileMode:                              FileMode.
* FilePos:                               FilePos.
* FileSize:                              FileSize.
* FillChar:                              FillChar.
* flush:                                 flush.
* foo <1>:                               GPC bugs.
* foo <2>:                               Miscellaneous.
* foo <3>:                               Parameters.
* foo <4>:                               Typed constants.
* foo <5>:                               Objects.
* foo <6>:                               Keywords.
* foo <7>:                               AutoMake.
* foo <8>:                               Parameter passing.
* foo <9>:                               Tree nodes.
* foo <10>:                              Lexical analyzer.
* foo <11>:                              xor.
* foo <12>:                              uses.
* foo <13>:                              TypeOf.
* foo <14>:                              succ.
* foo <15>:                              record.
* foo <16>:                              pred.
* foo <17>:                              object.
* foo <18>:                              near.
* foo <19>:                              import.
* foo <20>:                              far.
* foo <21>:                              addr.
* foo <22>:                              Importing from other languages.
* foo:                                   OOP.
* Foo:                                   Schemata.
* foo <1>:                               Units.
* foo <2>:                               Source structures.
* foo <3>:                               Environment Variables.
* foo <4>:                               Link Options.
* foo <5>:                               Optimize Options.
* foo <6>:                               Debugging Options.
* foo <7>:                               Warning Options.
* foo <8>:                               Code Gen Options.
* foo:                                   Invoking GPC.
* for:                                   for.
* forward:                               forward.
* frac:                                  frac.
* FreeMem:                               FreeMem.
* front-end <1>:                         Tree nodes.
* front-end:                             Language definition.
* Function:                              Function.
* functions as parameters:               Parameter passing.
* ge:                                    ge.
* Get:                                   Get.
* GetFile:                               GetFile.
* GetMem:                                GetMem.
* GetTimeStamp:                          GetTimeStamp.
* global offset table:                   Code Gen Options.
* GNU Pascal command options:            Invoking GPC.
* goto:                                  goto.
* gp-relative references (MIPS):         MIPS Options.
* GPC and other languages:               Other languages.
* GPC bugs:                              GPC bugs.
* GPC internals:                         GPC source.
* GPC source:                            GPC source.
* GPC_EXEC_PREFIX:                       Environment Variables.
* GPI files:                             GPI files.
* gprof:                                 Debugging Options.
* grammar:                               Language definition.
* grouping options:                      Invoking GPC.
* gt:                                    gt.
* Halt:                                  Halt.
* hardware models and configurations, specifying: Submodel Options.
* high:                                  high.
* HPPA Options:                          HPPA Options.
* i386 Options:                          i386 Options.
* IBM RS/6000 and PowerPC Options:       RS/6000 and PowerPC Options.
* IBM RT options:                        RT Options.
* identifying source, compiler (88k):    M88K Options.
* if:                                    if.
* Im:                                    Im.
* Implementation:                        Implementation.
* import:                                import.
* in:                                    in.
* inc:                                   inc.
* Index:                                 Index.
* inherited <1>:                         inherited.
* inherited:                             OOP.
* inline:                                inline.
* InOutRes:                              InOutRes.
* InOutResStr:                           InOutResStr.
* Input:                                 Input.
* Insert:                                Insert.
* installing binary distributions:       binary distributions.
* installing GNU Pascal:                 Installation.
* int:                                   int.
* Integer:                               Integer.
* Integer types:                         Integer types.
* integer types, "main branch":          Main branch integer types.
* integer types, "natural":              Natural integer types.
* integer types, compatibility:          Integer types and compatibility.
* integer types, specified size:         Integer types with specified size.
* integer types, summary:                Summary of integer types.
* Intel 386 Options:                     i386 Options.
* Interface:                             Interface.
* intermediate code:                     Tree nodes.
* IOresult:                              IOresult.
* kernel and user registers (29k):       AMD29K Options.
* Label:                                 Label.
* language definition:                   Language definition.
* language dialect options:              Pascal Dialect Options.
* large bit shifts (88k):                M88K Options.
* LastPosition:                          LastPosition.
* le:                                    le.
* length:                                length.
* lexical analyzer:                      Lexical analyzer.
* Libraries:                             Link Options.
* LIBRARY_PATH:                          Environment Variables.
* link options:                          Link Options.
* linking:                               Importing from other languages.
* ln:                                    ln.
* LoCase:                                LoCase.
* LongCard:                              LongCard.
* LongestCard:                           LongestCard.
* LongestInt:                            LongestInt.
* LongestReal:                           LongestReal.
* LongestWord:                           LongestWord.
* LongInt:                               LongInt.
* longjmp warnings:                      Warning Options.
* LongReal:                              LongReal.
* LongWord:                              LongWord.
* low:                                   low.
* lt:                                    lt.
* M680x0 options:                        M680x0 Options.
* M88k options:                          M88K Options.
* machine dependent options:             Submodel Options.
* magic:                                 Tree nodes.
* main program <1>:                      Exporting to other languages.
* main program:                          Importing from other languages.
* make:                                  Preprocessor Options.
* Mark:                                  Mark.
* max:                                   max.
* MaxChar:                               MaxChar.
* MaxInt:                                MaxInt.
* MaxReal:                               MaxReal.
* MedCard:                               MedCard.
* MedInt:                                MedInt.
* MedReal:                               MedReal.
* MedWord:                               MedWord.
* memory model (29k):                    AMD29K Options.
* messages, warning:                     Warning Options.
* min:                                   min.
* MinReal:                               MinReal.
* MIPS options:                          MIPS Options.
* MkDir:                                 MkDir.
* mod:                                   mod.
* Module:                                Module.
* Modules, source structure:             Modules.
* move:                                  move.
* MoveLeft:                              MoveLeft.
* MoveRight:                             MoveRight.
* MS-DOS <1>:                            EMX.
* MS-DOS:                                DJGPP.
* ne:                                    ne.
* near:                                  near.
* New <1>:                               New.
* New:                                   OOP.
* NewCString:                            NewCString.
* Nil:                                   Nil.
* not:                                   not.
* NULL:                                  NULL.
* OBJC_INCLUDE_PATH:                     Environment Variables.
* object:                                object.
* Object-orientated programming:         OOP.
* Objects:                               Exporting to other languages.
* OCS (88k):                             M88K Options.
* odd:                                   odd.
* of:                                    of.
* only:                                  only.
* OOP:                                   OOP.
* Operator:                              Operator.
* Operators:                             Operators.
* operators, built-in:                   Built-in operators.
* operators, user-defined:               User-defined operators.
* optimize options:                      Optimize Options.
* options to control warnings:           Warning Options.
* options, code generation:              Code Gen Options.
* options, debugging:                    Debugging Options.
* options, dialect:                      Pascal Dialect Options.
* options, directory search:             Directory Options.
* options, GNU Pascal command:           Invoking GPC.
* options, grouping:                     Invoking GPC.
* options, linking:                      Link Options.
* options, optimization:                 Optimize Options.
* options, order:                        Invoking GPC.
* options, preprocessor:                 Preprocessor Options.
* or:                                    or.
* or else:                               or else.
* or_else:                               or_else.
* ord:                                   ord.
* order of options:                      Invoking GPC.
* OS/2:                                  EMX.
* others:                                others.
* otherwise:                             otherwise.
* Output:                                Output.
* output file option:                    Overall Options.
* overloaded virtual fn, warning:        Warning Options.
* pack:                                  pack.
* packed:                                packed.
* page:                                  page.
* pAnsiChar:                             pAnsiChar.
* ParamCount:                            ParamCount.
* parameter passing:                     Parameter passing.
* ParamStr:                              ParamStr.
* parser:                                Language definition.
* parser generator, Bison:               Installation.
* pChar:                                 pChar.
* PIC:                                   Code Gen Options.
* Pointer:                               Pointer.
* pointer arithmetics:                   Pointer arithmetics.
* polar:                                 polar.
* pos:                                   pos.
* Position:                              Position.
* pow:                                   pow.
* pred:                                  pred.
* preprocessor options:                  Preprocessor Options.
* procedural parameters:                 Parameter passing.
* Procedure:                             Procedure.
* processor selection (29k):             AMD29K Options.
* prof:                                  Debugging Options.
* Program:                               Program.
* programming in GPC:                    Programming.
* Programs, source structure:            Programs.
* protected:                             protected.
* PtrCard:                               PtrCard.
* PtrInt:                                PtrInt.
* PtrWord:                               PtrWord.
* Put:                                   Put.
* r0-relative references (88k):          M88K Options.
* Re:                                    Re.
* read:                                  read.
* readln:                                readln.
* ReadStr:                               ReadStr.
* Real:                                  Real.
* record:                                record.
* register positions in frame (88k):     M88K Options.
* Release:                               Release.
* rename:                                rename.
* repeat:                                repeat.
* reset:                                 reset.
* restricted:                            restricted.
* Result:                                Result.
* return:                                return.
* rewrite:                               rewrite.
* RmDir:                                 RmDir.
* round:                                 round.
* RS/6000 and PowerPC Options:           RS/6000 and PowerPC Options.
* RT options:                            RT Options.
* Run time library:                      Run time library.
* run-time options:                      Code Gen Options.
* RunError:                              RunError.
* schemata:                              Schemata.
* search path:                           Directory Options.
* second include path:                   Preprocessor Options.
* Seek:                                  Seek.
* SeekRead:                              SeekRead.
* SeekUpdate:                            SeekUpdate.
* SeekWrite:                             SeekWrite.
* Self:                                  Self.
* sequential consistency on 88k:         M88K Options.
* set:                                   set.
* SetLength:                             SetLength.
* SetType:                               SetType.
* shl:                                   shl.
* ShortCard:                             ShortCard.
* ShortInt:                              ShortInt.
* ShortReal:                             ShortReal.
* ShortWord:                             ShortWord.
* shr:                                   shr.
* sin:                                   sin.
* Single:                                Single.
* SizeOf:                                SizeOf.
* smaller data references (88k):         M88K Options.
* smaller data references (MIPS):        MIPS Options.
* SmallInt:                              SmallInt.
* source structures:                     Source structures.
* SPARC options:                         SPARC Options.
* specifying compiler version and target machine: Target Options.
* specifying hardware config:            Submodel Options.
* specifying machine version:            Target Options.
* sqr:                                   sqr.
* sqrt:                                  sqrt.
* stack checks (29k):                    AMD29K Options.
* StandardError:                         StandardError.
* StandardInput:                         StandardInput.
* StandardOutput:                        StandardOutput.
* static:                                static.
* stdarg.h and RT PC:                    RT Options.
* StdErr:                                StdErr.
* storem bug (29k):                      AMD29K Options.
* Str:                                   Str.
* String:                                String.
* String2CString:                        String2CString.
* StrPCopy:                              StrPCopy.
* structure passing (88k):               M88K Options.
* submodel options:                      Submodel Options.
* subrange types:                        Subrange types.
* SubStr:                                SubStr.
* succ:                                  succ.
* suppressing warnings:                  Warning Options.
* SVr4:                                  M88K Options.
* syntax checking:                       Warning Options.
* synthesized methods, warning:          Warning Options.
* target machine, specifying:            Target Options.
* target options:                        Target Options.
* tcov:                                  Debugging Options.
* Text:                                  Text.
* then:                                  then.
* Time:                                  Time.
* TimeStamp:                             TimeStamp.
* TMPDIR:                                Environment Variables.
* to:                                    to.
* to begin:                              to begin.
* to end:                                to end.
* tree nodes:                            Tree nodes.
* Trim:                                  Trim.
* true:                                  true.
* trunc:                                 trunc.
* Truncate:                              Truncate.
* Type:                                  Type.
* type casts:                            Type casts.
* TypeOf:                                TypeOf.
* types, schema:                         Schemata.
* UnBind:                                UnBind.
* underscores, avoiding (88k):           M88K Options.
* Unit:                                  Unit.
* Units, source structure:               Units.
* unpack:                                unpack.
* unresolved references and -nodefaultlibs: Link Options.
* unresolved references and -nostdlib:   Link Options.
* until:                                 until.
* UpCase:                                UpCase.
* update:                                update.
* uses:                                  uses.
* Val:                                   Val.
* value:                                 value.
* Var:                                   Var.
* varargs.h and RT PC:                   RT Options.
* VAX options:                           VAX Options.
* virtual:                               virtual.
* VMT:                                   Exporting to other languages.
* Void:                                  Void.
* warning for overloaded virtual fn:     Warning Options.
* warning for synthesized methods:       Warning Options.
* warning messages:                      Warning Options.
* while:                                 while.
* Windows 95:                            Windows 95/NT.
* Windows NT:                            Windows 95/NT.
* with:                                  with.
* Word:                                  Word.
* write:                                 write.
* writeln:                               writeln.
* WriteStr:                              WriteStr.
* xor:                                   xor.
* zero division on 88k:                  M88K Options.


