Node: Keywords, Next: Support, Previous: Reference, Up: Top

## Pascal keywords and operators supported by GNU Pascal.

This chapter lists all keywords understood by GNU Pascal. The keywords are taken from the following standards and dialects:

- ISO 7185 Pascal (CP)
- ISO 10206 Extended Pascal (EP)
- ANSI draft Object Pascal (OP)
- UCSD Pascal (UCSD)
- Borland Pascal 7.0 (BP)
- Borland Delphi (BD)
- Pascal-SC (PXSC, Pascal eXtensions for Scientific Calculations)
- VAX Pascal (VP)
- Sun Pascal (SP)
- Traditional Macintosh Pascal (MP)
- GNU Pascal extensions (GPC)

The table below lists all known keywords with short descriptions. The links point to the longer descriptions in the reference.

By default (using GPC extensions) all keywords are enabled. Only those are marked `GPC` in the table below that are valid only in the GPC extensions.

All keywords that are specific to some dialects (i.e., not marked “any”) can also be used as identifiers (with a few exceptions, see below). Then, however, they generally cannot be used as keywords anymore. So you can compile code from dialects that use them as keywords and code that uses them as identifiers, i.e., you do not have to modify your correct ISO 7185 programs in order to compile them with GPC without any dialect option. Some words can even be used as keywords and identifiers in parallel, including `forward` (according to ISO 7185 Pascal), and `near` and `far` (according to Borland Pascal).

The exceptions are:

- `Operator` can't be used as a type, untyped constant or exported interface, i.e. when it would be followed by `=` (unless it's disabled as a keyword explicitly or by dialect options, see below). This is because of a conflict with a definition of the operator `=`. (It can be used as a typed constant, but it might be confusing if you later decide to make it untyped, so use with care.)
- The first statement after `initialization` (Delphi specific unit initialization) must not start with `(`. (Statements starting with `(` are uncommon, anyway, but not impossible.) This does not restrict the usage of `Initialization` as an identifier.
- The following keywords can't be used immediately after an `import` part: `uses`, `implementation`, `operator`, `constructor`, `destructor`. Using `uses` instead of `import`, or putting some other declaration between `import` and the problematic keyword helps.

A dialect option turns off all keywords that do not belong to this dialect. Besides, any keyword can be enabled and disabled with the compiler options `{$enable-keyword}` and `{$disable-keyword}`.

absolute (BP, BD) (see absolute)
  overloaded variable declaration
abstract (OP) (see abstract)
  abstract object type or method declaration
all (all) (see all)
  `export` (see export) extension (`export foo = all`)
and (any) (see and)
  Boolean or bitwise `and` operator or part of the `and then` (see and then) operator
and_then (EP, OP) (see and_then)
  short-circuit Boolean `and` (see and) operator
array (any) (see array)
  array type declaration
as (OP, BD) (see as)
  object type membership test and conversion
asm (BP, BD) (see asm)
  GNU style inline assembler code
asmname (GPC) (see asmname)
  DEPRECATED! linker name of routines and variables
attribute (GPC) (see attribute)
  attributes of routines and variables
begin (any) (see begin)
  begin of a code block, part of a `to begin do` (see to begin do) module constructor
bindable (EP, OP) (see bindable)
  external bindability of files
c (GPC) (see c)
  DEPRECATED! declaration of external routine
case (any) (see case)
  multi-branch conditional statement or variant `record` (see record) type
c_language (GPC) (see c_language)
  DEPRECATED! declaration of external routine
class (OP, BD) (see class)
  OOE/Delphi style object class (not yet implemented)
const (any) (see const)
  constant declaration or constant parameter declaration
constructor (OP, BP, BD) (see constructor)
  object constructor
destructor (OP, BP, BD) (see destructor)
  object destructor
div (any) (see div)
  integer division operator
do (any) (see do)
  part of a `while` (see while) or `for` (see for) loop, a `with` (see with) statement, or a `to begin do` (see to begin do) or `to end do` (see to end do) module constructor or destructor
downto (any) (see downto)
  part of a `for` (see for) loop counting downwards
else (any) (see else)
  alternative part of an `if` (see if) statement, default `case` (see case) branch, part of the `or else` (see or else) operator
end (any) (see end)
  end of a code block, end of a `case` (see case) statement, end of a `record` (see record) or `object` (see object) declaration, part of a `to end do` (see to end do) module destructor
export (export) (see export)
  module interface export
