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: high,  Next: if,  Prev: Halt,  Up: Reference

high
====

   (Under construction.)

Syntax
------

       Function high ( ORDINAL TYPE OR VARIABLE ): Integer;
   or
       Function high ( ARRAY TYPE OR VARIABLE ): Integer;

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

Standards
---------

Example
-------

See also
--------


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

if
==

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

Im
==

   (Under construction.)

Syntax
------

       Function Im ( z: Complex ): Real;

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

Standards
---------

Example
-------

See also
--------


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

import
======

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

   The reserved word `import' in the *import part* of a program makes
the program import an interface.  The syntax is

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

   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.

Standards
---------

   ISO-7185 Standard Pascal does not define `import' and Modules in
general.  These are defined in the ISO-10206 Extended Pascal standard.

   GNU Pascal does not yet support `qualified' import.

See also
--------

   *Note Module::, *Note Unit::, *Note uses::.


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

Implementation
==============

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: in,  Next: inc,  Prev: Implementation,  Up: Reference

in
==

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: inc,  Next: Index,  Prev: in,  Up: Reference

inc
===

   (Under construction.)

Syntax
------

       Procedure inc ( Var x: ORDINAL TYPE );
   or
       Procedure inc ( Var x: ORDINAL TYPE; amount: Integer );

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

Standards
---------

Example
-------

See also
--------


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

Index
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

inherited
=========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

inline
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

InOutRes
========

   (Under construction.)

Syntax
------

       Var
         InOutRes: Integer;

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

Standards
---------

Example
-------

See also
--------


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

InOutResStr
===========

   (Under construction.)

Syntax
------

       Var
         InOutResStr: CString;

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

Standards
---------

Example
-------

See also
--------


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

Input
=====

   (Under construction.)

Syntax
------

       Var
         Input: Text;

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

Standards
---------

Example
-------

See also
--------


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

Insert
======

   (Under construction.)

Syntax
------

       Procedure Insert ( Source: String; Var Dest: String; Position: Integer );

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

Standards
---------

Example
-------

See also
--------


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

int
===

   (Under construction.)

Syntax
------

       Function int ( x: Real ): Real;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Integer,  Next: Interface,  Prev: int,  Up: Reference

Integer
=======

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::.

Standards
---------

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

See also
--------

   *Note Integer types::, *Note Subrange types::.


File: gpc.info,  Node: Interface,  Next: IOresult,  Prev: Integer,  Up: Reference

Interface
=========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: IOresult,  Next: Label,  Prev: Interface,  Up: Reference

IOresult
========

   (Under construction.)

Syntax
------

       Function IOresult: Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Label,  Next: LastPosition,  Prev: IOresult,  Up: Reference

Label
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: LastPosition,  Next: le,  Prev: Label,  Up: Reference

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

   (Under construction.)

Syntax
------

       Function LastPosition ( Var F: TYPED FILE ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: le,  Next: length,  Prev: LastPosition,  Up: Reference

le
==

   (Under construction.)

Syntax
------

       Function le ( S1, S2: String ): Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: length,  Next: ln,  Prev: le,  Up: Reference

length
======

   (Under construction.)

Syntax
------

       Function length ( S: String ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: ln,  Next: LoCase,  Prev: length,  Up: Reference

ln
==

   (Under construction.)

Syntax
------

       Function ln ( x: Real ): Real;
   or
       Function ln ( z: Complex ): Complex;

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

Standards
---------

Example
-------

See also
--------


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

LoCase
======

   (Under construction.)

Syntax
------

       Function LoCase ( Ch: Char ): Char;

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

Standards
---------

Example
-------

See also
--------


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

LongCard
========

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::.

Standards
---------

   ISO Pascal does not define `LongCard'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

LongInt
=======

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::.

Standards
---------

   ISO Pascal does not define `LongInt'.

   Borland Pascal and Delphi also define `LongInt', but it is a 32-bit
signed integer type there (*Note Integer:: in GNU Pascal).  Both
Borland languages define *Note Comp:: as a 64-bit signed integer type
which is also supported by GPC for compatibility.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

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

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::.

Standards
---------

   ISO Pascal does not define `LongestCard'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

LongestInt
==========

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::.

Standards
---------

   ISO Pascal does not define `LongestInt'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

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

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

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

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::.

