This is gpc.info, produced by makeinfo version 4.0 from gpc.texi.

INFO-DIR-SECTION GNU programming tools
START-INFO-DIR-ENTRY
* GPC: (gpc).                   The GNU Pascal Compiler.
END-INFO-DIR-ENTRY
INFO-DIR-SECTION Individual utilities
START-INFO-DIR-ENTRY
* GPC: (gpc)Invoking GPC.       The GNU Pascal Compiler.
END-INFO-DIR-ENTRY

   This file documents the GNU Pascal Compiler.

   Copyright (C) 1988, 1996-2000 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", "The GNU
Project", "The GNU Manifesto" and "Funding for Free Software" 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", "The GNU Project", "The GNU Manifesto" and "Funding for Free
Software" 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: Testing,  Prev: Reporting Bugs,  Up: Support

Running the GPC Test Suite
==========================

   _Note:_ If you have installed a GPC binary distribution, you usually
don't have the Test Suite installed (you can download the GPC source
distribution to get it, however), so this section does not apply to
you. Still, you can find in the section `Contributing Tests to the Test
Suite' how to report GPC bugs in the form of new test programs so we
can fix them as fast as possible.

   The files in the test directory and subdirectories are for testing
GPC only and should not be of any other use.

   Note: A few of the tests do not make sense on all systems. They are
equipped with checks and will be skipped if they find the system not
suitable. Skipped tests do *not* indicate a GPC bug, unless you have a
reason to be sure that the particular test should make sense on your
system.

   * To run the whole Test Suite, type `make' in the test directory (or
     `make check' in the `p' object directory after building GPC).

   * The output will show all errors encountered (hopefully none) and
     tests skipped, and finally display a summary giving the number of
     successful, failed and skipped tests. Any failed test indicates a
     bug in GPC which should be reported to the GPC mailing list,
     <gpc@gnu.de>. Don't forget to mention the operating system you ran
     the test on and any other relevant information about what you did.

   * You can also type `make pascal.check-long' to get a long output
     which is a sequence of file names followed by `OK' for successful
     tests, `SKIPPED' for skipped tests (both in capital letters), and
     anything else for failed tests.

   * To run only some of the tests, you can type something like `make
     MASK="foo[1-7]*.pas"' or `make MASK="foo42.pas" pascal.check-long'.

   * To clean up after running the tests, type `make clean'.



File: gpc.info,  Node: To Do,  Next: Internals,  Prev: Support,  Up: Top

The GNU Pascal To-Do List.
**************************

   This is the To-Do list for the GNU Pascal Compiler.

   The GNU Pascal development team is constantly working on making GNU
Pascal more reliable and more comfortable. However, there are some
known bugs which will take some time to be fixed (any help welcome!),
and we do not want to hide them from you. You might also be interested
to know what features are planned to be implemented in the future. This
list is meant to keep track of the known bugs and wanted features of
GPC.

   If you want to report a new bug or suggest a new feature, the best
way to do it is in the mailing list. This way, other GPC users can
provide additional ideas, perhaps work-arounds for bugs, and the GPC
maintainers can sooner start to think about how to solve the problem.
The GPC mailing list is <gpc@gnu.de>. To subscribe, send the command
`subscribe gpc your@email.address' in the body of a mail to
<majordomo@gnu.de> (the subject is ignored). An archive of the mailing
list can be found on the GPC home page.

   The list changes every few days. The present version refers to the
current GPC snapshot, version 20001101.

   This list is part of the GNU Pascal Manual, included in GPC
distributions and snapshots. You can always browse the most current
version of the list on GPC's WWW page in HTML.  If you check the To-Do
list regularly you can decide if and when to try a new snapshort.

* Menu:

* Known Bugs::        Known bugs in GPC
* Planned Features::  Features planned for GPC
* Done::              Fixed bugs and implemented features


File: gpc.info,  Node: Known Bugs,  Next: Planned Features,  Up: To Do

Known bugs in GPC
=================

   In the following sections, you can find information about GPC bugs
that are known to the developers. The list always corresponds to the
latest developer versions of GPC, usually not to the latest official
distribution.

   If you encounter a bug with GPC, please check whether it is one of
the known bugs. If not, report it to the GNU Pascal mailing list.  (But
always report it if you solve the problem! ;-)

   Entries will be removed from the list as soon as the problem is
