The list of the most common messages of the Error class (to find the error you need, use Ctrl + F.):
0. <Smth1> expected but <Smth2> found. This message usually occurs with a syntax error. For example, in the case of non-balance brackets, the compiler will report: ')' expected but ';' found (comma was found instead of the expected parenthesis).
The compiler often reports that the 'end' is expected, for example: x:= 5,7; here the comma delimiter is inappropriate, and the end is reported. ('END' expected but ',' found)
1. <Name> is not a type identifier. This <Name> is not a type name.
2. ‘;’ not allowed before 'Else'. Do not put a semicolon before else.
3. Abstract method must be virtual or dynamic.
4. Ambiguous overloaded call to <Block name>. The compiler cannot unambiguously select an overloaded block. Change the setting.
5. Array type required. The error occurs in cases when the index of the array element indicates more levels than provided by the description, and if the array is not described. For example, after declaring a two-dimensional array x or a simple variable x, the element x [2,1,1] is mistakenly written (it shows three dimensions).
6. Assignment to FOR-loop variable <Name>. Assigning a value to the FOR loop parameter in the loop body.
For example, due to a slip, the name i is used twice in a multiple cycle:
For i:= 1 to n do For i:= 1 to m do ...
7. Break or Continue outside of loop. Break or Continue is not in a loop.
8. Cannot initialize local variables. Local variables are not allowed to initialize (set them values in the description).
9. Cannot assign to/read a read-only/write-only property. Assigning a value to the read / only property and reading the write / only property is prohibited.
10. Constant expression expected. At this point there should be a constant or constant expression, for example, the selection constant in the Case structure.
11. Constant expression violates subrange bounds. The output of a constant value from the range. The control is not complete. For example, “get away with hands” assignment x: = 3000000000, where x is of type integer, but the value of x will be distorted.
12. Constant or type identifier expected. A type name or type-range is required.
13. Could not compile used unit <Name>. Compilation of the attached module <Name> is not possible.
14. Data type too large. The type defines a structure larger than 2 GB; it's too much.
15. Declaration expected but <Smth> found. Missing description or operator.
16. Declaration of <Name> differs from previous declarations. This block header does not correspond to the block ahead declaration.
17. Default parameter <Name> must be by-value or constant. The optional parameter (with default value) should not be called by reference.
18. Expression expected. In this place of the program should be an expression.
19. Expression too complicated. The expression is unnecessarily difficult to compile.
20. File type not allowed here. In this place or in this role, the file variable cannot be used. For example, it cannot be a formal parameter value.
21. For loop control variable must be simple local variable. The loop parameter must be a simple local (described in the same block) variable.
22. For loop control variable must have ordinal type. The loop parameter must be of ordinal type. Real type is prohibited.
23. Function needs result type. In the function header, you must specify the type of its result.
24. Identifier expected but <Smth> found. In this place should be the name. For example, the name is missing
functions after Function.
25. Identifier redeclared <Name>. <Name> is described again, but within a block, a name can only be described once. Check whether the local variable is indicated by the same name as the formal block parameter.
26. Illegal character in input file <sign>. Forbidden sign, for example, “Russian” letter, or you left the bracket }, removing the opening bracket {.
27. Illegal type in Read/Readln (Write/Writeln) statement. The element of the forbidden type in the list of I/O.
28. Incompatible types <type indication>. Mismatch of types on assignment or types of operands of one operation. The message is also issued when structures are used incorrectly. For example, z is a record, the assignment z: = 0 is mistakenly written (it is necessary to work with record fields).
29. Invalid function result type. Invalid function result type.
30. Label already defined: <Label>. <Label> already marks another statement.
31. Left side cannot be assigned to. There cannot be such left side in assignment. Examples: an attempt to assign a value to a file variable, assigning a value to a formal constant parameter.
32. Line too long. In the line of the program text more than 255 characters.
33. Low bound exceeds high bound. The lower limit exceeds the upper one.
34. Missing operator or semicolon. Skipping an operation (for example, before the parenthesis) or skipping a semicolon. When skipping ';' error marker is on the next sentence (declaration or statement).
35. Missing parameter type. No type of formal parameter value or procedure type parameter is specified.
36. Not enough actual parameters. Not enough actual parameters.
37. Need to specify at least one dimension. It is necessary to set at least one size of the dynamic array in the SetLength operator.
38. Number of elements differs from declaration. The number of elements in the structural constant does not match its description.
39. Operator not applicable to this operand type. The operation is not applicable to operands of this type. For example: 'А' or 'В'; 'Text1'* 'Text2'.
40. Order of fields in record constant differs from declaration. The order of the fields in the constant record does not match the description of the record.
41. Ordinal type required. An ordinal type is required (for example, in an index).
42. Out of memory. The compiler does not have enough memory.
43. Statement expected but <Smth> found. The operator must be in this place. The message is issued in all cases when the description (<Smth>) is mistakenly placed in the body of the block or the initialization section. An erroneous form of calling the Procedure <Name> procedure or the Function <Name> function also causes a message.
44. Sets may have at most 256 elements. A set (type Set) cannot contain more than 256 elements.
45. Slice standard function only allowed as open array argument. The function Slice can only be used as an actual parameter.
46. Statement not allowed in interface part. The sentences in the program module interface section are not allowed.
47. Syntax error in real number. Syntax error in writing a real type number.
48. There is no overload version of <Name> that can be called with these arguments. An overloaded <Name> block that could be called with this argument is not provided. Example: IntToStr(x), where x is a real type expression.
49. Too many actual parameters. There are more actual parameters than formal ones.
50. Type actual and formal var parameters must be identical. The type of the actual parameter must be identical to the type
formal parameter variable.
51. Type of expression must be <Type>. The expression must be of the specified type. For example, after While and Until should be a logical expression.
52. Undeclared identifier: <Name>. Not described <Name>. Check if the description is in the right place, if there are any typos in the name. If the name of the form component is specified, check whether the component was placed on the given form.
53. Unexpected end of file in comment started on line <N>. Unexpected end of file with incomplete comments, beginning of comment - in line N.
54. Unit name mismatch: <Name>. The module name is wrong.
55. Unsatisfied forward or external declaration <Name>. There is no description of the block whose declaration was given (header in the interface or in the description of the object type, or a proactive description).
56. Unterminate string. He is closed with an apostrophe constant string of type string.
Consider also some messages of the classes warning and hint.
1. Return value of function <Name> might be undefined. There is no assignment of its result in the function body.
2. Variable <Name> might not have been initialized. Specifies the name of a variable with no value specified.
3. For-Loop variable <Name> may be undefined after loop. Attempt to use the value of the parameter For-loop after the completion of this loop.
4. Text after final ‘END.' ignored by compiler. The text following the final line of the module is ignored by the compiler.
5. Variable <Name> is declared but never used in <Block name>. Draws attention to the variable <Name>, described, but not found application.
6. Value assigned to <Name> never used. At least one value of the <Name> variable is not used at all.
Some recommendations:
Do not delete the old version of the code until you are sure that the error has been fixed. It is better to comment out the code at the time, enclosing it in brackets: {code}
The compiler does not analyze how the program will be executed, therefore, the output of the index value from the range reveals only if the index is specified by a constant expression. The division by zero is generally skipped, except for the div operator, in case the divisor is a constant expression.