Enum Type

From Free Pascal wiki

Deutsch (de) English (en) français (fr)

An enumeration is a custom data type in Pascal. It is a discrete value that can be referred to by a unique identifier.



An enumeration is defined by surrounding a non-empty comma-separated list of identifiers that were not yet defined in the current scope with parentheses:

1 program enumerationDemo(input, output, stdErr);
2 type
3 	fruit = (apple, banana, citrus);

Thus, a variable of the type fruit may assume the values apple, banana, or citrus.

4 var
5 	snack: fruit;
6 begin
7 	snack := apple;
8 end.


Every member of an enumerated type has an ordinal value which can be obtained using the standard function ord. The first member of any enumeration has the ordinal value zero, and every following member are enumerated with consecutive numbers.

In some cases, however, it would be quite useful if the ordinal values were different. FPC allows Delphi-style explicit definition of indices by following member identifiers with an equal sign and an integer value:

	sign = (negative = -1, none = 0, positive = 1);

All values must be ascending order. Note, it is not necessary to define all members with an explicit ordinal value, this example just happens to define all of them. You may skip giving individual members an explicit index, however, the automatic continuous numbering must not clash with the indices provided.

Instead of a single = FPC also allows :=.


FPC prefixes all members of enumeration type definitions in the type section with their corresponding type name. By default, the short name without a prefix is inserted into the symbol table as an alias in order to meet Pascal standards.

Since version 2.6.0 FPC supports disabling member identifiers from being aliased by using the {$scopedEnums on} local compiler directive, thus requiring users to always specify the type name as a prefix:

program scopedEnumerationDemo(input, output, stdErr);
	{$scopedEnums on}
	logLevel = (error, warning, info, debug);
	verbosity: logLevel;
	verbosity := logLevel.debug;

This setting only affects definition of new enumeration data types. If the compiler switch {$scopedEnums …} was on during definition of a enumeration type, you have to precede any values of that enumeration type with the data type’s name and a dot (in the example above this means logLevel.).

This is useful if names are likely to clash with other identifiers, for example sysUtils.tUseBoolStrs is defined in that way (with {$scopedEnums on}), or if isolate identifiers would be meaningless or confusing like in objPas.tEndian. Usage introduces some incompatibility to other compilers though.


The size an enumeration type occupies depends on

  1. the minimum enumeration size compiler configuration, and
  2. the range, that is ord(high(enumeration)) - ord(low(enumeration)).

The local compiler directive {$minEnumSize n} determines the minimum size in Bytes of an enumeration data type. {$minEnumSize n} is (for Delphi compatibility) an alias for {$packEnum n}/{$Z}.

  • {$minEnumSize 1}, {$packEnum 1}, {$Z1} or {$Z‑}instruct the compiler to use just at least one Byte for the enumeration type in question.
  • {$minEnumSize 2}, {$packEnum 2} and {$Z2}: 2 Bytes minimum.
  • {$minEnumSize 4}, {$packEnum 4}, {$Z4} or {$Z+}: use at least 4 Bytes.

Furthermore, {$minEnumSize normal}, {$minEnumSize default} and {$minEnumSize 0} restore the default value. In {$mode TP} the default value is 1 whereas in all other modes it is 4. Such a “large” minimum size aides quick read/write access.

It stands to reason that an enumeration data type has to occupy at least as much space as all discrete values require to be stored. If less or equal to 28 (256) elements have to be storable, the compiler may store a variable of this kind as a single Byte. A range of 216 elements will be stored in two Bytes if not in one Byte suffices. More than 216 members are stored in four Bytes. These rules may, of course, be superseded by the previously mentioned {$minEnumSize} setting.


Out-of-box functionality

The standard functions pred and succ will return the predecessor and successor of a value. Note that range checks may trigger run-time errors.

The pre-defined data type Boolean is an enumeration data type.

The functions low and high will give the lowest or highest available named item of an enumeration data type.


Enumeration data types are particularly useful for implementing “masks”: By defining a set of  you have a neat data type fulfilling certain nice properties.

Comparative remarks

In some programming languages enumeration type definitions become “synonyms” to certain integer values. In Pascal, however, this is not the case. You may not mix a symbol referring to a member of an enumeration with other integer values. You will have to utilize ord or an explicit typecast to the enumeration data type.

See also