solved in the developers' current GPC version. (Exception: If we can't
reproduce the problem, but someone else can, the entry will be removed
when we hear from this person that the problem is solved.)  Problems
which are announced to be solved, but for which we (or the person who
can reproduce the problem) did not get the proof (i.e., a GPC source
patch) yet, are marked `(ok)'.

   A message ID (like `<42@foo.bar>') refers to a message in the GPC
mailing list where the topic was discussed (usually a bug report). A
note of the form `(xy20001231)' refers to an internal message of the
GPC developers. A file name like `(foo42.pas)' refers to the according
program in the GPC test suite included in the GPC source distribution.

* Menu:

* Urgent::  Things left to do until the next release of GPC
* Bugs::    Other known bugs in GPC


File: gpc.info,  Node: Urgent,  Next: Bugs,  Up: Known Bugs

Things left to do until the next release of GPC
-----------------------------------------------

   Bugs:

   * enumeration types declared within a set or record type or variable
     or constant declaration or the case selector of a record within a
     unit are not visible in the main program (fjf211.pas,
     fjf239[ab].pas)

   * enumeration types do not always properly survive transport through
     two interfaces (russell2.pas, miguel2.pas, daj2.pas)

   * some functions in boolean shortcuts are always called
     (fjf226[a-\infty].pas)

   * possible stack overflow when using string expressions in a loop
     (fjf419.pas)

   * GPC sometimes crashes with `-g'
     <Pine.SGI.4.10.9903231101500.6691-100000@pugh.bip.bham.ac.uk> (ok?)

   Wanted features:

   * make it possible to declare routines as I/O critical

   * `gp' make utility to replace automake; compile and link programs,
     but compile units without linking and without a warning that there
     is nothing to link; store GPC version numbers, platform and
     options in GPD files and re-compile automatically in `--automake'
     mode when they don't match; `--library-path' and `--include-path'
     as synonyms for (multiple) `-L' and `-I' options


File: gpc.info,  Node: Bugs,  Prev: Urgent,  Up: Known Bugs