Standards
---------

   ISO Pascal does not define `LongestWord'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

LongReal
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

LongWord
========

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::.

Standards
---------

   ISO Pascal does not define `LongWord'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


File: gpc.info,  Node: low,  Next: lt,  Prev: LongWord,  Up: Reference

low
===

   (Under construction.)

Syntax
------

Syntax
------

       Function low ( ORDINAL TYPE OR VARIABLE ): Integer;
   or
       Function low ( ARRAY TYPE OR VARIABLE ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: lt,  Next: Mark,  Prev: low,  Up: Reference

lt
==

   (Under construction.)

Syntax
------

       Function lt ( S1, S2: String ): Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Mark,  Next: max,  Prev: lt,  Up: Reference

Mark
====

   (Under construction.)

Syntax
------

       Procedure Mark ( Var P: Pointer );

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

Standards
---------

Example
-------

See also
--------


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

max
===

   (Under construction.)

Syntax
------

       Function max ( x1, x2: ORDINAL OR REAL TYPE ): SAME TYPE;

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

Standards
---------

Example
-------

See also
--------


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

MaxChar
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

MaxInt
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

MaxReal
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

MedCard
=======

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::.

Standards
---------

   ISO Pascal does not define `MedCard'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

MedInt
======

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::.

Standards
---------

   ISO Pascal does not define `MedInt'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


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

MedReal
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: MedWord,  Next: min,  Prev: MedReal,  Up: Reference

MedWord
=======

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

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

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

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

Standards
---------

   ISO Pascal does not define `MedWord'.

See also
--------

   *Note Integer types::, *Note Subrange types::.


File: gpc.info,  Node: min,  Next: MinReal,  Prev: MedWord,  Up: Reference

min
===

   (Under construction.)

Syntax
------

       Function min ( x1, x2: ORDINAL OR REAL TYPE ): SAME TYPE;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: MinReal,  Next: MkDir,  Prev: min,  Up: Reference

MinReal
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: MkDir,  Next: mod,  Prev: MinReal,  Up: Reference

MkDir
=====

   (Under construction.)

Syntax
------

       Procedure MkDir ( Directory: String );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: mod,  Next: Module,  Prev: MkDir,  Up: Reference

mod
===

   (Under construction.)

Syntax
------

       Operator mod ( p, q: Integer ) = r: Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Module,  Next: move,  Prev: mod,  Up: Reference

Module
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: move,  Next: MoveLeft,  Prev: Module,  Up: Reference

move
====

   (Under construction.)

Syntax
------

       Procedure move ( Const Source; Var Dest; Count: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: MoveLeft,  Next: MoveRight,  Prev: move,  Up: Reference

MoveLeft
========

   (Under construction.)

Syntax
------

       Procedure MoveLeft ( Const Source; Var Dest; Count: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: MoveRight,  Next: near,  Prev: MoveLeft,  Up: Reference

MoveRight
=========

   (Under construction.)

Syntax
------

       Procedure MoveRight ( Const Source; Var Dest; Count: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: near,  Next: ne,  Prev: MoveRight,  Up: Reference

near
====

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

   The `near' 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 `near' pointers is void.)

