An error against the Turbo Pascal language was encountered. This typically happens when an illegal character is found in the source file.
An INTERRUPT procedure must be global.
The specified procedure directive is ignored by FPC programs.
When you want to use overloading using the OVERLOAD directive, then all declarations need to have OVERLOAD specified.
Exported function names inside a specific DLL must all be different.
Exported function indexes inside a specific DLL must all be different.
DLL function index must be in the range 1..$FFFF.
It is currently not possible to include debug information in a relocatable DLL.
Stabs debug info is wrong for relocatable DLL or EXES. Use -WN if you want to debug win32 executables.
You are declaring an object constructor with a name which is not init, and the -Ss switch is in effect. See the switch -Ss (see page 123).
You are declaring an object destructor with a name which is not done, and the -Ss switch is in effect. See the switch -Ss (see page 123).
You tried to compile a program with C++ style inlining, and forgot to specify the -Si option (-Si (see page 122)). The compiler doesn’t support C++ styled inlining by default.
Constructors must be in the ’public’ part of an object (class) declaration.
Destructors must be in the ’public’ part of an object (class) declaration.
You can declare only one destructor for a class.
Classes must be defined globally. They cannot be defined inside a procedure or function.
An invalid object (class) declaration was encountered, i.e. an object or class without methods that isn’t derived from another object or class. For example:
Type o = object
a : longint;
end;
a : longint;
end;
will trigger this error.
This is a note indicating that the declared object has no virtual method table.
You are calling a function with parameters that are of a different type than the declared parameters of the function.
There is an error in the parameter list of the function or procedure – the number of parameters is not correct.
The compiler encountered a symbol with the same name as an overloaded function, but it is not a function it can overload.
You’re declaring overloaded functions, but with the same parameter list. Overloaded function must have at least 1 different parameter in their declaration.
You declared a function with the same parameters but different result type or function modifiers.
You declared the function in the interface part, or with the forward directive, but defined it with a different parameter list.
Free Pascal allows enumeration constructions as in C. Examine the following two declarations:
type a = (A_A,A_B,A_E:=6,A_UAS:=200);
type a = (A_A,A_B,A_E:=6,A_UAS:=4);
type a = (A_A,A_B,A_E:=6,A_UAS:=4);
The second declaration would produce an error. A_UAS needs to have a value higher than A_E, i.e. at least 7.
With stores a variable locally on the stack, but this is not possible if the variable belongs to another segment.
You can nest function definitions only 31 levels deep.
The constants are out of their allowed range.
The constants are out of their allowed range.
You are specifying the same label 2 times in a case statement.
The upper bound of a case label is less than the lower bound and this is useless.
You cannot declare a constant of type class or object.
You are trying to assign an overloaded function to a procedural variable. This is not allowed.
The length of a shortstring in Pascal is limited to 255 characters. You are trying to declare a string with length less than 1 or greater than 255.
If you have a pointer a to an object type, then the statement new(a) will not initialize the object (i.e. the constructor isn’t called), although space will be allocated. You should issue the new(a,init) statement. This will allocate space, and call the constructor of the object.
You cannot use new(p) or dispose(p) if p is an untyped pointer because no size is associated to an untyped pointer. It is accepted for compatibility in TP and DELPHI modes, but the compiler will still warn you if it finds such a construct.
This happens when the compiler scans a procedure declaration that contains a dot, i.e., an object or class method, but the type in front of the dot is not a known type.
You cannot use a type inside an expression.
This identifier is not a method. This happens when the compiler scans a procedure declaration that contains a dot, i.e., an object or class method, but the procedure name is not a procedure of this type.
This identifier is not a method. This happens when the compiler scans a procedure declaration that contains a dot, i.e., an object or class method, but the procedure name is not a procedure of this type.
When using the -vd switch, the compiler tells you when it starts processing a procedure or function implementation.
The compiler expects a floating point expression, and gets something else.
You are using the fail keyword outside a constructor method.
You are declaring a destructor with a parameter list. Destructor methods cannot have parameters.
This error occurs in a situation like the following:
Type :
Tclass = Class of Tobject;
Var C : TClass;
begin
...
C.free
Tclass = Class of Tobject;
Var C : TClass;
begin
...
C.free
Free is not a class method and hence cannot be called with a class reference.
This is related to the previous error. You cannot call a method of an object from inside a class method. The following code would produce this error:
class procedure tobject.x;
begin
free
begin
free
Because free is a normal method of a class it cannot be called from a class method.
One of the labels is not of the same type as the case variable.
You can only export procedures and functions when you write a library. You cannot export variables or constants.
A method that is declared virtual in a parent class, should be overridden in the descendant class with the override directive. If you don’t specify the override directive, you will hide the parent method; you will not override it.
You are trying to override a virtual method of a parent class that does not exist.
You specified no read directive for a property.
This message is no longer used, as the stored directive has been implemented.
There is an error in the read or write directives for an array property. When you declare an array property, you can only access it with procedures and functions. The following code would cause such an error.
tmyobject = class
i : integer;
property x [i : integer]: integer read I write i;
i : integer;
property x [i : integer]: integer read I write i;
Fields that are declared in a protected section of an object or class declaration cannot be accessed outside the module where the object is defined, or outside descendent object methods.
Fields that are declared in a private section of an object or class declaration cannot be accessed outside the module where the class is defined.
If you declare overridden methods in a class definition, they must have the same return type.
You cannot declare a function or procedure within a function or procedure that was declared as an export procedure.
You cannot declare a procedure that is a method for an object as exported.
When calling a function declared with var parameters, the variables in the function call must be of exactly the same type. There is no automatic type conversion.
When calling inherited methods, you are trying to call a method of a non-related class. You can only call an inherited method of a parent class.
You are trying to use the self parameter outside an object’s method. Only methods get passed the self parameters.
A construction like sometype.somemethod is only allowed in a method.
You are using the format : (colon) 2 times on an expression that is not a real expression.
The declaration of a set contains an error. Either one of the elements is outside the range of the set type, or two of the elements are in fact the same.
You specified an illegal type in a new statement. The extended syntax of new needs an object as a parameter.
When using the extended syntax of new, you must specify the constructor method of the object you are trying to create. The procedure you specified is not a constructor.
When using the extended syntax of dispose, you must specify the destructor method of the object you are trying to dispose of. The procedure you specified is not a destructor.
When declaring a constant record, you specified the fields in the wrong order.
A with statement needs an argument that is of the type record or class. You are using with on an expression that is not of this type.
In Free Pascal, you can specify a return value for a function when using the exit statement. This error occurs when you try to do this with a procedure. Procedures cannot return a value.
You’re declaring a procedure as destructor, constructor or class operator, when the procedure isn’t a class method.
You’re trying to use an overloaded operator when it is not overloaded for this type.
You cannot overload assignment for types that the compiler considers as equal.
The combination of operator, arguments and return type are incompatible.
You are trying to re-raise an exception where it is not allowed. You can only re-raise exceptions in an except block.
You cannot generate an instance of a class with the extended syntax of new. The constructor must be used for that. For the same reason, you cannot call dispose to de-allocate an instance of a class, the destructor must be used for that.
When using the -So switch, procedure overloading is switched off. Turbo Pascal does not support function overloading.
You are trying to overload an operator which cannot be overloaded. The following operators can be overloaded :
+, -, *, /, =, >, <, <=, >=, is, as, in, **, :=
When overloading the = operator, the function must return a boolean value.
You are declaring a method as abstract, when it is not declared to be virtual.
You’re trying to force the compiler into doing something it cannot do yet.
You cannot derive objects, classes, cppclasses and interfaces intertwined. E.g. a class cannot have an object as parent and vice versa.
The procedure directive you specified is unknown.
You cannot specify more than one variable before the absolute, export, external, weakexternal, public and cvar directives. As a result, for example the following construct will provide this error:
Var Z : Longint;
X,Y : Longint absolute Z;
X,Y : Longint absolute Z;
The address of an absolute directive can only point to a variable or constant. Therefore, the following code will produce this error:
Procedure X;
var p : longint absolute x;
var p : longint absolute x;
You cannot specify more than one variable with a initial value in Delphi mode.
Abstract methods can only be declared, you cannot implement them. They should be overridden by a descendant class.
You are defining an overloaded function in the implementation part of a unit, but there is no corresponding declaration in the interface part of the unit.
If you declare objects or classes that contain virtual methods, you need to have a constructor and destructor to initialize them. The compiler encountered an object or class with virtual methods that doesn’t have a constructor/destructor pair.
When -vc is used, the compiler tells you when it defines macros.
When -vc is used, the compiler tells you when it undefines macros.
When -vc is used, the compiler tells you what values macros get.
When you turn on information messages (-vi), the compiler tells you what units it is recompiling.
This tells you that the reading of the interface of the current unit has started
This tells you that the code reading of the implementation of the current unit, library or program starts
When you request debug messages (-vd) the compiler tells you what units it recompiles for the second time.
You want to override a property of a parent class, when there is, in fact, no such property in the parent class.
You specified a property as Default, but the class already has a default property, and a class can have only one default property.
Only array properties of classes can be made default properties.
You cannot have virtual constructors in objects. You can only have them in classes.
You are trying to access a default property of a class, but this class (or one of its ancestors) doesn’t have a default property.
If you want a published section in a class definition, you must use the {$M+} switch, which turns on generation of type information.
To be able to use an object as an ancestor object, it must be defined first. This error occurs in the following situation:
Type ParentClas = Class;
ChildClass = Class(ParentClass)
...
end;
ChildClass = Class(ParentClass)
...
end;
where ParentClass is declared but not defined.
You cannot overload locally, i.e. inside procedures or function definitions.
This procedure directive is not allowed in the interface section of a unit. You can only use it in the implementation section.
This procedure directive is not allowed in the implementation section of a unit. You can only use it in the interface section.
This procedure directive cannot be part of a procedural or function type declaration.
You will get this error if a function is defined as forward twice. Or if it occurs in the interface section, and again as a forward declaration in the implementation section.
These two procedure directives are mutually exclusive.
Inline procedures don’t support this declaration.
Inlining of procedures is disabled.
When information messages are on, the compiler warns you when it writes the browser log (generated with the {$Y+ } switch).
The compiler thinks that a pointer may need a dereference.
The selected assembler reader (with {$ASMMODE xxx} is not supported. The compiler can be compiled with or without support for a particular assembler reader.
You specified a procedure directive that conflicts with other directives. For instance cdecl and pascal are mutually exclusive.
This error happens when you declare a function or procedure with e.g. cdecl; but omit this directive in the implementation, or vice versa. The calling convention is part of the function declaration, and must be repeated in the function definition.
Set properties or indexed properties cannot have a default value.
The value of a default declared property must be known at compile time. The value you specified is only known at run time. This happens e.g. if you specify a variable name as a default value.
Only class type variables can be in a published section of a class if they are not declared as a property.
Properties in a published section cannot be array properties. They must be moved to public sections. Properties in a published section must be an ordinal type, a real type, strings or sets.
Some targets need a name for the imported procedure or a cdecl specifier.
A division by zero was encountered.
An operation on two real type values produced an overflow or a division by zero.
The upper bound of an array declaration is less than the lower bound and this is not possible.
The size of the constant string is larger than the size you specified in string type definition.
The size of the constant string is larger than the size you specified in the Array[x..y] of char definition.
Free Pascal supports only integer or string values as message constants.
A method declared with the message directive as message handler can take only one parameter which must be declared as call by reference. Parameters are declared as call by reference using the var-directive.
A label for a message is used twice in one object/class.
The Self parameter can only be passed explicitly to a method which is declared as message handler.
Threadvars must be static or global; you cannot declare a thread local to a procedure. Local variables are always local to a thread, because every thread has its own stack and local variables are stored on the stack.
You cannot use direct assembler when using a binary writer. Choose an other output format or use another assembler reader.
You are trying to load the ObjPas unit manually from a uses clause. This is not a good idea. Use the {$MODE OBJFPC} or {$mode delphi} directives which load the unit automatically.
Override is not supported for objects, use virtual instead to override a method of a parent object.
Some data types (e.g. ansistring) need initialization/finalization code which is implicitly generated by the compiler. Such data types cannot be used in the variant part of a record.
Resourcestring cannot be declared local, only global or using the static directive.
An exit statement with an argument for the return value cannot be used here. This can happen for example in try..except or try..finally blocks.
If you specify a storage symbol in a property declaration, it must be a boolean type.
You cannot use this type of symbol as storage specifier in property declaration. You can use only methods with the result type boolean, boolean class fields or boolean constants.
A class-typed field in the published section of a class can only be a class which was compiled in {$M+} or which is derived from such a class. Normally such a class should be derived from TPersistent.
This error is triggered when you have a {$Calling} directive without a calling convention specified. It also happens when declaring a procedure in a const block and you used a ; after a procedure declaration which must be followed by a procedure directive. Correct declarations are:
const
p : procedure;stdcall=nil;
p : procedure stdcall=nil;
p : procedure;stdcall=nil;
p : procedure stdcall=nil;
The value you use to index a property must be of an ordinal type, for example an integer or enumerated type.
The length of the procedure/function name must be at least 2 characters long. This is because of a bug in dlltool which doesn’t parse the .def file correctly with a name of length 1.
You need to compile this file without the -WD switch on the command line.
You need to use {$MODE OBJFPC} or {$MODE DELPHI} to compile this file. Or use the corresponding command line switch, either -Mobjfpc or -MDelphi.
Exporting of functions or procedures with a specified index is not supported on this target.
Exporting of variables is not supported on this target.
The GUID indication does not have the proper syntax. It should be of the form
{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
Where each X represents a hexadecimal digit.
The compiler cannot find a suitable procedure which implements the given method of an interface. A procedure with the same name is found, but the arguments do not match.
This happens when the compiler scans a class declaration that contains interface function name mapping code like this:
type
TMyObject = class(TObject, IDispatch)
function IUnknown.QueryInterface=MyQueryInterface;
....
TMyObject = class(TObject, IDispatch)
function IUnknown.QueryInterface=MyQueryInterface;
....
and the interface before the dot is not listed in the inheritance list.
Types like qword or int64 are not allowed as array index type.
Constructor and destructor declarations are not allowed in interfaces. In the most cases method QueryInterface of IUnknown can be used to create a new interface.
The access specifiers public, private, protected and published cannot be used in interfaces, Objective-C protocols and categories because all methods of an interface/protocol/category must be public.
Declarations of fields are not allowed in interfaces, helpers and Objective-C protocols and categories. An interface/helper/protocol/category can contain only methods and properties with method read/write specifiers.
Declaring local procedures as external is not possible. Local procedures get hidden parameters that will make the chance of errors very high.
In Delphi mode, not all fields of a typed constant record have to be initialized, but the compiler warns you when it detects such situations.
In all syntax modes but Delphi mode, you cannot leave some fields uninitialized in the middle of a typed constant record.
You can leave some fields at the end of a type constant record uninitialized (The compiler will initialize them to zero automatically). This may be the cause of subtle problems.
The varargs directive (or the “...” varargs parameter in MacPas mode) can only be used with procedures or functions that are declared with external and one of cdecl, cppdecl, stdcall and mwpascal. This functionality is only supported to provide a compatible interface to C functions like printf.
You cannot declare Self as a const or var parameter, it must always be a call-by-value parameter.
When you want to assign an interface to a constant, then the interface must have a GUID value set.
Properties must refer to a field or method in the same class.
There are two directives in the procedure declaration that specify a calling convention. Only the last directive will be used.
You cannot assign the address of a method to a typed constant which has a ’procedure of object’ type, because such a constant requires two addresses: that of the method (which is known at compile time) and that of the object or class instance it operates on (which cannot be known at compile time).
It is not possible to specify a default value for several parameters at once. The following is invalid:
Procedure MyProcedure (A,B : Integer = 0);
Instead, this should be declared as
Procedure MyProcedure (A : Integer = 0; B : Integer = 0);
The specified parameter requires a default value.
You’re trying to force the compiler into doing something it cannot do yet.
Any array passed to a C function is passed by a pointer (i.e. by reference).
You cannot add any other argument after an array of const for cdecl functions, as the size pushed on stack for this argument is not known.
This is an indicator that a previously declared type is being redefined as something else. This may, or may not be, a potential source of errors.
Functions declared with the cdecl modifier do not pass an extra implicit parameter.
Openstring is not supported for functions that have the cdecl modifier.
Variables declared as threadvar cannot be initialized with a default value. The variables will always be filled with zero at the start of a new thread.
The message directive is only supported for Class types.
A class method can only be specified for procedures and functions.
Some calling conventions are supported only by certain CPUs. I.e. most non-i386 ports support only the standard ABI calling convention of the CPU.
reintroduce is not supported for objects, Objective-C classes and Objective-C protocols.
If locations for arguments are specified explicitly as it is required by some syscall conventions, each argument must have its own location. Things like
procedure p(i,j : longint 'r1');
are not allowed.
If one argument has an explicit argument location, all arguments of a procedure must have one.
Syscalls specific: the specified explicit location string for this parameter cannot be parsed, invalid, or The location specified for an argument isn’t recognized by the compiler.
The libbase for MorphOS/AmigaOS can be given only as longint, dword or any pointer variable.
It isn’t allowed to use goto statements referencing labels outside the current procedure. The following example shows the problem:
...
procedure p1;
label
l1;
procedure p2;
begin
goto l1; // This goto ISN'T allowed
end;
begin
p2
l1:
end;
...
procedure p1;
label
l1;
procedure p2;
begin
goto l1; // This goto ISN'T allowed
end;
begin
p2
l1:
end;
...
Your procedure body is too long for the compiler. You should split the procedure into multiple smaller procedures.
This can occur under many circumstances. Usually when trying to evaluate constant expressions.
You made an expression which isn’t an integer, and the compiler expects the result to be an integer.
One of the following is happening :
- You’re trying to access a field of a variable that is not a record.
- You’re indexing a variable that is not an array.
- You’re dereferencing a variable that is not a pointer.
You are declaring a subrange, and the high limit is less than the low limit of the range.
The parameter of a exit call in macpas mode must be either the name of the current subroutine or of a surrounding one
The type of a for loop variable must be an ordinal type. Loop variables cannot be reals or strings. You also cannot assign values to loop variables inside the loop (Except in Delphi and TP modes). Use a while or repeat loop instead if you need to do something like that, since those constructs were built for that.
Declaring local variables as external is not allowed. Only global variables can reference external variables.
The procedure is already declared with the EXTERNAL directive in an interface or forward declaration.
The Variant type is used in the unit without any used unit using the Variants unit. The compiler has implicitly added the Variants unit to the uses list. To remove this warning the Variants unit needs to be added to the uses statement.
The specifier class and directive static cannot be used in interfaces because all methods of an interface must be public.
An operation on two integer values produced an overflow.
strict can be only used together with protected or private.
slice can be used only for arguments accepting an open array parameter.
A DISPINTERFACE is a special type of interface which cannot have a parent class. Dispinterface always derive from IDispatch type.
A DISPINTERFACE always needs an interface identification (a GUID).
If you declare overridden methods in a class definition, they must have the same return type. Some versions of Delphi allow you to change the return type of interface methods, and even to change procedures into functions, but the resulting code may crash depending on the types used and the way the methods are called.
The dispid keyword must be followed by an ordinal constant (the dispid index).
Regardless of the size taken up by its elements, an array cannot have more than high(ptrint) elements. Additionally, the range type must be a subrange of ptrint.
If you declare an array or record as packed in Mac Pascal mode (or as packed in any mode with {$bitpacking on}), it will be packed at the bit level. This means it becomes impossible to take addresses of individual array elements or record fields. The only exception to this rule is in the case of packed arrays elements whose packed size is a multiple of 8 bits.
Only regular (and possibly in the future also open) arrays can be packed.
If you declare an array or record as packed in Mac Pascal mode (or as packed in any mode with {$bitpacking on}), it will be packed at the bit level. For performance reasons, they cannot be used as loop variables.
The usage of VAR, TYPE and CONST to declare new types inside an object is allowed only inside records, objects and classes.
Only Classes, Objects, Interfaces and Records are allowed to be used as generic.
Do not use the lineinfo unit directly, Use the -gl switch which automatically adds the correct unit for reading the selected type of debugging information. The unit that needs to be used depends on the type of debug information used when compiling the binary.
The first time you declare a function you have to declare it completely, including all parameters and the result type.
Types which are not generics cannot be specialized.
When specializing a generic, only non-generic types can be used as parameters.
If an object requires a VMT either because it contains a constructor or virtual methods, it’s not allowed to create constants of it. In TP and Delphi mode this is allowed for compatibility reasons.
It isn’t allowed to take the address of labels outside the current procedure.
Variables declared as external cannot be initialized with a default value.
Some types like file types cannot be used as function result.
To perform an operation on integers, the compiler converts both operands to their common type, which appears to be an invalid type. To determine the common type of the operands, the compiler takes the minimum of the minimal values of both types, and the maximum of the maximal values of both types. The common type is then minimum..maximum.
Generics must be always specialized before being used as variable type.
When using pure assembler routines, the list with modified registers is ignored.
A property which implements an interface must be of type class or interface.
A property which implements an interface actually implements a different interface.
A property which implements an interface must have at least a read specifier.
A property which implements an interface may not have a write specifier.
A property which implements an interface may not have a stored specifier.
The interface which is implemented by a property is not an interface implemented by the class.
The compiler parsed a floating point expression, but it is not supported.
The delegated interface is not implemented by the class given in the implements clause.
The implements keyword must be followed by an interface type.
On most targets it is not possible to change the name under which a variable is exported inside the exports statement of a library. In that case, you have to specify the export name at the point where the variable is declared, using the export and alias directives.
A ”weak external” symbol is a symbol which may or may not exist at (either static or dynamic) link time. This concept may not be available (or implemented yet) on the current cpu/OS target.
Classes and interfaces being defined forward must have the same type when being implemented. A forward interface cannot be changed into a class.
The virtual method overrides an method that is declared with a higher visibility. This might give unexpected results. E.g., in case the new visibility is private then a call to “inherited” in a new child class will call the higher-visible method in a parent class and ignores the private method.
Once a method or property has been defined in a class or object, you cannot define any fields afterwards without starting a new visibility section (such as public, private, etc.). The reason is that otherwise the source code can appear ambiguous to the compiler, since it is possible to use modifiers such as default and register also as field names.
In Pascal, types are not considered to be identical simply because they are semantically equivalent. Two variables or parameters are only considered to be of the same type if they refer to the same type definition. As a result, it is not allowed to define new types inside parameter lists, because then it is impossible to refer to the same type definition in the procedure headers of the interface and implementation of a unit (both procedure headers would define a separate type). Keep in mind that expressions such as “file of byte” or “string[50]” also define a new type.
ABSTRACT and SEALED cannot be used together in one declaration
Sealed means that class cannot be derived by another class.
Sealed means that class cannot be derived. Therefore no one class is able to override an abstract method in a sealed class.
You are declaring a method as final, when it is not declared to be virtual.
You are trying to override a virtual method of a parent class that does not exist.
It is not possible to associate multiple messages with a single method.
Only ”MoveNext” and ”Current” enumerator identifiers are supported.
”MoveNext” or ”Current” identifier must follow the enumerator modifier.
”MoveNext” enumerator pattern method must be a function with Boolean return type and no required arguments
”Current” enumerator pattern property must have a getter
Class or Object can have only one enumerator MoveNext declaration.
Class or Object can have only one enumerator Current declaration.
For in loop can be used not for all types. For example it cannot be used for the enumerations with jumps.
Objective-C messages require their Objective-C name (selector name) to be specified using the message ‘someName:’ procedure directive. While bindings to other languages automatically generate such names based on the identifier you use (by replacing all underscores with colons), this is unsafe since nothing prevents an Objective-C method name to contain actual colons.
The Objective-C language does not have any constructors or destructors. While there are some messages with a similar purpose (such as init and dealloc), these cannot be identified using automatic parsers and do not guarantee anything like Pascal constructors/destructors (e.g., you have to take care of only calling “designated” inherited “constructors”). For these reasons, we have opted to follow the standard Objective-C patterns for instance creation/destruction.
Due to compiler implementation reasons, message names are currently limited to 255 characters.
Due to compiler implementation reasons, mangled message names (i.e., the symbol names used in the assembler code) are currently limited to 255 characters.
If no parent class is specified for an Object Pascal class, then it automatically derives from TObject. Objective-C classes however do not automatically derive from NSObject, because one can have multiple root classes in Objective-C. For example, in the Cocoa framework both NSObject and NSProxy are root classes. Therefore, you have to explicitly define a parent class (such as NSObject) if you want to derive your Objective-C class from it.
In Object Pascal, “published” determines whether or not RTTI is generated. Since the Objective-C runtime always needs RTTI for everything, this specified does not make sense for Objective-C classes.
This error indicates the use of Objective-C language features without an Objective-C mode switch active. Enable one via the -M command line switch, or the $modeswitch x directive.
It is not possible to reintroduce methods in Objective-C or Java like in Object Pascal. Methods with the same name always map to the same virtual method entry. In order to make this clear in the source code, the compiler always requires the override directive to be specified when implementing overriding Objective-C or Java methods in Pascal. If the implementation is external, this rule is relaxed because Objective-C and Java do not have any override-style keyword (since it’s the default and only behaviour in these languages), which makes it hard for automated header conversion tools to include it everywhere. The type in which the inherited method is defined is explicitly mentioned, because this may either be an objcclass or an objccategory in case of Objective-C.
An overriding Objective-C method cannot have a different message name than an inherited method. The reason is that these message names uniquely define the message to the Objective-C runtime, which means that giving them a different message name breaks the “override” semantics.
Duplicating an Objective-C or Java type using type x = type y; is not yet supported. You may be able to obtain the desired effect using type x = objcclass(y) end; resp. type x = class(y) end; instead.
It is not possible to declare a variable as an instance of an Objective-C category or an Object Pascal class helper. A category/class helper adds methods to the scope of an existing class, but does not define a type by itself. An exception of this rule is when inheriting an Object Pascal class helper from another class helper.
A category replaces an existing method in an Objective-C class, rather than that it overrides it. Calling an inherited method from an category method will call that method in the extended class’ parent, not in the extended class itself. The replaced method in the original class is basically lost, and can no longer be called or referred to. This behaviour corresponds somewhat more closely to reintroduce than to override (although in case of reintroduce in Object Pascal, hidden methods are still reachable via inherited). The type in which the inherited method is defined is explicitly mentioned, because this may either be an objcclass or an objccategory.
Interface getters are called via a helper in the run time library, and hence have to use the default calling convention for the target (register on i386 and x86_64, stdcall on other architectures).
The data in a typed file cannot be of a reference counted type (such as ansistring or a record containing a field that is reference counted).
You are trying to use an overloaded operator when it is not overloaded for this type.
You are trying to use an overloaded operator when it is not overloaded for this type.
When declaring a typed constant array, you provided to few elements to initialize the array
Only when a piece of code is compiled with ansistrings enabled ({$H+}), string constants longer than 255 characters are allowed.
univ parameters are compatible with all values of the same size, but this cannot be checked in case a parameter’s size is unknown at compile time.
You are trying to declare more than one class constructor but only one class constructor can be declared.
You are trying to declare more than one class destructor but only one class destructor can be declared.
You are declaring a class constructor with a parameter list. Class constructor methods cannot have parameters.
You are declaring a class destructor with a parameter list. Class destructor methods cannot have parameters.
Objective-Pascal constructs are not supported when {$modeswitch ObjectiveC1} is not active.
It is not possible to use unicodechar and unicodestring constants in constant expressions that have to be converted into an ansistring or shortstring at compile time, for example inside typed constants. The reason is that the compiler cannot know what the actual ansi encoding will be at run time.
Objective-C “fast enumeration” support was added in Objective-C 2.0, and hence the appropriate modeswitch has to be activated to expose this feature. Note that Objective-C 2.0 programs require Mac OS X 10.5 or later.
Objective-C for-in loops (fast enumeration) require that the compiler can find a unit called CocoaAll that contains definitions for the NSFastEnumerationProtocol and NSFastEnumerationState types. If you get this error, most likely the compiler is finding and loading an alternate CocoaAll unit.
A nested procedural variable consists of two components: the address of the procedure/function to call (which is always known at compile time), and also a parent frame pointer (which is never known at compile time) in case the procedural variable contains a reference to a nested procedure/function. Therefore such typed constants can only be initialized with global functions/procedures since these do not require a parent frame pointer.
At the moment, scanner supports recording of only one token buffer at the time (guarded by internal error 200511173 in tscannerfile.startrecordtokens). Since generics are implemented by recording tokens, it is not possible to have declaration of a generic (type or method) inside another generic.
An Objective-C protocol or Java Interface must be fully defined before classes can conform to it. This error occurs in the following situation (example for Objective-C, but the same goes for Java interfaces):
Type MyProtocol = objcprotoocl;
ChildClass = Class(NSObject,MyProtocol)
...
end;
ChildClass = Class(NSObject,MyProtocol)
...
end;
where MyProtocol is declared but not defined.
Published sections can be used only inside classes.
Destructor declarations are not allowed in records or helpers.
Class methods declarations are not allowed in records without static modifier. Records have no inheritance and therefore non static class methods have no sense for them.
Constructor declarations with no arguments are not allowed in records or record/type helpers.
It is required that either the result of the routine or at least one of its parameters be of the specified type. For example class operators either take an instance of the structured type in which they are defined, or they return one.
Type parameters may be specialized with types which (e.g. ansistring) need initialization/finalization code which is implicitly generated by the compiler.
A section directive is not valid for variables being declared as external.
A variable placed in a custom section is always statically allocated so it must be either a static or global variable.
Some directives and specifiers like ”virtual”, ”dynamic”, ”override” are not allowed inside helper types in mode ObjFPC (they are ignored in mode Delphi), because they have no meaning within helpers. Also ”abstract” isn’t allowed in either mode.
Class constructor declarations are not allowed in helpers.
As records don’t support inheritance the use of ”inherited” is prohibited for these as well as for record helpers (in mode ”Delphi” only).
Records with types must be defined globally. Types cannot be defined inside records which are defined in a procedure or function or in anonymous records.
A class may delegate an interface using the ”implements” clause only to a single property. Delegating it multiple times is a error.
Method resolution clause maps a method of an interface to a method of the current class. Therefore the current class has to implement the interface directly. Delegation is not possible.
Method resolution is only possible for interfaces that are implemented directly, not by delegation.
When declaring a string with a given codepage, the range of valid codepages values is limited to 0 to 65535.
A final (class) field must be assigned a single value in the (class) constructor, and cannot be overwritten afterwards. A final (typed) constant is read-only.
Support for final fields in non-external classes requires a full data flow analysis implementation in FPC, which it currently still lacks.
Java interfaces define a namespace in which formal constant can be defined, but since they define no storage it is not possible to define typed constants in them (those are more or less the same as initialised class fields).
Java does not automatically add inherited constructors to child classes, so that they can be hidden. For compatibility with external Java code, FPC does the same. If you require access to the same constructors in a child class, define them in the child class and call the inherited one from there.
The compiler sometimes internally constructs Pascal code that is subsequently injected into the program. These messages display such code, in order to help with debugging errors in them.
Certain language features are not supported on targets that are managed virtual machines.
The JVM does not natively support virtual constructor. Unforunately, we are not aware of a way to emulate them in a way that makes it possible to support calling virtual constructors for the current instance inside another constructor.
The JVM does not allow lowering the visibility of an overriding method.
nostackframe call modifier is supposed to be used in conjunction with assembler.
nostackframe call modifier used without assembler modifier might still generate local stack needs.
Automatically generated getters/setters cannot have the same name as existing identifiers, because this may change the behaviour of existing code.
Automatically generated property getters/setters on the JVM platform are virtual methods, because the JVM does not support non-virtual methods that can be changed in child classes. This means that if a child class changes an inherited property definition, the behaviour of that property can change compared to native targets since even if a variable is declared as the parent type, by calling the virtual method the getter from the child will be used. This is different from the behaviour on native targets or when not activating automatically generated setters/getters, because in that case only the declared type of a variable influences the property behaviour.
If a property’s specified getter/setter already corresponded to the naming convention specified by the automatic getter/setter generation setting except in terms of upper/lowercase, the compiler will print a warning because it cannot necessarily change that other declaration itself not can it add one using the correct case (it could conflict with the original declaration). Manually correct the case of the getter/setter to conform to the desired coding rules. TChild overrides
Records with constants must be defined globally. Constants cannot be defined inside records which are defined in a procedure or function or in anonymous records.
Records with methods must be defined globally. Methods cannot be defined inside records which are defined in a procedure or function or in anonymous records.
Records with properties must be defined globally. Properties cannot be defined inside records which are defined in a procedure or function or in anonymous records.
Records with class members must be defined globally. Class members cannot be defined inside records which are defined in a procedure or function or in anonymous records.
The visibility sections (protected) and (strict protected) are only useful together with inheritance. Since records do not support that they are forbidden.
This directive is not allowed in the given context. E.g. ”static” is not allowed for instance methods or class operators.
The use of assembler blocks/routines is not allowed inside generics.
Properties cannot be declared local, only global, using the static directive or inside structured types.
Some platforms, such as the JVM platform, encode the parameters in the routine name in a prescribed way, and this encoding may map different Pascal types to the same encoded (a.k.a. “mangled”) name. This error can only be solved by removing or changing the conflicting definitions’ parameter declarations or routine names.
A default parameter value allows you to not specify a value for this parameter when calling the routine, and the compiler will instead pass the specified default (constant) value. As a result, default values can only be specified for parameters that can accept constant values.
The specified pointer type modifier is ignored, because it is not supported on the current platform. This happens, for example, when a far pointer is declared on a non-x86 platform.
A generic declared in the interface section of a unit must not reference symbols that belong solely to the implementation section of that unit.
This tells you that the recursive reading of the uses clauses triggered already a compilation of the current unit, so the current compilation can be aborted.
Methods introduced in a generic must be implemented for the generic. It is not possible to implement them only for specializations.
Generic methods are not allowed in interfaces, because there is no way to specialize a suitable implementation.
Generic methods can not be declared as virtual as there’d need to be a VMT entry for each specialization. This is however not possible with a static VMT.
Support for dynamic packages is not implemented for the specified target OS or it is at least not tested and thus disabled.
The HardFloat directive can only be used if an instruction set is used which supports floating point operations.
The index specified for the compilerproc directive is not an index that’s recognized by the compiler.
An operator overload is defined for the specified overload, but the internal overload by the compiler takes precedence. This only happens for operators that had been overloadable before (e.g. dynamic array + dynamic array), but aren’t anymore due to an internal operator being defined while this behavior is controllable by a modeswitch (in case of dynamic arrays that is the modeswitch ArrayOperators).
A threadvar section inside a class or record was started without it being prefixed by class.
This error occurs in a situation like the following:
Type
TObj = object
procedure test;
end;
begin
TObj.test;
TObj = object
procedure test;
end;
begin
TObj.test;
test is not a static method and hence cannot be called through a type, but only using an instance.
If a function is declared normally in the interface or as a forward declaration, and then later as external, the compiler must generate a stub that calls the external function. Due to code generation limitations, this cannot be done on some platforms. Even on platforms where it is supported, this is quite inefficient.
A custom attribute is defined, but there is no identifier to bind it to.
1 to 2
1-1 The size of enumeration values is limited to 4 bytes. As the value can be signed, the range of valid values is limited to a signed 32 Bit value (i.e. longint).
1 to 2
1-1 The size of enumeration values is limited to 4 bytes. As the value can be signed, the range of valid values is limited to a signed 32 Bit value (i.e. longint).
This error occurs if one tries to define a method for a type that is originally declared in a different unit.
At the current location specifying a constraint is not allowed. For example in delphi mode, a constraint might not be specified in the header of the implementation.
AmigaOS/MorphOS syscall specific: for int64/qword parameter only a single register location is specified
AmigaOS/MorphOS syscall specific: for a parameter which is smaller than 64bit, a register pair is specified
AmigaOS/MorphOS syscall specific: for 64bit register pairs, only data registers are supported
MorphOS syscall specific: only consecutive (f.e.: d1-d2) registers are supported for 64bit register pairs