This is ../p/doc/info/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-2002 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: Delete,  Next: destructor,  Prev: DefineSize,  Up: Reference

Delete
======

   (Under construction.)

Synopsis
--------

     procedure Delete (var S: String; FirstChar, Count: Integer);
   or
     procedure Delete (var S: String; FirstChar: Integer);

Description
-----------

Conforming to
-------------

   `Delete' is a UCSD Pascal extension. The possibility to omit the
third parameter is a GNU Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: destructor,  Next: Dispose,  Prev: Delete,  Up: Reference

destructor
==========

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

   `destructor' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: Dispose,  Next: div,  Prev: destructor,  Up: Reference

Dispose
=======

   (Under construction.)

Synopsis
--------

     Dispose (PointerVar: Pointer);
   or
     Dispose (PointerVar: Pointer; TAG FIELD VALUES);
   or
     Dispose (ObjectPointerVar: Pointer; DESTRUCTOR CALL);

Description
-----------

Conforming to
-------------

   `Dispose' is defined in ISO-7185 Pascal and supported by most known
Pascal variants, but not by UCSD Pascal.  Its use for objects is a
Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: div,  Next: do,  Prev: Dispose,  Up: Reference

div
===

   (Under construction.)

Synopsis
--------

     operator div (p, q: Integer) = r: Integer;

Description
-----------

Conforming to
-------------

   `div' is defined in ISO-7185 Pascal and supported by all known
Pascal variants.

Example
-------

See also
--------


File: gpc.info,  Node: do,  Next: Double,  Prev: div,  Up: Reference

do
==

Synopsis
--------

     for ... do
       STATEMENT
   or
     while ... do
       STATEMENT
   or
     with ... do
       STATEMENT
   or
     to begin do
       STATEMENT
   or
     to end do
       STATEMENT

Description
-----------

   The `do' reserved word is used in combination with other Pascal
keywords in many ways. For description and examples see the relevant
reference sections: `for', `while', `with', `to begin', `to end'.

Conforming to
-------------

   `do' is defined in ISO-7185 Pascal and supported by all known Pascal
variants.

Example
-------

   See references.

See also
--------

   *Note for::, *Note while::, *Note with::, *Note to begin do::, *Note
to end do::.


File: gpc.info,  Node: Double,  Next: downto,  Prev: do,  Up: Reference

Double
======

   (Under construction.)

Synopsis
--------

     type
       Double = Real;

Description
-----------

   `Double' is a synonym for the `Real' data type and supported for
compatibility with other compilers.

Conforming to
-------------

   `Double' is a Borland Pascal extension.

Example
-------

     program DoubleDemo;
     var
       A: Double;  { There is nothing special with `Double'. }
       B: Real;
     begin
       A := Pi;
       A := B
     end.

See also
--------


File: gpc.info,  Node: downto,  Next: else,  Prev: Double,  Up: Reference

downto
======

Synopsis
--------

     for VARIABLE := VALUE1 downto VALUE2 do
       STATEMENT

Description
-----------

   The `downto' reserved word is used in combination with `for' to
build a `for' loop.

Conforming to
-------------

   `downto' is defined in ISO-7185 Pascal and supported by all known
Pascal variants.

Example
-------

   See *Note for::.

See also
--------

   *Note for::.


File: gpc.info,  Node: else,  Next: Empty,  Prev: downto,  Up: Reference

else
====

Synopsis
--------

   As part of the `if' ... `then' ... `else' statement:
     if BOOLEAN EXPRESSION then
       STATEMENT1
     else
       STATEMENT2
   or, as part of the `case' ... `else' statement:
     case EXPRESSION of
       SELECTOR: STATEMENT;
       ...
       SELECTOR: STATEMENT
     else
       STATEMENT;
       ...
       STATEMENT
     end

Description
-----------

   `else' is part of the `if ... then ... else' statement which
provides a possibility to execute statements alternatively.  In the
`case' statement, `else' starts a series of statements which is
executed if no selector fit in EXPRESSION. In this case, `else' is a
synonym for `otherwise'.

Conforming to
-------------

   `else' in `if' statements is defined in ISO-7185 Pascal and
supported by all known Pascal variants. `else' in `case' statements is
a Borland Pascal extension; ISO-10206 Extended Pascal has `otherwise'
instead.

Example
-------

     program ElseDemo;
     var
       i: Integer;
     begin
       Write ('Enter a number: ');
       ReadLn (i);
       if i > 42 then
         WriteLn ('The number is greater than 42')
       else
         WriteLn ('The number is not greater than 42')
     end.

See also
--------

   *Note if::, *Note case::, *Note otherwise::.


File: gpc.info,  Node: Empty,  Next: end,  Prev: else,  Up: Reference

Empty
=====

   (Under construction.)

Synopsis
--------

     function Empty (var F: ANY FILE): Boolean;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: end,  Next: EOF,  Prev: Empty,  Up: Reference

end
===

Synopsis
--------

     begin
       STATEMENT;
       STATEMENT;
       ...
       STATEMENT
     end

Description
-----------

   The reserved word `end' closes a `begin' ... `end'; statement which
joins several STATEMENTS together into one compound statement.

   @@ end of a <case> statement @@ end of a record or object declaration
@@ part of a <to end do> module destructor

Conforming to
-------------

   `end' is defined in ISO-7185 Pascal and supported by all Pascal
