Difference between revisions of "Unit"
m (→See also: corrected old link, use http_s_) |
m (more syntax highlighting) |
||
Line 1: | Line 1: | ||
{{Unit}} | {{Unit}} | ||
− | A | + | A <syntaxhighlight lang="pascal" enclose="none">unit</syntaxhighlight> is a [[Source code|source code]] file (or the [[Binary|binary]] compiled from that [[File|file]]) which was written using the [[Pascal]] programming language, and that is designed to be a single module in an [[Application|application]] or an [[Object module|object module]]. |
== Aim == | == Aim == | ||
Line 10: | Line 10: | ||
Units were also used on older versions of Pascal when it was necessary on computers with limited resources to be able to load [[Routine|routines]] as needed rather than keeping every routine of the [[Executable program|executable program]] in memory all of the time. | Units were also used on older versions of Pascal when it was necessary on computers with limited resources to be able to load [[Routine|routines]] as needed rather than keeping every routine of the [[Executable program|executable program]] in memory all of the time. | ||
− | A unit that needs to access e. g. [[Procedure|procedures]] and [[Data type|data types]] in another unit must specify those units it needs to access in a [[Uses]] | + | A unit that needs to access e. g. [[Procedure|procedures]] and [[Data type|data types]] in another unit must specify those units it needs to access in a [[Uses|<syntaxhighlight lang="pascal" enclose="none">uses</syntaxhighlight> statement]] (but linking is done without the need to write a makefile as in C). |
− | A unit may also be used to declare a series of global [[Const|constants]] or [[ | + | A unit may also be used to declare a series of global [[Const|constants]] or [[Global variables|variables]] for use by the entire application, without actually containing any executable code. |
− | This is similar to the < | + | This is similar to the <syntaxhighlight lang="Fortran" enclose="none">common</syntaxhighlight> keyword in the Fortran programming language. |
== Format == | == Format == | ||
− | A unit is defined with the | + | A unit is defined with the <syntaxhighlight lang="pascal" enclose="none">unit</syntaxhighlight> keyword followed by the unit-identifier. |
The unit-identifier (in the following example the unit's name is “minimalunit”) should match the filename it is written in. | The unit-identifier (in the following example the unit's name is “minimalunit”) should match the filename it is written in. | ||
A minimal working example (which does nothing) is: | A minimal working example (which does nothing) is: | ||
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal"> |
unit minimalunit; | unit minimalunit; | ||
interface | interface | ||
− | + | // here comes stuff that the unit publicly offers | |
implementation | implementation | ||
− | + | // here comes the implementation of offered stuff and | |
− | + | // optionally internal stuff (only known in the unit) | |
end. | end. | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | where the part after | + | where the part after <syntaxhighlight lang="pascal" enclose="none">interface</syntaxhighlight> corresponds to the <syntaxhighlight lang="java" enclose="none">public</syntaxhighlight>-part of other languages and <syntaxhighlight lang="pascal" enclose="none">implementation</syntaxhighlight> does so to <syntaxhighlight lang="java" enclose="none">private</syntaxhighlight>. |
A more advanced basic structure is | A more advanced basic structure is | ||
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal"> |
unit advancedunit; | unit advancedunit; | ||
interface | interface | ||
Line 38: | Line 38: | ||
initialization | initialization | ||
− | + | // here may be placed code that is | |
− | + | // executed as the unit gets loaded | |
finalization | finalization | ||
− | + | // code executed at program end | |
end. | end. | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | The optional | + | The optional <syntaxhighlight lang="pascal" enclose="none">initialization</syntaxhighlight> and <syntaxhighlight lang="pascal" enclose="none">finalization</syntaxhighlight> blocks may be followed by code that is executed on program start/end. |
=== Detailed unit example === | === Detailed unit example === | ||
A step-by-step example: | A step-by-step example: | ||
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal"> |
unit randomunit; | unit randomunit; | ||
− | + | // this unit does something | |
− | + | // public - - - - - - - - - - - - - - - - - - - - - - - - - | |
interface | interface | ||
type | type | ||
− | + | // the type TRandomNumber gets globally known | |
− | + | // since it is included somewhere (uses-statement) | |
TRandomNumber = integer; | TRandomNumber = integer; | ||
− | + | // of course the const- and var-blocks are possible, too | |
− | + | // a list of procedure/function signatures makes | |
− | + | // them useable from outside of the unit | |
function getRandomNumber(): TRandomNumber; | function getRandomNumber(): TRandomNumber; | ||
− | + | // an implementation of a function/procedure | |
− | + | // must not be in the interface-part | |
− | + | // private - - - - - - - - - - - - - - - - - - - - - - - - - | |
implementation | implementation | ||
var | var | ||
− | + | // var in private-part | |
− | + | // => only modifiable inside from this unit | |
chosenRandomNumber: TRandomNumber; | chosenRandomNumber: TRandomNumber; | ||
function getRandomNumber(): TRandomNumber; | function getRandomNumber(): TRandomNumber; | ||
begin | begin | ||
− | + | // return value | |
getRandomNumber := chosenRandomNumber; | getRandomNumber := chosenRandomNumber; | ||
end; | end; | ||
− | + | // initialization is the part executed | |
− | + | // when the unit is loaded/included | |
initialization | initialization | ||
begin | begin | ||
− | + | // choose our random number | |
chosenRandomNumber := 3; | chosenRandomNumber := 3; | ||
− | + | // chosen by fair-dice-roll | |
− | + | // guaranteed to be random | |
end; | end; | ||
− | + | // finalization is worked off at program end | |
finalization | finalization | ||
begin | begin | ||
− | + | // this unit says 'bye' at program halt | |
writeln('bye'); | writeln('bye'); | ||
end; | end; | ||
end.</syntaxhighlight> | end.</syntaxhighlight> | ||
− | To include a unit just use the | + | To include a unit just use the <syntaxhighlight lang="pascal" enclose="none">uses</syntaxhighlight>-statement. |
− | <syntaxhighlight> | + | <syntaxhighlight lang="pascal" highlight="2-4"> |
program chooseNextCandidate; | program chooseNextCandidate; | ||
uses | uses | ||
− | + | // include a unit | |
randomunit; | randomunit; | ||
Line 114: | Line 114: | ||
end. | end. | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | When compiling, FPC checks this program for unit dependencies. It has to be able to find the unit "randomunit". | + | When compiling, FPC checks this program for unit dependencies. |
+ | It has to be able to find the unit "randomunit". | ||
− | The simplest way to satisfy this is to have a unit whose name matches the file name it is written in (appending .pas is OK and encouraged). | + | The simplest way to satisfy this is to have a unit whose name matches the file name it is written in (appending <tt>.pas</tt> is OK and encouraged). |
The unit file may be in the same directory where the program source is in or in the unit path FPC looks for units. | The unit file may be in the same directory where the program source is in or in the unit path FPC looks for units. | ||
== Unit precedence == | == Unit precedence == | ||
− | When multiple units are described in a use clause, conflicts can occur with identifiers (procedures, types, functions etc.) that have the same name in multiple units. In FreePascal, the last unit “wins” and provides the code for the unit. | + | When multiple units are described in a use clause, conflicts can occur with identifiers (procedures, types, functions etc.) that have the same name in multiple units. |
+ | In FreePascal, the last unit “wins” and provides the code for the unit. | ||
− | If you want to achieve a different behavior, you can explicitly prepend <tt>''unitname.''identifier</tt> to specify the unit you want to use, or reorder the units. The former is often the clearest option. | + | If you want to achieve a different behavior, you can explicitly prepend <tt>''unitname.''identifier</tt> to specify the unit you want to use, or reorder the units. |
+ | The former is often the clearest option. | ||
− | <syntaxhighlight lang=" | + | <syntaxhighlight lang="pascal">unit interestCalculations; |
interface | interface | ||
Line 136: | Line 139: | ||
end.</syntaxhighlight> | end.</syntaxhighlight> | ||
− | Specifying the unit of declaration explicitly:<syntaxhighlight lang="Pascal">program interestCalculator; | + | Specifying the unit of declaration explicitly: |
+ | <syntaxhighlight lang="Pascal">program interestCalculator; | ||
uses | uses | ||
Line 154: | Line 158: | ||
begin | begin | ||
− | end.</syntaxhighlight>Note, the <tt>interestCalculations</tt> unit will still perform its own calculations with its own <tt>basisType</tt> (here < | + | end.</syntaxhighlight> |
+ | Note, the <tt>interestCalculations</tt> unit will still perform its own calculations with its own <tt>basisType</tt> (here [[Currency|<syntaxhighlight lang="pascal" enclose="none">currency</syntaxhighlight>]]). | ||
+ | You can only alter (“shadow”) declarations in the current [[Scope|scope]] (and descending). | ||
== See also == | == See also == |
Revision as of 18:31, 11 February 2018
│
Deutsch (de) │
English (en) │
español (es) │
suomi (fi) │
français (fr) │
português (pt) │
русский (ru) │
A unit
is a source code file (or the binary compiled from that file) which was written using the Pascal programming language, and that is designed to be a single module in an application or an object module.
Aim
A unit may be used where functionality needs to be provided to an application program or to other units. It allows writing code that performs that functionality once and have it used in many places. This can reduce the possibility of errors and increase code reusage.
A binary unit may be used where a unit author wishes to provide certain functionality to be used in a Pascal program but does not wish to provide the source code that performs that functionality.
Units were also used on older versions of Pascal when it was necessary on computers with limited resources to be able to load routines as needed rather than keeping every routine of the executable program in memory all of the time.
A unit that needs to access e. g. procedures and data types in another unit must specify those units it needs to access in a uses
statement (but linking is done without the need to write a makefile as in C).
A unit may also be used to declare a series of global constants or variables for use by the entire application, without actually containing any executable code.
This is similar to the common
keyword in the Fortran programming language.
Format
A unit is defined with the unit
keyword followed by the unit-identifier.
The unit-identifier (in the following example the unit's name is “minimalunit”) should match the filename it is written in.
A minimal working example (which does nothing) is:
unit minimalunit;
interface
// here comes stuff that the unit publicly offers
implementation
// here comes the implementation of offered stuff and
// optionally internal stuff (only known in the unit)
end.
where the part after interface
corresponds to the public
-part of other languages and implementation
does so to private
.
A more advanced basic structure is
unit advancedunit;
interface
implementation
initialization
// here may be placed code that is
// executed as the unit gets loaded
finalization
// code executed at program end
end.
The optional initialization
and finalization
blocks may be followed by code that is executed on program start/end.
Detailed unit example
A step-by-step example:
unit randomunit;
// this unit does something
// public - - - - - - - - - - - - - - - - - - - - - - - - -
interface
type
// the type TRandomNumber gets globally known
// since it is included somewhere (uses-statement)
TRandomNumber = integer;
// of course the const- and var-blocks are possible, too
// a list of procedure/function signatures makes
// them useable from outside of the unit
function getRandomNumber(): TRandomNumber;
// an implementation of a function/procedure
// must not be in the interface-part
// private - - - - - - - - - - - - - - - - - - - - - - - - -
implementation
var
// var in private-part
// => only modifiable inside from this unit
chosenRandomNumber: TRandomNumber;
function getRandomNumber(): TRandomNumber;
begin
// return value
getRandomNumber := chosenRandomNumber;
end;
// initialization is the part executed
// when the unit is loaded/included
initialization
begin
// choose our random number
chosenRandomNumber := 3;
// chosen by fair-dice-roll
// guaranteed to be random
end;
// finalization is worked off at program end
finalization
begin
// this unit says 'bye' at program halt
writeln('bye');
end;
end.
To include a unit just use the uses
-statement.
program chooseNextCandidate;
uses
// include a unit
randomunit;
begin
writeln('next candidate: no. ' + getRandomNumber());
end.
When compiling, FPC checks this program for unit dependencies. It has to be able to find the unit "randomunit".
The simplest way to satisfy this is to have a unit whose name matches the file name it is written in (appending .pas is OK and encouraged). The unit file may be in the same directory where the program source is in or in the unit path FPC looks for units.
Unit precedence
When multiple units are described in a use clause, conflicts can occur with identifiers (procedures, types, functions etc.) that have the same name in multiple units. In FreePascal, the last unit “wins” and provides the code for the unit.
If you want to achieve a different behavior, you can explicitly prepend unitname.identifier to specify the unit you want to use, or reorder the units. The former is often the clearest option.
unit interestCalculations;
interface
type
basisType = currency;
implementation
end.
Specifying the unit of declaration explicitly:
program interestCalculator;
uses
interestCalculations;
type
// we already loaded a declaration of "basisType"
// from the interestCalculations unit, but we're
// re-declaring it here again ("shadowing")
basisType = extended;
var
// last declaration wins: originalCapital is an extended
originalCapital: basisType;
// specify a scope to use the declaration valid there
monthlyMargin: interestCalculations.basisType;
begin
end.
Note, the interestCalculations unit will still perform its own calculations with its own basisType (here currency
).
You can only alter (“shadow”) declarations in the current scope (and descending).
See also
- “Unit scope” in the “reference guide” (FPC HTML documentation)
- “Compiling a unit” in the “users's guide” (FPC HTML documentation)