Supported types

See also: the $INITIALIZE directive, EEPROM memory allocation, Records

PMP supports the following variable types (types after a | sign are aliases):

• BYTE | UINT8: unsigned byte. This is the most effective format in PMP.
• CHAR: unsigned byte (see below).
• SHORTINT | INT8: integer (8-bit, signed).
• WORD | UINT16: unsigned integer (16-bit, unsigned).
• INTEGER | INT16: integer (16-bit, signed).
• LONGINT | DINT | INT32: long integer (32-bit, signed).
• BIGINT | QINT | INT64: NEW! (V2.1) : big integer (64-bit, signed).
• LONGWORD | DWORD | UINT32: long word (32-bit, unsigned).
• BIGWORD | QWORD | UINT64: NEW! (V2.1) : big word (64-bit, unsigned).
• SINGLE: floating point value in the IEEE standard 32-bit (23 bits mantissa) format (see FP chapter).
• REAL: floating point value in the special PMP's proprietary format; it is 48-bit wide (6 bytes), with 32-bit mantissa (see FP chapter) (note 2).
• BOOLEAN: boolean, uses only one bit in memory.
• ARRAY OF BYTE | CHAR | SHORTINT | WORD | INTEGER | LONGINT | LONGWORD | SINGLE | REAL: one dimension array of simple type.
• ARRAY OF BOOLEAN: one dimension array of bits (not very efficient if indexed by a variable).
• STRING: variable length array of CHAR; the default length is 16 characters (see the $STRINGS directive) (note 1).
• STRING [n]: variable length array of CHAR, with n range is 0..255  (note 1).
• RECORD: set of simple-typed fields, with or without methods.
• POINTER: untyped pointer.
• Declared TYPE.
• SET OF <enumeration>. NEW! (V2.1): Enumeration is limited to 32 items.
• SFR: unsigned byte located at a processor special function register. SFRs are always treated as VOLATILE.

Note 1: Strings are always implemented as an array of bytes; the first byte at index 0 contains the effective length of the string, while next bytes contains the characters of the string.

Note 2: The standard IEEE 64-bit DOUBLE format is not supported.

NEW! (V2.1): In extended syntax mode, an initialized ARRAY variable may be declared without bounds, as for a constant array. The actual bounds will be 0..(<number-of-elements> - 1).

PMP is a single pass compiler. Variables must be declared prior to their use.

Variables declared within procedures or functions are local.

Variables declared in a unit interface section are global to other units and to the main program.

Variables declared in the main program are local to the main program.

By default variables without an explicit initial value are NOT initialized by PMP; this task is left to the programmer (see the CLR - Clear a variable built-in procedure). Nevertheless a special directive may be used to force variables initialization at startup, see the $INITIALIZE directive.

Some examples:

CONST
 AnArrayMax = 2;

VAR
 AnArray: ARRAY[-2 .. AnArrayMax] OF BYTE; { boundaries may be negative }
 {$SPACE EEPROM} // next in EEPROM
 EE_BYTE_1, EE_BYTE_2: BYTE;
 EE_BYTE_3: BYTE = 123; { EE simple variable with an initial value }
 EEArray: ARRAY[1 .. 2] OF BYTE = (100, 200); { EE arrays may have initial values }
 {$SPACE RAM} // next in RAM
 RAMArray1: ARRAY[1 .. 2] OF BYTE = (100, 200); { New in V2: RAM variables may have initial values }
 RAMArray2: ARRAY OF BYTE = (100, 200); { New in V2.1: RAM array variables with initial values may be declared without bounds }
 MyString: STRING; { defaults to 16 characters wide (see $STRINGS), so it uses 17 bytes }
 MyString2: STRING[4]; { 4 characters string, using 5 bytes. }
 EE_BYTE_4: EEPROM BYTE; { Single EE simple variable: the EEPROM keyword overrides the $SPACE RAM }

TYPE
 tMyRecord = RECORD
   X, Y: BYTE;
   B1, B2: BOOLEAN;
 END;

VAR
 MyRecord: tMyRecord;