variants.

Example
-------

     program EndDemo;
     begin
       if True then
         WriteLn ('single statement');
       if True then
         begin                     { clamp statement1 ... }
           WriteLn ('statement1');
           WriteLn ('statement2')
         end                       { ... to statement2 }
     end.

See also
--------

   *Note begin end Compound Statement::, *Note begin::


File: gpc.info,  Node: EOF,  Next: EOLn,  Prev: end,  Up: Reference

EOF
===

   (Under construction.)

Synopsis
--------

     function EOF (var F: ANY FILE): Boolean;
   or
     function EOF: Boolean;

Description
-----------

Conforming to
-------------

   `EOF' is defined in ISO-7185 Pascal and supported by all Pascal
variants.

Example
-------

See also
--------


File: gpc.info,  Node: EOLn,  Next: EpsReal,  Prev: EOF,  Up: Reference

EOLn
====

   (Under construction.)

Synopsis
--------

     function EOLn (var F: ANY FILE): Boolean;
   or
     function EOLn: Boolean;

Description
-----------

Conforming to
-------------

   `EOLn' is defined in ISO-7185 Pascal and supported by all Pascal
variants.

Example
-------

See also
--------


File: gpc.info,  Node: EpsReal,  Next: EQ,  Prev: EOLn,  Up: Reference

EpsReal
=======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

   `EpsReal' is an ISO-10206 Extended Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: EQ,  Next: Erase,  Prev: EpsReal,  Up: Reference

EQ
==

   (Under construction.)

Synopsis
--------

     function EQ (S1, S2: String): Boolean;

Description
-----------

Conforming to
-------------

   `EQ' is an ISO-10206 Extended Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: Erase,  Next: Exclude,  Prev: EQ,  Up: Reference

Erase
=====

   (Under construction.)

Synopsis
--------

     procedure Erase (var F: ANY FILE);

Description
-----------

Conforming to
-------------

   `Erase' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: Exclude,  Next: Exit,  Prev: Erase,  Up: Reference

Exclude
=======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Exit,  Next: Exp,  Prev: Exclude,  Up: Reference

Exit
====

Synopsis
--------

     procedure Exit;

Description
-----------

   `Exit' leaves the currently executed procedure or function.  Note:
If `Exit' is called within the main program, it will be terminated
instantly.

Conforming to
-------------

   `Exit' is a UCSD Pascal extension. GNU Pascal does not support all
uses of `Exit' but only those defined in Borland Pascal.

Example
-------

     program ExitDemo;
     
     procedure Foo (Bar: Integer);
     var
       Baz, Fac: Integer;
     begin
       if Bar < 1 then
         Exit;                  { Exit foo }
       Fac := 1;
       for Baz := 1 to Bar do
         begin
           Fac := Fac * Baz;
           if Fac >= Bar then       { Exit foo }
             Exit;
           WriteLn (Bar,' is greater then ', baz, '!, which is equal to ', Fac)
       end
     end;
     
     begin
       Foo (-1);
       Foo (789);
       Exit;                  { Terminates program }
       Foo (987654321)        { This is not executed any more }
     end.

See also
--------

   *Note Break::, *Note Continue::, *Note Halt::


File: gpc.info,  Node: Exp,  Next: export,  Prev: Exit,  Up: Reference

Exp
===

Synopsis
--------

     function Exp (x: Real): Real;
   or
     function Exp (z: Complex): Complex;

Description
-----------

   The exponential function `Exp' computes the value of e to the power
of x, where the Euler number e = Exp (1) is the base of the natural
logarithm.

Conforming to
-------------

   The function `Exp' is defined in ISO-7185 Pascal; its application to
complex values is defined in ISO-10206 Extended Pascal.

Example
-------

     program ExpDemo;
     var
       z: Complex;
     begin
       z := Cmplx (1, - 2 * Pi);  { z = 1 - 2 pi i }
       z := Exp (z);  { yields e = Exp (1), since Exp ix = Cos x + i Sin x }
       WriteLn (Ln (Re (z)) : 0 : 5)  { prints 1 = Ln (Exp (1)) }
     end.

See also
--------

   *Note Ln::


File: gpc.info,  Node: export,  Next: exports,  Prev: Exp,  Up: Reference

export
======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

   `export' is an ISO-10206 Extended Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: exports,  Next: Extend,  Prev: export,  Up: Reference

exports
=======

   Not yet implemented.

Synopsis
--------

Description
-----------

Conforming to
-------------

   `exports' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: Extend,  Next: Extended,  Prev: exports,  Up: Reference

Extend
======

   (Under construction.)

Synopsis
--------

     procedure Extend (var F: ANY FILE; [FileName: String;]
                                         [BlockSize: Cardinal]);

Description
-----------

   `Extend' opens a file for writing. If the file does not exist, it is
created. If it does exist, the file pointer is positioned after the
last element.

   Like `Rewrite', `Reset' and `Append' do, `Extend' accepts an
optional second and third parameter for the name of the file in the
filesystem and, for untyped files, the block size of the file. (For
details, see *Note Rewrite::.)

Conforming to
-------------

   `Extend' is an ISO-10206 Extended extension. Borland Pascal Pascal
has *Note Append:: instead.  The `BlockSize' parameter is a Borland
Pascal extension.  The `FileName' parameter is a GNU extension.

