13.8 Unit loading messages.

Unitsearch: arg1

When you use the -vt, the compiler tells you where it tries to nd unit les.

PPU Loading arg1

When the -vt switch is used, the compiler tells you what units it loads.

PPU Name: arg1

When you use the -vu ag, the unit name is shown.

PPU Flags: arg1

When you use the -vu ag, the unit ags are shown.

PPU Crc: arg1

When you use the -vu ag, the unit CRC check is shown.

PPU Time: arg1

When you use the -vu ag, the time the unit was compiled is shown.

PPU File too short

The ppule is too short, not all declarations are present.

PPU Invalid Header (no PPU at the begin)

A unit le contains as the rst three bytes the ascii codes of PPU

PPU Invalid Version arg1

This unit le was compiled with a dierent version of the compiler, and cannot be read.

PPU is compiled for another processor

This unit le was compiled for a dierent processor type, and cannot be read

PPU is compiled for an other target

This unit le was compiled for a dierent target, and cannot be read

PPU Source: arg1

When you use the -vu ag, the unit source le name is shown.

Writing arg1

When you specify the -vu switch, the compiler will tell you where it writes the unit le.

Fatal: Can't Write PPU-File

An error occurred when writing the unit le.

Fatal: Error reading PPU-File

This means that the unit le was corrupted, and contains invalid information. Recompilation will be necessary.

Fatal: unexpected end of PPU-File

Unexpected end of le. This may mean that the PPU le is corrupted.

Fatal: Invalid PPU-File entry: arg1

The unit the compiler is trying to read is corrupted, or generated with a newer version of the compiler.

Fatal: PPU Dbx count problem

There is an inconsistency in the debugging information of the unit.

Error: Illegal unit name: arg1

The name of the unit does not match the le name.

Fatal: Too much units

Free Pascal has a limit of 1024 units in a program. You can change this behavior by changing the maxunits constant in the fmodule.pas le of the compiler, and recompiling the compiler.

Fatal: Circular unit reference between arg1 and arg2

Two units are using each other in the interface part. This is only allowed in the implementation part. At least one unit must contain the other one in the implementation section.

Fatal: Can't compile unit arg1, no sources available

A unit was found that needs to be recompiled, but no sources are available.

Fatal: Can't nd unit arg1

You tried to use a unit of which the PPU le isn't found by the compiler. Check your conguration le for the unit paths

Warning: Unit arg1 was not found but arg2 exists

Fatal: Unit arg1 searched but arg2 found

Dos truncation of 8 letters for unit PPU les may lead to problems when unit name is longer than 8 letters.

Warning: Compiling the system unit requires the -Us switch

When recompiling the system unit (it needs special treatment), the -Us must be specied.

Fatal: There were arg1 errors compiling module, stopping

When the compiler encounters a fatal error or too many errors in a module then it stops with this message.

Load from arg1 (arg2) unit arg3

When you use the -vu ag, which unit is loaded from which unit is shown.

Recompiling arg1, checksum changed for arg2

Recompiling arg1, source found only

When you use the -vu ag, these messages tell you why the current unit is recompiled.

Recompiling unit, static lib is older than ppule

When you use the -vu ag, the compiler warns if the static library of the unit are older than the unit le itself.

Recompiling unit, shared lib is older than ppule

When you use the -vu ag, the compiler warns if the shared library of the unit are older than the unit le itself.

Recompiling unit, obj and asm are older than ppule

When you use the -vu ag, the compiler warns if the assembler or object le of the unit are older than the unit le itself.

Recompiling unit, obj is older than asm

When you use the -vu ag, the compiler warns if the assembler le of the unit is older than the object le of the unit.

Parsing interface of arg1

When you use the -vu ag, the compiler warns that it starts parsing the interface part of the unit

Parsing implementation of arg1

When you use the -vu ag, the compiler warns that it starts parsing the implementation part of the unit

Second load for unit arg1

When you use the -vu ag, the compiler warns that it starts recompiling a unit for the second time. This can happend with interdepend units.

PPU Check le arg1 time arg2

When you use the -vu ag, the compiler show the lename and date and time of the le which a recompile depends on

Warning: Can't recompile unit arg1, but found modifed include les

A unit was found to have modied include les, but some source les were not found, so recompilation is impossible.

Hint: File arg1 is newer than Release PPU le arg2

A modied source le for a unit was found that was compiled with the release ag (-Ur). The unit will not implicitly be recompiled because this release ag is set.

Using a unit which was not compiled with correct FPU mode

Trying to compile code while using units which were not compiled with the same oating point format mode. Either all code should be compiled with FPU emulation on, or with FPU emulation o.

Loading interface units from arg1

When you use the -vu ag, the compiler warns that it starts loading the units dened in the interface part of the unit.

Loading implementation units from arg1

When you use the -vu ag, the compiler warns that it starts loading the units dened in the implementation part of the unit.

Interface CRC changed for unit arg1

When you use the -vu ag, the compiler warns that it the CRC calculated for the interface has been changed after the implementation has been parsed.

Implementation CRC changed for unit arg1

When you use the -vu ag, the compiler warns that it the CRC calculated has been changed after the implementation has been parsed.

Finished compiling unit arg1

When you use the -vu ag, the compiler warns that it has nished compiling the unit.

Add dependency of arg1 to arg2

When you use the -vu ag, the compiler warns that it has added a dependency between the two units.

No reload, is caller: arg1

When you use the -vu ag, the compiler warns that it has will not reload the unit because it is the unit that wants to load this unit

No reload, already in second compile: arg1

When you use the -vu ag, the compiler warns that it has will not reload the unit because it is already in a second recompile

Flag for reload: arg1

When you use the -vu ag, the compiler warns that it has to reload the unit

Forced reloading

When you use the -vu ag, the compiler warns that it has is reloading the unit because it was required

Previous state of arg1: arg2

When you use the -vu ag, the compiler shows the previous state of the unit

Already compiling arg1, setting second compile

When you use the -vu ag, the compiler warns that it starts recompiling a unit for the second time. This can happend with interdepend units.

Loading unit arg1

When you use the -vu ag, the compiler warns that it starts loading the unit.

Finished loading unit arg1

When you use the -vu ag, the compiler warns that it nished loading the unit.

Registering new unit arg1

When you use the -vu ag, the compiler warns that it has found a new unit and registers it in the internal lists.

Re-resolving unit arg1

When you use the -vu ag, the compiler warns that it has to recalculate the internal data of the unit

Skipping re-resolving unit arg1, still loading used units

When you use the -vu ag, the compiler warns that it skips to recalculate the internal data of the unit because there is no data to recalculate