exports (BP, BD) (see exports)
  library export (not yet implemented)
external (UCSD, BP, BD, MP) (see external)
  declaration of an external object
far (BP, BD) (see far)
  BP directive (ignored)
file (any) (see file)
  non-text file type declaration
finalization (BD) (see finalization)
  unit finalization
for (any) (see for)
  loop statement where the number of loops is known in advance
forward (any) (see forward)
  declaration of a routine whose definition follows below
function (any) (see function)
  function declaration
goto (any) (see goto)
  statement to jump to a `label` (see label)
if (any) (see if)
  conditional statement
implementation (all except CP) (see implementation)
  module or unit implementation part
import (EP, OP) (see import)
  module interface import
in (any) (see in)
  set membership test or part of a `for` (see for) loop iterating through sets
inherited (OP, BP, BD, MP) (see inherited)
  reference to methods of ancestor object types
initialization (BD) (see initialization)
  unit initialization
interface (interface) (see interface)
  module or unit interface part
interrupt (BP, BD) (see interrupt)
  interrupt handler declaration (not yet implemented)
is (OP, BD) (see is)
  object type membership test
label (any) (see label)
  label declaration for a `goto` (see goto) statement
library (BP, BD) (see library)
  library declaration (not yet implemented)
mod (any) (see mod)
  integer remainder operator
module (module) (see module)
  EP style or PXSC style module
name (name) (see name)
  linker name
near (BP, BD) (see near)
  BP directive (ignored)
nil (any) (see nil)
  reserved value for unassigned pointers
not (any) (see not)
  Boolean or bitwise negation operator
object (BP, BD, MP) (see object)
  BP style object declaration
of (any) (see of)
  part of an `array` (see array), `set` (see set) or typed `file` (see file) type declaration, a `case` (see case) statement, a variant `record` (see record) type or a `type of` (see type of) type inquiry
only (EP, OP) (see only)
  import specification
operator (PXSC) (see operator)
  operator declaration
or (any) (see or)
  Boolean or bitwise `or` operator or part of the `or else` (see or else) operator
or_else (EP, OP) (see or_else)
  short-circuit Boolean `or` (see or) operator
otherwise (EP, OP, MP) (see otherwise)
  default `case` (see case) branch, default value in a structured value of `array` (see array) type
packed (any) (see packed)
  declaration of packed structured types (`record` (see record), `array` (see array), `set` (see set), `file` (see file)), also packed ordinal subranges
pow (EP, OP) (see pow)
  exponentiation operator with integer exponent
private (private) (see private)
  private object fields
procedure (any) (see procedure)
  procedure declaration
program (any) (see program)
  start of a Pascal program
property (OP, BD) (see property)
  object properties (not yet implemented)
protected (protected) (see protected)
  read-only formal parameters or module export and protected object fields
public (public) (see public)
  public object fields
published (published) (see published)
  published object fields
qualified (qualified) (see qualified)
  import specification
record (any) (see record)
  record type declaration
repeat (any) (see repeat)
  loop statement
resident (BP, BD) (see resident)
  library export specification (not yet implemented)
restricted (EP, OP) (see restricted)
  restricted type specification
segment (UCSD) (see segment)
  segment specification (not yet implemented)
set (any) (see set)
  set type declaration
shl (BP, BD, MP) (see shl)
  bitwise left shift operator
shr (BP, BD, MP) (see shr)
  bitwise right shift operator
then (any) (see then)
  part of an `if` (see if) statement or part of the `and then` (see and then) operator
to (any) (see to)
  part of a `for` (see for) loop counting upwards or a `to begin do` (see to begin do) or `to end do` (see to end do) module constructor or destructor
type (any) (see type)
  type declaration or part of a `type of` (see type of) type inquiry
unit (UCSD, BP, BD, MP) (see unit)
  UCSD and BP style unit declaration
until (any) (see until)
  end of a `repeat` (see repeat) statement
uses (UCSD, BP, BD, MP) (see uses)
  unit import
value (EP, OP) (see value)
  variable/type initializer
var (any) (see var)
  variable declaration or reference parameter declaration
view (OP) (see view)
  object class view (not yet implemented)
virtual (OP, BP, BD, MP) (see virtual)
  virtual object method declaration
while (any) (see while)
  loop statement
with (any) (see with)
  automatic `record` (see record) or object field access
xor (BP, BD, MP) (see xor)
  Boolean or bitwise `exclusive or` operator