Example
-------

     program ExtendDemo;
     var
       Sample: Text;
     begin
       Assign (Sample, 'sample.txt');
       Rewrite (Sample);
       WriteLn (Sample, 'Hello, World!');  { `sample.txt' now has one line }
       Close (Sample);
     
       { ... }
     
       Extend (Sample);
       WriteLn (Sample, 'Hello again!');   { `sample.txt' now has two lines }
       Close (Sample)
     end.

See also
--------

   *Note Assign::, *Note Reset::, *Note Rewrite::, *Note Update::,
*Note Append::.


File: gpc.info,  Node: Extended,  Next: extern,  Prev: Extend,  Up: Reference

Extended
========

   (Under construction.)

Synopsis
--------

     type
       Extended = LongReal;

Description
-----------

Conforming to
-------------

Example
-------

     program ExtendedDemo;
     var
       a: Extended;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------


File: gpc.info,  Node: extern,  Next: external,  Prev: Extended,  Up: Reference

extern
======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: external,  Next: Fail,  Prev: extern,  Up: Reference

external
========

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Fail,  Next: False,  Prev: external,  Up: Reference

Fail
====

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: False,  Next: far,  Prev: Fail,  Up: Reference

False
=====

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: far,  Next: file,  Prev: False,  Up: Reference

far
===

Synopsis
--------

Description
-----------

   The `far' directive can be appended to a procedure or function
heading but is ignored by GPC. It is there for Borland compatibility,
only. (Since the GNU compilers provide a flat memory model, the
distinction between `near' and `far' pointers is void.)

