|
|
@@ -1,1513 +0,0 @@
|
|
|
- \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}
|
peter