C.6 Code generator messages

This section lists all messages that can be displayed if the code generator encounters an error condition.

Error 6009: Parameter list size exceeds 65535 bytes

The I386 processor limits the parameter list to 65535 bytes. (The RET instruction causes this.)

Error 6012: File types must be var parameters

You cannot specify files as value parameters, i.e., they must always be declared var parameters.

Error 6013: The use of a far pointer isn’t allowed there

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];  
 

Error 6015: EXPORT declared functions cannot be called

No longer in use.

Warning 6016: Possible illegal call of constructor or destructor

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.

Note 6017: Inefficient code

Your statement seems dubious to the compiler.

Warning 6018: Unreachable code

You specified a construct which will never be executed. Example:

 while false do  
   begin  
   {.. code ...}  
   end;  
 

Error 6020: Abstract methods cannot be called directly

You cannot call an abstract method directly. Instead, you must call an overriding child method, because an abstract method isn’t implemented.

Register 〈arg. 1〉 weight 〈arg. 2〉 〈arg. 3〉

Debugging message. Shown when the compiler considers a variable for keeping in the registers.

Stack frame is omitted

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.

Error 6031: Object or class methods cannot be inline.

You cannot have inlined object methods.

Error 6032: Procvar calls cannot be inline.

A procedure with a procedural variable call cannot be inlined.

Error 6033: No code for inline procedure stored

The compiler couldn’t store code for the inline procedure.

Error 6035: Element zero of an ansi/wide- or longstring cannot be accessed, use (set)length instead

You should use setlength to set the length of an ansi/wide/longstring and length to get the length of such string type.

Error 6037: Constructors or destructors cannot be called inside a ’with’ clause

Inside a with clause you cannot call a constructor or destructor for the object you have in the with clause.

Error 6038: Cannot call message handler methods directly

A message method handler method cannot be called directly if it contains an explicit Self argument.

Error 6039: Jump in or outside of an exception block

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:  
 ...  
 

Error 6040: Control flow statements are not allowed in a finally block

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.

Warning 6041: Parameters size exceeds limit for certain cpu’s

This indicates that you are declaring more than 64K of parameters, which might not be supported on other processor targets.

Warning 6042: Local variable size exceed limit for certain cpu’s

This indicates that you are declaring more than 32K of local variables, which might not be supported on other processor targets.

Error 6043: Local variables size exceeds supported limit

This indicates that you are declaring more than 32K of local variables, which is not supported by this processor.

Error 6044: BREAK not allowed

You’re trying to use break outside a loop construction.

Error 6045: CONTINUE not allowed

You’re trying to use continue outside a loop construction.

Fatal error 6046: Unknown compilerproc ”〈arg. 1〉”. Check if you use the correct run time library.

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.

Fatal error 6047: Cannot find system type ”〈arg. 1〉”. Check if you use the correct run time library.

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.

Hint 6048: Inherited call to abstract method ignored

This message appears only in Delphi mode when you call an abstract method of a parent class via inherited;. The call is then ignored.

Error 6049: Goto label ”〈arg. 1〉” not defined or optimized away

The label used in the goto definition is not defined or optimized away by the unreachable code elemination.

Fatal error 6050: Cannot find type ”〈arg. 1〉” in unit ”〈arg. 2〉”. Check if you use the correct run time library.

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.

Error 6051: Interprocedural gotos are allowed only to outer subroutines

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

Error 6052: Label must be defined in the same scope as it is declared

In ISO mode, labels must be defined in the same scope as they are declared.

Error 6053: Leaving procedures containing explicit or implicit exceptions frames using goto is not allowed

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.

Error 6054: In ISO mode, the mod operator is defined only for positive quotient

In ISO pascal, only positive values are allowed for the quotient: n mod m is only valid if m>0.

Auto inlining: 〈arg. 1〉

Due to auto inlining turned on, the compiler auto inlines this subroutine.

Error 6056: The function used, is not supported by the selected instruction set: 〈arg. 1〉

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

Fatal error 6057: Maximum number of units (〈arg. 1〉) reached for the current target

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.

Note 6058: Call to subroutine ”〈arg. 1〉” marked as inline is not inlined

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.

Error 6059: Case statement does not handle ordinal value ”〈arg. 1〉”, and no else/otherwise statement is present.

Warning 6060: Case statement does not handle all possible cases

The case statement does not contain labels for all possible values of the operand, and no else statement is present.

Warning 6061: The current subroutine ”〈arg. 1〉” cannot be compiled for the target CPU, creating dummy

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.

Warning 6062: The target CPU does not support preserving the registers in subroutine ”〈arg. 1〉”

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.