Conforming to
-------------

   `far' is a Borland Pascal extension.

Example
-------

     program FarDemo;
     
     var
       p: procedure;
     
     {$W-}  { Don't warn about the uselessness of `far' }
     
     procedure Foo; far;  { `far' has no effect in GPC }
     begin
       WriteLn ('Foo')
     end;
     
     begin
       p := Foo;  { Would also work without `far' in GPC. }
       p
     end.

See also
--------

   *Note near::.


File: gpc.info,  Node: file,  Next: FileMode,  Prev: far,  Up: Reference

file
====

   (Under construction.)

Synopsis
--------

   In type definitions:
     File of TYPE
   or
     File

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: FileMode,  Next: FilePos,  Prev: file,  Up: Reference

FileMode
========

   (Under construction.)

Synopsis
--------

     var
       FileMode: Integer;

Description
-----------

Conforming to
-------------

   `FileMode' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: FilePos,  Next: FileSize,  Prev: FileMode,  Up: Reference

FilePos
=======

   (Under construction.)

Synopsis
--------

     function FilePos (var F: ANY FILE): Integer;

Description
-----------

Conforming to
-------------

   `FilePos' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: FileSize,  Next: FillChar,  Prev: FilePos,  Up: Reference

FileSize
========

   (Under construction.)

Synopsis
--------

     function FileSize (var F: ANY FILE): Integer;

Description
-----------

Conforming to
-------------

   `FileSize' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: FillChar,  Next: Finalize,  Prev: FileSize,  Up: Reference

FillChar
========

   (Under construction.)

Synopsis
--------

     procedure FillChar (var Dest; Count: SizeType; Val: Char);
   or
     procedure FillChar (var Dest; Count: SizeType; Val: Byte);

Description
-----------

Conforming to
-------------

   `FillChar' is a UCSD Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: Finalize,  Next: Flush,  Prev: FillChar,  Up: Reference

Finalize
========

   (Under construction.)

Synopsis
--------

     procedure Finalize (var Aynthing);

Description
-----------

   `Finalize' does all necessary clean-ups for the parameter. This is
normally done automatically when a variable goes out of scope, so you
need to call `Finalize' only in special situations, e.g.  when you
deallocate a dynamic variable with `FreeMem' rather than `Dispose'.

Conforming to
-------------

   `Finalize' is a Delphi extension.

Example
-------

See also
--------

   *Note Initialize::, *Note Dispose::, *Note FreeMem::.


File: gpc.info,  Node: Flush,  Next: for,  Prev: Finalize,  Up: Reference

Flush
=====

   (Under construction.)

Synopsis
--------

     procedure Flush (var F: ANY FILE);

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: for,  Next: FormatString,  Prev: Flush,  Up: Reference

for
===

Synopsis
--------

   For ordinal index variables:
     for ORDINAL VARIABLE := INITIAL VALUE to FINAL VALUE do
       STATEMENT
   or
     for ORDINAL VARIABLE := INITIAL VALUE downto FINAL VALUE do
       STATEMENT

   For sets:
     for SET ELEMENT TYPE VARIABLE in SOME SET do
       STATEMENT

   For pointer index variables:
     for POINTER VARIABLE := INITIAL ADDRESS to FINAL ADDRESS do
       STATEMENT
   or
     for POINTER VARIABLE := INITIAL ADDRESS downto FINAL ADDRESS do
       STATEMENT

   @@ Set member iteration

Description
-----------

   The `for' statement is a count loop. For further information see
*Note for Statement::.

Conforming to
-------------

   `for' is defined in ISO-7185 Pascal and supported by all Pascal
variants. Iteration of Pointers is a Borland Pascal extension.  Set
member iteration is an ISO-10206 Extended Pascal extension.

Example
-------

     program ForDemo;
     var
       CharSet: set of Char;
       c: Char;
       n: Integer;
       Fac: array [0 .. 10] of Integer;
       PInt: ^Integer;
     begin
        CharSet := ['g', 'p', 'c'];
        for c in CharSet do
          WriteLn (c);       { prints c g p in three lines }
        Fac[0] := 1;
        for n := 1 to 10 do  { computes the factorial of n for n = 0 .. 10 }
          Fac[n] := Fac[n - 1] * n;
        {$X+}
        { prints n! for n = 0 .. 10 }
        for PInt := @Fac[0] to @Fac[10] do
          WriteLn (PInt - @Fac[0], '! = ', PInt^)
     end.

See also
--------

   *Note Set Types::, *Note Pointer Arithmetics::


File: gpc.info,  Node: FormatString,  Next: forward,  Prev: for,  Up: Reference

FormatString
============

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: forward,  Next: Frac,  Prev: FormatString,  Up: Reference

forward
=======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Frac,  Next: FrameAddress,  Prev: forward,  Up: Reference

Frac
====

   (Under construction.)

Synopsis
--------

     function Frac (x: Real): Real;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: FrameAddress,  Next: FreeMem,  Prev: Frac,  Up: Reference

FrameAddress
============

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: FreeMem,  Next: function,  Prev: FrameAddress,  Up: Reference

FreeMem
=======

Synopsis
--------

     procedure FreeMem (var p: Pointer; Size: Cardinal);
   or
     procedure FreeMem (var p: Pointer);

Description
-----------

   Releases a chunk of memory previously allocated using `GetMem'.  The
parameter SIZE is optional, and its value is ignored.

   Since Extended Pascal's schemata provide a cleaner way to implement
dynamical arrays and such, we recommend using `GetMem' and `FreeMem'
only for low-level applications or for interfacing with other languages.

Conforming to
-------------

   `FreeMem' is a Borland Pascal extension. `FreeMem' with only one
parameter is a GNU Pascal extension.

Example
-------

   *Note GetMem::.

See also
--------

   *Note GetMem::, *Note Schema Types::, *Note Dispose::, *Note Mark::,
*Note Release::.


File: gpc.info,  Node: function,  Next: GE,  Prev: FreeMem,  Up: Reference

function
========

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: GE,  Next: Get,  Prev: function,  Up: Reference

GE
==

   (Under construction.)

Synopsis
--------

     function GE (S1, S2: String): Boolean;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Get,  Next: GetMem,  Prev: GE,  Up: Reference

Get
===

   (Under construction.)

Synopsis
--------

     procedure Get (var F: TYPED FILE);

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: GetMem,  Next: GetTimeStamp,  Prev: Get,  Up: Reference

GetMem
======

Synopsis
--------

     procedure GetMem (var p: Pointeger; Size: Cardinal);
   or
     function GetMem (Size: Cardinal): Pointer;

Description
-----------

   Allocates dynamical storage on the heap and returns a pointer to it
in `p' or as the function result.

   Since Extended Pascal's schemata provide a cleaner way to implement
dynamical arrays and such, we recommend using `GetMem' and `FreeMem'
only for low-level applications.

Conforming to
-------------

   `GetMem' is a Borland Pascal extension.  The use of `GetMem' as a
function is a GNU Pascal extension.

Example
-------

   The Borland-comatibility unit `Graph' from the `BPcompat' package
supports a `GetImage' and a `PutImage' procedure which need a variable
of size `ImageSize' as a buffer.  Since these are "black box" routines,
the buffer can't reasonably be a schema providing a dynamical array.
Instead, we have to use `GetMem' and `FreeMem' for dynamical memory
allocation.

     program GetMemDemo;
     var
       Buffer: Pointer;
       Size: Cardinal;
     begin
       Size := Random (10000); { the size can be determined at run time }
       Buffer := GetMem (Size);  { or: GetMem (Buffer, Size); }
       { Do something with Buffer }
       FreeMem (Buffer)  { or: FreeMem (Buffer, Size) }
     end.

See also
--------

   *Note FreeMem::, *Note New::, *Note Schema Types::.


File: gpc.info,  Node: GetTimeStamp,  Next: goto,  Prev: GetMem,  Up: Reference

GetTimeStamp
============

   (Under construction.)

Synopsis
--------

     procedure GetTimeStamp (var T: TimeStamp);

Description
-----------

Conforming to
-------------

   `GetTimeStamp' is an ISO-10206 Extended Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: goto,  Next: GT,  Prev: GetTimeStamp,  Up: Reference

goto
====

   (Under construction.)

Synopsis
--------

     goto LABEL

Description
-----------

   The `goto' statement transfers control to statement with the label
`label'.

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: GT,  Next: Halt,  Prev: goto,  Up: Reference

GT
==

   (Under construction.)

Synopsis
--------

     function GT (S1, S2: String): Boolean;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Halt,  Next: High,  Prev: GT,  Up: Reference

Halt
====

Synopsis
--------

     Halt;
   or
     Halt (ExitCode: Integer);

Description
-----------

   `Halt' terminates the program with exitcode 0. If `ExitCode', is
specified, it is returned by `Halt' on exit.

Conforming to
-------------

   `Halt' is a UCSD Pascal extension.

Example
-------

     program HaltDemo;
     begin
       WriteLn ('This string will always be this program''s output.');
       Halt;  { Terminate right here and right now. }
       WriteLn ('And this string won''t ever!')
     end.

See also
--------

   *Note Break::, *Note Continue::, *Note Exit::, *Note Return::, *Note
goto::.


File: gpc.info,  Node: High,  Next: if,  Prev: Halt,  Up: Reference

High
====

Synopsis
--------

     function High (ORDINAL TYPE OR VARIABLE): ORDINAL TYPE;
   or
     function High (ARRAY TYPE OR VARIABLE): ARRAY INDEX TYPE;
   or
     function High (STRING VARIABLE): Integer;

Description
-----------

   For ordinal types or variables of that type, `High' returns the
highest value a variable of that type can assume.

   For array types or variables of that type, `High' returns the
highest index a variable of that type can assume. Note: the result is of
the same type as the array index is. If the array has more than one
dimension, `High' returns the highest index in the first dimension.

   If the argument is a string variable, `High' returns the
discriminant of the string type (i.e. its capacity).

Conforming to
-------------

   `High' is a Borland Pascal extension.

Example
-------

     program HighDemo;
     type
       Colors = (Red, Green, Blue);
     var
       Col: array [Colors] of (Love, Hope, Faithfulness);
       Foo: Colors;
       Bar: Integer;
       Baz: String (123);
     begin
       Foo := High (Col);             { yields Blue }
       Bar := Ord (High (Col[Foo]));  { yields Ord (Faithfulness), i.e., 2 }
       Bar := High (Integer);         { returns highest possible ``Integer'' }
       Bar := High (Baz)              { returns 123 }
     end.

See also
--------

   *Note Low::


File: gpc.info,  Node: if,  Next: Im,  Prev: High,  Up: Reference

if
==

Synopsis
--------

     if BOOLEAN EXPRESSION then
       STATEMENT
   or with an alternative statement:
     if BOOLEAN EXPRESSION then
       STATEMENT1
     else
       STATEMENT2

Description
-----------

   The `if ... then' statement executes STATEMENT1 depending on
`Boolean expression' being true. If `else' is specified, it continues
executing STATEMENT2 instead.

Conforming to
-------------

   `if' is defined in ISO-7185 Pascal and supported by all Pascal
variants.

Example
-------

     program IfDemo;
     var
       Foo, Bar: Boolean;
     begin
       Foo := True;
       Bar := False;
       if ((1 = 1) or (2 = 3)) and (Foo = not Bar) then
         begin
           { This is executed if either Foo is true but not Bar or vice versa }
           WriteLn ('Either Foo or Bar is true.');
           if Bar then
             WriteLn ('You will see this text if Bar is true.')
         end
       else { This whole `else' branch is not executed }
         if 1 = 1 then
           if True = False then
             WriteLn ('This text is never written on screen.')
           else  { Note: This ``else'' belongs to ``if True = False'' }
             WriteLn ('This text is never written on screen as well.')
         else  { Note: This ``else'' belongs to ``if 1 = 1'' }
           WriteLn ('Nor is this.')
     end.

See also
--------

   *Note if Statement::, *Note else::, *Note then::


File: gpc.info,  Node: Im,  Next: implementation,  Prev: if,  Up: Reference

Im
==

Synopsis
--------

     function Im (z: Complex): Real;

Description
-----------

   `Im' extracts the imaginary part of the complex number `z'.  The
result is a real value.

Conforming to
-------------

   `Im' is an ISO-10206 Extended Pascal extension.

Example
-------

     program ImDemo;
     var
       z: Complex;
     begin
       z := Cmplx (1, 2);  { 1 + i * 2 }
       WriteLn (Im (z) : 0 : 5)  { 2.00000 }
     end.

See also
--------

   *Note Cmplx::, *Note Re::, *Note Arg::.


File: gpc.info,  Node: implementation,  Next: import,  Prev: Im,  Up: Reference

implementation
==============

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: import,  Next: in,  Prev: implementation,  Up: Reference

import
======

Synopsis
--------

     program @@fragment foo;
     
     import
       bar1;
       bar3 (baz1 => glork1) in 'baz.pas';
       bar2 only (baz2, baz3 => glork2);
     
     [...]

Description
-----------

   The reserved word `import' in the _import part_ of a program makes
the program import an interface.

   The `in' above tells GPC to look for the module in the specified
file; otherwise the file name is derived from the name of the interface
by adding first `.p', then `.pas' - which only works if the name of the
exported interface coincides with the file name.

   The symbol `=>' denotes import renaming: The entity which is
exported under the name `baz1' by the interface `bar3' will be known
under the new name `glork1' in the program.

   The `only' qualifier means that only the listed identifiers will be
imported from the interface. Renaming works together with `only', too.

   There must be at most one import part in a program.

   The interfaces needn't be exported by Extended Pascal modules but
may be UCSD/Borland Pascal units as well.

Conforming to
-------------

   `import' and modules in general are an ISO-10206 Extended Pascal
extension.

   GNU Pascal does not yet support `qualified' import.

Example
-------

See also
--------

   *Note module::, *Note unit::, *Note uses::.


File: gpc.info,  Node: in,  Next: Inc,  Prev: import,  Up: Reference

in
==

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Inc,  Next: Include,  Prev: in,  Up: Reference

Inc
===

Synopsis
--------

   For ordinal types:
     procedure Inc (var x: ORDINAL TYPE);
   or
     procedure Inc (var x: ORDINAL TYPE; Amount: Integer);

   For pointer types:
     procedure Inc (var p: ANY POINTER TYPE);
   or
     procedure Inc (var p: ANY POINTER TYPE; Amount: Integer);

Description
-----------

   For ordinal types, `inc' increases the value of `x' by one or by
`amount' if it is given.

   If the argument `p' is pointing to a specified type (typed pointer),
`inc' increases the address of `p' by the size of the type `p' is
pointing to or by `amount' times that size respectively. If `p' is an
untyped pointer (i.e. `p' is of type *Note Pointer::), `p' is increased
by one.

Conforming to
-------------

   `Inc' is a Borland Pascal extension.  Yet application of `Inc' to
pointers is defined in Borland Pascal.  The combination of the second
argument with application to pointers is a GNU extension.

Example
-------

     program IncDemo;
     var
       Foo: Integer;
       Bar: array [1 .. 5] of Integer;
       Baz: ^Integer;
     begin
       Foo := 4;
       Inc (Foo, 5);      { yields 9 }
       {$X+}              { Turn on extended systax }
       Baz := @Bar[1];    { Baz points to y[1] }
       Inc (Baz, 2);      { Baz points to y[3] }
     end.

See also
--------

   *Note Dec::, *Note Pred::, *Note Succ::, *Note Pointer Arithmetics::.


File: gpc.info,  Node: Include,  Next: Index,  Prev: Inc,  Up: Reference

Include
=======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Index,  Next: inherited,  Prev: Include,  Up: Reference

Index
=====

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: inherited,  Next: Initialize,  Prev: Index,  Up: Reference

inherited
=========

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Initialize,  Next: inline,  Prev: inherited,  Up: Reference

Initialize
==========

   (Under construction.)

Synopsis
--------

     procedure Initialize (var Aynthing);

Description
-----------

   `Initialize' does all necessary initializations for the parameter
(e.g., setting of string and schema discriminants, and object VMT
pointers, initialization of file variables). This is normally done
automatically at the start of the lifetime of a variable, so you need
to call `Initialize' only in special situations, e.g. when you allocate
a dynamic variable with `GetMem' rather than `New'.

Conforming to
-------------

   `Initialize' is a Delphi extension.

Example
-------

See also
--------

   *Note Finalize::, *Note New::, *Note GetMem::.


File: gpc.info,  Node: inline,  Next: InOutRes,  Prev: Initialize,  Up: Reference

inline
======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: InOutRes,  Next: Input,  Prev: inline,  Up: Reference

InOutRes
========

   (Under construction.)

Synopsis
--------

     var
       InOutRes: Integer;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Input,  Next: Insert,  Prev: InOutRes,  Up: Reference

Input
=====

   (Under construction.)

Synopsis
--------

     var
       Input: Text;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Insert,  Next: Int,  Prev: Input,  Up: Reference

Insert
======

   (Under construction.)

Synopsis
--------

     procedure Insert (Source: String; var Dest: String; Position: Integer);

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Int,  Next: Integer,  Prev: Insert,  Up: Reference

Int
===

   (Under construction.)

Synopsis
--------

     function Int (x: Real): Real;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Integer,  Next: interface,  Prev: Int,  Up: Reference

Integer
=======

Synopsis
--------

     type
       Integer  { built-in type }
   or
     type
       Integer (n)  { built-in type class }

Description
-----------

   `Integer' is the "natural" signed integer type in GNU Pascal.  On
most platforms it is 32 bits wide and thus has a range of `-2147483648
.. 2147483647'.  Use it whenever you need a general-purpose signed
integer type.

   As an extension, GPC allows to use `Integer' as a pseudo-schema to
produce types with a specified size in bits; for example

     type
       Int16 = Integer (16);

   defines an integer type with 16 bits.  The same mechanism works for
`Cardinal' and `Word', too.

   `Integer' in GNU Pascal is compatible to `Int' in GNU C.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   In ISO Pascal, `Integer' is the only built-in integer type.
(However see *Note Subrange Types::.)

Example
-------

     program IntegerDemo;
     var
       a: Integer;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: interface,  Next: interrupt,  Prev: Integer,  Up: Reference

interface
=========

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: interrupt,  Next: IOResult,  Prev: interface,  Up: Reference

interrupt
=========

   Not yet implemented.

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: IOResult,  Next: is,  Prev: interrupt,  Up: Reference

IOResult
========

   (Under construction.)

Synopsis
--------

     function IOResult: Integer;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: is,  Next: label,  Prev: IOResult,  Up: Reference

is
==

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------

   *Note as::, *Note TypeOf::, *Note OOP::.


File: gpc.info,  Node: label,  Next: LastPosition,  Prev: is,  Up: Reference

label
=====

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: LastPosition,  Next: LE,  Prev: label,  Up: Reference

LastPosition
============

   (Under construction.)

Synopsis
--------

     function LastPosition (var F: TYPED FILE): Integer;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: LE,  Next: Length,  Prev: LastPosition,  Up: Reference

LE
==

   (Under construction.)

Synopsis
--------

     function LE (S1, S2: String): Boolean;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Length,  Next: library,  Prev: LE,  Up: Reference

Length
======

   (Under construction.)

Synopsis
--------

     function Length (S: String): Integer;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: library,  Next: Ln,  Prev: Length,  Up: Reference

library
=======

   Not yet implemented.

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Ln,  Next: LoCase,  Prev: library,  Up: Reference

Ln
==

Synopsis
--------

     function Ln (x: Real): Real;
   or
     function Ln (z: Complex): Complex;

Description
-----------

   The natural logarith `Ln' is the logarithm with base e, where e is
the Euler number e = Exp (1) = 2.718281828...

Conforming to
-------------

   The function `Ln' is defined in ISO-7185 Pascal; its application to
complex values is defined in ISO-10206 Extended Pascal.

Example
-------

     program LnDemo;
     var
       z: Complex;
     begin
       z := Cmplx (1, 1);
       z := Ln (z)  { yields Ln (SqRt (2)) + i * Pi / 4 }
                    { since Ln (i * x) = Ln Abs (x) + i * Arg (x) }
     end.

See also
--------


File: gpc.info,  Node: LoCase,  Next: LongBool,  Prev: Ln,  Up: Reference

LoCase
======

   (Under construction.)

Synopsis
--------

     function LoCase (Ch: Char): Char;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: LongBool,  Next: LongCard,  Prev: LoCase,  Up: Reference

LongBool
========

   (Under construction.)

Synopsis
--------

     type
       LongBool = Boolean (BitSizeOf (LongInt));

Description
-----------

Conforming to
-------------

Example
-------

     program LongBoolDemo;
     var
       a: LongBool;
     begin
       LongInt (a) := 1;
       if a then WriteLn ('Ord (True) = 1')
     end.

See also
--------


File: gpc.info,  Node: LongCard,  Next: LongestBool,  Prev: LongBool,  Up: Reference

LongCard
========

Synopsis
--------

     type
       LongCard = Cardinal (BitSizeOf (LongInt));

Description
-----------

   `LongCard' is an unsigned integer type which is longer than
`Cardinal'.  On most platforms it is 64 bits wide and thus has a range
of `0..18446744073709551615'.

   `LongCard' in GNU Pascal is compatible to `long long unsigned int'
in GNU C.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `LongCard' is a GNU Pascal extension.

Example
-------

     program LongCardDemo;
     var
       a: LongCard;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: LongestBool,  Next: LongestCard,  Prev: LongCard,  Up: Reference

LongestBool
===========

   (Under construction.)

Synopsis
--------

     type
       LongestBool = Boolean (BitSizeOf (LongestInt));

Description
-----------

Conforming to
-------------

Example
-------

     program LongestBoolDemo;
     var
       a: LongestBool;
     begin
       LongestInt (a) := 1;
       if a then WriteLn ('Ord (True) = 1')
     end.

See also
--------


File: gpc.info,  Node: LongestCard,  Next: LongestInt,  Prev: LongestBool,  Up: Reference

LongestCard
===========

Synopsis
--------

     type
       LongestCard = Cardinal (BitSizeOf (LongestInt));

Description
-----------

   `LongestCard' is GPC's longest-possible unsigned integer type.
Currently, this is the same as *Note LongCard::.  On most platforms it
is 64 bits wide and thus has a range of `0..18446744073709551615'.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `LongestCard' is a GNU Pascal extension.

Example
-------

     program LongestCardDemo;
     var
       a: LongestCard;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: LongestInt,  Next: LongestReal,  Prev: LongestCard,  Up: Reference

LongestInt
==========

Synopsis
--------

     type
       LongestInt = LongInt;  { might get bigger than LongInt someday }

Description
-----------

   `LongestInt' is GPC's longest-possible signed integer type.
Currently, this is the same as *Note LongInt::.  On most platforms it
is 64 bits wide and thus has a range of
`-9223372036854775808..9223372036854775807'.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `LongestInt' is a GNU Pascal extension.

Example
-------

     program LongestIntDemo;
     var
       a: LongestInt;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: LongestReal,  Next: LongestWord,  Prev: LongestInt,  Up: Reference

LongestReal
===========

   (Under construction.)

Synopsis
--------

     type
       LongestReal = LongReal;  { might get bigger than LongReal someday }

Description
-----------

Conforming to
-------------

Example
-------

     program LongestRealDemo;
     var
       a: LongestReal;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------


File: gpc.info,  Node: LongestWord,  Next: LongInt,  Prev: LongestReal,  Up: Reference

LongestWord
===========

Synopsis
--------

     type
       LongestWord = LongestCard;

Description
-----------

   `LongestWord' is GPC's longest-possible unsigned integer type.
Currently, this is the same as *Note LongWord::.  On most platforms it
is 64 bits wide and thus has a range of `0..18446744073709551615'.  (It
is the same as *Note LongestCard::.)

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `LongestWord' is a GNU Pascal extension.

Example
-------

     program LongestWordDemo;
     var
       a: LongestWord;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: LongInt,  Next: LongReal,  Prev: LongestWord,  Up: Reference

LongInt
=======

Synopsis
--------

     type
       LongInt  { built-in type }

Description
-----------

   `LongInt' is a signed integer type which is longer than `Integer'.
On most platforms it is 64 bits wide and thus has a range of
`-9223372036854775808..9223372036854775807'.

   `LongInt' in GNU Pascal is compatible to `long long int' in GNU C.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `LongInt' is a Borland Pascal extension.  Borland Pascal defines
`LongInt' as a 32-bit signed integer type (*Note Integer:: in GNU
Pascal).

