 \section{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 \var{-v} switches.
 \begin{description}
\item [Compiler: arg1]
 When the \var{-vt} switch is used, this line tells you what compiler
 is used.
\item [Compiler OS: arg1]
 When the \var{-vd} switch is used, this line tells you what the source
 operating system is.
\item [Info: Target OS: arg1]
 When the \var{-vd} switch is used, this line tells you what the target
 operating system is.
\item [Using executable path: arg1]
 When the \var{-vt} switch is used, this line tells you where the compiler
 looks for it's binaries.
\item [Using unit path: arg1]
 When the \var{-vt} switch is used, this line tells you where the compiler
 looks for compiled units. You can set this path with the \var{-Fu}
\item [Using include path: arg1]
 When the \var{-vt} switch is used, this line tells you where the compiler
 looks for it's include files (files used in \var{\{\$I xxx\}} statements).
 You can set this path with the \var{-I} option.
\item [Using library path: arg1]
 When the \var{-vt} switch is used, this line tells you where the compiler
 looks for the libraries. You can set this path with the \var{-Fl} option.
\item [Using object path: arg1]
 When the \var{-vt} switch is used, this line tells you where the compiler
 looks for object files you link in (files used in \var{\{\$L xxx\}} statements).
 You can set this path with the \var{-Fo} option.
\item [Info: arg1 Lines compiled, arg2 sec]
 When the \var{-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).
\item [Fatal: No memory left]
 The compiler doesn't have enough memory to compile your program. There are
 several remedies for this:
 \begin{itemize}
 \item If you're using the build option of the compiler, try compiling the
 different units manually.
 \item If you're compiling a huge program, split it up in units, and compile
 these separately.
 \item If the previous two don't work, recompile the compiler with a bigger
 heap (you can use the \var{-Ch} option for this, \seeo{Ch})
 \end{itemize}
\item [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.
\item [Error: Writing Resource String Table file: arg1]
 This message is shown when the compiler encountered an error when writing
 the Resource String Table file
\item [Info: Fatal:]
 Prefix for Fatal Errors
\item [Info: Error:]
 Prefix for Errors
\item [Info: Warning:]
 Prefix for Warnings
\item [Info: Note:]
 Prefix for Notes
\item [Info: Hint:]
 Prefix for Hints
 \end{description}
 \section{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.
 \begin{description}
\item [Fatal: Unexpected end of file]
 this typically happens in one of the following cases :
 \begin{itemize}
 \item The source file ends before the final \var{end.} statement. This
 happens mostly when the \var{begin} and \var{end} statements aren't
 balanced;
 \item An include file ends in the middle of a statement.
 \item A comment wasn't closed.
 \end{itemize}
\item [Fatal: String exceeds line]
 You forgot probably to include the closing ' in a string, so it occupies
 multiple lines.
\item [Fatal: illegal character arg1 (arg2)]
 An illegal character was encountered in the input file.
\item [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.
\item [Start reading includefile arg1]
 When you provide the \var{-vt} switch, the compiler tells you
 when it starts reading an included file.
\item [Warning: Comment level arg1 found]
 When the \var{-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.
\item [Note: \$F directive (FAR) ignored]
 The \var{FAR} directive is a 16-bit construction which is recorgnised
 but ignored by the compiler, since it produces 32 bit code.
\item [Note: Stack check is global under Linux]
 Stack checking with the \var{-Cs} switch is ignored under \linux, since
 \linux does this for you. Only displayed when \var{-vn} is used.
\item [Note: Ignored compiler switch arg1]
 With \var{-vn} on, the compiler warns if it ignores a switch
\item [Warning: Illegal compiler switch arg1]
 You included a compiler switch (i.e. \var{\{\$... \}}) which the compiler
 doesn't know.
\item [Warning: This compiler switch has a global effect]
 When \var{-vw} is used, the compiler warns if a switch is global.
\item [Error: Illegal char constant]
 This happens when you specify a character with its ASCII code, as in
 \var{\#96}, but the number is either illegal, or out of range. The range
 is 1-255.
\item [Fatal: Can't open file arg1]
 \fpc cannot find the program or unit source file you specified on the
 command line.
\item [Fatal: Can't open include file arg1]
 \fpc cannot find the source file you specified in a \var{\{\$include ..\}}
 statement.
\item [Error: Too many \$ENDIFs or \$ELSEs]
 Your \var{\{\$IFDEF ..\}} and {\{\$ENDIF\}} statements aren't balanced.
\item [Warning: Records fields can be aligned to 1,2,4,8,16 or 32 bytes only]
 You are specifying the \var{\{\$PACKRECORDS n\} } with an illegal value for
 \var{n}. Only 1, 2, 4, 8, 16 and 32 are valid in this case.
\item [Warning: Enumerated can be saved in 1,2 or 4 bytes only]
 You are specifying the \var{\{\$PACKENUM n\}} with an illegal value for
 \var{n}. Only 1,2 or 4 are valid in this case.
\item [Error: \$ENDIF expected for arg1 arg2 defined in line arg3]
 Your conditional compilation statements are unbalanced.
\item [Error: Syntax error while parsing a conditional compiling expression]
 There is an error in the expression following the \var{\{\$if ..\}} compiler
 directive.
\item [Error: Evaluating a conditional compiling expression]
 There is an error in the expression following the \var{\{\$if ..\}} compiler
 directive.
\item [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 \var{-vw} switch is used.
\item [Error: ENDIF without IF(N)DEF]
 Your \var{\{\$IFDEF ..\}} and {\{\$ENDIF\}} statements aren't balanced.
\item [Fatal: User defined: arg1]
 A user defined fatal error occurred. see also the \progref
\item [Error: User defined: arg1]
 A user defined error occurred. see also the \progref
\item [Warning: User defined: arg1]
 A user defined warning occurred. see also the \progref
\item [Note: User defined: arg1]
 A user defined note was encountered. see also the \progref
\item [Hint: User defined: arg1]
 A user defined hint was encountered. see also the \progref
\item [Info: User defined: arg1]
 User defined information was encountered. see also the \progref
\item [Error: Keyword redefined as macro has no effect]
 You cannot redefine keywords with macros.
\item [Fatal: Macro buffer overflow while reading or expanding a macro]
 Your macro or it's result  was too long for the compiler.
\item [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.
\item [Error: compiler switches aren't allowed in (* ... *) styled comments]
 Compiler switches should always be between \var{\{ \}} comment delimiters.
\item [Handling switch "arg1"]
 When you set debugging info on (\var{-vd}) the compiler tells you when it
 is evaluating conditional compile statements.
\item [ENDIF arg1 found]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements.
\item [IFDEF arg1 found, arg2]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements.
\item [IFOPT arg1 found, arg2]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements.
\item [IF arg1 found, arg2]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements.
\item [IFNDEF arg1 found, arg2]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements.
\item [ELSE arg1 found, arg2]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements.
\item [Skipping until...]
 When you turn on conditional messages(\var{-vc}), the compiler tells you
 where it encounters conditional statements, and whether it is skipping or
 compiling parts.
\item [Info: Press <return> to continue]
 When the \var{-vi} switch is used, the compiler stops compilation
 and waits for the \var{Enter} key to be pressed when it encounters
 a \var{\{\$STOP\}} directive.
\item [Warning: Unsupported switch arg1]
 When warings are turned on (\var{-vw}) the compiler warns you about
 unsupported switches. This means that the switch is used in Delphi or
 Turbo Pascal, but not in \fpc
\item [Warning: Illegal compiler directive arg1]
 When warings are turned on (\var{-vw}) the compiler warns you about
 unrecognised switches. For a list of recognised switches, \progref
\item [Back in arg1]
 When you use (\var{-vt}) the compiler tells you when it has finished
 reading an include file.
\item [Warning: Unsupported application type: arg1]
 You get this warning, ff you specify an unknown application type
 with the directive \var{\{\$APPTYPE\}}
\item [Warning: APPTYPE isn't support by the target OS]
 The \var{\{\$APPTYPE\}} directive is supported by win32 applications only.
\item [Warning: DESCRIPTION is only supported for OS2 and Win32]
 The \var{\{\$DESCRIPTION\}} directive is only supported for OS2 and Win32 targets.
\item [Note: VERSION is not supported by target OS.]
 The \var{\{\$VERSION\}} directive is only supported by win32 target.
\item [Note: VERSION only for exes or DLLs]
 The \var{\{\$VERSION\}} directive is only used for executable or DLL sources.
\item [Warning: Wrong format for VERSION directive arg1]
 The \var{\{\$VERSION\}} directive format is majorversion.minorversion
 where majorversion and minorversion are words.
\item [Warning: Unsupported assembler style specified arg1]
 When you specify an assembler mode with the \var{\{\$ASMMODE xxx\}}
 the compiler didn't recognize the mode you specified.
\item [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.
\item [Error: Wrong switch toggle, use ON/OFF or +/-]
 You need to use ON or OFF or a + or - to toggle the switch
\item [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
\item [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.
\item [Error: Illegal value for FPU register limit]
 Valid values for this directive are 0..8 and NORMAL/DEFAULT
\item [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.
\item [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 \var{\{\$MACRO ON\}} in the source
\item [Warning: APPID is only supported for PalmOS]
 The \var{\{\$APPID\}} directive is only supported for the PalmOS target.
\item [Warning: APPNAME is only supported for PalmOS]
 The \var{\{\$APPNAME\}} directive is only supported for the PalmOS target.
\item [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.
 \end{description}
 \section{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.
 \begin{description}
\item [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.
\item [Warning: Procedure type FAR ignored]
 This is a warning. \var{FAR} is a construct for 8 or 16 bit programs. Since
 the compile generates 32 bit programs, it ignores this directive.
\item [Warning: Procedure type NEAR ignored]
 This is a warning. \var{NEAR} is a construct for 8 or 16 bit programs. Since
 the compile generates 32 bit programs, it ignores this directive.
\item [Warning: Procedure type INTERRUPT ignored for not i386]
 This is a warning. \var{INTERRUPT} is a i386 specific construct
 and is ignored for other processors.
\item [Error: INTERRUPT procedure can't be nested]
 An \var{INTERRUPT} procedure must be global.
\item [Warning: Procedure type arg1 ignored]
 This is a warning. \var{REGISTER},\var{REINTRODUCE} is ignored by FPC programs for now.
 This is introduced first for Delphi compatibility.
\item [Error: Not all declarations of arg1 are declared with OVERLOAD]
 When you want to use overloading using the \var{OVERLOAD} directive, then
 all declarations need to have \var{OVERLOAD} specified.
\item [Error: No DLL File specified]
 No longer in use.
\item [Error: Duplicate exported function name arg1]
 Exported function names inside a specific DLL must all be different
\item [Error: Duplicate exported function index arg1]
 Exported function names inside a specific DLL must all be different
\item [Error: Invalid index for exported function]
 DLL function index must be in the range \var{1..\$FFFF}
\item [Warning: Relocatable DLL or executable arg1 debug info does not work, disabled.]
\item [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.
\item [Error: Constructor name must be INIT]
 You are declaring a constructor with a name which isn't \var{init}, and the
 \var{-Ss} switch is in effect. See the \var{-Ss} switch (\seeo{Ss}).
\item [Error: Destructor name must be DONE]
 You are declaring a destructor with a name which isn't \var{done}, and the
 \var{-Ss} switch is in effect. See the \var{-Ss} switch (\seeo{Ss}).
\item [Error: Illegal open parameter]
 You are trying to use the wrong type for an open parameter.
\item [Error: Procedure type INLINE not supported]
 You tried to compile a program with C++ style inlining, and forgot to
 specify the \var{-Si} option (\seeo{Si}). The compiler doesn't support C++
 styled inlining by default.
\item [Warning: Private methods shouldn't be VIRTUAL]
 You declared a method in the private part of a object (class) as
 \var{virtual}. This is not allowed. Private methods cannot be overridden
 anyway.
\item [Warning: Constructor should be public]
 Constructors must be in the 'public' part of an object (class) declaration.
\item [Warning: Destructor should be public]
 Destructors must be in the 'public' part of an object (class) declaration.
\item [Note: Class should have one destructor only]
 You can declare only one destructor for a class.
\item [Error: Local class definitions are not allowed]
 Classes must be defined globally. They cannot be defined inside a
 procedure or function
\item [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:
 \begin{verbatim}
 Type o = object
          a : longint;
          end;
 \end{verbatim}
 will trigger this error.
\item [Error: The object arg1 has no VMT]
\item [Error: Illegal parameter list]
 You are calling a function with parameters that are of a different type than
 the declared parameters of the function.
\item [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.
\item [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.
\item [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.
\item [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.
\item [Error: function header doesn't match the forward declaration arg1]
 You declared a function with same parameters but
 different result type or function modifiers.
\item [Error: function header arg1 doesn't match forward : var name changes arg2 => arg3]
 You declared the function in the \var{interface} part, or with the
 \var{forward} directive, but define it with a different parameter list.
\item [Note: Values in enumeration types have to be ascending]
 \fpc allows enumeration constructions as in C. Given the following
 declaration two declarations:
 \begin{verbatim}
 type a = (A_A,A_B,A_E:=6,A_UAS:=200);
 type a = (A_A,A_B,A_E:=6,A_UAS:=4);
 \end{verbatim}
 The second declaration would produce an error. \var{A\_UAS} needs to have a
 value higher than \var{A\_E}, i.e. at least 7.
\item [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).
\item [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.
\item [Error: function nesting > 31]
 You can nest function definitions only 31 times.
\item [Error: range check error while evaluating constants]
 The constants are out of their allowed range.
\item [Warning: range check error while evaluating constants]
 The constants are out of their allowed range.
\item [Error: duplicate case label]
 You are specifying the same label 2 times in a \var{case} statement.
\item [Error: Upper bound of case range is less than lower bound]
 The upper bound of a \var{case} label is less than the lower bound and this
 is useless
\item [Error: typed constants of classes are not allowed]
 You cannot declare a constant of type class or object.
\item [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.
\item [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 \var{Longstrings} and \var{AnsiStrings}.
\item [Warning: use extended syntax of NEW and DISPOSE for instances of objects]
 If you have a pointer \var{a} to a class type, then the statement
 \var{new(a)} will not initialize the class (i.e. the constructor isn't
 called), although space will be allocated. you should issue the
 \var{new(a,init)} statement. This will allocate space, and call the
 constructor of the class.
\item [Warning: use of NEW or DISPOSE for untyped pointers is meaningless]
\item [Error: use of NEW or DISPOSE is not possible for untyped pointers]
 You cannot use \var{new(p)} or \var{dispose(p)} if \var{p} is an untyped pointer
 because no size is associated to an untyped pointer.
 Accepted for compatibility in \var{tp} and \var{delphi} modes.
\item [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.
\item [Error: type identifier not allowed here]
 You cannot use a type inside an expression.
\item [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.
\item [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.
\item [procedure/function arg1]
 When using the \var{-vp} switch, the compiler tells you when it starts
 processing a procedure or function implementation.
\item [Error: Illegal floating point constant]
 The compiler expects a floating point expression, and gets something else.
\item [Error: FAIL can be used in constructors only]
 You are using the \var{FAIL} instruction outside a constructor method.
\item [Error: Destructors can't have parameters]
 You are declaring a destructor with a parameter list. Destructor methods
 cannot have parameters.
\item [Error: Only class methods can be referred with class references]
 This error occurs in a situation like the following:
 \begin{verbatim}
 Type :
    Tclass = Class of Tobject;

 Var C : TClass;

 begin
 ...
 C.free
 \end{verbatim}
 \var{Free} is not a class method and hence cannot be called with a class
 reference.
\item [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:
 \begin{verbatim}
 class procedure tobject.x;

 begin
   free
 \end{verbatim}
 Because free is a normal method of a class it cannot be called from a class
 method.
\item [Error: Constant and CASE types do not match]
 One of the labels is not of the same type as the case variable.
\item [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.
\item [Warning: An inherited method is hidden by arg1]
 A method that is declared \var{virtual} in a parent class, should be
 overridden in the descendent class with the \var{override} directive. If you
 don't specify the \var{override} directive, you will hide the parent method;
 you will not override it.
\item [Error: There is no method in an ancestor class to be overridden: arg1]
 You try to \var{override} a virtual method of a parent class that doesn't
 exist.
\item [Error: No member is provided to access property]
 You specified no \var{read} directive for a property.
\item [Warning: Stored prorperty directive is not yet implemented]
 The \var{stored} directive is not yet implemented
\item [Error: Illegal symbol for property access]
 There is an error in the \var{read} or \var{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.
 \begin{verbatim}
 tmyobject = class
   i : integer;
   property x [i : integer]: integer read I write i;
 \end{verbatim}

\item [Error: Cannot access a protected field of an object here]
 Fields that are declared in a \var{protected} section of an object or class
 declaration cannot be accessed outside the module wher the object is
 defined, or outside descendent object methods.
\item [Error: Cannot access a private field of an object here]
 Fields that are declared in a \var{private} section of an object or class
 declaration cannot be accessed outside the module where the class is
 defined.
\item [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.
\item [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.
\item [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.
\item [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.
\item [Error: methods can't be EXPORTed]
 You cannot declare a procedure that is a method for an object as
 \var{export}ed. That is, your methods cannot be called from a C program.
\item [Error: call by var parameters have to match exactly: Got arg1 expected arg2]
 When calling a function declared with \var{var} parameters, the variables in
 the function call must be of exactly the same type. There is no automatic
 type conversion.
\item [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.
\item [Error: SELF is only allowed in methods]
 You are trying to use the \var{self} parameter outside an object's method.
 Only methods get passed the \var{self} parameters.
\item [Error: methods can be only in other methods called direct with type identifier of the class]
 A construction like \var{sometype.somemethod} is only allowed in a method.
\item [Error: Illegal use of ':']
 You are using the format \var{:} (colon) 2 times on an expression that
 is not a real expression.
\item [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.
\item [Error: Pointer to object expected]
 You specified an illegal type in a \var{New} statement.
 The extended synax of \var{New} needs an  object as a parameter.
\item [Error: Expression must be constructor call]
 When using the extended syntax of \var{new}, you must specify the constructor
 method of the object you are trying to create. The procedure you specified
 is not a constructor.
\item [Error: Expression must be destructor call]
 When using the extended syntax of \var{dispose}, you must specify the
 destructor method of the object you are trying to dispose of.
 The procedure you specified is not a destructor.
\item [Error: Illegal order of record elements]
 When declaring a constant record, you specified the fields in the wrong
 order.
\item [Error: Expression type must be class or record type]
 A \var{with} statement needs an argument that is of the type \var{record}
 or \var{class}. You are using \var{with} on an expression that is not of
 this type.
\item [Error: Procedures can't return a value]
 In \fpc, you can specify a return value for a function when using
 the \var{exit} statement. This error occurs when you try to do this with a
 procedure. Procedures  cannot return a value.
\item [Error: constructors and destructors must be methods]
 You're declaring a procedure as destructor or constructor, when the
 procedure isn't a class method.
\item [Error: Operator is not overloaded]
 You're trying to use an overloaded operator when it isn't overloaded for
 this type.
\item [Error: Impossible to overload assignment for equal types]
 You can not overload assignment for types
 that the compiler considers as equal.
\item [Error: Impossible operator overload]
 The combination of operator, arguments and return type are
 incompatible.
\item [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 \var{except} block.
\item [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
 \var{new}. The constructor must be used for that. For the same reason, you
 cannot call \var{Dispose} to de-allocate an instance of a class, the
 destructor must be used for that.
\item [Error: Assembler incompatible with function return type]
 You're trying to implement a \var{assembler} function, but the return type
 of the function doesn't allow that.
\item [Error: Procedure overloading is switched off]
 When using the \var{-So} switch, procedure overloading is switched off.
 Turbo Pascal does not support function overloading.
\item [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 :
 \begin{verbatim}
    +, -, *, /, =, >, <, <=, >=, is, as, in, **, :=
 \end{verbatim}
\item [Error: Comparative operator must return a boolean value]
 When overloading the \var{=} operator, the function must return a boolean
 value.
\item [Error: Only virtual methods can be abstract]
 You are declaring a method as abstract, when it isn't declared to be
 virtual.
\item [Fatal: Use of unsupported feature!]
 You're trying to force the compiler into doing something it cannot do yet.
\item [Error: The mix of CLASSES and OBJECTS isn't allowed]
 You cannot derive \var{objects} and \var{classes} intertwined . That is,
 a class cannot have an object as parent and vice versa.
\item [Warning: Unknown procedure directive had to be ignored: arg1]
 The procedure direcive you secified is unknown. Recognised procedure
 directives are \var{cdecl}, \var{stdcall}, \var{popstack}, \var{pascal}
 \var{register}, \var{export}.
\item [Error: absolute can only be associated to ONE variable]
 You cannot specify more than one variable before the \var{absolute} directive.
 Thus, the following construct will provide this error:
 \begin{verbatim}
 Var Z : Longint;
     X,Y : Longint absolute Z;
 \end{verbatim}
 \item [ absolute can only be associated a var or const ]
 The address of a \var{absolute} directive can only point to a variable or
 constant. Therefore, the following code will produce this error:
 \begin{verbatim}
   Procedure X;

  var p : longint absolute x;
 \end{verbatim}

\item [Error: absolute can only be associated a var or const]
 The address of a \var{absolute} directive can only point to a variable or
 constant. Therefore, the following code will produce this error:
 \begin{verbatim}
   Procedure X;

  var p : longint absolute x;
 \end{verbatim}

\item [Error: Only ONE variable can be initialized]
 You cannot specify more than one variable with a initial value
 in Delphi syntax.
\item [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.
\item [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.
\item [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.
\item [Macro defined: arg1]
 When \var{-vm} is used, the compiler tells you when it defines macros.
\item [Macro undefined: arg1]
 When \var{-vm} is used, the compiler tells you when it undefines macros.
\item [Macro arg1 set to arg2]
 When \var{-vm} is used, the compiler tells you what values macros get.
\item [Info: Compiling arg1]
 When you turn on information messages (\var{-vi}), the compiler tells you
 what units it is recompiling.
\item [Parsing interface of unit arg1]
 This tells you that the reading of the interface
 of the current unit starts
\item [Parsing implementation of arg1]
 This tells you that the code reading of the implementation
 of the current unit, library or program starts
\item [Compiling arg1 for the second time]
 When you request debug messages (\var{-vd}) the compiler tells you what
 units it recompiles for the second time.
\item [Error: Array properties aren't allowed here]
 You cannot use array properties at that point in the source.
\item [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.
\item [Error: Only one default property is allowed, found inherited default property in class arg1]
 You specified a property as \var{Default}, but a parent class already has a
 default property, and a class can have only one default property.
\item [Error: The default property must be an array property]
 Only array properties of classes can be made \var{default} properties.
\item [Error: Virtual constructors are only supported in class object model]
 You cannot have virtual constructors in objects. You can only have them
 in classes.
\item [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.
\item [Error: The class can't have a published section, use the {\$M+} switch]
 If you want a \var{published} section in a class definition, you must
 use the \var{\{\$M+\}} switch, whch turns on generation of type
 information.
\item [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:
 \begin{verbatim}
  Type ParentClas = Class;
       ChildClass = Class(ParentClass)
         ...
       end;
 \end{verbatim}
 Where \var{ParentClass} is declared but not defined.
\item [Error: Local operators not supported]
 You cannot overload locally, i.e. inside procedures or function
 definitions.
\item [Error: Procedure directive arg1 not allowed in interface section]
 This procedure directive is not allowed in the \var{interface} section of
 a unit. You can only use it in the \var{implementation} section.
\item [Error: Procedure directive arg1 not allowed in implementation section]
 This procedure directive is not defined in the \var{implementation} section of
 a unit. You can only use it in the \var{interface} section.
\item [Error: Procedure directive arg1 not allowed in procvar declaration]
 This procedure directive cannot be part of a procedural or function
 type declaration.
\item [Error: Function is already declared Public/Forward arg1]
 You will get this error if a function is defined as \var{forward} twice.
 Or it is once in the \var{interface} section, and once as a \var{forward}
 declaration in the \var{implmentation} section.
\item [Error: Can't use both EXPORT and EXTERNAL]
 These two procedure directives are mutually exclusive
\item [Error: NAME keyword expected]
 The definition of an external variable needs a \var{name} clause.
\item [Warning: arg1 not yet supported inside inline procedure/function]
 Inline procedures don't support this declaration.
\item [Warning: Inlining disabled]
 Inlining of procedures is disabled.
\item [Info: Writing Browser log arg1]
 When information messages are on, the compiler warns you when it
 writes the browser log (generated with the \var{\{\$Y+ \}} switch).
\item [Hint: Maybe pointer dereference is missing]
 The compiler thinks that a pointer may need a dereference.
\item [Fatal: Selected assembler reader not supported]
 The selected assembler reader (with \var{\{\$ASMMODE xxx\}} is not
 supported. The compiler can be compiled with or without support for a
 particular assembler reader.
\item [Error: Procedure directive arg1 has conflicts with other directives]
 You specified a procedure directive that conflicts with other directives.
 for instance \var{cdecl} and \var{pascal} are mutually exclusive.
\item [Error: Calling convention doesn't match forward]
 This error happens when you declare a function or procedure with
 e.g. \var{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.
\item [Error: Register calling (fastcall) not supported]
 The \var{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.
\item [Error: Property can't have a default value]
 Set properties or indexed properties cannot have a default value.
\item [Error: The default value of a property must be constant]
 The value of a \var{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.
\item [Error: Symbol can't be published, can be only a class]
 Only class type variables can be in a \var{published} section of a class
 if they are not declared as a property.
\item [Error: That kind of property can't be published]
 Properties in a \var{published} section cannot be array properties.
 they must be moved to public sections. Properties in a \var{published}
 section must be an ordinal type, a real type, strings or sets.
\item [Warning: Empty import name specified]
 Both index and name for the import are 0 or empty
\item [Warning: An import name is required]
 Some targets need a name for the imported procedure or a cdecl specifier
\item [Error: Function internal name changed after use of function]
 This is an internal error; please report any occurrences of this error
 to the \fpc team.
\item [Error: Division by zero]
 There is a divsion by zero encounted
\item [Error: Invalid floating point operation]
 An operation on two real type values produced an overflow or a division
 by zero.
\item [Error: Upper bound of range is less than lower bound]
 The upper bound of a \var{case} label is less than the lower bound and this
 is not possible
\item [Warning: string "arg1" is longer than arg2]
 The size of the constant string is larger than the size you specified in
 string type definition
\item [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
\item [Error: Illegal expression after message directive]
 \fpc supports only integer or string values as message constants
\item [Error: Message handlers can take only one call by ref. parameter]
 A method declared with the \var{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{var}-directive
\item [Error: Duplicate message label: arg1]
 A label for a message is used twice in one object/class
\item [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.
\item [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
\item [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
\item [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 \var{\{\$mode objfpc\}} or
 \var{\{\$mode delphi\}}
 directives which load the unit automaticly
\item [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
\item [Error: Data types which requires initialization/finalization can't be used in variant records]
 Some data type (e.g. \var{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.
\item [Error: Resourcestrings can be only static or global]
 Resourcestring can not be declared local, only global or using the static
 directive.
\item [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 \var{try..except} or \var{try..finally} blocks
\item [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
\item [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
\item [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 \var{\{\$M+\}} or which are derived from such a class. Normally
 such a class should be derived from TPersitent
\item [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:
 \begin{verbatim}
 const
   p : procedure;stdcall=nil;
   p : procedure stdcall=nil;
 \end{verbatim}
\item [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.
\item [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.
\item [Error: No DEFFILE entry can be generated for unit global vars]
\item [Error: Compile without -WD option]
 You need to compile this file without the -WD switch on the
 commandline
\item [Fatal: You need ObjFpc (-S2) or Delphi (-Sd) mode to compile this module]
 You need to use \var{\{\$mode objfpc\}} or \var{\{\$mode delphi\}} to compile this file.
 Or use the equivalent commandline switches -S2 or -Sd.
\item [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.
\item [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.
\item [Error: Type "arg1" can't be used as array index type]
 Types like DWord or Int64 aren't allowed as array index type
\item [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.
\item [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
\item [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.
\item [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
\item [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).
 \end{description}
 \section{Type checking errors}
 This section lists all errors that can occur when type checking is
 performed.
 \begin{description}
\item [Error: Type mismatch]
 This can happen in many cases:
 \begin{itemize}
 \item The variable you're assigning to is of a different type than the
 expression in the assignment.
 \item You are calling a function or procedure with parameters that are
 incompatible with the parameters in the function or procedure definition.
 \end{itemize}
\item [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:
 \begin{verbatim}
 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.
 \end{verbatim}
\item [Error: Type mismatch between arg1 and arg2]
 The types are not equal
\item [Error: Type identifier expected]
 The identifier is not a type, or you forgot to supply a type identifier.
\item [Error: Variable identifier expected]
 This happens when you pass a constant to a \var{Inc} var or \var{Dec}
 procedure. You can only pass variables as arguments to these functions.
\item [Error: Integer expression expected, but got "arg1"]
 The compiler expects an expression of type integer, but gets a different
 type.
\item [Error: Boolean expression expected, but got "arg1"]
 The expression must be a boolean type, it should be return true or
 false.
\item [Error: Ordinal expression expected]
 The expression must be of ordinal type, i.e., maximum a \var{Longint}.
 This happens, for instance, when you specify a second argument
 to \var{Inc} or \var{Dec} that doesn't evaluate to an ordinal value.
\item [Error: pointer type expected, but got "arg1"]
 The variable or expression isn't of the type \var{pointer}. This
 happens when you pass a variable that isn't a pointer to \var{New}
 or \var{Dispose}.
\item [Error: class type expected, but got "arg1"]
 The variable of expression isn't of the type \var{class}. This happens
 typically when
 \begin{enumerate}
 \item The parent class in a class declaration isn't a class.
 \item An exception handler (\var{On}) contains a type identifier that
 isn't a class.
 \end{enumerate}
\item [Error: Variable or type indentifier expected]
 The argument to the \var{High} or \var{Low} function is not a variable
 nor a type identifier.
\item [Error: Can't evaluate constant expression]
 No longer in use.
\item [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
\item [Error: Operation not implemented for sets]
 several binary operations are not defined for sets
 like div mod ** (also >= <= for now)
\item [Warning: Automatic type conversion from floating type to COMP which is an integer type]
 An implicit type conversion from a real type to a \var{comp} is
 encountered. Since \var{Comp} is a 64 bit integer type, this may indicate
 an error.
\item [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
\item [Error: string types doesn't match, because of \$V+ mode]
 When compiling in \var{\{\$V+\}} mode, the string you pass as a parameter
 should be of the exact same type as the declared parameter of the procedure.
\item [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:
 \begin{verbatim}
   Tenum = (a,b,e:=5);
 \end{verbatim}
 you cannot use the \var{Succ} or \var{Pred} functions on them.
\item [Error: Can't read or write variables of this type]
 You are trying to \var{read} or \var{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.
\item [Error: Can't use readln or writeln on typed file]
 \var{readln} and \var{writeln} are only allowed for text files.
\item [Error: Can't use read or write on untyped file.]
 \var{read} and \var{write} are only allowed for text or typed files.
\item [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.
\item [Warning: lo/hi(dword/qword) returns the upper/lower word/dword]
 \fpc supports an overloaded version of \var{lo/hi} for \var{longint/dword/int64/qword}
 which returns the lower/upper word/dword of the argument. TP always uses
 a 16 bit \var{lo/hi} which returns always bits 0..7 for \var{lo} and the
 bits 8..15 for \var{hi}. If you want the TP behavior you have
 to type cast the argument to \var{word/integer}
\item [Error: Integer or real expression expected]
 The first argument to \var{str} must a real or integer type.
\item [Error: Wrong type arg1 in array constructor]
 You are trying to use a type in an array constructor which is not
 allowed.
\item [Error: Incompatible type for arg no. arg1: Got arg2, expected arg3]
 You are trying to pass an invalid type for the specified parameter.
\item [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.
\item [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.
\item [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.
\item [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
\item [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.
\item [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.
\item [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.
\item [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.
\item [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.
\item [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.
\item [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.
 \end{description}
 \section{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.
 \begin{description}
\item [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.
\item [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.
\item [Error: Duplicate identifier arg1]
 The identifier was already declared in the current scope.
\item [Hint: Identifier already defined in arg1 at line arg2]
 The identifier was already declared in a previous scope.
\item [Error: Unknown identifier arg1]
 The identifier encountered hasn't been declared, or is used outside the
 scope where it's defined.
\item [Error: Forward declaration not solved arg1]
 This can happen in two cases:
 \begin{itemize}
 \item This happens when you declare a function (in the \var{interface} part, or
 with a \var{forward} directive, but do not implement it.
 \item You reference a type which isn't declared in the current \var{type}
 block.
 \end{itemize}
\item [Fatal: Identifier type already defined as type]
 You are trying to redefine a type.
\item [Error: Error in type definition]
 There is an error in your definition of a new array type:
 \item One of the range delimiters in an array declaration is erroneous.
 For example, \var{Array [1..1.25]} will trigger this error.
\item [Error: Type identifier not defined]
 The type identifier has not been defined yet.
\item [Error: Forward type not resolved arg1]
 A symbol was forward defined, but no declaration was encountered.
\item [Error: Only static variables can be used in static methods or outside methods]
 A static method of an object can only access static variables.
\item [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.
\item [Fatal: record or class type expected]
 The variable or expression isn't of the type \var{record} or \var{class}.
\item [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.
\item [Warning: Label not defined arg1]
 A label was declared, but not defined.
\item [Error: Label used but not defined arg1]
 A label was declared and used, but not defined.
\item [Error: Illegal label declaration]
 This error should never happen; it occurs if a label is defined outside a
 procedure or function.
\item [Error: GOTO and LABEL are not supported (use switch -Sg)]
 You must compile a program which has \var{label}s and \var{goto} statements
 with the  \var{-Sg} switch. By default, \var{label} and \var{goto} aren't
 supported.
\item [Error: Label not found]
 A \var{goto label} was encountered, but the label isn't declared.
\item [Error: identifier isn't a label]
 The identifier specified after the \var{goto} isn't of type label.
\item [Error: label already defined]
 You are defining a label twice. You can define a label only once.
\item [Error: illegal type declaration of set elements]
 The declaration of a set contains an invalid type definition.
\item [Error: Forward class definition not resolved arg1]
 You declared a class, but you didn't implement it.
\item [Hint: Unit arg1 not used in arg2]
 The unit referenced in the \var{uses} clause is not used.
\item [Hint: Parameter arg1 not used]
 This is a warning. The identifier was declared (locally or globally) but
 wasn't used (locally or globally).
\item [Note: Local variable arg1 not used]
 You have declared, but not used a variable in a procedure or function
 implementation.
\item [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).
\item [Note: Local variable arg1 is assigned but never used]
 The variable in a procedure or function
 implementation is declared, set but never used.
\item [Hint: Local arg1 arg2 is not used]
 A local symbol is never used.
\item [Note: Private field arg1.arg2 is never used]
\item [Note: Private field arg1.arg2 is assigned but never used]
\item [Note: Private method arg1.arg2 never used]
\item [Error: Set type expected]
 The variable or expression isn't of type \var{set}. This happens in an
 \var{in} statement.
\item [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.
\item [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.
\item [Error: Unknown record field identifier arg1]
 The field doesn't exist in the record definition.
\item [Warning: Local variable arg1 does not seem to be initialized]
\item [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)
\item [Error: identifier idents no member arg1]
 When using the extended syntax of \var{new}, you must specify the constructor
 method of the class you are trying to create. The procedure you specified
 does not exist.
\item [Found declaration: arg1]
 You get this when you use the \var{-vb} switch. In case an overloaded
 procedure is not found, then all candidate overloaded procedures are
 listed, with their parameter lists.
\item [Error: Data segment too large (max. 2GB)]
 You get this when you declare an array whose size exceeds the 2GB limit.
 \end{description}
 \section{Code generator messages}
 This section lists all messages that can be displayed if the code
 generator encounters an error condition.
 \begin{description}
\item [Error: BREAK not allowed]
 You're trying to use \var{break} outside a loop construction.
\item [Error: CONTINUE not allowed]
 You're trying to use \var{continue} outside a loop construction.
\item [Error: Expression too complicated - FPU stack overflow]
 Your expression is too long for the compiler. You should try dividing the
 construct over multiple assignments.
\item [Error: Illegal expression]
 This can occur under many circumstances. Mostly when trying to evaluate
 constant expressions.
\item [Error: Invalid integer expression]
 You made an expression which isn't an integer, and the compiler expects the
 result to be an integer.
\item [Error: Illegal qualifier]
 One of the following is happening :
 \begin{itemize}
 \item You're trying to access a field of a variable that is not a record.
 \item You're indexing a variable that is not an array.
 \item You're dereferencing a variable that is not a pointer.
 \end{itemize}
\item [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.
\item [Error: Illegal counter variable]
 The type of a \var{for} loop variable must be an ordinal type.
 Loop variables cannot be reals or strings.
\item [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 \var{word} and \var{longint}, and then you call
 it with a parameter which is of type \var{integer}.
\item [Error: Parameter list size exceeds 65535 bytes]
 The I386 processor limits the parameter list to 65535 bytes (the \var{RET}
 instruction causes this)
\item [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.
\item [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.
\item [Error: File types must be var parameters]
 You cannot specify files as value parameters, i.e. they must always be
 declared \var{var} parameters.
\item [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 \var{mem} construct
 has a far reference as a result, so the following code will produce this
 error:
 \begin{verbatim}
 var p : pointer;
 ...
 p:=@mem[a000:000];
 \end{verbatim}
\item [Error: illegal call by reference parameters]
 You are trying to pass a constant or an expression to a procedure that
 requires a \var{var} parameter. Only variables can be passed as a \var{var}
 parameter.
\item [Error: EXPORT declared functions can't be called]
 No longer in use.
\item [Warning: Possible illegal call of constructor or destructor (doesn't match to this context)]
 No longer in use.
\item [Note: Inefficient code]
 You construction seems dubious to the compiler.
\item [Warning: unreachable code]
 You specified a loop which will never be executed. Example:
 \begin{verbatim}
 while false do
   begin
   {.. code ...}
   end;
 \end{verbatim}
\item [Error: procedure call with stackframe ESP/SP]
 The compiler encountered a procedure  or function call inside a
 procedure that uses a \var{ESP/SP} stackframe. Normally, when a call is
 done the procedure needs a \var{EBP} stackframe.
\item [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.
\item [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.
\item [Fatal: Unknown float type]
 The compiler cannot determine the kind of float that occurs in an expression.
\item [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.
\item [Fatal: Extended cg68k not supported]
 The \var{extended} type is not supported on the m68k platform.
\item [Fatal: 32-bit unsigned not supported in MC68000 mode]
 The cardinal is not supported on the m68k platform.
\item [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.
\item [Register arg1 weight arg2 arg3]
 Debugging message. Shown when the compiler considers a variable for
 keeping in the registers.
\item [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.
\item [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.
\item [Error: Object or class methods can't be inline.]
 You cannot have inlined object methods.
\item [Error: Procvar calls can't be inline.]
 A procedure with a procedural variable call cannot be inlined.
\item [Error: No code for inline procedure stored]
 The compiler couldn't store code for the inline procedure.
\item [Error: Direct call of interrupt procedure arg1 is not possible]
 You can not call an interrupt procedure directly from FPC code
\item [Error: Element zero of an ansi/wide- or longstring can't be accessed, use (set)length instead]
 You should use \var{setlength} to set the length of an ansi/wide/longstring
 and \var{length} to get the length of such kinf of string
\item [Error: Include and exclude not implemented in this case]
 \var{include} and \var{exclude} are only partially
 implemented for \var{i386} processors
 and not at all for \var{m68k} processors.
\item [Error: Constructors or destructors can not be called inside a 'with' clause]
 Inside a \var{With} clause you cannot call a constructor or destructor for the
 object you have in the \var{with} clause.
\item [Error: Cannot call message handler method directly]
 A message method handler method can't be called directly if it contains an
 explicit self argument
\item [Error: Jump in or outside of an exception block]
 It isn't allowed to jump in or outside of an exception block like \var{try..finally..end;}:
 \begin{verbatim}
 label 1;

 ...

 try
    if not(final) then
      goto 1;   // this line will cause an error
 finally
   ...
 end;
 1:
 ...
 \end{verbatim}
\item [Error: Control flow statements aren't allowed in a finally block]
 It isn't allowed to use the control flow statements \var{break},
 \var{continue} and \var{exit}
 inside a finally statement. The following example shows the problem:
 \begin{verbatim}
 ...
   try
      p;
   finally
      ...
      exit;  // This exit ISN'T allowed
   end;
 ...

 \end{verbatim}
 If the procedure \var{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
 \end{description}

 \section{Errors of assembling/linking stage}
 This section lists errors that occur when the compiler is processing the
 command line or handling the configuration files.
 \begin{description}
\item [Warning: Source operating system redefined]
\item [Info: Assembling (pipe) arg1]
\item [Error: Can't create assember file: arg1]
 The mentioned file can't be create. Check if you've
 permission to create this file
\item [Error: Can't create object file: arg1]
 The mentioned file can't be create. Check if you've
 permission to create this file
\item [Error: Can't create archive file: arg1]
 The mentioned file can't be create. Check if you've
 permission to create this file
\item [Error: Assembler arg1 not found, switching to external assembling]
\item [Using assembler: arg1]
\item [Error: Error while assembling exitcode arg1]
\item [Error: Can't call the assembler, error arg1 switching to external assembling]
\item [Info: Assembling arg1]
\item [Info: Assembling smartlink arg1]
\item [Warning: Object arg1 not found, Linking may fail !]
\item [Warning: Library arg1 not found, Linking may fail !]
\item [Error: Error while linking]
\item [Error: Can't call the linker, switching to external linking]
\item [Info: Linking arg1]
\item [Error: Util arg1 not found, switching to external linking]
\item [Using util arg1]
\item [Error: Creation of Executables not supported]
\item [Error: Creation of Dynamic/Shared Libraries not supported]
\item [Info: Closing script arg1]
\item [Error: resource compiler not found, switching to external mode]
\item [Info: Compiling resource arg1]
\item [unit arg1 can't be static linked, switching to smart linking]
\item [unit arg1 can't be smart linked, switching to static linking]
\item [unit arg1 can't be shared linked, switching to static linking]
\item [Error: unit arg1 can't be smart or static linked]
\item [Error: unit arg1 can't be shared or static linked]
\end{description}
 \section{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.
 \begin{description}
\item [Unitsearch: arg1]
 When you use the \var{-vt}, the compiler tells you where it tries to find
 unit files.
\item [PPU Loading arg1]
 When the \var{-vt} switch is used, the compiler tells you
 what units it loads.
\item [PPU Name: arg1]
 When you use the \var{-vu} flag, the unit name is shown.
\item [PPU Flags: arg1]
 When you use the \var{-vu} flag, the unit flags are shown.
\item [PPU Crc: arg1]
 When you use the \var{-vu} flag, the unit CRC check is shown.
\item [PPU Time: arg1]
 When you use the \var{-vu} flag, the time the unit was compiled is shown.
\item [PPU File too short]
 The ppufile is too short, not all declarations are present.
\item [PPU Invalid Header (no PPU at the begin)]
 A unit file contains as the first three bytes the ascii codes of \var{PPU}
\item [PPU Invalid Version arg1]
 This unit file was compiled with a different version of the compiler, and
 cannot be read.
\item [PPU is compiled for an other processor]
 This unit file was compiled for a different processor type, and
 cannot be read
\item [PPU is compiled for an other target]
 This unit file was compiled for a different target, and
 cannot be read
\item [PPU Source: arg1]
 When you use the \var{-vu} flag, the unit CRC check is shown.
\item [Writing arg1]
 When you specify the \var{-vu} switch, the compiler will tell you where it
 writes the unit file.
\item [Fatal: Can't Write PPU-File]
 An error occurred when writing the unit file.
\item [Fatal: Error reading PPU-File]
 This means that the unit file was corrupted, and contains invalid
 information. Recompilation will be necessary.
\item [Fatal: unexpected end of PPU-File]
 Unexpected end of file.
\item [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.
\item [Fatal: PPU Dbx count problem]
 There is an inconsistency in the debugging information of the unit.
\item [Error: Illegal unit name: arg1]
 The name of the unit doesn't match the file name.
\item [Fatal: Too much units]
 \fpc has a limit of 1024 units in a program. You can change this behavior
 by changing the \var{maxunits} constant in the \file{files.pas} file of the
 compiler, and recompiling the compiler.
\item [Fatal: Circular unit reference between arg1 and arg2]
 Two units are using each other in the interface part. This is only allowed
 in the \var{implementation} part. At least one unit must contain the other one
 in the \var{implementation} section.
\item [Fatal: Can't compile unit arg1, no sources available]
 A unit was found that needs to be recompiled, but no sources are
 available.
\item [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.
\item [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
\item [Warning: Unit arg1 was not found but arg2 exists]
\item [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.
\item [Warning: Compiling the system unit requires the -Us switch]
 When recompiling the system unit (it needs special treatment), the
 \var{-Us} must be specified.
\item [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.
\item [Load from arg1 (arg2) unit arg3]
 When you use the \var{-vu} flag, which unit is loaded from which unit is
 shown.
\item [Recompiling arg1, checksum changed for arg2]
\item [Recompiling arg1, source found only]
 When you use the \var{-vu} flag, these messages tell you why the current
 unit is recompiled.
\item [Recompiling unit, static lib is older than ppufile]
 When you use the \var{-vu} flag, the compiler warns if the static library
 of the unit are older than the unit file itself.
\item [Recompiling unit, shared lib is older than ppufile]
 When you use the \var{-vu} flag, the compiler warns if the shared library
 of the unit are older than the unit file itself.
\item [Recompiling unit, obj and asm are older than ppufile]
 When you use the \var{-vu} flag, the compiler warns if the assembler or
 object file of the unit are older than the unit file itself.
\item [Recompiling unit, obj is older than asm]
 When you use the \var{-vu} flag, the compiler warns if the assembler
 file of the unit is older than the object file of the unit.
\item [Parsing interface of arg1]
 When you use the \var{-vu} flag, the compiler warns that it starts
 parsing the interface part of the unit
\item [Parsing implementation of arg1]
 When you use the \var{-vu} flag, the compiler warns that it starts
 parsing the implementation part of the unit
\item [Second load for unit arg1]
 When you use the \var{-vu} flag, the compiler warns that it starts
 recompiling a unit for the second time. This can happend with interdepend
 units.
\item [PPU Check file arg1 time arg2]
 When you use the \var{-vu} flag, the compiler show the filename and
 date and time of the file which a recompile depends on
\item [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.
\item [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.
\item [Hint: File arg1 is newer than Release PPU file arg2]
 \end{description}

 \section{Command-line handling errors}
 This section lists errors that occur when the compiler is processing the
 command line or handling the configuration files.
 \begin{description}
\item [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 \var{'-'} sign.
\item [Warning: DEF file can be created only for OS/2]
 This option can only be specified when you're compiling for OS/2
\item [Error: nested response files are not supported]
 you cannot nest response files with the \var{@file} command-line option.
\item [Fatal: No source file name in command line]
 The compiler expects a source file name on the command line.
\item [Note: No option inside arg1 config file]
 The compiler didn't find any option in that config file.
\item [Error: Illegal parameter: arg1]
 You specified an unknown option.
\item [Hint: -? writes help pages]
 When an unknown option is given, this message is diplayed.
\item [Fatal: Too many config files nested]
 You can only nest up to 16 config files.
\item [Fatal: Unable to open file arg1]
 The option file cannot be found.
\item [Reading further options from arg1]
 Displayed when you have notes turned on, and the compiler switches
 to another options file.
\item [Warning: Target is already set to: arg1]
 Displayed if more than one \var{-T} option is specified.
\item [Warning: Shared libs not supported on DOS platform, reverting to static]
 If you specify \var{-CD} for the \dos platform, this message is displayed.
 The compiler supports only static libraries under \dos
\item [Fatal: too many IF(N)DEFs]
 the \var{\#IF(N)DEF} statements in the options file are not balanced with
 the \var{\#ENDIF} statements.
\item [Fatal: too many ENDIFs]
 the \var{\#IF(N)DEF} statements in the options file are not balanced with
 the \var{\#ENDIF} statements.
\item [Fatal: open conditional at the end of the file]
 the \var{\#IF(N)DEF} statements in the options file are not balanced with
 the \var{\#ENDIF} statements.
\item [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
 \var{-g} switch, this warning will be displayed.
\item [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
 \var{-g} switch, this warning will be displayed.
\item [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.
\item [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.
\item [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.
\item [Warning: Assembler output selected "arg1" is not compatible with "arg2"]
\item [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.
\item [*** press enter ***]
\end{description}
