Subsections

- 1 General compiler messages
- 2 Scanner messages.
- 3 Parser messages
- 4 Type checking errors
- 5 Symbol handling
- 6 Code generator messages
- 7 Errors of assembling/linking stage
- 8 Unit loading messages.
- 9 Command-line handling errors
- 10 Assembler reader errors.
  - 1 General assembler errors
  - 2 I386 specific errors
  - 3 m68k specific errors.

#
C. Compiler messages

This appendix is meant to list all the compiler messages. The list of messages is generated from he compiler source itself, and should be faitly complete. At this point, only assembler errors are not in the list.

# 1 General compiler messages

This section gives the compiler messages which are not fatal, but which display useful information. The number of such messages can be controlled with the various verbosity level `-v` switches.

Compiler: arg1
  When the `-vt` switch is used, this line tells you what compiler is used.
Compiler OS: arg1
  When the `-vd` switch is used, this line tells you what the source operating system is.
Info: Target OS: arg1
  When the `-vd` switch is used, this line tells you what the target operating system is.
Using executable path: arg1
  When the `-vt` switch is used, this line tells you where the compiler looks for it's binaries.
Using unit path: arg1
  When the `-vt` switch is used, this line tells you where the compiler looks for compiled units. You can set this path with the `-Fu`
Using include path: arg1
  When the `-vt` switch is used, this line tells you where the compiler looks for it's include files (files used in `{$I xxx}` statements). You can set this path with the `-I` option.
Using library path: arg1
  When the `-vt` switch is used, this line tells you where the compiler looks for the libraries. You can set this path with the `-Fl` option.
Using object path: arg1
  When the `-vt` switch is used, this line tells you where the compiler looks for object files you link in (files used in `{$L xxx}` statements). You can set this path with the `-Fo` option.
Info: arg1 Lines compiled, arg2 sec
  When the `-vi` switch is used, the compiler reports the number of lines compiled, and the time it took to compile them (real time, not program time).
Fatal: No memory left
  The compiler doesn't have enough memory to compile your program. There are several remedies for this:
  - If you're using the build option of the compiler, try compiling the different units manually.
  - If you're compiling a huge program, split it up in units, and compile these separately.
  - If the previous two don't work, recompile the compiler with a bigger heap (you can use the `-Ch` option for this, See Ch)
Info: Writing Resource String Table file: arg1
  This message is shown when the compiler writes the Resource String Table file containing all the resource strings for a program.
Error: Writing Resource String Table file: arg1
  This message is shown when the compiler encountered an error when writing the Resource String Table file
Info: Fatal:
  Prefix for Fatal Errors
Info: Error:
  Prefix for Errors
Info: Warning:
  Prefix for Warnings
Info: Note:
  Prefix for Notes
Info: Hint:
  Prefix for Hints

# 2 Scanner messages.

This section lists the messages that the scanner emits. The scanner takes care of the lexical structure of the pascal file, i.e. it tries to find reserved words, strings, etc. It also takes care of directives and conditional compiling handling.

Fatal: Unexpected end of file
  this typically happens in one of the following cases :
  - The source file ends before the final `end.` statement. This happens mostly when the `begin` and `end` statements aren't balanced;
  - An include file ends in the middle of a statement.
  - A comment wasn't closed.
Fatal: String exceeds line
  You forgot probably to include the closing ' in a string, so it occupies multiple lines.
Fatal: illegal character arg1 (arg2)
  An illegal character was encountered in the input file.
Fatal: Syntax error, arg1 expected but arg2 found
  This indicates that the compiler expected a different token than the one you typed. It can occur almost everywhere where you make a mistake against the pascal language.
Start reading includefile arg1
  When you provide the `-vt` switch, the compiler tells you when it starts reading an included file.
Warning: Comment level arg1 found
  When the `-vw` switch is used, then the compiler warns you if it finds nested comments. Nested comments are not allowed in Turbo Pascal and can be a possible source of errors.
Note: $F directive (FAR) ignored
  The `FAR` directive is a 16-bit construction which is recorgnised but ignored by the compiler, since it produces 32 bit code.
Note: Stack check is global under Linux
  Stack checking with the `-Cs` switch is ignored under LINUX, since LINUX does this for you. Only displayed when `-vn` is used.
Note: Ignored compiler switch arg1
  With `-vn` on, the compiler warns if it ignores a switch
Warning: Illegal compiler switch arg1
  You included a compiler switch (i.e. `{$... }`) which the compiler doesn't know.
Warning: This compiler switch has a global effect
  When `-vw` is used, the compiler warns if a switch is global.
Error: Illegal char constant
  This happens when you specify a character with its ASCII code, as in `#96`, but the number is either illegal, or out of range. The range is 1-255.
Fatal: Can't open file arg1
  Free Pascal cannot find the program or unit source file you specified on the command line.
Fatal: Can't open include file arg1
  Free Pascal cannot find the source file you specified in a `{$include ..}` statement.
Error: Too many $ENDIFs or $ELSEs
  Your `{$IFDEF ..}` and {$ENDIF} statements aren't balanced.
Warning: Records fields can be aligned to 1,2,4,8,16 or 32 bytes only
  You are specifying the `{$PACKRECORDS n}` with an illegal value for `n`. Only 1, 2, 4, 8, 16 and 32 are valid in this case.
Warning: Enumerated can be saved in 1,2 or 4 bytes only
  You are specifying the `{$PACKENUM n}` with an illegal value for `n`. Only 1,2 or 4 are valid in this case.
Error: $ENDIF expected for arg1 arg2 defined in line arg3
  Your conditional compilation statements are unbalanced.
Error: Syntax error while parsing a conditional compiling expression
  There is an error in the expression following the `{$if ..}` compiler directive.
Error: Evaluating a conditional compiling expression
  There is an error in the expression following the `{$if ..}` compiler directive.
Warning: Macro contents is cut after char 255 to evalute expression
  The contents of macros canno be longer than 255 characters. This is a safety in the compiler, to prevent buffer overflows. This is shown as a warning, i.e. when the `-vw` switch is used.
Error: ENDIF without IF(N)DEF
  Your `{$IFDEF ..}` and {$ENDIF} statements aren't balanced.
Fatal: User defined: arg1
  A user defined fatal error occurred. see also the Programmers' guide
Error: User defined: arg1
  A user defined error occurred. see also the Programmers' guide
Warning: User defined: arg1
  A user defined warning occurred. see also the Programmers' guide
Note: User defined: arg1
  A user defined note was encountered. see also the Programmers' guide
Hint: User defined: arg1
  A user defined hint was encountered. see also the Programmers' guide
Info: User defined: arg1
  User defined information was encountered. see also the Programmers' guide
Error: Keyword redefined as macro has no effect
  You cannot redefine keywords with macros.
Fatal: Macro buffer overflow while reading or expanding a macro
  Your macro or it's result was too long for the compiler.
Warning: Extension of macros exceeds a deep of 16.
  When expanding a macro macros have been nested to a level of 16. The compiler will expand no further, since this may be a sign that recursion is used.
Error: compiler switches aren't allowed in (* ... *) styled comments
  Compiler switches should always be between `{ }` comment delimiters.
Handling switch "arg1"
  When you set debugging info on (`-vd`) the compiler tells you when it is evaluating conditional compile statements.
ENDIF arg1 found
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements.
IFDEF arg1 found, arg2
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements.
IFOPT arg1 found, arg2
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements.
IF arg1 found, arg2
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements.
IFNDEF arg1 found, arg2
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements.
ELSE arg1 found, arg2
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements.
Skipping until...
  When you turn on conditional messages(`-vc`), the compiler tells you where it encounters conditional statements, and whether it is skipping or compiling parts.
