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: Reference,  Next: GPC source,  Prev: Programming,  Up: Top

The Alphabetical GPC Language Reference
***************************************

   *This chapter is under development, so don't be too excited about the
paragraph below!*

   This chapter contains an alphabetical list of all built-in
identifiers of the GNU Pascal compiler.  It does not cover extensions
provided by external libraries which are supposed to come with their
own documentation.

* Menu:

* abs::
* absolute::
* addr::
* AlignOf::
* all::
* and::
* and then::
* and_then::
* AnsiChar::
* append::
* arctan::
* arg::
* array::
* asm::
* asmname::
* Assign::
* assigned::
* attribute::
* begin::
* Bind::
* bindable::
* Binding::
* BindingType::
* BitSizeOf::
* BlockRead::
* BlockWrite::
* Boolean::
* break::
* Byte::
* ByteBool::
* ByteCard::
* ByteInt::
* C::
* C_Language::
* Card::
* Cardinal::
* case::
* Char::
* ChDir::
* chr::
* close::
* cmplx::
* Comp::
* Complex::
* Concat::
* conjugate::
* Const::
* Constructor::
* continue::
* Copy::
* cos::
* CString::
* CString2String::
* Date::
* dec::
* default::
* DefineSize::
* Delete::
* Destructor::
* Dispose::
* div::
* do::
* Double::
* downto::
* else::
* empty::
* end::
* eof::
* eoln::
* EpsReal::
* eq::
* erase::
* Exit::
* exp::
* Export::
* extend::
* Extended::
* extern::
* external::
* false::
* far::
* File::
* FileMode::
* FilePos::
* FileSize::
* FillChar::
* flush::
* for::
* forward::
* frac::
* FreeMem::
* Function::
* ge::
* Get::
* GetFile::
* GetMem::
* GetTimeStamp::
* goto::
* gt::
* Halt::
* high::
* if::
* Im::
* import::
* Implementation::
* in::
* inc::
* Index::
* inherited::
* inline::
* InOutRes::
* InOutResStr::
* Input::
* Insert::
* int::
* Integer::
* Interface::
* IOresult::
* Label::
* LastPosition::
* le::
* length::
* ln::
* LoCase::
* LongCard::
* LongInt::
* LongestCard::
* LongestInt::
* LongestReal::
* LongestWord::
* LongReal::
* LongWord::
* low::
* lt::
* Mark::
* max::
* MaxChar::
* MaxInt::
* MaxReal::
* MedCard::
* MedInt::
* MedReal::
* MedWord::
* min::
* MinReal::
* MkDir::
* mod::
* Module::
* move::
* MoveLeft::
* MoveRight::
* near::
* ne::
* New::
* NewCString::
* Nil::
* not::
* NULL::
* object::
* odd::
* of::
* only::
* Operator::
* or::
* or else::
* or_else::
* ord::
* others::
* otherwise::
* Output::
* pack::
* packed::
* page::
* pAnsiChar::
* ParamCount::
* ParamStr::
* pChar::
* Pointer::
* polar::
* pos::
* Position::
* pow::
* pred::
* Procedure::
* Program::
* protected::
* PtrCard::
* PtrInt::
* PtrWord::
* Put::
* Re::
* read::
* readln::
* ReadStr::
* Real::
* record::
* Release::
* rename::
* repeat::
* reset::
* restricted::
* Result::
* return::
* rewrite::
* RmDir::
* round::
* RunError::
* Seek::
* SeekRead::
* SeekUpdate::
* SeekWrite::
* Self::
* set::
* SetLength::
* SetType::
* ShortCard::
* ShortInt::
* ShortReal::
* ShortWord::
* Single::
* shl::
* shr::
* sin::
* SizeOf::
* SmallInt::
* sqr::
* sqrt::
* StandardError::
* StandardInput::
* StandardOutput::
* static::
* StdErr::
* Str::
* StrPCopy::
* String::
* String2CString::
* SubStr::
* succ::
* Text::
* then::
* Time::
* TimeStamp::
* to::
* to begin::
* to end::
* Trim::
* true::
* trunc::
* Truncate::
* Type::
* TypeOf::
* UnBind::
* Unit::
* unpack::
* until::
* UpCase::
* update::
* uses::
* Val::
* value::
* Var::
* virtual::
* Void::
* while::
* with::
* Word::
* write::
* writeln::
* WriteStr::
* xor::