Example
-------

     program LongIntDemo;
     var
       a: LongInt;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: LongReal,  Next: LongWord,  Prev: LongInt,  Up: Reference

LongReal
========

   (Under construction.)

Synopsis
--------

     type
       LongReal  { built-in type }

Description
-----------

Conforming to
-------------

Example
-------

     program LongRealDemo;
     var
       a: LongReal;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------


File: gpc.info,  Node: LongWord,  Next: Low,  Prev: LongReal,  Up: Reference

LongWord
========

Synopsis
--------

     type
       LongWord = LongCard;

Description
-----------

   `LongWord' is an unsigned integer type which is larger than `Word'.
On most platforms it is 64 bits wide and thus has a range of
`0..18446744073709551615'.  It is the same as *Note LongCard::.

   `LongWord' in GNU Pascal is compatible to `long long unsigned int'
in GNU C.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `LongWord' is a GNU Pascal extension.

Example
-------

     program LongWordDemo;
     var
       a: LongWord;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: Low,  Next: LT,  Prev: LongWord,  Up: Reference

Low
===

Synopsis
--------

     function Low (ORDINAL TYPE OR VARIABLE): ORDINAL TYPE;
   or
     function Low (ARRAY TYPE OR VARIABLE): ARRAY ELEMENT TYPE;
   or
     function Low (STRING VARIABLE): Integer;

Description
-----------

   For ordinal types or variables of that type, `Low' returns the