Info: Press <return> to continue
  When the `-vi` switch is used, the compiler stops compilation and waits for the `Enter` key to be pressed when it encounters a `{$STOP}` directive.
Warning: Unsupported switch arg1
  When warings are turned on (`-vw`) the compiler warns you about unsupported switches. This means that the switch is used in Delphi or Turbo Pascal, but not in Free Pascal
Warning: Illegal compiler directive arg1
  When warings are turned on (`-vw`) the compiler warns you about unrecognised switches. For a list of recognised switches, Programmers' guide
Back in arg1
  When you use (`-vt`) the compiler tells you when it has finished reading an include file.
Warning: Unsupported application type: arg1
  You get this warning, ff you specify an unknown application type with the directive `{$APPTYPE}`
Warning: APPTYPE isn't support by the target OS
  The `{$APPTYPE}` directive is supported by win32 applications only.
Warning: DESCRIPTION is only supported for OS2 and Win32
  The `{$DESCRIPTION}` directive is only supported for OS2 and Win32 targets.
Note: VERSION is not supported by target OS.
  The `{$VERSION}` directive is only supported by win32 target.
Note: VERSION only for exes or DLLs
  The `{$VERSION}` directive is only used for executable or DLL sources.
Warning: Wrong format for VERSION directive arg1
  The `{$VERSION}` directive format is majorversion.minorversion where majorversion and minorversion are words.
Warning: Unsupported assembler style specified arg1
  When you specify an assembler mode with the `{$ASMMODE xxx}` the compiler didn't recognize the mode you specified.
Warning: ASM reader switch is not possible inside asm statement, arg1 will be effective only for next
  It is not possible to switch from one assembler reader to another inside an assmebler block. The new reader will be used for next assembler statement only.
Error: Wrong switch toggle, use ON/OFF or +/-
  You need to use ON or OFF or a + or - to toggle the switch
Error: Resource files are not supported for this target
  The target you are compiling for doesn't support resource files. The only targets which can use resource files are Win32 and OS/2 (EMX) currently
Warning: Include environment arg1 not found in environment
  The included environment variable can't be found in the environment, it'll be replaced by an empty string instead.
Error: Illegal value for FPU register limit
  Valid values for this directive are 0..8 and NORMAL/DEFAULT
Warning: Only one resource file is supported for this target
  The target you are compiling for supports only one resource file. This is the case of OS/2 (EMX) currently. The first resource file found is used, the others are discarded.
Warning: Macro support has been turned off
  A macro declaration has been found, but macro support is currently off, so the declaration will be ignored. To turn macro support on compile with -Sm on the commandline or add `{$MACRO ON}` in the source
Warning: APPID is only supported for PalmOS
  The `{$APPID}` directive is only supported for the PalmOS target.
Warning: APPNAME is only supported for PalmOS
  The `{$APPNAME}` directive is only supported for the PalmOS target.
Error: Constant strings can't be longer than 255 chars
  A single string constant can contain at most 255 chars. Try splitting up the string in multiple smaller parts and concatenate them with a + operator.

# 3 Parser messages

This section lists all parser messages. The parser takes care of the semantics of you language, i.e. it determines if your pascal constructs are correct.

Error: Parser - Syntax Error
  An error against the Turbo Pascal language was encountered. This happens typically when an illegal character is found in the sources file.
Warning: Procedure type FAR ignored
  This is a warning. `FAR` is a construct for 8 or 16 bit programs. Since the compile generates 32 bit programs, it ignores this directive.
Warning: Procedure type NEAR ignored
  This is a warning. `NEAR` is a construct for 8 or 16 bit programs. Since the compile generates 32 bit programs, it ignores this directive.
Warning: Procedure type INTERRUPT ignored for not i386
  This is a warning. `INTERRUPT` is a i386 specific construct and is ignored for other processors.
Error: INTERRUPT procedure can't be nested
  An `INTERRUPT` procedure must be global.
Warning: Procedure type arg1 ignored
  This is a warning. `REGISTER`,`REINTRODUCE` is ignored by FPC programs for now. This is introduced first for Delphi compatibility.
Error: Not all declarations of arg1 are declared with OVERLOAD
  When you want to use overloading using the `OVERLOAD` directive, then all declarations need to have `OVERLOAD` specified.
Error: No DLL File specified
  No longer in use.
Error: Duplicate exported function name arg1
  Exported function names inside a specific DLL must all be different
Error: Duplicate exported function index arg1
  Exported function names inside a specific DLL must all be different
Error: Invalid index for exported function
  DLL function index must be in the range `1..$FFFF`
Warning: Relocatable DLL or executable arg1 debug info does not work, disabled.
Warning: To allow debugging for win32 code you need to disable relocation with -WN option
  Stabs info is wrong for relocatable DLL or EXES use -WN if you want to debug win32 executables.
Error: Constructor name must be INIT
  You are declaring a constructor with a name which isn't `init`, and the `-Ss` switch is in effect. See the `-Ss` switch (See Ss).
Error: Destructor name must be DONE
  You are declaring a destructor with a name which isn't `done`, and the `-Ss` switch is in effect. See the `-Ss` switch (See Ss).
Error: Illegal open parameter
  You are trying to use the wrong type for an open parameter.
Error: Procedure type INLINE not supported
  You tried to compile a program with C++ style inlining, and forgot to specify the `-Si` option (See Si). The compiler doesn't support C++ styled inlining by default.
Warning: Private methods shouldn't be VIRTUAL
  You declared a method in the private part of a object (class) as `virtual`. This is not allowed. Private methods cannot be overridden anyway.
Warning: Constructor should be public
  Constructors must be in the 'public' part of an object (class) declaration.
Warning: Destructor should be public
  Destructors must be in the 'public' part of an object (class) declaration.
Note: Class should have one destructor only
  You can declare only one destructor for a class.
Error: Local class definitions are not allowed
  Classes must be defined globally. They cannot be defined inside a procedure or function
Fatal: Anonym class definitions are not allowed
  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;

  will trigger this error.
Error: The object arg1 has no VMT
Error: Illegal parameter list
  You are calling a function with parameters that are of a different type than the declared parameters of the function.
Error: Wrong parameter type specified for arg no. arg1
  There is an error in the parameter list of the function or procedure. The compiler cannot determine the error more accurate than this.
Error: Wrong amount of parameters specified
  There is an error in the parameter list of the function or procedure, the number of parameters is not correct.
Error: overloaded identifier arg1 isn't a function
  The compiler encountered a symbol with the same name as an overloaded function, but it isn't a function it can overload.
Error: overloaded functions have the same parameter list
  You're declaring overloaded functions, but with the same parameter list. Overloaded function must have at least 1 different parameter in their declaration.
Error: function header doesn't match the forward declaration arg1
  You declared a function with same parameters but different result type or function modifiers.
Error: function header arg1 doesn't match forward : var name changes arg2 => arg3
  You declared the function in the `interface` part, or with the `forward` directive, but define it with a different parameter list.
Note: Values in enumeration types have to be ascending
  Free Pascal allows enumeration constructions as in C. Given the following declaration 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);

  The second declaration would produce an error. `A_UAS` needs to have a value higher than `A_E`, i.e. at least 7.
Note: Interface and implementation names are different arg1 => arg2
  This note warns you if the implementation and interface names of a functions are different, but they have the same mangled name. This is important when using overloaded functions (but should produce no error).
Error: With can not be used for variables in a different segment
  With stores a variable locally on the stack, but this is not possible if the variable belongs to another segment.
Error: function nesting > 31
  You can nest function definitions only 31 times.
Error: range check error while evaluating constants
  The constants are out of their allowed range.
Warning: range check error while evaluating constants
  The constants are out of their allowed range.
Error: duplicate case label
  You are specifying the same label 2 times in a `case` statement.