Other known bugs in GPC
-----------------------

   * methods returning records don't work (chief39.pas)

   * bugs with packed subranges (couper[1-3].pas)

   * `setlimit' is applied when it shouldn't be ((a) variable/constant
     declarations, (b) `set of ShortCard', (c) constant sets), fatal
     range overflows in set constructors (couper8.pas, couper10.pas)
     <2C4F3FEF.20000809173117.FOO-13A6.frank@g-n-u.de>

   * string types declared in modules don't always work (daj3.pas)

   * declaring a procedure in the implementation with the same name as
     an imported procedure doesn't work (chief18.pas), detect name
     collisions between imported EP modules (mod9.pas)

   * don't allow assigning a pointer to a schema to a variable of type
     pointer to discriminated schema with different discriminant
     (fjf130.pas)

   * global dynamic variables (john1.pas) and global variables
     initialized by a function (fjf210b.pas) don't work

   * check for using, incrementing, ... unused variables
     <199711270257.VAA06393@mint.mint.net> (kevin2.pas), especially for
     strings, also for `for'-loop counters after the loop (EP 6.8.1)
     and modifying `for'-loop counters within the loop or in local
     routines <200005240807.EAA05355@mail.bcpl.net>

   * dynamic sets don't work (->PPS)

   * there are some bugs with mathematical functions. GPC fails, for
     example, the Paranoia test.

   * the compiler does not always recover well after a parse error
     <199911040915.KAA11168@humulus.daimi.au.dk>

   * type problem with const/protected integer parameters (chief31.pas)

   * bug with const parameters and derived object types (tc19991003)

   * give a warning rather than an error (and nothing in
     `--borland-pascal') when assigning/passing by value an object of
     derived type to one of a base type (and change the VMT pointer in
     the destination/actual parameter), don't change the VMT pointer
     when assigning to a polymorphic object (chief35[ab].pas,
     fjf451*.pas)

   * `prior parameter's size depends on `foo'' error with protected
     string parameters (daj1.pas)

   * declarations of subranges of enumeration types cause `conflicting
     types' messages (drf8.pas)

   * file parameters must not automatically be bindable in
     `--extended-pascal' (fjf193c.pas)

   * automatically close dynamically allocated files on dispose and
     files declared in a statement block at the end of the statement
     block (fjf219[a-c].pas); handle variant records correctly
     <6r9ir5$7v5$1@nntpd.lkg.dec.com> (fjf219d.pas); close files before
     gotos out of their scope (fjf219[ef].pas)

   * const real parameters don't work (fjf228.pas)

   * arithmetic expressions don't work as lower array/subrange bounds
     (fjf248.pas)

   * identifiers declared in a unit that have the same name as some
     object method are not visible (fjf278.pas, russell2.pas)

   * pointers to objects returned by methods can't be dereferenced
     (fjf299.pas)

   * integer parameters to built-in routines are not always converted
     to the right type (fjf349.pas)

   * types declared in a module interface are not visible in the
     implementation (kevin13.pas)

   * procedural variables are always passed by value
     <ABcLeYr887@e00827.vno.lt> (marius1.pas)

   * `inline' and `asmname' don't work together if compiling without
     optimization (maur3.pas)

   * module bug (mod12.pas)

   * Read, ReadStr and Val for all integer, real, char and string
     types; [no-]read-range-checking (also for subtypes of char!),
     [no-]read-base-specifier, [no-]read-white-space (not in Val!)
     (read?.pas)

   * fixed string comparisons are wrong (takashi1.pas)

   * char fields of packed records don't work in read (tom5.pas)

   * count of parameters to methods in error messages should not
     include Self
     <8F990E3D9A6FD1118F3B0000F81EA1D84985CE@exchsa2.dsto.defence.gov.au>

   * bug on machines with strict alignment requirements
     <199906021618.MAA06228@sten27.software.mitel.com>

   * too many parameters to `New' are not checked

   * `MedInt' (and therefore SizeType under DJGPP) is not accepted as
     the 4th parameter to BlockRead, BlockWrite (fjf252.pas)

   * compilation of interface declarations takes quadratic time

   * installation: bug(s) in GPC's makefiles; Make-lang.in is missing a
     rule so GPC can't be built without building GCC

   * forward referencing pointers generate debug info that appears as
     generic pointers; no information of `with' statements is currently
     given to the debugger; error in debug entries generated for
     objects
     <8F990E3D9A6FD1118F3B0000F81EA1D84985D7@exchsa2.dsto.defence.gov.au>

   * problems with initialising sets to the empty set
     <onOioOAQz365EwbY@tcs02.demon.co.uk>

   * Solaris: the preprocessor doesn't understand `defined'
     (fjf266.pas,fjf238.pas)
     <19990129132623.21658.qmail@euler.stams.strath.ac.uk>

   * IRIX: writing reals doesn't work (gcc bug with varargs)
     <Pine.SGI.4.10.9903240952350.12280-300000@pugh.bip.bham.ac.uk>,
     <39DDC168.7CFFE872@larc.nasa.gov>

   * HP/UX: `unrecognizable insn' error in connection with conformant
     or const string parameters)
     <199809280741.JAA17719@rug105.cs.rug.nl> (sietse1.pas),
     <Pine.SOL.4.10.9908051751550.23095-100000@niflheim.rutgers.edu>,
     <396C3531.3A327722@cs.rug.nl>


File: gpc.info,  Node: Planned Features,  Next: Done,  Prev: Known Bugs,  Up: To Do

Features planned for GPC
========================

   In the following sections, you can find informations about features
which have been suggested and/or discussed for inclusion into GPC,
usually in the GPC mailing list. The division into the sections and the
names of the sections may change when this seems useful. The entries
within each section are in no particular order.

   Some of the entries may be a bit difficult to read. Double question
marks (`??') within the entries mean that it's not yet clear how to do
the thing. Triple question marks (`???') mean that it's not clear
whether to do it at all. ;-)

* Menu:

* Planned - Strings::            String types
* Planned - Records/arrays::     Record and array types
* Planned - Files::              Files
* Planned - Other types::        Other types
* Planned - Units and modules::  Units and modules
* Planned - OOP::                Object oriented programming extensions
* Planned - Misc::               Miscellaneous GPC topics
* Planned - Utilities::          Useful utilities for GPC


File: gpc.info,  Node: Planned - Strings,  Next: Planned - Records/arrays,  Up: Planned Features

Planned features: Strings
-------------------------

   * const/var `AnyString' parameters and pointers (records internally,
     cf. gpc.pas) (GetCapacity; only for var parameters)

   * `SetLength' for non-Pascal string types; use truncate-flag; don't
     require extended syntax for `SetLength'

   * make work on all string types: string functions from
     rts/gstrings.pas, Concat/+ (function with conformant array;
     Optimize `s := s + ch') (fh19971105)

   * new option `--arrays-of-char-as-cstrings={none,zero-based,all}' to
     allow assigning [zero-based] arrays of char to cstring variables
     (warning otherwise) (cstrini2.pas); make padding of those arrays
     in initialized variables and in assignments dependent on this
     switch (fh19970921) (fjf57.pas, ok) and if the length matches
     exactly, give a warning (fh19971013) (cstrassign.pas); pass those
     arrays as cstrings in read*, write*, str (P_*STRING; current
     length=-1 in two places); compile time warning (and treatment as
     non-zero-based) if it's not clear at compile time if a conformant
     array or schema is zero-based or not, and an operation depends on
     this in the zero-based state

   * Short strings (Length, Capacity) and switches
     (tc19980326.2,tc19980327); allow `type x=string' (undiscriminated)
     when switch is set so that strings don't default to length 255
     (fh19971113) (fjf97.pas, ok); don't add a #0 terminator when
     passing as a CString parameter (automatically use String2CString)

   * automatically convert CStrings to Strings?

   * optimize assignment of and (non-trimming) comparison with a
     constant empty string

   * general switch `--bp-strings'

   * offer trimming string relations as functions

   * undiscriminated strings -> remove pointers to string constants

   * `WriteStr'-like function

   * unused local variables of string types are not detected

   * wide characters

   * open array/string parameters (`$P', `$V' in BP; undocumented
     `OpenString' identifier in BP)


File: gpc.info,  Node: Planned - Records/arrays,  Next: Planned - Files,  Prev: Planned - Strings,  Up: Planned Features

Planned features: Records/arrays
--------------------------------

   * array/record initializers: recognize indices and field names
     (sven4.pas), ISO structured constants (constdef.pas); variant
     records <C1256791.0021F002.00@synln01.synstar.de>; allow omitting
     fields; fields in arbitrary order ???; index/field name optional;
     arrays: warning/error when too few fields are given; initialized
     schemata

   * initialized types in records/arrays (inirec[24].pas)

   * when applying `New' to a variant record type with a selector
     given, only allocate the space necessary for the selected variant
     (varrec2.pas)

   * Oregon and Vax Pascal structured constants
     <80256540.005E7D08.00@buffer1.quantel.com> ???

   * automatically detected upper array bounds in structured
     constants/intialized variables (-> PXSC)

   * simplify code to compute size of dynamical variables if no
     bitfields are involved


File: gpc.info,  Node: Planned - Files,  Next: Planned - Other types,  Prev: Planned - Records/arrays,  Up: Planned Features

Planned features: Files
-----------------------

   * AnyFile parameters and pointers

   * keep files in FDRList while they live, not only while they're
     open, so _p_fdrdone() can be applied to all of them

   * packed files (EP) ??

   * write: left/center/both(?) justification???; rounding (PXSC) ???

   * BlockRead, BlockWrite: make last parameter internally a function
     result and allow any integer type to be passed for it for
     compatibility with 16 bit BP code

   * improve TFDDs (also for typed and untyped files)
     (OpenProc/CloseProc)

   * read/write operators ???

   * let Assign call _p_initfdr() in `--borland-pascal'


File: gpc.info,  Node: Planned - Other types,  Next: Planned - Units and modules,  Prev: Planned - Files,  Up: Planned Features

Planned features: Other types
-----------------------------

   * read Booleans and enum types from files, write enum types to files

   * UCSD Pascal's `Integer[n]' ??? BCD?

   * enum types with specified values ???; Inc, Pred, ... ??

   * enum type extensions (syntax??)

   * check for dereferencing nil pointers

   * general subtypes ???

   * type cast operators ???

   * make `SizeOf' work on specially declared untyped var and const
     parameters (`AnyType'?)

   * sparse sets; sets of arbitrary types ?? ???

   * optimize set constructors even better ???

   * superfluous warning with sets and variable elements (fh19970928)

   * variables of type undiscriminated schema; functions returning
     undiscriminated schemata (pg19980813.3)

   * record and array values (EP)

   * initalization and finalization code for arbitrary types (e.g. GMP
     types)

   * give an error rather than a warning when casting between types of
     different size in {$X-}

   * storage class qualifiers (`external', `asmname', `static',
     `volatile', `attribute')

   * `SELECTED_REAL_KIND' for real types (cf. Fortran, drf) ?? ???

   * resize schemata (cf. `SetLength' in Delphi)


File: gpc.info,  Node: Planned - Units and modules,  Next: Planned - OOP,  Prev: Planned - Other types,  Up: Planned Features

Planned features: Units and modules
-----------------------------------

   * qualified identifiers <34508F33.4F685BD1@keele.ac.uk> (also
     `program_name.identifier'?) (problem module.id vs. record.field);
     also for operators; `gpc' for built-in identifiers; duplicate
     identifiers in different units (fjf260[ab].pas); giving the same
     name to a routine in an interface and a local routine doesn't work
     (fjf240.pas); don't capitalize variable names in error messages
     and file name queries

   * `external name', `asmname', ...; (-> BP, Delphi) ??, like `$L'
     (fh19990325.2)

   * modules without implementation ??? (pmod1.pas)

   * `asmname' for units

   * `gpc-main' in GPI files

   * qualified import (mod10.pas)

   * units without initialization code or variables needing
     initialization should not get a constructor

   * GPI format ??

   * inline functions in GPI files

   * unit inheritance (of a complete interface with one statement or
     selectively)
     <Pine.HPP.3.96.971105161603.28577A-100000@tea.geophysik.tu-freiberg.de>,
     <199711061008.LAA25341@agnes.dida.physik.uni-essen.de> ??; virtual
     procedures ???

   * allow accessing non-exported identifiers in the implementation of
     a module ???
     <Pine.BSI.3.96.971110210330.7570A-100000@malasada.lava.net>

   * `Initialization/Finalization' (Delphi: =`to begin/end do') (???)
     (only in `--delphi'?)


File: gpc.info,  Node: Planned - OOP,  Next: Planned - Misc,  Prev: Planned - Units and modules,  Up: Planned Features

Planned features: OOP
---------------------

   * init VMT (fjf445*.pas)

   * published, public, protected, private (scope limited to a unit in
     `--borland-pascal', and to the object type normally)

   * `ProcVar := Obj.Method' {$X+}

   * VMT link (global, local, new: set to 0 or @VMT; destructor: reset
     to 0)

   * checks: @object<>nil, typeof(object)<>0, size=-negsize; separate
     switches; function initialized (that does these 3 tests) ???

   * virtual constructors

   * `OBJ is CLASS', type cast

   * `is_exactly' (instead of `TypeOf (OBJ) = TypeOf (CLASS)' ???

   * `CLASS is CLASS' (implemented in Pascal with `Parent')

   * `OBJ is INTERFACE' (not so easy?) ???

   * abstract methods, object types

   * allow method-implementation right after the declaration ???

   * friends ???

   * `dynamic' (= `virtual' ?)

   * `class' (reference to an object type); allow classes and object
     types to inherit from each other; OOE;
     <01BD7A3A.6B187A20.prucha@helicon.co.at>; obpascal.zip

   * `New': Delphi syntax; Dispose?? (automatically?; set references
     automatically to nil) (-> FPC)

   * `--base-class=foo', `--base-object=bar' ???

   * properties <01BD7A3A.6B187A20.prucha@helicon.co.at>,
     <16131.199805071354@potter.cc.keele.ac.uk>

   * interfaces (cf. OOE, Java)

   * object constants???

   * virtual constructors in interfaces (load)???

   * VMT problem with interfaces (my solution??? also with dynamic
     linking???)

   * VMTs (also for local classes (EP modules???)!) in GPI files,
     written to assembler file by main program; `--cfiles=foo': .s file
     with VMTs for C/assembler??? (also .h???)

   * Variables of type pointer to more than one interface [and class]
     (also possible!)

   * method overloading ??? ??

   * class libraries (more or less TV compatible?/Free Vision/EFLIB)
     (streams as interface type?)

   * method pointers (`procedure/function of object') (-> Delphi) ???

   * declare VMT format in Pascal (only Size, NegSize, Parent,
     Childs?); <obj>.pVMT ?

   * VMT: ClassID (64/128 bits?) default 0, error when duplicated,
     warning when 0 and inherited from class with <>0 ?, not allowed
     for abstract classes!; ClassName (also for abstract classes?); [];
     ProgrammerID, BaseClassID at beginning of unit (redeclarable?) ???

   * in VMT: Parent: pVMT, Child: list of pVMT

   * for abstract classes: nearly empty VMTs (see VMT format)

   * find class by ClassID/ClassName (implementable in Pascal with
     `Child')

   * object constants, class variables (-> other name for `VMT');
     virtual/static

   * store in GPI: whether ClassID used, ClassName used, which classes
     are instantiated


File: gpc.info,  Node: Planned - Misc,  Next: Planned - Utilities,  Prev: Planned - OOP,  Up: Planned Features

Planned features: Misc
----------------------

   * don't call procedures functions in error messages
     <200007230522.BAA05497@strawberry.ncifcrf.gov>

   * switch to warn about everything that could cause portability
     problems

   * document all compiler options and switches; make `gpc --help'
     output all the options ???

   * guarantee full evaluation in `{$B+}', `--borland-pascal mode'

   * libraries (static/shared; DLL)
     <Pine.HPP.3.96.971110183550.7996B-100000@tea.geophysik.tu-freiberg.de>

   * smart linking

   * range, overflow (right operand of mod <=0 is an error), nil
     pointer, string length, object VMT (pointer, negative size field),
     etc. checking <199911040915.KAA11168@humulus.daimi.au.dk>; also
     for array slice access (miklos1.pas); check that strings converted
     to CStrings don't contain #0 characters; initialize strings
     (length field), pointers, ordinal values and reals(?) with invalid
     values if checking is on

   * overloading of unary operators

   * warn about assigning the address of a local procedure (variable?)
     to a global pointer variable (fjf139.pas) or returning it from a
     function

   * intel assembler syntax; BP BASM ???

   * function overloading (in units and static methods?? - with
     different parameters, override or overload?); asmname?? (perhaps:
     first occurrence of a procedure with normal asmname (=> all
     non-overloaded procedures get normal asmnames)?); cf. Delphi
     methods without `override'

   * and_else, or_then (names??); guarantee complete evaluation in
     `{$B+}' mode

   * `?:' (`x := if c then bar else baz')

   * C operators (`,', `=', `++'/`--' (pre/post), `+=', ...), as
     functions ?

   * `for var : type = foo to bar do' ???

   * error/exception handling (Java,Delphi?)
     <01BD7A3A.6B187A20.prucha@helicon.co.at> (tc20000623)

   * RTS checking (libgpc_g), switch?

   * simplify math functions
     <199708091006.MAA26576@agnes.dida.physik.uni-essen.de>

   * variable number of arguments <32F9CFE7.5CB@lmemw.ericsson.se> ??
     ???

   * multithreading support ?? ???

   * `--wirth-pascal' :-)

   * PXSC standard... (pxsc.zip, /home/peter/pxsc) (??)

   * Object Oriented Extensions (Technical Report) (??)

   * generic types (cf. OOE section C.1) (gentypes.pas) ???

   * default parameters (cf. OOE section C.4; Delphi 4?)
     (iniparm[12].pas)

   * Pascal++ standard... (??) ???

   * allow `procedure foo; inline;'

   * compile time assertions ???

   * Ignore{Value,Result}/Discard and Swap for arbitrary types

   * make operators also available as functions

   * `absolute' with automatic type detection; `absolute' procedures
     (with automatic parameter detection) ???

   * Delphi features: Initialize, Finalize, Slice, TypeInfo ???,
     dynamic arrays (tc19991012)

   * output column numbers in error messages ??

   * get the address of a (direct or indirect) caller

   * warn when `and' and `or' are combined without parentheses
     (-Wparentheses; on by default)

   * store the casing of the first occurrence of a Pascal identifier
     for error messages etc.

   * assembler blocks should be considered volatile by default ???
     (fh19980829.4)

   * BP compatible `Graph' unit


File: gpc.info,  Node: Planned - Utilities,  Prev: Planned - Misc,  Up: Planned Features

Planned features: Utilities
---------------------------

   * C header to Pascal translator

   * gdb: Pascal types (sets, files, subranges, schemata, strings, ...)

   * `indent'-like source code formatter for Pascal

   * AT&T <-> Intel assembler syntax converter ???


File: gpc.info,  Node: Done,  Prev: Planned Features,  Up: To Do

Fixed bugs and implemented features
===================================

* Menu:

* Fixed Bugs::            Problems that have been solved
* Implemented Features::  Features that have been implemented

