The GNU Modula-2 front end to GCC
 |
 |
|
|
DEFINITION MODULE SYSTEM ;
EXPORT QUALIFIED BITSPERBYTE, BYTESPERWORD,
LOC, WORD, BYTE, ADDRESS, INTEGER8,
INTEGER16, INTEGER32, INTEGER64, CARDINAL8,
CARDINAL16, CARDINAL32, CARDINAL64, WORD16,
WORD32, WORD64, BITSET8, BITSET16,
BITSET32, REAL32, REAL64, REAL128,
COMPLEX32, COMPLEX64, COMPLEX128, CSIZE_T,
CSSIZE_T,
ADR, TSIZE, ROTATE, SHIFT, THROW, TBITSIZE ;
(* SIZE is also exported if -fpim2 is used *)
CONST
BITSPERBYTE = __ATTRIBUTE__ __BUILTIN__ ((BITS_PER_UNIT)) ;
BYTESPERWORD = __ATTRIBUTE__ __BUILTIN__ ((UNITS_PER_WORD)) ;
(* all the following types are declared internally to gm2
TYPE
LOC ;
WORD ;
BYTE ;
ADDRESS ;
INTEGER8 ;
INTEGER16 ;
INTEGER32 ;
INTEGER64 ;
CARDINAL8 ;
CARDINAL16 ;
CARDINAL32 ;
CARDINAL64 ;
WORD16 ;
WORD32 ;
WORD64 ;
BITSET8 ;
BITSET16 ;
BITSET32 ;
REAL32 ;
REAL64 ;
REAL128 ;
COMPLEX32 ;
COMPLEX64 ;
COMPLEX128 ;
CSIZE_T ;
CSSIZE_T ;
*)
(*
all the functions below are declared internally to gm2
====================================================
PROCEDURE ADR (VAR v: <anytype>): ADDRESS;
(* Returns the address of variable v. *)
PROCEDURE SIZE (v: <type>) : ZType;
(* Returns the number of BYTES used to store a v of
any specified <type>. Only available if -fpim2 is used.
*)
PROCEDURE TSIZE (<type>) : CARDINAL;
(* Returns the number of BYTES used to store a value of the
specified <type>.
*)
PROCEDURE ROTATE (val: <a set type>;
num: INTEGER): <type of first parameter>;
(* Returns a bit sequence obtained from val by rotating up/right
or down/right by the absolute value of num. The direction is
down/right if the sign of num is negative, otherwise the direction
is up/left.
*)
PROCEDURE SHIFT (val: <a set type>;
num: INTEGER): <type of first parameter>;
(* Returns a bit sequence obtained from val by shifting up/left
or down/right by the absolute value of num, introducing
zeros as necessary. The direction is down/right if the sign of
num is negative, otherwise the direction is up/left.
*)
PROCEDURE THROW (i: INTEGER) ;
(*
THROW is a GNU extension and was not part of the PIM or ISO
standards. It throws an exception which will be caught by the EXCEPT
block (assuming it exists). This is a compiler builtin function which
interfaces to the GCC exception handling runtime system.
GCC uses the term throw, hence the naming distinction between
the GCC builtin and the Modula-2 runtime library procedure Raise.
The later library procedure Raise will call SYSTEM.THROW after
performing various housekeeping activities.
*)
PROCEDURE TBITSIZE (<type>) : CARDINAL ;
(* Returns the minimum number of bits necessary to represent
<type>. This procedure function is only useful for determining
the number of bits used for any type field within a packed RECORD.
It is not particularly useful elsewhere since <type> might be
optimized for speed, for example a BOOLEAN could occupy a WORD.
*)
*)
(* The following procedures are invoked by GNU Modula-2 to
shift non word sized set types. They are not strictly part
of the core PIM Modula-2, however they are used by
GNU Modula-2 to implement the SHIFT procedure defined above,
which are in turn used by the Logitech compatible libraries.
Users will access these procedures by using the procedure
SHIFT above and GNU Modula-2 will map SHIFT onto one of
the following procedures.
*)
(*
ShiftVal - is a runtime procedure whose job is to implement
the SHIFT procedure of ISO SYSTEM. GNU Modula-2 will
inline a SHIFT of a single WORD sized set and will only
call this routine for larger sets.
*)
PROCEDURE ShiftVal (VAR s, d: ARRAY OF BITSET;
SetSizeInBits: CARDINAL;
ShiftCount: INTEGER) ;
(*
ShiftLeft - performs the shift left for a multi word set.
This procedure might be called by the back end of
GNU Modula-2 depending whether amount is known at compile
time.
*)
PROCEDURE ShiftLeft (VAR s, d: ARRAY OF BITSET;
SetSizeInBits: CARDINAL;
ShiftCount: CARDINAL) ;
(*
ShiftRight - performs the shift left for a multi word set.
This procedure might be called by the back end of
GNU Modula-2 depending whether amount is known at compile
time.
*)
PROCEDURE ShiftRight (VAR s, d: ARRAY OF BITSET;
SetSizeInBits: CARDINAL;
ShiftCount: CARDINAL) ;
(*
RotateVal - is a runtime procedure whose job is to implement
the ROTATE procedure of ISO SYSTEM. GNU Modula-2 will
inline a ROTATE of a single WORD (or less)
sized set and will only call this routine for larger sets.
*)
PROCEDURE RotateVal (VAR s, d: ARRAY OF BITSET;
SetSizeInBits: CARDINAL;
RotateCount: INTEGER) ;
(*
RotateLeft - performs the rotate left for a multi word set.
This procedure might be called by the back end of
GNU Modula-2 depending whether amount is known at compile
time.
*)
PROCEDURE RotateLeft (VAR s, d: ARRAY OF BITSET;
SetSizeInBits: CARDINAL;
RotateCount: CARDINAL) ;
(*
RotateRight - performs the rotate right for a multi word set.
This procedure might be called by the back end of
GNU Modula-2 depending whether amount is known at compile
time.
*)
PROCEDURE RotateRight (VAR s, d: ARRAY OF BITSET;
SetSizeInBits: CARDINAL;
RotateCount: CARDINAL) ;
END SYSTEM.
The different dialects of Modula-2 PIM-[234] and ISO Modula-2 declare the function SIZE in different places. PIM-[34] and ISO Modula-2 declare SIZE as a pervasive function (declared in the base module). PIM-2 defined SIZE in the SYSTEM module (as shown above).
GNU Modula-2 allows users to specify the dialect of Modula-2 by using the -fiso and -fpim2 command line switches.
The data types CSIZE_T and CSSIZE_T are also exported from the SYSTEM module. The type CSIZE_T is unsigned and is mapped onto the target C data type size_t whereas the type CSSIZE_T is mapped onto the signed C data type ssize_t.
It is anticipated that these should only be used to provide cross platform definition modules for C libraries.
There are also a variety of fixed sized INTEGER and CARDINAL types. The variety of the fixed sized types will depend upon the target architecture.