Error: Upper bound of case range is less than lower bound
  The upper bound of a `case` label is less than the lower bound and this is useless
Error: typed constants of classes are not allowed
  You cannot declare a constant of type class or object.
Error: functions variables of overloaded functions are not allowed
  You are trying to assign an overloaded function to a procedural variable. This isn't allowed.
Error: string length must be a value from 1 to 255
  The length of a string in Pascal is limited to 255 characters. You are trying to declare a string with length lower than 1 or greater than 255 (This is not true for `Longstrings` and `AnsiStrings`.
Warning: use extended syntax of NEW and DISPOSE for instances of objects
  If you have a pointer `a` to a class type, then the statement `new(a)` will not initialize the class (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 class.
Warning: use of NEW or DISPOSE for untyped pointers is meaningless
Error: use of NEW or DISPOSE is not possible for untyped pointers
  You cannot use `new(p)` or `dispose(p)` if `p` is an untyped pointer because no size is associated to an untyped pointer. Accepted for compatibility in `tp` and `delphi` modes.
Error: class identifier expected
  This happens when the compiler scans a procedure declaration that contains a dot, i.e., a object or class method, but the type in front of the dot is not a known type.
Error: type identifier not allowed here
  You cannot use a type inside an expression.
Error: method identifier expected
  This identifier is not a method. This happens when the compiler scans a procedure declaration that contains a dot, i.e., a object or class method, but the procedure name is not a procedure of this type.
Error: function header doesn't match any method of this class arg1
  This identifier is not a method. This happens when the compiler scans a procedure declaration that contains a dot, i.e., a object or class method, but the procedure name is not a procedure of this type.
procedure/function arg1
  When using the `-vp` switch, the compiler tells you when it starts processing a procedure or function implementation.
Error: Illegal floating point constant
  The compiler expects a floating point expression, and gets something else.
Error: FAIL can be used in constructors only
  You are using the `FAIL` instruction outside a constructor method.
Error: Destructors can't have parameters
  You are declaring a destructor with a parameter list. Destructor methods cannot have parameters.
Error: Only class methods can be referred with class references
  This error occurs in a situation like the following:

       Type :
          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.
Error: Only class methods can be accessed in class methods
  This is related to the previous error. You cannot call a method of an object from a inside a class method. The following code would produce this error:

       class procedure tobject.x;

       begin
         free

  Because free is a normal method of a class it cannot be called from a class method.
Error: Constant and CASE types do not match
  One of the labels is not of the same type as the case variable.
Error: The symbol can't be exported from a library
  You can only export procedures and functions when you write a library. You cannot export variables or constants.
Warning: An inherited method is hidden by arg1
  A method that is declared `virtual` in a parent class, should be overridden in the descendent class with the `override` directive. If you don't specify the `override` directive, you will hide the parent method; you will not override it.
Error: There is no method in an ancestor class to be overridden: arg1
  You try to `override` a virtual method of a parent class that doesn't exist.
Error: No member is provided to access property
  You specified no `read` directive for a property.
Warning: Stored prorperty directive is not yet implemented
  The `stored` directive is not yet implemented
Error: Illegal symbol for property access
  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 woud cause such an error.

       tmyobject = class
         i : integer;
         property x [i : integer]: integer read I write i;

Error: Cannot access a protected field of an object here
  Fields that are declared in a `protected` section of an object or class declaration cannot be accessed outside the module wher the object is defined, or outside descendent object methods.
Error: Cannot access a private field of an object here
  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.
Warning: overloaded method of virtual method should be virtual: arg1
  If you declare overloaded methods in a class, then they should either all be virtual, or none. You shouldn't mix them.
Warning: overloaded method of non-virtual method should be non-virtual: arg1
  If you declare overloaded methods in a class, then they should either all be virtual, or none. You shouldn't mix them.
Error: overloaded methods which are virtual must have the same return type: arg1
  If you declare virtual overloaded methods in a class definition, they must have the same return type.
Error: EXPORT declared functions can't be nested
  You cannot declare a function or procedure within a function or procedure that was declared as an export procedure.
Error: methods can't be EXPORTed
  You cannot declare a procedure that is a method for an object as `export`ed. That is, your methods cannot be called from a C program.
Error: call by var parameters have to match exactly: Got arg1 expected arg2
  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.
Error: Class isn't a parent class of the current class
  When calling inherited methods, you are trying to call a method of a strange class. You can only call an inherited method of a parent class.
Error: SELF is only allowed in methods
  You are trying to use the `self` parameter outside an object's method. Only methods get passed the `self` parameters.
Error: methods can be only in other methods called direct with type identifier of the class
  A construction like `sometype.somemethod` is only allowed in a method.
Error: Illegal use of ':'
  You are using the format `:` (colon) 2 times on an expression that is not a real expression.
Error: range check error in set constructor or duplicate set element
  The declaration of a set contains an error. Either one of the elements is outside the range of the set type, either two of the elements are in fact the same.
Error: Pointer to object expected
  You specified an illegal type in a `New` statement. The extended synax of `New` needs an object as a parameter.
Error: Expression must be constructor call
  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.
Error: Expression must be destructor call
  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.
Error: Illegal order of record elements
  When declaring a constant record, you specified the fields in the wrong order.
Error: Expression type must be class or record type
  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.
Error: Procedures can't return a value
  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.
Error: constructors and destructors must be methods
  You're declaring a procedure as destructor or constructor, when the procedure isn't a class method.
Error: Operator is not overloaded
  You're trying to use an overloaded operator when it isn't overloaded for this type.
Error: Impossible to overload assignment for equal types
  You can not overload assignment for types that the compiler considers as equal.
Error: Impossible operator overload
  The combination of operator, arguments and return type are incompatible.
Error: Re-raise isn't possible there
  You are trying to raise an exception where it isn't allowed. You can only raise exceptions in an `except` block.
Error: The extended syntax of new or dispose isn't allowed for a class
  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.
Error: Assembler incompatible with function return type
  You're trying to implement a `assembler` function, but the return type of the function doesn't allow that.
Error: Procedure overloading is switched off
  When using the `-So` switch, procedure overloading is switched off. Turbo Pascal does not support function overloading.
Error: It is not possible to overload this operator (overload = instead)
  You are trying to overload an operator which cannot be overloaded. The following operators can be overloaded :

          +, -, *, /, =, >, <, <=, >=, is, as, in, **, :=

Error: Comparative operator must return a boolean value
  When overloading the `=` operator, the function must return a boolean value.
Error: Only virtual methods can be abstract
  You are declaring a method as abstract, when it isn't declared to be virtual.
Fatal: Use of unsupported feature!
  You're trying to force the compiler into doing something it cannot do yet.
Error: The mix of CLASSES and OBJECTS isn't allowed
  You cannot derive `objects` and `classes` intertwined . That is, a class cannot have an object as parent and vice versa.
Warning: Unknown procedure directive had to be ignored: arg1
  The procedure direcive you secified is unknown. Recognised procedure directives are `cdecl`, `stdcall`, `popstack`, `pascal` `register`, `export`.
Error: absolute can only be associated to ONE variable
  You cannot specify more than one variable before the `absolute` directive. Thus, the following construct will provide this error:

       Var Z : Longint;
           X,Y : Longint absolute Z;

absolute can only be associated a var or const
  The address of a `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;

Error: absolute can only be associated a var or const
  The address of a `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;

Error: Only ONE variable can be initialized
  You cannot specify more than one variable with a initial value in Delphi syntax.
Error: Abstract methods shouldn't have any definition (with function body)
  Abstract methods can only be declared, you cannot implement them. They should be overridden by a descendant class.
Error: This overloaded function can't be local (must be exported)
  You are defining a overloaded function in the implementation part of a unit, but there is no corresponding declaration in the interface part of the unit.
Warning: Virtual methods are used without a constructor in arg1
  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.
Macro defined: arg1
  When `-vm` is used, the compiler tells you when it defines macros.
Macro undefined: arg1
  When `-vm` is used, the compiler tells you when it undefines macros.
Macro arg1 set to arg2
  When `-vm` is used, the compiler tells you what values macros get.
Info: Compiling arg1
  When you turn on information messages (`-vi`), the compiler tells you what units it is recompiling.
Parsing interface of unit arg1
  This tells you that the reading of the interface of the current unit starts
Parsing implementation of arg1
  This tells you that the code reading of the implementation of the current unit, library or program starts
Compiling arg1 for the second time
  When you request debug messages (`-vd`) the compiler tells you what units it recompiles for the second time.
Error: Array properties aren't allowed here
  You cannot use array properties at that point in the source.
Error: No property found to override
  You want to overrride a property of a parent class, when there is, in fact, no such property in the parent class.
Error: Only one default property is allowed, found inherited default property in class arg1
  You specified a property as `Default`, but a parent class already has a default property, and a class can have only one default property.
Error: The default property must be an array property
  Only array properties of classes can be made `default` properties.
Error: Virtual constructors are only supported in class object model
  You cannot have virtual constructors in objects. You can only have them in classes.
Error: No default property available
  You try to access a default property of a class, but this class (or one of it's ancestors) doesn't have a default property.
Error: The class can't have a published section, use the $M+ switch
  If you want a `published` section in a class definition, you must use the `{$M+}` switch, whch turns on generation of type information.
Error: Forward declaration of class arg1 must be resolved here to use the class as ancestor
  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;

  Where `ParentClass` is declared but not defined.
Error: Local operators not supported
  You cannot overload locally, i.e. inside procedures or function definitions.
Error: Procedure directive arg1 not allowed in interface section
  This procedure directive is not allowed in the `interface` section of a unit. You can only use it in the `implementation` section.
Error: Procedure directive arg1 not allowed in implementation section
  This procedure directive is not defined in the `implementation` section of a unit. You can only use it in the `interface` section.
Error: Procedure directive arg1 not allowed in procvar declaration
  This procedure directive cannot be part of a procedural or function type declaration.
Error: Function is already declared Public/Forward arg1
  You will get this error if a function is defined as `forward` twice. Or it is once in the `interface` section, and once as a `forward` declaration in the `implmentation` section.
Error: Can't use both EXPORT and EXTERNAL
  These two procedure directives are mutually exclusive
Error: NAME keyword expected
  The definition of an external variable needs a `name` clause.
Warning: arg1 not yet supported inside inline procedure/function
  Inline procedures don't support this declaration.
Warning: Inlining disabled
  Inlining of procedures is disabled.
Info: Writing Browser log arg1
  When information messages are on, the compiler warns you when it writes the browser log (generated with the `{$Y+ }` switch).
Hint: Maybe pointer dereference is missing
  The compiler thinks that a pointer may need a dereference.
Fatal: Selected assembler reader not supported
  The selected assembler reader (with `{$ASMMODE xxx}` is not supported. The compiler can be compiled with or without support for a particular assembler reader.
Error: Procedure directive arg1 has conflicts with other directives
  You specified a procedure directive that conflicts with other directives. for instance `cdecl` and `pascal` are mutually exclusive.
Error: Calling convention doesn't match forward
  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.
Error: Register calling (fastcall) not supported
  The `register` calling convention, i.e., arguments are passed in registers instead of on the stack is not supported. Arguments are always passed on the stack.
Error: Property can't have a default value
  Set properties or indexed properties cannot have a default value.
Error: The default value of a property must be constant
  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.
Error: Symbol can't be published, can be only a class
  Only class type variables can be in a `published` section of a class if they are not declared as a property.
Error: That kind of property can't be published
  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.
Warning: Empty import name specified
  Both index and name for the import are 0 or empty
Warning: An import name is required
  Some targets need a name for the imported procedure or a cdecl specifier
Error: Function internal name changed after use of function
  This is an internal error; please report any occurrences of this error to the Free Pascal team.
Error: Division by zero
  There is a divsion by zero encounted
Error: Invalid floating point operation
  An operation on two real type values produced an overflow or a division by zero.
Error: Upper bound of range is less than lower bound
  The upper bound of a `case` label is less than the lower bound and this is not possible
Warning: string "arg1" is longer than arg2
  The size of the constant string is larger than the size you specified in string type definition
Error: string length is larger than array of char length
  The size of the constant string is larger than the size you specified in the array[x..y] of char definition
Error: Illegal expression after message directive
  Free Pascal supports only integer or string values as message constants
Error: Message handlers can take only one call by ref. parameter
  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
Error: Duplicate message label: arg1
  A label for a message is used twice in one object/class
Error: Self can only be an explicit parameter in mehtods that are message handlers
  The self parameter can only be passed explicitly to a method which is declared as message method handler.
Error: Threadvars can be only static or global
  Threadvars must be static or global, you can't declare a thread local to a procedure. Local variables are always local to a thread, because every thread has it's own stack and local variables are stored on the stack
Fatal: Direct assembler not supported for binary output format
  You can't use direct assembler when using a binary writer, choose an other outputformat or use an other assembler reader
Warning: Don't load OBJPAS unit manual, use mode switch instead
  You're trying to load the ObjPas unit manual from a uses clause. This is not a good idea to do, you can better use the `{$mode objfpc}` or `{$mode delphi}` directives which load the unit automaticly
Error: OVERRIDE can't be used in objects
  Override isn't support for objects, use VIRTUAL instead to override a method of an anchestor object
Error: Data types which requires initialization/finalization can't be used in variant records
  Some data type (e.g. `ansistring`) needs initialization/finalization code which is implicitly generated by the compiler. Such data types can't be used in the variant part of a record.
Error: Resourcestrings can be only static or global
  Resourcestring can not be declared local, only global or using the static directive.
Error: Exit with argument can't be used here
  an exit statement with an argument for the return value can't be used here, this can happen e.g. in `try..except` or `try..finally` blocks
Error: The type of the storage symbol must be boolean
  If you specify a storage symbol in a property declaration, it must be of the type boolean
Error: This symbol isn't allowed as storage symbol
  You can't 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
Error: Only class which are compiled in $M+ mode can be published
  In the published section of a class can be only class as fields used which are compiled in `{$M+}` or which are derived from such a class. Normally such a class should be derived from TPersitent
Error: Procedure directive expected
  When declaring a procedure in a const block you used a ; after the procedure declaration after which a procedure directive must follow. Correct declarations are:

       const
         p : procedure;stdcall=nil;
         p : procedure stdcall=nil;

Error: The value for a property index must be of an ordinal type
  The value you use to index a property must be of an ordinal type, for example an integer or enumerated type.
Error: Procedure name to short to be exported
  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 correct with a name of length 1.
Error: No DEFFILE entry can be generated for unit global vars
Error: Compile without -WD option
  You need to compile this file without the -WD switch on the commandline
Fatal: You need ObjFpc (-S2) or Delphi (-Sd) mode to compile this module
  You need to use `{$mode objfpc}` or `{$mode delphi}` to compile this file. Or use the equivalent commandline switches -S2 or -Sd.
Error: Can't export with index under arg1
  Exporting of functions or procedures with a specified index is not support on all targets. The only platforms currently supporting export with index are OS/2 and Win32.
Error: Exporting of variables is not supported under arg1
  Exporting of variables is not support on all targets. The only platform currently supporting export of variables is Win32.
Error: Type "arg1" can't be used as array index type
  Types like DWord or Int64 aren't allowed as array index type
Warning: Some fields coming before "arg1" weren't initialized
  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.
Error: Some fields coming before "arg1" weren't initialized
  In all syntax modes but Delphi mode, you can't leave some fields uninitialized in the middle of a typed constant record
Hint: Some fields coming after "arg1" weren't initialized
  You can leave some fields at the end of a type constant record uninitialized (the compiler will initialize them to zero automatically), but then the compiler gives you a hint when it detects such situations.
Error: Self must be a normal (call-by-value) parameter
  You can't declare self as a const or var parameter, it must always be a call-by-value parameter
Error: Typed constants of the type "procedure of object" can only be initialized with NIL
  You can't 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 can not be known at compile time).

# 4 Type checking errors

This section lists all errors that can occur when type checking is performed.

Error: Type mismatch
  This can happen in many cases:
  - The variable you're assigning to is of a different type than the expression in the assignment.
  - You are calling a function or procedure with parameters that are incompatible with the parameters in the function or procedure definition.
Error: Incompatible types: got "arg1" expected "arg2"
  There is no conversion possible between the two types Another possiblity is that they are declared in different declarations:

       Var
          A1 : Array[1..10] Of Integer;
          A2 : Array[1..10] Of Integer;

       Begin
          A1:=A2; { This statement gives also this error, it
                    is due the strict type checking of pascal }
       End.

Error: Type mismatch between arg1 and arg2
  The types are not equal
Error: Type identifier expected
  The identifier is not a type, or you forgot to supply a type identifier.
Error: Variable identifier expected
  This happens when you pass a constant to a `Inc` var or `Dec` procedure. You can only pass variables as arguments to these functions.
Error: Integer expression expected, but got "arg1"
  The compiler expects an expression of type integer, but gets a different type.
Error: Boolean expression expected, but got "arg1"
  The expression must be a boolean type, it should be return true or false.
Error: Ordinal expression expected
  The expression must be of ordinal type, i.e., maximum a `Longint`. This happens, for instance, when you specify a second argument to `Inc` or `Dec` that doesn't evaluate to an ordinal value.
Error: pointer type expected, but got "arg1"
  The variable or expression isn't of the type `pointer`. This happens when you pass a variable that isn't a pointer to `New` or `Dispose`.
Error: class type expected, but got "arg1"
  The variable of expression isn't of the type `class`. This happens typically when
  1. The parent class in a class declaration isn't a class.
  2. An exception handler (`On`) contains a type identifier that isn't a class.
Error: Variable or type indentifier expected
  The argument to the `High` or `Low` function is not a variable nor a type identifier.
Error: Can't evaluate constant expression
  No longer in use.
Error: Set elements are not compatible
  You are trying to make an operation on two sets, when the set element types are not the same. The base type of a set must be the same when taking the union
Error: Operation not implemented for sets
  several binary operations are not defined for sets like div mod ** (also >= <= for now)
Warning: Automatic type conversion from floating type to COMP which is an integer type
  An implicit type conversion from a real type to a `comp` is encountered. Since `Comp` is a 64 bit integer type, this may indicate an error.
Hint: use DIV instead to get an integer result
  When hints are on, then an integer division with the '/' operator will procuce this message, because the result will then be of type real
Error: string types doesn't match, because of $V+ mode
  When compiling in `{$V+}` mode, the string you pass as a parameter should be of the exact same type as the declared parameter of the procedure.
Error: succ or pred on enums with assignments not possible
  When you declared an enumeration type which has assignments in it, as in C, like in the following:

         Tenum = (a,b,e:=5);

  you cannot use the `Succ` or `Pred` functions on them.
Error: Can't read or write variables of this type
  You are trying to `read` or `write` a variable from or to a file of type text, which doesn't support that. Only integer types, booleans, reals, pchars and strings can be read from/written to a text file.
Error: Can't use readln or writeln on typed file
  `readln` and `writeln` are only allowed for text files.
Error: Can't use read or write on untyped file.
  `read` and `write` are only allowed for text or typed files.
Error: Type conflict between set elements
  There is at least one set element which is of the wrong type, i.e. not of the set type.
Warning: lo/hi(dword/qword) returns the upper/lower word/dword
  Free Pascal supports an overloaded version of `lo/hi` for `longint/dword/int64/qword` which returns the lower/upper word/dword of the argument. TP always uses a 16 bit `lo/hi` which returns always bits 0..7 for `lo` and the bits 8..15 for `hi`. If you want the TP behavior you have to type cast the argument to `word/integer`
Error: Integer or real expression expected
  The first argument to `str` must a real or integer type.
Error: Wrong type arg1 in array constructor
  You are trying to use a type in an array constructor which is not allowed.
Error: Incompatible type for arg no. arg1: Got arg2, expected arg3
  You are trying to pass an invalid type for the specified parameter.
Error: Method (variable) and Procedure (variable) are not compatible
  You can't assign a method to a procedure variable or a procedure to a method pointer.
Error: Illegal constant passed to internal math function
  The constant argument passed to a ln or sqrt function is out of the definition range of these functions.
Error: Can't get the address of constants
  It's not possible to get the address of a constant, because they aren't stored in memory, you can try making it a typed constant.
Error: Argument can't be assigned to
  Only expressions which can be on the left side of an assignment can be passed as call by reference argument Remark: Properties can be only used on the left side of an assignment, but they can't be used as arguments
Error: Can't assign local procedure/function to procedure variable
  It's not allowed to assign a local procedure/function to a procedure variable, because the calling of local procedure/function is different. You can only assign local procedure/function to a void pointer.
Error: Can't assign values to an address
  It's not allowed to assign a value to an address of a variable, constant, procedure or function. You can try compiling with -So if the identifier is a procedure variable.
Error: Can't assign values to const variable
  It's not allowed to assign a value to a variable which is declared as a const. This is normally a parameter declared as const, to allow changing make the parameter value or var.
Error: Array type required
  If you are accessing a variable using an index '[<x>]' then the type must be an array. In FPC mode also a pointer is allowed.
Warning: Mixing signed expressions and cardinals gives a 64bit result
  If you divide (or calculate the modulus of) a signed expression by a cardinal (or vice versa), or if you have overflow and/or range checking turned on and use an arithmetical expression (+, -, *, div, mod) in which both signed numbers and cardinals appear, then everything has to be evaluated in 64bit which is slower than normal 32bit arithmetics. You can avoid this by typecasting one operand so it matches the resulttype of the other one.
Warning: Mixing signed expressions and cardinals here may cause a range check error
  If you use a binary operator (and, or, xor) and one of the operands is a cardinal while the other one is a signed expression, then, if range checking is turned on, you may get a range check error because in such a case both operands are converted to cardinal before the operation is carried out. You can avoid this by typecasting one operand so it matches the resulttype of the other one.
Error: Typecast has different size (arg1 -> arg2) in assignment
  Type casting to a type with a different size is not allowed when the variable is used for assigning.

# 5 Symbol handling

This section lists all the messages that concern the handling of symbols. This means all things that have to do with procedure and variable names.

Error: Identifier not found arg1
  The compiler doesn't know this symbol. Usually happens when you misspel the name of a variable or procedure, or when you forgot to declare a variable.
Fatal: Internal Error in SymTableStack()
  An internal error occurred in the compiler; If you encounter such an error, please contact the developers and try to provide an exact description of the circumstances in which the error occurs.
Error: Duplicate identifier arg1
  The identifier was already declared in the current scope.
Hint: Identifier already defined in arg1 at line arg2
  The identifier was already declared in a previous scope.
Error: Unknown identifier arg1
  The identifier encountered hasn't been declared, or is used outside the scope where it's defined.
Error: Forward declaration not solved arg1
  This can happen in two cases:
  - This happens when you declare a function (in the `interface` part, or with a `forward` directive, but do not implement it.
  - You reference a type which isn't declared in the current `type` block.
Fatal: Identifier type already defined as type
  You are trying to redefine a type.
Error: Error in type definition
  There is an error in your definition of a new array type:
  One of the range delimiters in an array declaration is erroneous. For example, `Array [1..1.25]` will trigger this error.
Error: Type identifier not defined
  The type identifier has not been defined yet.
Error: Forward type not resolved arg1
  A symbol was forward defined, but no declaration was encountered.
Error: Only static variables can be used in static methods or outside methods
  A static method of an object can only access static variables.
Error: Invalid call to tvarsym.mangledname()
  An internal error occurred in the compiler; If you encounter such an error, please contact the developers and try to provide an exact description of the circumstances in which the error occurs.
Fatal: record or class type expected
  The variable or expression isn't of the type `record` or `class`.
Error: Instances of classes or objects with an abstract method are not allowed
  You are trying to generate an instance of a class which has an abstract method that wasn't overridden.
Warning: Label not defined arg1
  A label was declared, but not defined.
Error: Label used but not defined arg1
  A label was declared and used, but not defined.
Error: Illegal label declaration
  This error should never happen; it occurs if a label is defined outside a procedure or function.
Error: GOTO and LABEL are not supported (use switch -Sg)
  You must compile a program which has `label`s and `goto` statements with the `-Sg` switch. By default, `label` and `goto` aren't supported.
Error: Label not found
  A `goto label` was encountered, but the label isn't declared.
Error: identifier isn't a label
  The identifier specified after the `goto` isn't of type label.
Error: label already defined
  You are defining a label twice. You can define a label only once.
Error: illegal type declaration of set elements
  The declaration of a set contains an invalid type definition.
Error: Forward class definition not resolved arg1
  You declared a class, but you didn't implement it.
Hint: Unit arg1 not used in arg2
  The unit referenced in the `uses` clause is not used.
Hint: Parameter arg1 not used
  This is a warning. The identifier was declared (locally or globally) but wasn't used (locally or globally).
Note: Local variable arg1 not used
  You have declared, but not used a variable in a procedure or function implementation.
Hint: Value parameter arg1 is assigned but never used
  This is a warning. The identifier was declared (locally or globally) set but not used (locally or globally).
Note: Local variable arg1 is assigned but never used
  The variable in a procedure or function implementation is declared, set but never used.
Hint: Local arg1 arg2 is not used
  A local symbol is never used.
Note: Private field arg1.arg2 is never used
Note: Private field arg1.arg2 is assigned but never used
Note: Private method arg1.arg2 never used
Error: Set type expected
  The variable or expression isn't of type `set`. This happens in an `in` statement.
Warning: Function result does not seem to be set
  You can get this warning if the compiler thinks that a function return value is not set. This will not be displayed for assembler procedures, or procedures that contain assembler blocks.
Warning: Type arg1 is not aligned correctly in current record for C
  Arrays with sizes not multiples of 4 will be wrongly aligned for C structures.
Error: Unknown record field identifier arg1
  The field doesn't exist in the record definition.
Warning: Local variable arg1 does not seem to be initialized
Warning: Variable arg1 does not seem to be initialized
  These messages are displayed if the compiler thinks that a variable will be used (i.e. appears in the right-hand-side of an expression) when it wasn't initialized first (i.e. appeared in the left-hand side of an assigment)
Error: identifier idents no member arg1
  When using the extended syntax of `new`, you must specify the constructor method of the class you are trying to create. The procedure you specified does not exist.
Found declaration: arg1
  You get this when you use the `-vb` switch. In case an overloaded procedure is not found, then all candidate overloaded procedures are listed, with their parameter lists.
Error: Data segment too large (max. 2GB)
  You get this when you declare an array whose size exceeds the 2GB limit.

# 6 Code generator messages

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

Error: BREAK not allowed
  You're trying to use `break` outside a loop construction.
Error: CONTINUE not allowed
  You're trying to use `continue` outside a loop construction.
Error: Expression too complicated - FPU stack overflow
  Your expression is too long for the compiler. You should try dividing the construct over multiple assignments.
Error: Illegal expression
  This can occur under many circumstances. Mostly when trying to evaluate constant expressions.
Error: Invalid integer expression
  You made an expression which isn't an integer, and the compiler expects the result to be an integer.
Error: Illegal qualifier
  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.
Error: High range limit < low range limit
  You are declaring a subrange, and the lower limit is higher than the high limit of the range.
Error: Illegal counter variable
  The type of a `for` loop variable must be an ordinal type. Loop variables cannot be reals or strings.
Error: Can't determine which overloaded function to call
  You're calling overloaded functions with a parameter that doesn't correspond to any of the declared function parameter lists. e.g. when you have declared a function with parameters `word` and `longint`, and then you call it with a parameter which is of type `integer`.
Error: Parameter list size exceeds 65535 bytes
  The I386 processor limits the parameter list to 65535 bytes (the `RET` instruction causes this)
Error: Illegal type conversion
  When doing a type-cast, you must take care that the sizes of the variable and the destination type are the same.
Conversion between ordinals and pointers is not portable across platforms
  If you typecast a pointer to a longint, this code will not compile on a machine using 64bit for pointer storage.
Error: File types must be var parameters
  You cannot specify files as value parameters, i.e. they must always be declared `var` parameters.
Error: 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: illegal call by reference parameters
  You are trying to pass a constant or an expression to a procedure that requires a `var` parameter. Only variables can be passed as a `var` parameter.
Error: EXPORT declared functions can't be called
  No longer in use.
Warning: Possible illegal call of constructor or destructor (doesn't match to this context)
  No longer in use.
Note: Inefficient code
  You construction seems dubious to the compiler.
Warning: unreachable code
  You specified a loop which will never be executed. Example:

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

Error: procedure call with stackframe ESP/SP
  The compiler encountered a procedure or function call inside a procedure that uses a `ESP/SP` stackframe. Normally, when a call is done the procedure needs a `EBP` stackframe.
Error: Abstract methods can't be called directly
  You cannot call an abstract method directy, instead you must call a overriding child method, because an abstract method isn't implemented.
Fatal: Internal Error in getfloatreg(), allocation failure
  An internal error occurred in the compiler; If you encounter such an error, please contact the developers and try to provide an exact description of the circumstances in which the error occurs.
Fatal: Unknown float type
  The compiler cannot determine the kind of float that occurs in an expression.
Fatal: SecondVecn() base defined twice
  An internal error occurred in the compiler; If you encounter such an error, please contact the developers and try to provide an exact description of the circumstances in which the error occurs.
Fatal: Extended cg68k not supported
  The `extended` type is not supported on the m68k platform.
Fatal: 32-bit unsigned not supported in MC68000 mode
  The cardinal is not supported on the m68k platform.
Fatal: Internal Error in secondinline()
  An internal error occurred in the compiler; If you encounter such an error, please contact the developers and try to provide an exact description of the circumstances in which the error occurs.
Register arg1 weight arg2 arg3
  Debugging message. Shown when the compiler considers a variable for keeping in the registers.
Error: Stack limit excedeed in local routine
  Your code requires a too big stack. Some operating systems pose limits on the stack size. You should use less variables or try ro put large variables on the heap.
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: Object or class methods can't be inline.
  You cannot have inlined object methods.
Error: Procvar calls can't be inline.
  A procedure with a procedural variable call cannot be inlined.
Error: No code for inline procedure stored
  The compiler couldn't store code for the inline procedure.
Error: Direct call of interrupt procedure arg1 is not possible
  You can not call an interrupt procedure directly from FPC code
Error: Element zero of an ansi/wide- or longstring can't 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 kinf of string
Error: Include and exclude not implemented in this case
  `include` and `exclude` are only partially implemented for `i386` processors and not at all for `m68k` processors.
Error: Constructors or destructors can not 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: Cannot call message handler method directly
  A message method handler method can't be called directly if it contains an explicit self argument
Error: Jump in or outside of an exception block
  It isn't allowed to jump in or outside of an exception block like `try..finally..end;`:

       label 1;

       ...

       try
          if not(final) then
            goto 1;   // this line will cause an error
       finally
         ...
       end;
       1:
       ...

Error: Control flow statements aren't 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: exiting the procedure or searching for another exception handler

# 7 Errors of assembling/linking stage

This section lists errors that occur when the compiler is processing the command line or handling the configuration files.

Warning: Source operating system redefined
Info: Assembling (pipe) arg1
Error: Can't create assember file: arg1
  The mentioned file can't be create. Check if you've permission to create this file
Error: Can't create object file: arg1
  The mentioned file can't be create. Check if you've permission to create this file
Error: Can't create archive file: arg1
  The mentioned file can't be create. Check if you've permission to create this file
Error: Assembler arg1 not found, switching to external assembling
Using assembler: arg1
Error: Error while assembling exitcode arg1
Error: Can't call the assembler, error arg1 switching to external assembling
Info: Assembling arg1
Info: Assembling smartlink arg1
Warning: Object arg1 not found, Linking may fail !
Warning: Library arg1 not found, Linking may fail !
Error: Error while linking
Error: Can't call the linker, switching to external linking
Info: Linking arg1
Error: Util arg1 not found, switching to external linking
Using util arg1
Error: Creation of Executables not supported
Error: Creation of Dynamic/Shared Libraries not supported
Info: Closing script arg1
Error: resource compiler not found, switching to external mode
Info: Compiling resource arg1
unit arg1 can't be static linked, switching to smart linking
unit arg1 can't be smart linked, switching to static linking
unit arg1 can't be shared linked, switching to static linking
Error: unit arg1 can't be smart or static linked
Error: unit arg1 can't be shared or static linked

# 8 Unit loading messages.

This section lists all messages that can occur when the compiler is loading a unit from disk into memory. Many of these mesages are informational messages.

Unitsearch: arg1
  When you use the `-vt`, the compiler tells you where it tries to find unit files.
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` flag, the unit name is shown.
PPU Flags: arg1
  When you use the `-vu` flag, the unit flags are shown.
PPU Crc: arg1
  When you use the `-vu` flag, the unit CRC check is shown.
PPU Time: arg1
  When you use the `-vu` flag, the time the unit was compiled is shown.
PPU File too short
  The ppufile is too short, not all declarations are present.
PPU Invalid Header (no PPU at the begin)
  A unit file contains as the first three bytes the ascii codes of `PPU`
PPU Invalid Version arg1
  This unit file was compiled with a different version of the compiler, and cannot be read.
PPU is compiled for an other processor
  This unit file was compiled for a different processor type, and cannot be read
PPU is compiled for an other target
  This unit file was compiled for a different target, and cannot be read
PPU Source: arg1
  When you use the `-vu` flag, the unit CRC check is shown.
Writing arg1
  When you specify the `-vu` switch, the compiler will tell you where it writes the unit file.
Fatal: Can't Write PPU-File
  An error occurred when writing the unit file.
Fatal: Error reading PPU-File
  This means that the unit file was corrupted, and contains invalid information. Recompilation will be necessary.
Fatal: unexpected end of PPU-File
  Unexpected end of file.
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 doesn't match the file 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 files.pas file 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.
Warning: Can't recompile unit arg1, but found modifed include files
  A unit was found to have modified include files, but some source files were not found, so recompilation is impossible.
Fatal: Can't find unit arg1
  You tried to use a unit of which the PPU file isn't found by the compiler. Check your config files for the unit pathes
Warning: Unit arg1 was not found but arg2 exists
Fatal: Unit arg1 searched but arg2 found
  Dos truncation of 8 letters for unit PPU files 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 specified.
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` flag, 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` flag, these messages tell you why the current unit is recompiled.
Recompiling unit, static lib is older than ppufile
  When you use the `-vu` flag, the compiler warns if the static library of the unit are older than the unit file itself.
Recompiling unit, shared lib is older than ppufile
  When you use the `-vu` flag, the compiler warns if the shared library of the unit are older than the unit file itself.
Recompiling unit, obj and asm are older than ppufile
  When you use the `-vu` flag, the compiler warns if the assembler or object file of the unit are older than the unit file itself.
Recompiling unit, obj is older than asm
  When you use the `-vu` flag, the compiler warns if the assembler file of the unit is older than the object file of the unit.
Parsing interface of arg1
  When you use the `-vu` flag, the compiler warns that it starts parsing the interface part of the unit
Parsing implementation of arg1
  When you use the `-vu` flag, the compiler warns that it starts parsing the implementation part of the unit
Second load for unit arg1
  When you use the `-vu` flag, the compiler warns that it starts recompiling a unit for the second time. This can happend with interdepend units.
PPU Check file arg1 time arg2
  When you use the `-vu` flag, the compiler show the filename and date and time of the file which a recompile depends on
Hint: Conditional arg1 was not set at startup in last compilation of arg2
  when recompilation of an unit is required the compiler will check that the same conditionals are set for the recompiliation. The compiler has found a conditional that currently is defined, but was not used the last time the unit was compiled.
Hint: Conditional arg1 was set at startup in last compilation of arg2
  when recompilation of an unit is required the compiler will check that the same conditionals are set for the recompiliation. The compiler has found a conditional that was used the last time the unit was compiled, but the conditional is currently not defined.
Hint: File arg1 is newer than Release PPU file arg2

# 9 Command-line handling errors

This section lists errors that occur when the compiler is processing the command line or handling the configuration files.

Warning: Only one source file supported
  You can specify only one source file on the command line. The first one will be compiled, others will be ignored. This may indicate that you forgot a `'-'` sign.
Warning: DEF file can be created only for OS/2
  This option can only be specified when you're compiling for OS/2
Error: nested response files are not supported
  you cannot nest response files with the `@file` command-line option.
Fatal: No source file name in command line
  The compiler expects a source file name on the command line.
Note: No option inside arg1 config file
  The compiler didn't find any option in that config file.
Error: Illegal parameter: arg1
  You specified an unknown option.
Hint: -? writes help pages
  When an unknown option is given, this message is diplayed.
Fatal: Too many config files nested
  You can only nest up to 16 config files.
Fatal: Unable to open file arg1
  The option file cannot be found.
Reading further options from arg1
  Displayed when you have notes turned on, and the compiler switches to another options file.
Warning: Target is already set to: arg1
  Displayed if more than one `-T` option is specified.
Warning: Shared libs not supported on DOS platform, reverting to static
  If you specify `-CD` for the DOS platform, this message is displayed. The compiler supports only static libraries under DOS
Fatal: too many IF(N)DEFs
  the `#IF(N)DEF` statements in the options file are not balanced with the `#ENDIF` statements.
Fatal: too many ENDIFs
  the `#IF(N)DEF` statements in the options file are not balanced with the `#ENDIF` statements.
Fatal: open conditional at the end of the file
  the `#IF(N)DEF` statements in the options file are not balanced with the `#ENDIF` statements.
Warning: Debug information generation is not supported by this executable
  It is possible to have a compiler executable that doesn't support the generation of debugging info. If you use such an executable with the `-g` switch, this warning will be displayed.
Hint: Try recompiling with -dGDB
  It is possible to have a compiler executable that doesn't support the generation of debugging info. If you use such an executable with the `-g` switch, this warning will be displayed.
Error: You are using the obsolete switch arg1
  this warns you when you use a switch that is not needed/supported anymore. It is recommended that you remove the switch to overcome problems in the future, when the switch meaning may change.
Error: You are using the obsolete switch arg1, please use arg2
  this warns you when you use a switch that is not supported anymore. You must now use the second switch instead. It is recommended that you change the switch to overcome problems in the future, when the switch meaning may change.
Note: Switching assembler to default source writing assembler
  this notifies you that the assembler has been changed because you used the -a switch which can't be used with a binary assembler writer.
Warning: Assembler output selected "arg1" is not compatible with "arg2"
Warning: "arg1" assembler use forced
  The assembler output selected can not generate object files with the correct format. Therefore, the default assembler for this target is used instead.
*** press enter ***

# 10 Assembler reader errors.

This section lists the errors that are generated by the inline assembler reader. They are not the messages of the assembler itself.

## 1 General assembler errors

Divide by zero in asm evaluator
  This fatal error is reported when a constant assembler expressions does a division by zero.

Evaluator stack overflow, Evaluator stack underflow
  These fatal errors are reported when a constant assembler expression is too big to evaluate by the constant parser. Try reducing the number of terms.

Invalid numeric format in asm evaluator
  This fatal error is reported when a non-numeric value is detected by the constant parser. Normally this error should never occur.

Invalid Operator in asm evaluator
  This fatal error is reported when a mathematical operator is detected by the constant parser. Normally this error should never occur.

Unknown error in asm evaluator
  This fatal error is reported when an internal error is detected by the constant parser. Normally this error should never occur.

Invalid numeric value
  This warning is emitted when a conversion from octal,binary or hexadecimal to decimal is outside of the supported range.

Escape sequence ignored
  This error is emitted when a non ANSI C escape sequence is detected in a C string.

Asm syntax error - Prefix not found
  This occurs when trying to use a non-valid prefix instruction

Asm syntax error - Trying to add more than one prefix
  This occurs when you try to add more than one prefix instruction

Asm syntax error - Opcode not found
  You have tried to use an unsupported or unknown opcode

Constant value out of bounds
  This error is reported when the constant parser determines that the value you are using is out of bounds, either with the opcode or with the constant declaration used.

Non-label pattern contains @
  This only applied to the m68k and Intel styled assembler, this is reported when you try to use a non-label identifier with a '@' prefix.
Internal error in Findtype()
Internal Error in ConcatOpcode()
Internal Errror converting binary
Internal Errror converting hexadecimal
Internal Errror converting octal
Internal Error in BuildScaling()
Internal Error in BuildConstant()
internal error in BuildReference()
internal error in HandleExtend()
Internal error in ConcatLabeledInstr()
  These errors should never occur, if they do then you have found a new bug in the assembler parsers. Please contact one of the developers.
Opcode not in table, operands not checked
  This warning only occurs when compiling the system unit, or related files. No checking is performed on the operands of the opcodes.

@CODE and @DATA not supported
  This Turbo Pascal construct is not supported.
SEG and OFFSET not supported
  This Turbo Pascal construct is not supported.
Modulo not supported
  Modulo constant operation is not supported.
Floating point binary representation ignored
Floating point hexadecimal representation ignored
Floating point octal representation ignored
  These warnings occur when a floating point constant are declared in a base other then decimal. No conversion can be done on these formats. You should use a decimal representation instead.
Identifier supposed external
  This warning occurs when a symbol is not found in the symolb table, it is therefore considered external.
Functions with void return value can't return any value in asm code
  Only routines with a return value can have a return value set.

Error in binary constant
Error in octal constant
Error in hexadecimal constant
Error in integer constant
  These errors are reported when you tried using an invalid constant expression, or that the value is out of range.

Invalid labeled opcode
Asm syntax error - error in reference
Invalid Opcode
Invalid combination of opcode and operands
Invalid size in reference
Invalid middle sized operand
Invalid three operand opcode
Assembler syntax error
Invalid operand type
  You tried using an invalid combination of opcode and operands, check the syntax and if you are sure it is correct, please contact one of the developers.

Unknown identifier
  The identifier you are trying to access does not exist, or is not within the current scope.

Trying to define an index register more than once
Trying to define a segment register twice
Trying to define a base register twice
  You are trying to define an index/segment register more then once.

Invalid field specifier
  The record or object field you are trying to access does not exist, or is incorrect.

Invalid scaling factor
Invalid scaling value
Scaling value only allowed with index
  Allowed scaling values are 1,2,4 or 8.

Cannot use SELF outside a method
  You are trying to access the SELF identifier for objects outside a method.

Invalid combination of prefix and opcode
  This opcode cannot be prefixed by this instruction

Invalid combination of override and opcode
  This opcode cannot be overriden by this combination

Too many operands on line
  At most three operand instructions exist on the m68k, and i386, you are probably trying to use an invalid syntax for this opcode.

Duplicate local symbol
  You are trying to redefine a local symbol, such as a local label.

Unknown label identifer
Undefined local symbol
local symbol not found inside asm statement
  This label does not seem to have been defined in the current scope

Assemble node syntax error
Not a directive or local symbol
  The assembler statement is invalid, or you are not using a recognized directive.

## 2 I386 specific errors

repeat prefix and a segment override on `<=` i386 ...
  A problem with interrupts and a prefix instruction may occur and may cause false results on 386 and earlier computers.

Fwait can cause emulation problems with emu387
  This warning is reported when using the FWAIT instruction, it can cause emulation problems on systems which use the em387.dxe emulator.

You need GNU as version >= 2.81 to compile this MMX code
  MMX assembler code can only be compiled using GAS v2.8.1 or later.

NEAR ignored
FAR ignored
  `NEAR` and `FAR` are ignored in the intel assemblers, but are still accepted for compatiblity with the 16-bit code model.

Invalid size for MOVSX/MOVZX

16-bit base in 32-bit segment
16-bit index in 32-bit segment
  16-bit addressing is not supported, you must use 32-bit addressing.

Constant reference not allowed
  It is not allowed to try to address a constant memory address in protected mode.

Segment overrides not supported
  Intel style (eg: rep ds stosb) segment overrides are not support by the assembler parser.

Expressions of the form [sreg:reg...] are currently not supported
  To access a memory operand in a different segment, you should use the sreg:[reg...] snytax instead of [sreg:reg...]

Size suffix and destination register do not match
  In intel AT&T syntax, you are using a register size which does not concord with the operand size specified.

Invalid assembler syntax. No ref with brackets
Trying to use a negative index register
Local symbols not allowed as references
Invalid operand in bracket expression
Invalid symbol name:
Invalid Reference syntax
Invalid string as opcode operand:
Null label references are not allowed
Using a defined name as a local label
Invalid constant symbol
Invalid constant expression
/ at beginning of line not allowed
NOR not supported
Invalid floating point register name
Invalid floating point constant:
Asm syntax error - Should start with bracket
Asm syntax error - register:
Asm syntax error - in opcode operand
Invalid String expression
Constant expression out of bounds
Invalid or missing opcode
Invalid real constant expression
Parenthesis are not allowed
Invalid Reference
Cannot use __SELF outside a method
Cannot use __OLDEBP outside a nested procedure
Invalid segment override expression
Strings not allowed as constants
Switching sections is not allowed in an assembler block
Invalid global definition
Line separator expected
Invalid local common definition
Invalid global common definition
assembler code not returned to text
invalid opcode size
Invalid character: <
Invalid character: >
Unsupported opcode
Invalid suffix for intel assembler
Extended not supported in this mode
Comp not supported in this mode
Invalid Operand:
Override operator not supported

## 3 m68k specific errors.

Increment and Decrement mode not allowed together
  You are trying to use dec/inc mode together.

Invalid Register list in movem/fmovem
  The register list is invalid, normally a range of registers should be separated by - and individual registers should be separated by a slash.
Invalid Register list for opcode
68020+ mode required to assemble