Standards
---------

   ISO Pascal does not define `near', Borland Pascal does.

Example
-------

       Var
         p: Procedure;
     
       Procedure Foo; near;  (* `near' has no effect in GPC *)
     
       begin (* Foo *)
         [...]
       end (* Foo *);
     
       [...]
     
       p:= Foo;  (* Works, despite the `near'. *)

See also
--------

   *Note far::.


File: gpc.info,  Node: ne,  Next: New,  Prev: near,  Up: Reference

ne
==

   (Under construction.)

Syntax
------

       Function ne ( S1, S2: String ): Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: New,  Next: NewCString,  Prev: ne,  Up: Reference

New
===

   (Under construction.)

Syntax
------

       Procedure New ( Var P: ANY POINTER );
   or
       Procedure New ( Var P: POINTER TO A VARIANT RECORD; TAG FIELDS);
   or
       Procedure New ( Var P: POINTER TO A SCHEMA; DISCRIMINANTS);
   or
       Procedure New ( Var P: POINTER TO AN OBJECT; CONSTRUCTOR CALL);
   or
       Function New ( ANY POINTER TYPE ): SAME TYPE;
   or
       Function New ( VARIANT RECORD POINTER TYPE;
                      TAG FIELDS): SAME TYPE;
   or
       Function New ( SCHEMA POINTER TYPE;
                      DISCRIMINANTS): SAME TYPE;
   or
       Function New ( OBJECT POINTER TYPE;
                      CONSTRUCTOR CALL): SAME TYPE;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: NewCString,  Next: Nil,  Prev: New,  Up: Reference

NewCString
==========

   (Under construction.)

Syntax
------

       Function NewCString ( Const S: String ): CString;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Nil,  Next: not,  Prev: NewCString,  Up: Reference

Nil
===

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: not,  Next: NULL,  Prev: Nil,  Up: Reference

not
===

   (Under construction.)

Syntax
------

       Operator not ( b1, b2: Boolean ) = result: Boolean;
   or
       Operator not ( i1, i2: INTEGER TYPE ) = result: INTEGER TYPE;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: NULL,  Next: object,  Prev: not,  Up: Reference

NULL
====

   (Under construction.)

Syntax
------

       Var NULL: Void absolute 0;

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

   Variable at address `Nil'.

Standards
---------

   Delphi

Example
-------

See also
--------

   *Note Nil::.


File: gpc.info,  Node: object,  Next: odd,  Prev: NULL,  Up: Reference

object
======

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

   The keyword `object' is used to declare a new object type:

       Type
         foo = object
           a: Integer;
           Constructor Init;
           Procedure bar ( x: Integer ); virtual;
         end (* foo *);

   (For a longer example, see *Note OOP::.)

Standards
---------

   GNU Pascal follows the Borland Pascal 7.0 object model.

   ISO Pascal does not support Object-orientated programming.  There is
an ANSI draft for an "Object Pascal" language which is not yet
supported by GPC, but planned.  The Delphi language, also called
"Object Pascal" by Borland, is currently not supported by GPC either.

See also
--------

   *Note OOP::, *Note record::.


File: gpc.info,  Node: odd,  Next: of,  Prev: object,  Up: Reference

odd
===

   (Under construction.)

Syntax
------

       Function odd ( i: Integer ): Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: of,  Next: only,  Prev: odd,  Up: Reference

of
==

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: only,  Next: Operator,  Prev: of,  Up: Reference

only
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Operator,  Next: or,  Prev: only,  Up: Reference

Operator
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: or,  Next: or else,  Prev: Operator,  Up: Reference

or
==

Syntax
------

       Operator or ( operand1, operand2: Boolean ) = result: Boolean;
   or
       Operator or ( operand1, operand2: INTEGER TYPE ) = result: INTEGER TYPE;
   or
       Procedure or ( Var operand1: INTEGER TYPE; operand2: INTEGER TYPE );

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

   In GNU Pascal, `or' has three built-in meanings:

  1. Logical "or" between two `Boolean'-type expressions.  The result
     of the operation is of `Boolean' type.

     By default, `or' acts as a short-circuit operator in GPC:  If the
     first operand is `true', the second operand is not evaluated
     because the result is already known to be `true'.  You can change
     this to complete evaluation using the `--no-short-circuit'
     command-line option or the `(*$B+*)' compiler directive.

  2. Bitwise "or" between two integer-type expressions.  The result is
     of the common integer type of both expressions.

  3. Use as a "procedure":  `operand1' is "or"ed bitwise with
     `operand2'; the result is stored in `operand1'.


Standards
---------

   The logical `or' operator is defined in ISO-7185 Standard Pascal.

   According to ISO, you cannot rely on `or' being a short-circuit
operator.  On the other hand, GPC's default behaviour does *not*
contradict the ISO standard.  (See *Note or_else::.)  However, since it
seems to be a de-facto standard among ISO Pascal compilers to evaluate
both operands of `or', GPC switches to `--no-short-circuit' mode if one
of the language dialect options selecting ISO Pascal, for instance
`--extended-pascal', is given.  Use `--short-circuit' to override.

   ISO Pascal does not define the bitwise `or' operator; Borland Pascal
and Delphi do.

   Use of `or' as a "procedure" is a GNU extension.

Example
-------

       Var
         a, b, c: Integer;
     
       ...
     
       if ( a = 0 ) or ( b = 0 ) then  (* logical `or' *)
         c:= 1
       else if a or b = 0 then  (* bitwise `or' *)
         c:= 2
       else
         or ( c, a );  (* same as `c:= c or a' *)

   Note the difference between the logical `or' and the bitwise `or':
When `a' is 2 and `b' is 4, then `a or b' is 6.  *Beware:*  `a or b =
0' happens to mean the same as `( a = 0 ) and ( b = 0 )'.  (Note the
`and'!)

   Since bitwise `or' has a higher priority than the `=' operator,
parentheses are needed in `if ( a = 0 ) or ( b = 0 )' because otherwise
`0 or b' would be calculated first, and the remainder would cause a
parse error.

See also
--------

   *Note and::, *Note xor::, *Note Operators::.


File: gpc.info,  Node: or else,  Next: or_else,  Prev: or,  Up: Reference

or else
=======

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

   `or else' is an alias for the short-circuit logical operator
`or_else'.

Standards
---------

   While `or_else' is defined in ISO-10206 Extended Pascal, `or else'
is a GNU Extension.

Example
-------

       Var
         a: Integer;
     
       [...]
     
       if ( a = 0 ) or else ( 100 div a > 42 ) then  (* This is safe. *)
         [...];

See also
--------

   *Note or_else::, *Note or::, *Note and then::.


File: gpc.info,  Node: or_else,  Next: ord,  Prev: or else,  Up: Reference

or_else
=======

Syntax
------

       Operator or_else ( operand1, operand2: Boolean ) = result: Boolean;

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

   The `or_else' short-circuit logical operator performs the same
operation as the logical operator `or'.  But while the ISO standard
does not specify anything about the evaluation of the operands of
`or'--they may be evaluated in any order, or not at all--`or_else' has
a well-defined behaviour:  It evaluates the first operand.  If the
result is `true', `or_else' returns `true' without evaluating the
second operand.  If it is `false', the second operand is evaluated and
returned.

   Since the behaviour described above is the most effective way to
implement `or', GPC by default treats `or' and `or_else' exactly the
same.  If you want, for some reason, to have both operands of `or'
evaluated completely, you can specify the `--no-short-circuit'
command-line option, but this is not portable.  The portable way to
have both operands evaluated is to assign both to temporary variables
and then use `or'--or `or_else', it does not matter.

Standards
---------

   ISO-7185 Standard Pascal does not define `or_else'; ISO-10206
Extended Pascal does.

   Some people think that the ISO standard requires both operands of
`or' to be evaluated.  This is false.  What the ISO standard *does* say
is that you cannot rely on a certain order of evaluation of the
operands of `or'; in particular things like

       Var
         a: Integer;
     
       [...]
     
       if ( a = 0 ) or ( 100 div a > 42 ) then
         [...];

can crash according to ISO Pascal, although they cannot crash when
compiled with GNU Pascal running in default mode.

   If you want to write portable and efficient code in ISO-10206
Extended Pascal, *always* use `or_else'; *never* use `or'.

Example
-------

       Var
         a: Integer;
     
       [...]
     
       if ( a = 0 ) or_else ( 100 div a > 42 ) then  (* This is safe. *)
         [...];

See also
--------

   *Note or else::, *Note or::, *Note and_then::.


File: gpc.info,  Node: ord,  Next: others,  Prev: or_else,  Up: Reference

ord
===

   (Under construction.)

Syntax
------

       Function ord ( Ch: Char ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: others,  Next: otherwise,  Prev: ord,  Up: Reference

others
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: otherwise,  Next: Output,  Prev: others,  Up: Reference

otherwise
=========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Output,  Next: pack,  Prev: otherwise,  Up: Reference

Output
======

   (Under construction.)

Syntax
------

       Var
         Output: Text;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: pack,  Next: packed,  Prev: Output,  Up: Reference

pack
====

   (Under construction.)

Syntax
------

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

       Procedure pack ( Source: UNPACKED ARRAY;
                        FirstElement: INDEX TYPE;
                        Var Dest: PACKED ARRAY );

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: packed,  Next: page,  Prev: pack,  Up: Reference

packed
======

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

   `packed' is a reserved word.  According to ISO-7185 Standard Pascal
it can preceed `array' and `record' type definitions to indicate that
memory usage should be minimized for variables of this type, possibly
at the expense of loss of speed.

   As a GNU extension, `packed' can also be applied to *Note Subrange
types::.

Standards
---------

   The reserved word `packed' is defined in ISO-7185 Standard Pascal.

   According to ISO standard, only *packed* arrays of char with lower
bound 1 qualify as strings of fixed length.  GNU Pascal neither requires
`packed' nor the lower bound of 1 here.

Example
-------

       Type
         MonthInt = packed 1..12;  (* needs one byte   *)
         FastMonthInt = 1..12;     (* needs four bytes *)
     
         FixString10 = packed array [ 1..10 ] of Char;
         FoxyString10 = array [ 0..9 ] of Char;
     
         Flags = packed array [ 1..32 ] of Boolean;  (* needs four Bytes *)
     
         DateRec = packed record
           day: 1..31;            (* five bits *)
           month: MonthInt;       (* four bits *)
           year: Integer ( 15 );  (* 15 bits = -16384..16383 *)
         end (* DateRec *);
     
         Dates = array [ 1..1000 ] of DateRec;
     
       Var
         S: FixString10;
         T: FoxyString10;
     
       [...]
     
       S:= 'Hello!';   (* blank padded *)
       writeln ( S );
     
       T:= 'GNU Pascal';  (* GPC extension: this also works. *)
       writeln ( T );

   `DateRec' has 24 bits = 3 bytes in total; `Dates' has 3000 bytes.

See also
--------

   *Note pack::, *Note unpack::, *Note SizeOf::, *Note AlignOf::, *Note
BitSizeOf::.


File: gpc.info,  Node: page,  Next: pAnsiChar,  Prev: packed,  Up: Reference

page
====

   (Under construction.)

Syntax
------

       Procedure Page ( Var F: Text );
   or
       Procedure Page;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: pAnsiChar,  Next: ParamCount,  Prev: page,  Up: Reference

pAnsiChar
=========

   (Under construction.)

Syntax
------

       Type
         pAnsiChar = ^AnsiChar;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: ParamCount,  Next: ParamStr,  Prev: pAnsiChar,  Up: Reference

ParamCount
==========

Syntax
------

       Function ParamCount: Integer;

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

   `ParamCount' returns the number of command-line arguments given to
the program.  `ParamCount' returns 0 if no arguments have been given to
the program; the name of the program as an implicit argument is not
counted.

Standards
---------

   `ParamCount' is a Borland Pascal extension.

Example
-------

       Program Test;
     
       Var
         i: Integer;
     
       begin
         writeln ( 'You have invoked this program with ',
                   ParamCount, ' arguments.' );
         writeln ( 'These are:' );
         for i:= 1 to ParamCount do
           writeln ( ParamStr ( i ) );
       end.

See also
--------

   *Note ParamStr::.


File: gpc.info,  Node: ParamStr,  Next: pChar,  Prev: ParamCount,  Up: Reference

ParamStr
========

   (Under construction.)

Syntax
------

       Function ParamStr ( ParmNumber: Integer ): String;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: pChar,  Next: Pointer,  Prev: ParamStr,  Up: Reference

pChar
=====

   (Under construction.)

Syntax
------

       Type
         pChar = ^Char;
   or
       Type
         pChar = CString;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Pointer,  Next: polar,  Prev: pChar,  Up: Reference

Pointer
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: polar,  Next: pos,  Prev: Pointer,  Up: Reference

polar
=====

   (Under construction.)

Syntax
------

       Function polar ( rho, phi: Real ): Complex;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: pos,  Next: Position,  Prev: polar,  Up: Reference

pos
===

   (Under construction.)

Syntax
------

       Function pos ( SearchPattern, Source: String ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Position,  Next: pow,  Prev: pos,  Up: Reference

Position
========

   (Under construction.)

Syntax
------

       Function Position ( Var F: TYPED FILE );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: pow,  Next: pred,  Prev: Position,  Up: Reference

pow
===

   (Under construction.)

Syntax
------

       Operator pow ( base: Real; exponent: Integer ) = power: Real;
   or
       Operator pow ( base: Complex; exponent: Integer ) = power: Complex;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: pred,  Next: Procedure,  Prev: pow,  Up: Reference

pred
====

Syntax
------

       Function pred ( i: ORDINAL TYPE ): ORDINAL TYPE;
   or
       Function pred ( i: ORDINAL TYPE; j: Integer ): ORDINAL TYPE;

   or, with extended syntax (`--extended-syntax' or `(*$X+*)'),

       Function pred ( p: POINTER TYPE ): POINTER TYPE;
   or
       Function pred ( p: POINTER TYPE; j: Integer ): POINTER TYPE;

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

   Returns the predecessor of the ORDINAL TYPE value `i', or, if the
second argument `j' is given, its `j'th predecessor.  For integer
values `i', this is `i - 1' (or `i - j').  (No, `pred' does *not* work
faster than plain subtraction.  Both are optimized to a single machine
instruction or even expanded by the compiler, if possible.)

   If extended syntax is on, the argument may also be a pointer value.
In this case, the address is decremented by the size of the variable
pointed to, or, if `j' is given, by `j' times the size of the variable
pointed to.  If `p' points to an element of an array, the returned
pointer will point to the (`j'th) previous element of the array.

Standards
---------

   The `pred' function is defined in ISO-7185 Standard Pascal.  The
optional second parameter is defined in ISO-10206 Extended Pascal.
Application of `pred' to pointers is defined in Borland Pascal.  The
combination of the second argument with application to pointers is a
GNU extension.

Example
-------

       Program PredTest;
     
       Type
         Metasyntactical = ( foo, bar, baz );
     
       Var
         m: Metasyntactical;
         c: Char;
         a: array [ 1..7 ] of Integer;
         p: ^Integer;
     
       begin
         m:= pred ( bar );     (* foo *)
         c:= pred ( 'Z', 2 );  (* 'X' *)
         a [ 1 ]:= 42;
         a [ 4 ]:= pred ( a [ 1 ] );     (* 41 *)
         a [ 5 ]:= pred ( a [ 4 ], 3 );  (* 38 *)
         (*$X+*)
         p:= @a [ 5 ];
         p:= pred ( p );     (* now points to `a [ 4 ]' *)
         p:= pred ( p, 3 );  (* now points to `a [ 1 ]' *)
       end.

See also
--------

   *Note succ::, *Note dec::, *Note Pointer arithmetics::.


File: gpc.info,  Node: Procedure,  Next: Program,  Prev: pred,  Up: Reference

Procedure
=========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Program,  Next: protected,  Prev: Procedure,  Up: Reference

Program
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: protected,  Next: PtrCard,  Prev: Program,  Up: Reference

protected
=========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: PtrCard,  Next: PtrInt,  Prev: protected,  Up: Reference

PtrCard
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: PtrInt,  Next: PtrWord,  Prev: PtrCard,  Up: Reference

PtrInt
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: PtrWord,  Next: Put,  Prev: PtrInt,  Up: Reference

PtrWord
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Put,  Next: Re,  Prev: PtrWord,  Up: Reference

Put
===

   (Under construction.)

Syntax
------

       Procedure Put ( Var F: TYPED FILE );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Re,  Next: read,  Prev: Put,  Up: Reference

Re
==

   (Under construction.)

Syntax
------

       Function Re ( z: Complex ): Real;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: read,  Next: readln,  Prev: Re,  Up: Reference

read
====

   (Under construction.)

Syntax
------

       Procedure read ( Var F: TYPED FILE; VARIABLE );
   or
       Procedure read ( Var F: Text; VARIABLES );
   or
       Procedure read ( VARIABLES );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: readln,  Next: ReadStr,  Prev: read,  Up: Reference

readln
======

   (Under construction.)

Syntax
------

       Procedure readln ( Var F: Text; VARIABLES );
   or
       Procedure readln ( VARIABLES );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: ReadStr,  Next: Real,  Prev: readln,  Up: Reference

ReadStr
=======

   (Under construction.)

Syntax
------

       Procedure ReadStr ( Const S: String; VARIABLES );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Real,  Next: record,  Prev: ReadStr,  Up: Reference

Real
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: record,  Next: Release,  Prev: Real,  Up: Reference

record
======

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

   The reserved word `record' starts the definition of a new record
type.  The syntax is

       foo = record
         FIELD DECLARATIONS
       end (* foo *);

   or, with a variant part,

       foo = record
         FIELD DECLARATIONS
         case bar: VARIANT TYPE of
           SELECTOR: ( FIELD DECLARATIONS );
           SELECTOR: ( FIELD DECLARATIONS );
           ...
       end (* foo *);

   or, without a variant selector field,

       foo = record
         FIELD DECLARATIONS
         case VARIANT TYPE of
           SELECTOR: ( FIELD DECLARATIONS );
           SELECTOR: ( FIELD DECLARATIONS );
           ...
       end (* foo *);

   Records can be `packed' to save memory usage at the expense of speed.

   The variants of a variant record share one location in memory
(inside the record) and thus can be used to emulate type casting
without violating ISO-7185 Standard Pascal.

Standards
---------

   The reserved word `record' and record types are defined in ISO-7185
Standard Pascal.

   According to ISO Pascal, the variant type must be an identifier.
GNU Pascal, like UCSD and Borland Pascal, also allows a subrange here.

Example
-------

       Type
         fooPtr = ^foo;
     
         foo = record
           bar: Integer;
           nextFoo: fooPtr;
           case choice: 1..3 of
             1: ( a: Integer );   (* These three choices share *)
             2: ( b: Real );      (* one location in memory.   *)
             3: ( c: Char;
                  d: Boolean );
         end (* foo *);
     
         smallFoo = packed record
           b: 0..3;
           a: Integer ( 5 );
           r: Boolean;
         end (* smallFoo *);   (* needs 1 byte *)
     
       Var
         f: foo;
     
       [...]
     
       f.b:= 3.14;
       writeln ( f.a );  (* yields some strange number which is part of the   *)
                         (* internal representation of the real number `f.b'. *)

See also
--------

   *Note packed::, *Note array::, *Note object::.


File: gpc.info,  Node: Release,  Next: rename,  Prev: record,  Up: Reference

Release
=======

   (Under construction.)

Syntax
------

       Procedure Release ( P: Pointer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: rename,  Next: repeat,  Prev: Release,  Up: Reference

rename
======

   (Under construction.)

Syntax
------

       Procedure Rename ( Var F: ANY FILE; NewName: String );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: repeat,  Next: reset,  Prev: rename,  Up: Reference

repeat
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: reset,  Next: restricted,  Prev: repeat,  Up: Reference

reset
=====

   (Under construction.)

Syntax
------

       Procedure reset ( Var F: ANY FILE );
   or
       Procedure reset ( Var F: ANY FILE; FileName: String );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: restricted,  Next: Result,  Prev: reset,  Up: Reference

restricted
==========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Result,  Next: return,  Prev: restricted,  Up: Reference

Result
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: return,  Next: rewrite,  Prev: Result,  Up: Reference

return
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: rewrite,  Next: RmDir,  Prev: return,  Up: Reference

rewrite
=======

   (Under construction.)

Syntax
------

       Procedure rewrite ( Var F: ANY FILE );
   or
       Procedure rewrite ( Var F: ANY FILE; FileName: String );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: RmDir,  Next: round,  Prev: rewrite,  Up: Reference

RmDir
=====

   (Under construction.)

Syntax
------

       Procedure RmDir ( Directory: String );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: round,  Next: RunError,  Prev: RmDir,  Up: Reference

round
=====

   (Under construction.)

Syntax
------

       Function round ( x: Real ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: RunError,  Next: Seek,  Prev: round,  Up: Reference

RunError
========

   (Under construction.)

Syntax
------

       Procedure RunError ( ErrorCode: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Seek,  Next: SeekRead,  Prev: RunError,  Up: Reference

Seek
====

   (Under construction.)

Syntax
------

       Procedure Seek ( Var F: TYPED FILE; NewPosition: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: SeekRead,  Next: SeekUpdate,  Prev: Seek,  Up: Reference

SeekRead
========

   (Under construction.)

Syntax
------

       Procedure SeekRead ( Var F: TYPED FILE; NewPosition: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: SeekUpdate,  Next: SeekWrite,  Prev: SeekRead,  Up: Reference

SeekUpdate
==========

   (Under construction.)

Syntax
------

       Procedure SeekUpdate ( Var F: TYPED FILE; NewPosition: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: SeekWrite,  Next: Self,  Prev: SeekUpdate,  Up: Reference

SeekWrite
=========

   (Under construction.)

Syntax
------

       Procedure SeekWrite ( Var F: TYPED FILE; NewPosition: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Self,  Next: set,  Prev: SeekWrite,  Up: Reference

Self
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: set,  Next: SetLength,  Prev: Self,  Up: Reference

set
===

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: SetLength,  Next: SetType,  Prev: set,  Up: Reference

SetLength
=========

Syntax
------

       Procedure SetLength ( Var S: String; NewLength: Integer );

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

   `SetLength' explicitly assigns a new length `NewLength' to the
string parameter `S'.  The contents of the string is *not* changed; if
the operation increases the length of the string, the characters
appended at the end are *undefined*.

   If you want to use `SetLength', please enable "extended syntax"
(`--extended-syntax' or `(*$X+*)').

Standards
---------

   `SetLength' is a Borland Delphi 2.0 extension.

Example
-------

     Program TestSetLength;
     
     (*$X+*)  (* Enable "dangerous" features *)
     
     Var
       S: String ( 26 );
     
     begin
       S:= 'Hello, world!';
       SetLength ( S, length ( 'Hello' ) );
       writeln ( S );                                     (* 'Hello' *)
       SetLength ( S, 26 );
       writeln ( S );               (* 'Hello, world!(%$@§"!"§$§"$'  *)
                             (* undefined characters ^^^^^^^^^^^^^   *)
     
       SetLength ( S, 42 );  (* The overflow is *not* (yet) detected *)
       writeln ( S );        (* This might cause a runtime error.    *)
     end.

See also
--------

   *Note length::, *Note String::, *Note SetType::.


File: gpc.info,  Node: SetType,  Next: ShortCard,  Prev: SetLength,  Up: Reference

SetType
=======

Syntax
------

       Procedure SetType ( Var SomeObject; VMT: Pointer );

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

   The procedure `SetType' explicitly assigns a value to the implicit
VMT field of an object.  This is normally done implicitly when a
constructor is called.

   You can use this to write a polymorphic I/O routine which reads an
object from a file.  In this case, you cannot reasonably use `New' to
allocate the storage, but you `GetMem' it and initialize the object
manually using `SetType' before calling the constructor explicitly.

   This is a dangerous feature which yields a warning unless `(*$X+*)'
is given.

Standards
---------

   `SetType' is a GNU extension.

Example
-------

       (*$X+*)
     
       Type
         BasePtr = ^BaseObj;
     
         BaseObj = object
           Constructor Load;
         end (* BaseObj *)
     
         [Successor objects ...]
     
       [...]
     
       Function GetObject = Result: BasePtr;
     
       Var
         Size: Cardinal;
         VMT: Pointer;
     
       begin (* GetObject *)
         [Read the size of the object from some file and store it in `Size'.]
         GetMem ( Result, Size );
         [Read some ID from some file and look up the `VMT' from some table.]
         SetType ( Result^, VMT );
         (* Now the object is ready, and the constructor can be called. *)
         [Look up the correct constructor from some table and call it.]
       end (* GetObject *);

See also
--------

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


File: gpc.info,  Node: ShortCard,  Next: ShortInt,  Prev: SetType,  Up: Reference

ShortCard
=========

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

   `ShortCard' is an unsigned integer type which is not larger than
`Cardinal'.  On most platforms it is 16 bits wide and thus has a range
of `0..65535'.

   `ShortCard' in GNU Pascal is compatible to `short unsigned int' in
GNU C.

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

Standards
---------

   ISO Pascal does not define `ShortCard'.  (However see *Note Subrange
types::.)

See also
--------

   *Note Integer types::, *Note Subrange types::.

