Node: Highlights, Next: News, Previous: Welcome, Up: Top

## Some of GPC's most interesting features.

The GNU Pascal Compiler (GPC) is, as the name says, the Pascal compiler of the GNU family (http://www.gnu.org/software/gcc/). This means:

- GPC is a 32/64 bit compiler,
- does not have limits like the 64 kB or 640 kB limit known from certain operating systems – even on those systems –,
- runs on all operating systems supported by GNU C, including
  - GNU Hurd,
  - Linux on Intel, AMD64, Sparc, Alpha, S390, and all other supported types of hardware,
  - the BSD family: FreeBSD, NetBSD, OpenBSD,
  - DOS with 32 bits, using DJGPP or EMX,
  - MS-Windows 9x/NT, using CygWin or mingw or MSYS,
  - OS/2 with EMX,
  - Mac OS X,
  - MIPS-SGI-IRIX,
  - Alpha-DEC-OSF,
  - Sparc-Sun-Solaris,
  - HP/UX,

  and more (note: the runtime system only supports ASCII based systems; that includes almost all of today's systems, but a few IBM machines still use EBCDIC; on those, the compiler might run, but the runtime support might need major changes),

- can act as a native or as a cross compiler between all supported systems,
- produces highly optimized code for all these systems,
- is Free Software (Open-Source Software) according to the GNU General Public License,
- is compatible to other GNU languages and tools such as GNU C and the GNU debugger.

The compiler supports the following language standards and quasi-standards:

- ISO 7185 Pascal (see Resources),
- most of ISO 10206 Extended Pascal,
- Borland Pascal 7.0,
- parts of Borland Delphi, Mac Pascal and Pascal-SC (PXSC).

Some highlights:

- From Standard Pascal: Many popular Pascal compilers claim to extend Standard Pascal but miss these important features.
  - Conformant array parameters – the standardized and comfortable way to pass arrays of varying size to procedures and functions. [Example]
  - Passing local procedures as procedural parameters – with full access to all variables of the “parent” procedure. [Example]
  - Automatic file buffers and standard `Get` and `Put` procedures. Read ahead from files without temporary variables. [Example] This allows you, for instance, to validate numeric input from text files before reading without conversion through strings. [Example]
  - True packed records and arrays. Pack 8 Booleans into 1 byte. [Example]
  - Internal files. You don't have to worry about creating temporary file names and erasing the files later. [Example]
  - Global `goto`. (Yes, `goto` has its place when it is not restricted to the current routine.) [Example]
  - Automatically set discriminants of variant records in `New`. [Example]
  - Sets of arbitrary size. [Example]
- From Extended Pascal:
  - Strings of arbitrary length. [Example]
  - `ReadStr` and `WriteStr`. Read from and write to strings with the full comfort of `ReadLn`/`WriteLn`. [Example]
  - System-independent date/time routines. [Example]
  - Set member iteration: `for Ch in ['A' .. 'Z', 'a' .. 'z'] do ...` [Example]
  - Set extensions (symmetric difference, `Card`)
  - Generalized `Succ` and `Pred` functions (`foo := Succ (bar, 5);`).
  - Complex numbers. [Example] [Example]
  - Exponentiation operators (`pow` and `**`) for real and complex numbers.
  - Initialized variables. [Example]
  - Functions can return array or record values.
  - Result variables. [Example]
  - Modules.
  - Non-decimal numbers in base 2 through 36: `base#number`.
  - `MinReal`, `MaxReal`, `EpsReal`, `MaxChar` constants.
  - Schemata – the Pascal way to get dynamic arrays without dirty tricks. [Example]
  - Local variables may have dynamic size. [Example]
  - Array Slice Access – access parts of an array as a smaller array, even on the left side of an assignment [Example]
- Compatible to Borland Pascal 7.0 with objects (BP):
  - Supports units, objects, ..., and makes even things like `absolute` variables portable. [Example]
  - Comes with portable versions of the BP standard units with full source.

  - (PNG, 21 kB)

    True network-transparent CRT unit: You can run your CRT applications locally or while being logged in remotely, without any need to worry about different terminal types. Compatible to BP's unit, but with many extensions, such as overlapping windows. [Example]
  - Fully functional GUI (X11) version of CRT (also completely network transparent).
  - The `Random` function can produce the same sequence of pseudo-random numbers as BP does – if you need that instead of the much more elaborate default algorithm.
  - Supports BP style procedural variables as well as Standard Pascal's procedural parameters. [Example]
  - A `Ports` unit lets you access CPU I/O ports on systems where this makes sense. [Example]
  - Special compatibility features to help migrating from BP to GPC, like a `GPC for BP` unit which provides some of GPC's features for BP, and some routines to access sets of large memory blocks in a uniform way under GPC and BP (even in real mode). [Example]
  - Comes with a BP compatible `binobj` utility. [Example]
- From Borland Delphi:
  - `abstract` object types and methods
  - `is` and `as` operators to test object type membership
  - Comments with `//`
  - Empty parameter lists with `()`
  - Assertions
  - A `SetLength` procedure for strings makes it unnecessary to use dirty tricks like assignments to the “zeroth character”.
  - `Initialize` and `Finalize` for low-level handling of variables.
  - `initialization` and `finalization` for units.
- From Pascal-SC (PXSC):
  - User-definable operators. Add your vectors with `+`.
- Carefully designed GNU extensions help you to make your real-world programs portable:
  - 64-bit signed and unsigned integer types.
  - Special types guarantee compatibility to other GNU languages such as GNU C. Directives like `{$L foo.c}` make it easy to maintain projects written in multiple languages, e.g., including code written in other languages into Pascal programs [Example (Pascal part)] [Example (C part)],
  - or including Pascal code into programs written in other languages. [Example (Pascal part)] [Example (Pascal unit)] [Example (C part)]
  - Extensions like `BitSizeOf` and `ConvertFromBigEndian` help you to deal with different data sizes and endianesses. [Example]
  - Little somethings like `DirSeparator`, `PathSeparator`, `GetTempDirectory` help you to write programs that look and feel “at home” on all operating systems.
  - The `PExecute` routine lets you execute child processes in a portable way that takes full advantage of multitasking environments. [Example] [Example]
  - The GNU GetOpt routines give you comfortable access to Unix-style short and long command-line options with and without arguments. [Example]
  - Routines like `FSplit` or `FSearch` or `FExpand` know about the specifics of the various different operating systems. [Example]
  - The `FormatTime` function lets you format date and time values, according to various formatting rules. [Example]
- Useful and portable GNU standard units:
  - A `Pipes` unit gives you inter-process communication even under plain DOS. [Example] [Demo process for the example]
  - With the `RegEx` unit you can do searches with regular expressions. [Example]
  - The GNU MultiPrecision (`GMP`) unit allows you to do arithmetics with integer, real, and rational numbers of arbitrary precision. [Example: factorial] [Example: fibonacci] [Example: power] [Example: real power] [Example: pi]
  - Posix functions like `ReadDir`, `StatFS` or `FileLock` provide an efficient, easy-to-use and portable interface to the operating system. [Example] [Example] [Example]
  - A `DosUnix` unit compensates for some of the incompatibilities between two families of operating systems. [Example]
  - An `MD5` unit to compute MD5 message digests, according to RFC 1321. [Example]
  - A `FileUtils` unit which provides some higher-level file and directory handling routines. [Example]
  - A `StringUtils` unit which provides some higher-level string handling routines. [Example]
  - An `Intl` unit for internationalization. [Example] [Example]
  - A `Trap` unit to trap runtime errors and handle them within your program. [Example]
  - A `TFDD` unit that provides some tricks with text files, e.g. a “tee” file which causes everything written to it to be written to two other files. [Example]
  - A `HeapMon` unit to help you find memory leaks in your programs.

The demo programs mentioned above are available both on the WWW and in GPC source and binary distributions.

Disadvantages:

- The GNU debugger (GDB) still has some problems with Pascal debug info.
- Compilation with GPC takes quite long.

Co-workers welcome!

Able, committed programmers are always welcome in the GNU Pascal team. If you want to be independent of companies that you have to pay in order to get a compiler with more restrictive licensing conditions that only runs on one operating system, be invited to join the development team, Acknowledgments.