This section lists all messages that can be displayed if the code generator encounters an error condition.
The I386 processor limits the parameter list to 65535 bytes. (The RET instruction causes
this.)
You cannot specify files as value parameters, i.e., they must always be declared var
parameters.
Free Pascal doesn’t support far pointers, so you cannot take the address of an expression
which has a far reference as a result. The mem construct has a far reference as a result, so the
following code will produce this error:
var p : pointer;
...
p:=@mem[a000:000];
The compiler detected that a constructor or destructor is called within a a method. This will
probably lead to problems, since constructors / destructors require parameters on entry.
You specified a construct which will never be executed. Example:
while false do
begin
{.. code ...}
end;
You cannot call an abstract method directly. Instead, you must call an overriding child
method, because an abstract method isn’t implemented.
Debugging message. Shown when the compiler considers a variable for keeping in the
registers.
Some procedure/functions do not need a complete stack-frame, so it is omitted. This message
will be displayed when the -vd switch is used.
A procedure with a procedural variable call cannot be inlined.
You should use setlength to set the length of an ansi/wide/longstring and length to get the
length of such string type.
Inside a with clause you cannot call a constructor or destructor for the object you have in
the with clause.
A message method handler method cannot be called directly if it contains an explicit Self
argument.
It is not allowed to jump in or outside of an exception block like try..finally..end;. For
example, the following code will produce this error:
label 1;
...
try
if not(final) then
goto 1; // this line will cause an error
finally
...
end;
1:
...
It isn’t allowed to use the control flow statements break, continue and exit inside a finally
statement. The following example shows the problem:
...
try
p;
finally
...
exit; // This exit ISN'T allowed
end;
...
If the procedure p raises an exception the finally block is executed. If the execution reaches the exit, it’s unclear what to do: exit the procedure or search for another exception handler.
This indicates that you are declaring more than 64K of parameters, which might not be
supported on other processor targets.
This indicates that you are declaring more than 32K of local variables, which might not be
supported on other processor targets.
This indicates that you are declaring more than 32K of local variables, which is not
supported by this processor.
The compiler expects that the runtime library contains certain subroutines. If you see this
error and you didn’t change the runtime library code, it’s very likely that the runtime library
you’re using doesn’t match the compiler in use. If you changed the runtime library this error
means that you removed a subroutine which the compiler needs for internal use.
The compiler expects that the runtime library contains certain type definitions. If you see
this error and you didn’t change the runtime library code, it’s very likely that the runtime
library you’re using doesn’t match the compiler in use. If you changed the runtime library
this error means that you removed a type which the compiler needs for internal use.
This message appears only in Delphi mode when you call an abstract method of a parent
class via inherited;. The call is then ignored.
The label used in the goto definition is not defined or optimized away by the unreachable
code elemination.
The compiler expects that the runtime library contains certain type definitions. If you see
this error and you didn’t change the runtime library code, it’s very likely that the runtime
library you’re using doesn’t match the compiler in use. If you changed the runtime library
this error means that you removed a type which the compiler needs for internal use.
Gotos between subroutines are only allowed if the goto jumps from an inner to an outer
subroutine or from a subroutine to the main program
In ISO mode, labels must be defined in the same scope as they are declared.
Non-local gotos might not be used to leave procedures using exceptions either implicitly or
explicitly. Procedures which use automated types like ansistrings or class constructurs are
affected by this too.
In ISO pascal, only positive values are allowed for the quotient: n mod m is only valid if m>0.
Due to auto inlining turned on, the compiler auto inlines this subroutine.
Some functions cannot be implemented efficiently for certain instruction sets, one example is
fused multiply/add. To avoid very inefficient code, the compiler complains in this case, so
either select another instruction set or replace the function call by alternative code
Depending of target architecture, the number of units is limited. This limit has
been reached. A unit counts only if it contains initialization or finalization count.
The directive inline is only a hint to the compiler. Sometimes the compiler ignores this hint, a
subroutine marked as inline is not inlined. In this case, this hint is given. Compiling
with -vd might result in more information why the directive inline is ignored.
The case statement does not contain labels for all possible values of the operand, and no else
statement is present.
Some processors have a very limited instruction set so some routines cannot be compiled for
them. As it is not always clear from the beginning if a subroutine can be compiled for a
certain CPU or not, the compiler checks afterwards and creates a dummy if it cannot compile
the subroutine.
Certain processors have no memory (e. g. avr1 family), so they do not support
storing/restoring the used registers in an interrupt routine. The programmer has to ensure
that while there is a chance for the interrupt routine being called that no other code
depending on registers being preserved is executed.