lowest value a variable of that type can assume.

   For array types or variables of that type, `Low' returns the lowest
index a variable of that type can assume. Note: the result is of the
same type as the array index is. If the array has more than one
dimension, `Low' returns the lowest index in the first dimension.

   If the argument is a string variable, `Low' returns one.

Conforming to
-------------

Example
-------

     program LowDemo;
     type
       Colors = (Red, Green, Blue);
     var
       Col: array [12 .. 20] of Colors;
       Foo: 12 .. 20;
       Bar: Integer;
     begin
       Foo := Low (Col);            { returns 12 }
       Col[Foo] := Low (Col[Foo]);  { returns Red }
       Bar := Low (Integer)         { returns lowest ``Integer'' value }
     end.

See also
--------

   *Note High::


File: gpc.info,  Node: LT,  Next: Mark,  Prev: Low,  Up: Reference

LT
==

   (Under construction.)

Synopsis
--------

     function LT (S1, S2: String): Boolean;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Mark,  Next: Max,  Prev: LT,  Up: Reference

Mark
====

   (Under construction.)

Synopsis
--------

     procedure Mark (var P: Pointer);

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: Max,  Next: MaxChar,  Prev: Mark,  Up: Reference

Max
===

   (Under construction.)

Synopsis
--------

     function Max (x1, x2: ORDINAL OR REAL TYPE): SAME TYPE;

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: MaxChar,  Next: MaxInt,  Prev: Max,  Up: Reference

MaxChar
=======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: MaxInt,  Next: MaxReal,  Prev: MaxChar,  Up: Reference

MaxInt
======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: MaxReal,  Next: MedBool,  Prev: MaxInt,  Up: Reference

MaxReal
=======

   (Under construction.)

Synopsis
--------

Description
-----------

Conforming to
-------------

Example
-------

See also
--------


File: gpc.info,  Node: MedBool,  Next: MedCard,  Prev: MaxReal,  Up: Reference

MedBool
=======

   (Under construction.)

Synopsis
--------

     type
       MedBool = Boolean (BitSizeOf (MedInt));

Description
-----------

Conforming to
-------------

Example
-------

     program MedBoolDemo;
     var
       a: MedBool;
     begin
       MedInt (a) := 1;
       if a then WriteLn ('Ord (True) = 1')
     end.

See also
--------


File: gpc.info,  Node: MedCard,  Next: MedInt,  Prev: MedBool,  Up: Reference

MedCard
=======

Synopsis
--------

     type
       MedCard = Cardinal (BitSizeOf (MedInt));

Description
-----------

   `MedCard' is an unsigned integer type which is not smaller than
`Cardinal'.  On most platforms it actually is the same as `Cardinal'
and 32 bits wide and thus has a range of `0..4294967295'.

   `MedCard' in GNU Pascal is compatible to `long unsigned int' in GNU
C.  This compatibility is the reason why `MedCard' exists.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `MedCard' is a GNU Pascal extension.

Example
-------

     program MedCardDemo;
     var
       a: MedCard;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.


File: gpc.info,  Node: MedInt,  Next: MedReal,  Prev: MedCard,  Up: Reference

MedInt
======

Synopsis
--------

     type
       MedInt  { built-in type }

Description
-----------

   `MedInt' is a signed integer type which is not smaller than
`Integer'.  On most platforms it actually is the same as `Integer' and
32 bits wide and thus has a range of `-2147483648..2147483647'.

   `MedInt' in GNU Pascal is compatible to `long int' in GNU C.  This
compatibility is the reason why `MedInt' exists.

   There are lots of other integer types in GPC, see *Note Integer
Types::.

Conforming to
-------------

   `MedInt' is a GNU Pascal extension.

Example
-------

     program MedIntDemo;
     var
       a: MedInt;
     begin
       a := 42;
       WriteLn (a)
     end.

See also
--------

   *Note Integer Types::, *Note Subrange Types::.