File: gpc.info,  Node: abs,  Next: absolute,  Up: Reference

abs
===

Syntax
------

       Function abs ( i: INTEGER TYPE ): INTEGER TYPE;
   or
       Function abs ( x: REAL TYPE ): REAL TYPE;
   or
       Function abs ( z: COMPLEX TYPE ): REAL TYPE;

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

   Returns the absolute value of the argument.  For integer or real
values of `x', the definition is

       Function abs ( x: INTEGER OR REAL TYPE ): INTEGER OR REAL TYPE;
     
       begin (* abs *)
         if x < 0 then
           abs:= -x
         else
           abs:= x;
       end (* abs *);

   whereas for complex values it is

       Function abs ( x: Complex ): Complex;
     
       begin (* abs *)
         abs:= sqrt ( x * conjugate ( x ) );
       end (* abs *);

Standards
---------

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

Example
-------

       Program TestAbs;
     
       Var
         i1: Complex;
     
       begin
         writeln ( abs ( 42 ) );             (* 42    *);
         writeln ( abs ( -42 ) );            (* 42    *);
         writeln ( abs ( -12.1 ) : 0 : 1 );  (* 12.1  *);
         i1:= cmplx ( 1, 1 );                (* 1 + i *)
         writeln ( abs ( i1 ) : 0 : 3 );     (* 1.414, i.e. sqrt ( 2 ) *)
       end.

See also
--------

   *Note sqr::.


File: gpc.info,  Node: absolute,  Next: addr,  Prev: abs,  Up: Reference

absolute
========

Syntax
------

       Var
         VARIABLE NAME: DATA TYPE absolute VARIABLE REFERENCE;
   or
       Var
         VARIABLE NAME: DATA TYPE absolute INTEGER EXPRESSION;

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

   The first meaning of the `absolute' directive allows to put a
variable to the address of another one and thus provides a type-casting
mechanism.

   In most cases, VARIABLE REFERENCE will be just a variable name, but
GPC also allows arbitrary expressions here.  If VARIABLE REFERENCE has
neither a constant address nor is a variable parameter, GPC prints a
warning.  This warning is suppressed in "extended syntax" mode which is
switched on by the `--extended-syntax' option or the `(*$X+*)' compiler
directive.

   Other type-casting mechanisms in GPC are variant records (which are
valid in ISO-7185 Standard Pascal) and explicit type casts.

   The second meaning of `absolute' places a variable at a specified
address.  This is useful on machines without virtual memory addressing
for doing certain low-level operations, but should be avoided on
systems with memory protection such as UNIX-like systems.  GPC does not
check whether the specified virtual address makes any sense and does
not provide a built-in mechanism to map it to a real address.

   GPC warns about this second use of `absolute' unless "extended
syntax" has been requested.

Standards
---------

   ISO Pascal does not define `absolute'.

   Borland Pascal does define `absolute' but has a slightly different
syntax for the second meaning related to the addressing scheme of Intel
X86 processors working in real mode.

   Allowing arbitrary memory references instead of just variable names
in the first meaning of `absolute' is a GNU extension.

Example
-------

       Program TestAbsolute;
     
       (*$X+*)
     
       Const
         IOmemory = $F0000000;
     
       Var
         Mem: array [ 0..MaxInt ] of Byte absolute 0;
         SomeIOport: Byte absolute IOmemory + $C030;
     
       (* Beware:  Using any of the variables above will crash    *)
       (* your program unless you know exactly what you do!       *)
       (* That's why GPC warns about it without the X+ directive. *)
     
       Var
         x: Real;
         a: array [ 1..SizeOf ( Real ) ] of Byte absolute x;
         i: Integer;
     
         b: Byte absolute a [ i ];
         (* GNU extension: non-constant memory reference. *)
     
       begin
         x:= 3.14;
         (* Gather at the internal representation of a real variable. *)
         for i:= 1 to SizeOf ( Real ) do
           write ( a [ i ] : 4 );   (* Or (kind of abuse): `write ( b );' *)
         writeln;
       end.

See also
--------

   *Note record::, *Note Type casts::.


File: gpc.info,  Node: addr,  Next: AlignOf,  Prev: absolute,  Up: Reference

addr
====

   (Under construction.)

Syntax
------

       Function addr ( Const Foo ): Pointer;

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

   `addr' returns the address of its argument.

Standards
---------

   `assigned' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: AlignOf,  Next: all,  Prev: addr,  Up: Reference

AlignOf
=======

Syntax
------

       Function AlignOf ( Var x ): Integer;

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

   Returns the alignment of a type or variable in bytes.

Standards
---------

   `AlignOf' is a GNU extension.

Example
-------

       Var
         a: Integer;
         b: array [ 1..8 ] of Char;
     
       ...
     
       writeln ( AlignOf ( a ) );  (* Alignment of `Integer'; usually 4 bytes. *)
       writeln ( AlignOf ( b ) );  (* Alignment of `Char'; usually 1 byte. *)

   Although the array is bigger than a single char, it is accessed char
by char, so there usually is no need to align it on a 4 byte boundary
or such.  (This may be false on some platforms.)

See also
--------

   *Note SizeOf::, *Note BitSizeOf::, *Note TypeOf::.


File: gpc.info,  Node: all,  Next: and,  Prev: AlignOf,  Up: Reference

all
===

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

   `all' is a predefined export interface for Extended Pascal modules.
You can use it to export all identifiers declared in an interface module
automatically.

Standards
---------

   `all' is a GNU extension.

Example
-------

       Module TestAll Interface;
     
       export
         foo = all;  (* Same as `foo = ( a, b, bar );' *)
     
       Var
         a, b: Integer;
     
       Procedure bar;
     
       end.

See also
--------

   *Note Modules::.


File: gpc.info,  Node: and,  Next: and then,  Prev: all,  Up: Reference

and
===

Syntax
------

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

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

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

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

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

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

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


Standards
---------

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

   According to ISO, you cannot rely on `and' being a short-circuit
operator.  On the other hand, GPC's default behaviour does *not*
contradict the ISO standard.  (See *Note and_then::.)  However, since
it seems to be a de-facto standard among ISO Pascal compilers to
evaluate both operands of `and', 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 `and' operator; Borland
Pascal and Delphi do.

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

Example
-------

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

   Note the difference between the logical `and' and the bitwise `and':
When `a' is 2 and `b' is 4, then `a and b' is 0.  *Beware:*  `a and b
= 0' has nothing to do with `( a = 0 ) and ( b = 0 )'!

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

See also
--------

   *Note and_then::, *Note and then::, *Note or::, *Note xor::, *Note
Operators::.


File: gpc.info,  Node: and then,  Next: and_then,  Prev: and,  Up: Reference

and then
========

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

   `and then' is an alias for the short-circuit logical operator
`and_then'.

Standards
---------

   While `and_then' is defined in ISO-10206 Extended Pascal, `and then'
is a GNU Extension.

Example
-------

       Var
         p: ^Integer;
     
       [...]
     
       if ( p <> Nil ) and then ( p^ < 42 ) then  (* This is safe. *)
         [...];

See also
--------

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


File: gpc.info,  Node: and_then,  Next: AnsiChar,  Prev: and then,  Up: Reference

and_then
========

Syntax
------

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

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

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

   Since the behaviour described above is the most effective way to
implement `and', GPC by default treats `and' and `and_then' exactly the
same.  If you want, for some reason, to have both operands of `and'
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 `and'--or `and_then', it does not matter.

Standards
---------

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

   Some people think that the ISO standard requires both operands of
`and' 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 `and'; in particular things like

       Var
         p: ^Integer;
     
       [...]
     
       if ( p <> Nil ) and ( p^ < 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 `and_then'; *never* use `and'.

Example
-------

       Var
         p: ^Integer;
     
       [...]
     
       if ( p <> Nil ) and_then ( p^ < 42 ) then  (* This is safe. *)
         [...];

See also
--------

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


File: gpc.info,  Node: AnsiChar,  Next: append,  Prev: and_then,  Up: Reference

AnsiChar
========

Syntax
------

       Type
         AnsiChar = Char;

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

   `AnsiChar' is an 8 bit char type.  Currently, it is the same as
`Char', but this might change in the future, once `wide chars' (16 bit
chars) will be introduced into GPC.  Depending on the platform, `Char'
might be either `AnsiChar' or `WideChar' then.

Standards
---------

   ISO Pascal does not define `AnsiChar'; Delphi does.

Example
-------

       Var
         A: AnsiChar;  (* There is nothing special with `AnsiChar'. *)
         B: Char;
     
       [...]
     
       A:= 'A';
       A:= B;

See also
--------

   *Note pAnsiChar::, *Note Char::.


File: gpc.info,  Node: append,  Next: arctan,  Prev: AnsiChar,  Up: Reference

append
======

Syntax
------

       Procedure append ( Var F: ANY FILE );

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

Standards
---------

   `append' is a Borland Pascal extension.  ISO-10206 Extended Pascal
has *Note extend:: instead.

Example
-------

See also
--------

   *Note Assign::, *Note reset::, *Note rewrite::, *Note update::,
*Note extend::.


File: gpc.info,  Node: arctan,  Next: arg,  Prev: append,  Up: Reference

arctan
======

Syntax
------

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

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

   `arctan' returns the (principal value of the) arcus tangent of the
argument.  The result is in the range `-pi / 2 < arctan ( x ) < pi / 2'
for real arguments.

Standards
---------

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

Example
-------

       writeln ( 4 * arctan ( 1 ) : 0 : 5 );
       (* yields 3.14159; arctan ( 1 ) = pi / 4. *)

See also
--------

   *Note sin::, *Note cos::, *Note ln::, *Note arg::.


File: gpc.info,  Node: arg,  Next: array,  Prev: arctan,  Up: Reference

arg
===

Syntax
------

       Function arg ( z: Complex ): Real;

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

   `arg' returns the complex "argument", i.e. the angle (in radian) in
the complex plane with respect to the real axis, of its parameter `z'.
The result is in the range of `-pi < arg ( z ) <= pi'.

Standards
---------

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

Example
-------

       Program TestArg;
     
       Var
         z: Complex;
     
       begin
         z:= cmplx ( 1, 1 );  (* 1 + i *)
         writeln ( arg ( z ) : 0 : 5 );
         (* yields 0.78540, i.e. pi / 4. *)
       end.

See also
--------

   *Note arctan::, *Note ln::, *Note polar::.


File: gpc.info,  Node: array,  Next: asm,  Prev: arg,  Up: Reference

array
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: asm,  Next: asmname,  Prev: array,  Up: Reference

asm
===

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: asmname,  Next: Assign,  Prev: asm,  Up: Reference

asmname
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Assign,  Next: assigned,  Prev: asmname,  Up: Reference

Assign
======

Syntax
------

       Procedure Assign ( Var F: ANY FILE; FileName: String );

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

Standards
---------

   `Assign' is a Borland Pascal extension.

Example
-------

See also
--------

   *Note reset::, *Note rewrite::, *Note update::, *Note extend::,
*Note append::.


File: gpc.info,  Node: assigned,  Next: attribute,  Prev: Assign,  Up: Reference

assigned
========

   (Under construction.)

Syntax
------

       Function assigned ( p: Pointer ): Boolean;
   or
       Function assigned ( p: PROCEDURAL TYPE ): Boolean;

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

Standards
---------

   `assigned' is a Borland Pascal extension.

Example
-------

See also
--------


File: gpc.info,  Node: attribute,  Next: begin,  Prev: assigned,  Up: Reference

attribute
=========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: begin,  Next: Bind,  Prev: attribute,  Up: Reference

begin
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Bind,  Next: bindable,  Prev: begin,  Up: Reference

Bind
====

   (Under construction.)

Syntax
------

       Procedure Bind ( Var F: ANY FILE; B: BindingType );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: bindable,  Next: Binding,  Prev: Bind,  Up: Reference

bindable
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Binding,  Next: BindingType,  Prev: bindable,  Up: Reference

Binding
=======

   (Under construction.)

Syntax
------

       Function Binding ( F: ANY FILE ): BindingType;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: BindingType,  Next: BitSizeOf,  Prev: Binding,  Up: Reference

BindingType
===========

   (Under construction.)

Syntax
------

     UnixTimeType = LongInt;
     
     GPC_BindingType = {@@packed} record
                         Bound             : Boolean;
                         Force             : Boolean;      { Can be set to allow binding to non-writable files or directories }
                         Extensions_Valid  : Boolean;
                         Readable          : Boolean;
                         Writable          : Boolean;
                         Executable        : Boolean;
                         Existing          : Boolean;      { Binding points to an existing file }
                         Directory         : Boolean;      { Binding points to an existing directory; Existing is False then }
                         Size              : LongInt;      { Number of elements or -1 }
                         AccessTime,                       { Time of last access }
                         ModificationTime,                 { Time of last modification }
                         ChangeTime        : UnixTimeType; { Time of last change }
                         Error             : Integer;      { Unused currently }
                         CFile             : CFilePtr;     { allows binding a Pascal file to a C file }
                         Name              : String (Binding_Name_Length)
                       end;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: BitSizeOf,  Next: BlockRead,  Prev: BindingType,  Up: Reference

BitSizeOf
=========

Syntax
------

       Function BitSizeOf ( Var x ): Integer;

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

   Returns the size of a type or variable in bits.

Standards
---------

   `BitSizeOf' is a GNU extension.

Example
-------

       Var
         a: Integer;
         b: array [ 1..8 ] of Char;
         c: Integer ( 12 );
     
         d: packed record
           x: Integer ( 12 );
           y: 0..3;
         end (* d *);
     
       ...
     
       writeln ( BitSizeOf ( a ) );  (* Size of an `Integer'; usually 32 bits.  *)
       writeln ( BitSizeOf ( b ) );  (* Size of eight `Char's; usually 64 bits. *)
       writeln ( BitSizeOf ( c ) );  (* 16 bits (smallest addressable space).   *)
     
       writeln ( BitSizeOf ( d ) );    (* 16 *)
       writeln ( BitSizeOf ( d.x ) );  (* 12 *)
       writeln ( BitSizeOf ( d.y ) );  (*  2 *)

See also
--------

   *Note SizeOf::, *Note AlignOf::, *Note TypeOf::.


File: gpc.info,  Node: BlockRead,  Next: BlockWrite,  Prev: BitSizeOf,  Up: Reference

BlockRead
=========

   (Under construction.)

Syntax
------

       Procedure BlockRead ( Var F: File; Var Buffer; Blocks: Integer );
   or
       Procedure BlockRead ( Var F: File; Var Buffer; Blocks: Integer;
                             Var BlocksRead: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: BlockWrite,  Next: Boolean,  Prev: BlockRead,  Up: Reference

BlockWrite
==========

   (Under construction.)

Syntax
------

       Procedure BlockWrite ( Var F: File; Const Buffer; Blocks: Integer );
   or
       Procedure BlockWrite ( Var F: File; Const Buffer; Blocks: Integer;
                              Var BlocksWritten: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Boolean,  Next: break,  Prev: BlockWrite,  Up: Reference

Boolean
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: break,  Next: Byte,  Prev: Boolean,  Up: Reference

break
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Byte,  Next: ByteBool,  Prev: break,  Up: Reference

Byte
====

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

   `Byte' is an unsigned integer type which is one "unit" wide.  On
most platforms one unit has 8 bits, therefore the type is named "byte"
and usually has a range of `0..255'.  (It is the same as *Note
ByteCard::.)

   `Byte' in GNU Pascal is compatible to `unsigned char' in GNU C.

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

Standards
---------

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

   The `Byte' type appears in Borland Pascal and Delphi, too, where it
is an unsigned 8-bit integer type.

See also
--------

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


File: gpc.info,  Node: ByteBool,  Next: ByteCard,  Prev: Byte,  Up: Reference

ByteBool
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: ByteCard,  Next: ByteInt,  Prev: ByteBool,  Up: Reference

ByteCard
========

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

   `ByteCard' is an unsigned integer type which is one "unit" wide.  On
most platforms one unit has 8 bits, therefore the type is prefixed
"byte-" and usually has a range of `0..255'.

   `ByteCard' in GNU Pascal is compatible to `unsigned char' in GNU C.

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

Standards
---------

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

See also
--------

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


File: gpc.info,  Node: ByteInt,  Next: C,  Prev: ByteCard,  Up: Reference

ByteInt
=======

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

   `ByteInt' is a signed integer type which is one "unit" wide.  On
most platforms one unit has 8 bits, therefore the type is prefixed
"byte-" and usually has a range of `-128..127'.

   `ByteInt' in GNU Pascal is compatible to `signed char' in GNU C.

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

Standards
---------

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

   `ByteInt' in GNU Pascal corresponds to *Note ShortInt:: in Borland
Pascal and Delphi.

See also
--------

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


File: gpc.info,  Node: C,  Next: C_Language,  Prev: ByteInt,  Up: Reference

C
=

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: C_Language,  Next: Card,  Prev: C,  Up: Reference

C_Language
==========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Card,  Next: Cardinal,  Prev: C_Language,  Up: Reference

Card
====

   (Under construction.)

Syntax
------

       Function Card ( S: ANY SET ): Integer;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Cardinal,  Next: case,  Prev: Card,  Up: Reference

Cardinal
========

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

   `Cardinal' is the "natural" unsigned integer type in GNU Pascal.  On
most platforms it is 32 bits wide and thus has a range of
`0..4294967295'.  Use it whenever you need a general-purpose unsigned
integer type and don't need to care about compatibility to other Pascal
dialects.

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

       Type
         Card16 = Cardinal ( 16 );

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

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

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

Standards
---------

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

   The `Cardinal' type appears in Delphi, too, where it has 16 bits in
version 1.0, 32 from version 2.0 on.

See also
--------

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


File: gpc.info,  Node: case,  Next: Char,  Prev: Cardinal,  Up: Reference

case
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Char,  Next: ChDir,  Prev: case,  Up: Reference

Char
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: ChDir,  Next: chr,  Prev: Char,  Up: Reference

ChDir
=====

   (Under construction.)

Syntax
------

       Procedure ChDir ( Directory: String );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: chr,  Next: close,  Prev: ChDir,  Up: Reference

chr
===

   (Under construction.)

Syntax
------

       Function chr ( AsciiCode: Integer ): Char;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: close,  Next: cmplx,  Prev: chr,  Up: Reference

close
=====

   (Under construction.)

Syntax
------

       Procedure Close ( Var F: ANY FILE );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: cmplx,  Next: Comp,  Prev: close,  Up: Reference

cmplx
=====

   (Under construction.)

Syntax
------

       Function cmplx ( RealPart, ImaginaryPart: Real ): Complex;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Comp,  Next: Complex,  Prev: cmplx,  Up: Reference

Comp
====

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

   `Comp' 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'.

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

Standards
---------

   ISO Pascal does not define `Comp'.

   Borland Pascal and Delphi also define `Comp' as a 64-bit signed
integer type.  This compatibility is the reason why GPC supports `Comp'.
In some contexts, the Borland compilers treat `Comp' as a "real"
type--this behaviour is not supported by GPC.

See also
--------

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


File: gpc.info,  Node: Complex,  Next: Concat,  Prev: Comp,  Up: Reference

Complex
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Concat,  Next: conjugate,  Prev: Complex,  Up: Reference

Concat
======

   (Under construction.)

Syntax
------

       Function Concat ( S1, S2: String ): String;
   or
       Function Concat ( S1, S2, S3: String ): String;
   or
       ...

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: conjugate,  Next: Const,  Prev: Concat,  Up: Reference

conjugate
=========

   (Under construction.)

Syntax
------

       Function conjugate ( z: Complex ): Complex;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Const,  Next: Constructor,  Prev: conjugate,  Up: Reference

Const
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Constructor,  Next: continue,  Prev: Const,  Up: Reference

Constructor
===========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: continue,  Next: Copy,  Prev: Constructor,  Up: Reference

continue
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Copy,  Next: cos,  Prev: continue,  Up: Reference

Copy
====

Syntax
------

       Function Copy ( S: String; FirstChar, Count: Integer ): String;
   or
       Function Copy ( S: String; FirstChar: Integer ): String;

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

   `Copy' returns a sub-string of S starting with the character at
position FIRSTCHAR.  If COUNT is given, such many characters will be
copied into the sub-string.  If COUNT is omitted, the sub-string will
will range to the end of S.

   If `Count' is too large for the sub-string to fit in S, the result
will be truncated at the end of S.  If `FirstChar' exceeds the length
of S, the empty string will be returned.  (For a function which does
not truncate but triggers a runtime error instead, see *Note SubStr::.)

   Please note that GPC's strings may be longer than 255 characters.  If
you want to isolate the second half of a string S starting with the
third character, use `Copy ( S, 3 )' instead of `Copy ( S, 3, 255 )'.

Standards
---------

   `Copy' is defined in UCSD and Borland Pascal.  It does not appear in
ISO Pascal.  The possibility to omit the third parameter is a GPC
extension.

Example
-------

       Var
         S: String ( 42 );
     
       [...]
     
       S:= 'Hello';
       writeln ( Copy ( S, 2, 3 ) );   (* yields "ell" *)
       writeln ( Copy ( S, 3 ) );      (* yields "llo" *)
       writeln ( Copy ( S, 4, 7 ) );   (* yields "lo" *)
       writeln ( Copy ( S, 42 ) );     (* yields the empty string *)

See also
--------

   *Note SubStr::, String slice access.


File: gpc.info,  Node: cos,  Next: CString,  Prev: Copy,  Up: Reference

cos
===

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: CString,  Next: CString2String,  Prev: cos,  Up: Reference

CString
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: CString2String,  Next: Date,  Prev: CString,  Up: Reference

CString2String
==============

   (Under construction.)

Syntax
------

       Function CString2String ( S: CString ): String;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Date,  Next: dec,  Prev: CString2String,  Up: Reference

Date
====

   (Under construction.)

Syntax
------

       Function Date ( T: TimeStamp ):
           packed array [ 1..DATE LENGTH ] of Char;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: dec,  Next: default,  Prev: Date,  Up: Reference

dec
===

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: default,  Next: DefineSize,  Prev: dec,  Up: Reference

default
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: DefineSize,  Next: Delete,  Prev: default,  Up: Reference

DefineSize
==========

   (Under construction.)

Syntax
------

       Procedure DefineSize ( Var F: ANY FILE; NewSize: Integer );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Delete,  Next: Destructor,  Prev: DefineSize,  Up: Reference

Delete
======

   (Under construction.)

Syntax
------

       Procedure Delete ( Var S: String; FirstChar, Count: Integer );

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

Standards
---------

Example
-------

See also
--------


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

Destructor
==========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

Dispose
=======

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


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

div
===

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


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

do
==

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

Standards
---------

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

See also
--------

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


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

Double
======

   (Under construction.)

Syntax
------

       Type
         Double = Real;

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

Standards
---------

Example
-------

See also
--------


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

downto
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

else
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

empty
=====

   (Under construction.)

Syntax
------

       Function empty ( Var F: ANY FILE ): Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: end,  Next: eof,  Prev: empty,  Up: Reference

end
===

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: eof,  Next: eoln,  Prev: end,  Up: Reference

eof
===

   (Under construction.)

Syntax
------

       Function eof ( Var F: ANY FILE ): Boolean;
   or
       Function eof: Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: eoln,  Next: EpsReal,  Prev: eof,  Up: Reference

eoln
====

   (Under construction.)

Syntax
------

       Function eoln ( Var F: ANY FILE ): Boolean;
   or
       Function eoln: Boolean;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: EpsReal,  Next: eq,  Prev: eoln,  Up: Reference

EpsReal
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: eq,  Next: erase,  Prev: EpsReal,  Up: Reference

eq
==

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: erase,  Next: Exit,  Prev: eq,  Up: Reference

erase
=====

   (Under construction.)

Syntax
------

       Procedure erase ( Var F: ANY FILE );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Exit,  Next: exp,  Prev: erase,  Up: Reference

Exit
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: exp,  Next: Export,  Prev: Exit,  Up: Reference

exp
===

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Export,  Next: extend,  Prev: exp,  Up: Reference

Export
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: extend,  Next: Extended,  Prev: Export,  Up: Reference

extend
======

   (Under construction.)

Syntax
------

       Procedure extend ( Var F: ANY FILE );

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

Standards
---------

Example
-------

See also
--------


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

Extended
========

   (Under construction.)

Syntax
------

       Type
         Extended = LongReal;

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

Standards
---------

Example
-------

See also
--------


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

extern
======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

external
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: false,  Next: far,  Prev: external,  Up: Reference

false
=====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

far
===

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

Standards
---------

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

Example
-------

       Var
         p: Procedure;
     
       Procedure Foo; far;  (* `far' has no effect in GPC *)
     
       begin (* Foo *)
         [...]
       end (* Foo *);
     
       [...]
     
       p:= Foo;  (* Would also work without `far' in GPC. *)

See also
--------

   *Note near::.


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

FileMode
========

   (Under construction.)

Syntax
------

       Var
         FileMode: Integer;

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

Standards
---------

Example
-------

See also
--------


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

File
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

FilePos
=======

   (Under construction.)

Syntax
------

       Function FilePos ( Var F: ANY FILE ): Integer;

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

Standards
---------

Example
-------

See also
--------


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

FileSize
========

   (Under construction.)

Syntax
------

       Function FileSize ( Var F: ANY FILE ): Integer;

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

Standards
---------

Example
-------

See also
--------


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

FillChar
========

   (Under construction.)

Syntax
------

       Procedure FillChar ( Var Dest; Count: Integer; Value: Char );
   or
       Procedure FillChar ( Var Dest; Count: Integer; Value: Byte );

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: flush,  Next: for,  Prev: FillChar,  Up: Reference

flush
=====

   (Under construction.)

Syntax
------

       Procedure flush ( Var F: ANY FILE );

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

Standards
---------

Example
-------

See also
--------


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

for
===

   (Under construction.)

Syntax
------

       for ORDINAL VARIABLE := INITIAL VALUE to FINAL VALUE do
         STATEMENT
   or
       for ORDINAL VARIABLE := INITIAL VALUE downto FINAL VALUE do
         STATEMENT
   or
       for ORDINAL VARIABLE in SOME SET do
         STATEMENT

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

Standards
---------

Example
-------

See also
--------


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

forward
=======

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: frac,  Next: FreeMem,  Prev: forward,  Up: Reference

frac
====

   (Under construction.)

Syntax
------

       Function frac ( x: Real ): Real;

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: FreeMem,  Next: Function,  Prev: frac,  Up: Reference

FreeMem
=======

Syntax
------

       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.

Standards
---------

   ISO Pascal does not define `FreeMem', Borland Pascal does and
requires two parameters.  `FreeMem' with only one parameter is a GNU
extension.

Example
-------

   *Note GetMem::

See also
--------

   *Note GetMem::, *Note Schemata::, *Note Dispose::, *Note Mark::,
*Note Release::.


File: gpc.info,  Node: Function,  Next: ge,  Prev: FreeMem,  Up: Reference

Function
========

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: ge,  Next: Get,  Prev: Function,  Up: Reference

ge
==

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Get,  Next: GetFile,  Prev: ge,  Up: Reference

Get
===

   (Under construction.)

Syntax
------

       Procedure Get ( Var F: TYPED FILE );

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

Standards
---------

Example
-------

See also
--------


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

GetFile
=======

Syntax
------

       Function GetFile ( F: FILE TYPE ): Pointer;

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

   GNU Pascal files internally contain a C `FILE' descriptor.
`GetFile' returns a pointer to this, so you can pass it to external
procedures or functions, perhaps written in C, that cannot handle
Pascal files.

Standards
---------

   `GetFile' is a GNU extension.

Example
-------

       Program Hello;
     
       Procedure fputs ( S: CString; someFile: Pointer ); C;
     
       begin
         fputs ( 'Hello, world!'^J, GetFile ( Output ) );
       end.

See also
--------

   *Note C::, *Note CString::, *Note Other languages::.


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

GetMem
======

Syntax
------

       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.

Standards
---------

   ISO Pascal does not define `GetMem', Borland Pascal does, but only
as a procedure.  `GetMem' as a function is a GNU 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 TestGetMem;
     
       uses
         Graph;
     
       Var
         Buffer: Pointer;
         Size: Cardinal;
     
       begin
         [...]
         Size:= ImageSize ( 10, 10, 60, 30 );
         Buffer:= GetMem ( Size );  (* or: GetMem ( Buffer, Size ); *)
         GetImage ( 10, 10, 60, 30, Buffer^ );
         [...]
         FreeMem ( Buffer );  (* or: FreeMem ( Buffer, Size ); *)
         [...]
       end.

See also
--------

   *Note FreeMem::, *Note New::, *Note Schemata::.


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

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

   (Under construction.)

Syntax
------

       Procedure GetTimeStamp ( Var T: TimeStamp );

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

Standards
---------

Example
-------

See also
--------


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

goto
====

   (Under construction.)

Syntax
------

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

Standards
---------

Example
-------

See also
--------


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

gt
==

   (Under construction.)

Syntax
------

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

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

Standards
---------

Example
-------

See also
--------


File: gpc.info,  Node: Halt,  Next: high,  Prev: gt,  Up: Reference

Halt
====

   (Under construction.)

Syntax
------

       Procedure Halt;
   or
       Procedure Halt ( ExitCode: Integer );

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

Standards
---------

Example
-------

See also
--------

