Note: Turbo C's source program errors are divided into three types: fatal errors, general errors, and warnings. Among them, fatal errors are usually internal compilation errors; general errors refer to program syntax errors, disk or memory access errors, or command line errors, etc.; warnings only point out some suspicious situations, and they do not prevent compilation from proceeding.
The following lists fatal errors and general error information in alphabetical order A to Z, and compares and deals with English-Chinese:
(1) English-Chinese comparison and treatment methods for fatal errors:
A-B fatal error
Bad call of in-line function (Illegal call to the internal function)
Analysis and processing: When using an internal function defined by a macro, it cannot be called correctly. An internal function starts and ends with two underscores (__).
Irreducable expression tree (Unreducible expression tree)
Analysis and processing: This error refers to the expression in the file line being too complex, making the code generator unable to generate code for it. This expression must be avoided.
Register allocation failure (memory allocation failed)
Analysis and processing: This error refers to the expression in the file line being too complex and the code generator cannot generate code for it. This complicated expression should be simplified or simply avoid using it.
(II) General error information English and Chinese photos and processing methods
#operator not followed by maco argument name (# operator is not followed by macro change element name)
Analysis and processing: In the macro definition, # is used to identify a macro variable string. The “#” number must be followed by a macro change element name.
'xxxxx' not anargument ('xxxxx' is not a function parameter)
Analysis and processing: Define this identifier as a function parameter in the source program, but this identifier does not appear in the function.
Ambiguous symbol 'xxxxxx' (ambiguous symbol 'xxxxxx')
Analysis and processing: A domain name of two or more structures is the same, but has different offsets and types. When referring to the domain in a variable or expression without a structure name, ambiguousness will occur. At this time, a certain domain name needs to be modified or a structure name is added when referring to it.
Argument # missing name (parameter # name is missing)
Analysis and processing: The parameter name has been separated from the function prototype used to define the function. If the function is defined as a prototype, the function must contain all parameter names. Argument list syntax error (Syntax error occurred in the parameter table)
Analysis and processing: The parameters of a function call must be separated by commas and ended with a close bracket. If the source file contains a parameter that is followed by a comma or a close bracket, an error occurs.
Array bounds missing (the bounds of the array "]" is missing)
Analysis and processing: An array is defined in the source file, but this array does not end with the following right square brackets.
Array size too large (array too large)
Analysis and processing: The defined array is too large, exceeding the available memory space.
Assembler statement too long (assembly statement is too long)
Analysis and processing: The maximum length of internal assembly statements cannot exceed 480 bytes.
Bad configuration file (Incorrect configuration file)
Analysis and processing: The configuration file contains non-annotated text that is not suitable for command line selections. The configuration file command selection must start with a short horizontal line.
Bad file name format in include directive (including the file name format in the instruction is incorrect)
Analysis and processing: The included file name must be enclosed in quotes ("") or angle brackets (<filename>), otherwise this class of error will be generated. If a macro is used, the generated extended text is also incorrect because there is no quotation marks to identify.
Bad ifdef directive syntax (ifdef directive syntax error)
Analysis and processing: #ifdef must use a single identifier (only this one) as the body of the instruction.
Bad ifndef directive syntax (ifndef directive syntax error)
Analysis and processing: #ifndef must use a single identifier (only this one) as the body of the instruction.
Bad undef directive syntax (undef directive syntax error)
Analysis and processing: The #undef instruction must use a single identifier (only this one) as the body of the instruction.
Bad file size syntax (bit field length syntax error)
Analysis and processing: A constant expression with a bit field length of 1-16 bits.
Call of non-functin (call undefined function)
Analysis and processing: The function being called is undefined, usually due to incorrect function declaration or misspelling of the function name.
Cannot modify a const object (cannot modify a long-scale object)
Analysis and processing: Illegal operations (such as constant assignment) on objects defined as constants cause this error.
Case outside of switch (Case appears outside of switch)
Analysis and processing: The compiler finds that the Case statement appears outside the switch statement, and this type of failure is usually caused by mismatch in brackets.
Case statement missing (Case statement missing)
Analysis and processing: The Case language must contain a constant expression ending with a colon. If a colon is missed or other symbols are added before the colon, this type of error will occur.
Character constant too long (character constant is too long)
Analysis and processing: The length of a character constant can usually be only one or two characters long, and this error will occur if it exceeds this length.
Compound statement missing (missing compound statement)
Analysis and processing: When the compiler scans the source file, no end symbol (braces) is found. Such failures are usually caused by mismatch of curly braces.
Conflicting type modifiers
Analysis and processing: For the same pointer, only one index modifier (such as near or far) can be specified; for the same function, only one language modifier (such as Cdecl, pascal or interrupt) can be given.
Constant expression required (required constant expression)
Analysis and processing: The size of the array must be a constant, and this error is usually caused by a misspelling of the #define constant.
Could not find file '' (The file not found)
Analysis and processing: The compiler cannot find the file given on the command line.
Declaration missing (Explanation missed)
Analysis and processing: This kind of error will occur when a struct or union domain declaration is included in the source file and a semicolon is missed later.
Declaration needs type or storage class (describing that type or storage class must be given)
Analysis and processing: The correct variable description must indicate the variable type, otherwise such errors will occur.
Declaration syntax error (indicates that there is a syntax error)
Analysis and processing: In the source file, if a description loses certain symbols or inputs extra symbols, such errors will occur.
Default outside of switch (Default statement appears outside the switch statement)
Analysis and processing: This type of error is usually caused by mismatch in brackets.
Define directive needs an identifier (The Define directive must have an identifier)
Analysis and processing: The first non-space character after #define must be an identifier. If other characters appear at this position, this error will be caused.
Division by zero (divider is zero)
Analysis and processing: When the divisor of the constant expression in the source file is zero, this error will be caused.
Do statement must have while (the While keyword must be included in the do statement)
Analysis and processing: If the source file contains a do statement without the While keyword, this error will occur.
DO while statement missing ( (The symbol "(" is missing in the Do while statement)
Analysis and processing: In the do statement, if there is no left bracket after the while keyword, this error will occur. Do while statement missing; (The semicolon dropped in the Do while statement)
Analysis and processing: In the conditional expression of the DO statement, if there is no semicolon after the closing bracket, this kind of error occurs.
Duplicate Case (Case case is not unique)
Analysis and processing: Each case of a Switch statement must have a unique constant expression value. Otherwise, this error will occur.
Enum syntax error (Enum syntax error)
Analysis and processing: If the identifier table format indicated by the enum is incorrect, this kind of error will occur.
Enumeration constant syntax error (Enumeration constant syntax error)
Analysis and processing: If the expression value assigned to an enum type variable is not a constant, this kind of error will occur.
Error Directive: xxxx (Error command: xxxx)
Analysis and processing: When the source file processes the #error instruction, the information pointed out by the instruction is displayed.
Error Writing output file (Error writing output file)
Analysis and processing: This type of error is usually caused by the full disk space and the inability to write operations.
Expression syntax error (expression syntax error)
Analysis and processing: This error is usually caused by two consecutive operators, the brackets do not match or the missing brackets, and the previous statement misses a semicolon.
Extra parameter in call (ultra extra parameters appear when calling)
Analysis and processing: This error is caused by the fact that when calling a function, the actual number of parameters is more than the number of parameters in the function definition.
Extra parameter in call to xxxxxxx(ultra extra parameters appear when calling the xxxxxxxx function)
File name too long (the file name is too long)
Analysis and processing: If the file name given by the #include directive is too long, the compiler cannot process it, this kind of error will occur. Usually, the length of the file name under DOS cannot exceed 64 characters.
For statement missing ) (For the word name is missing ")")
Analysis and processing: In the for statement, if the closing bracket is missing after the control expression, this kind of error will occur.
For statement missing( ("(")
For statement missing; (For statement missing ";")
Analysis and processing: In the for statement, if a semicolon is missing after an expression, this kind of error will occur.
Function call missing) (")")
Analysis and processing: If the right-handed brackets or brackets do not match in the parameter table of the function call, this type of error will occur.
Function definition out of place (function definition position error)
Function doesn't take a variable number of argument
Goto statement missing label (Goto statement missing label)
If statement missing( (If statement missing "(")
If statement missing) (If statement missing)
illegal initialization (illegal initialization)
illegal octal digit (illegal octal number)
Analysis and processing: This type of error is usually caused by the octal constant containing non-octal numbers.
lllegal pointer subtraction (illegal pointer subtraction)
lllegal structure operation (illegal structure operation)
illegal use of floating point (floating point operation is illegal)
illegal use of pointer
Improper use of a typedef symbol (the typedef symbol is used improperly)
Incompatible storage class (incompatible storage type)
Incompatible type conversion (incompatible type conversion)
Incorrect commadn line argument:xxxxxx (Incorrect command line argument:xxxxxx)
Incorrect commadn file argument:xxxxxx (Incorrect configuration file parameters:xxxxxxx)
Incorrect number format (incorrect data format)
Incorrect use of default (deflult is incorrectly used)
Initializer syntax error (initialization syntax error)
Invalid indirection (Invalid indirection)
Invalid macro argument separator (invalid macro parameter separator)
Invalid pointer addition (Invalid pointer addition)
Invalid use of dot (point is wrong)
Macro argument syntax error (macro parameter syntax error)
Macro expansion too long (the macro expansion is too long)
Mismatch number of parameters in definition (the number of parameters in the definition does not match)
Misplaced break (break position error)
Misplaced continue (wrong location)
Misplaced decimal point (the decimal point position is wrong)
Misplaced else (else is wrong)
Misplaced else drive (clse command location is wrong)
Misplaced endif directive (the endif directive location is wrong)
Must be addressable (must be addressable)
Must take address of memory location (must be memory address)
No file name ending (no file terminator)
No file names given (No file name given)
Non-protable pointer assignment (assigns values to non-portable pointers)
Non-protable pointer comparison (Comparison of non-portable pointers)
Non-protable return type conversion (not portable return type conversion)
Not an allowed type
Out of memory (not enough memory)
Pointer required on left side of (the operator must be a pointer on the left side of)
Redeclaration of 'xxxxx' ('xxxxx' redefinition)
Size of structure or array not known
Statement missing; (Sentence missing ";")
Structure or union syntax error
Structure size too large (too large)
Subscription missing ] (Subscription missing ‘]’)
Switch statement missing ( (switch statement missing "(")
Switch statement missing ) (")")
Too few parameters in call (too few parameters)
Too few parameter in call to 'xxxxx' (too few parameters when calling 'xxxxxx')
Too many cases (too many cases)
Too many decimal points (too many decimal points in decimal)
Too many default cases (too many defaut)
Too many exponents (too many rank codes)
Too many initializers (too many initializers)
Too many storage classes in declaration (The description is too many storage classes)
Too many types in declaration (too many types in the description)
Too much auto memory in function (too much auto memory in function)
Too much global define in file (too much global data defined in the file)
Two consecutive dots (two continuous dots)
Type mismatch in parameter # (parameter "#" type does not match)
Type mismatch in parameter # in call to 'XXXXXXX' (The parameter # type does not match when calling 'XXXXXX')
Type missmatch in parameter 'XXXXXXX' (parameter 'XXXXXX' type does not match)
Type mismatch in parameter 'YYYYYYY' in call to 'YYYYYYY' (the parameter 'XXXXXXXXX' does not match when calling 'YYYYYYYY')
Type mismatch in redeclaration of 'XXX' (Redefine type mismatch)
Unable to create output file '' (The output file cannot be created'')
Unable to create
Unable to execute command 'xxxxxxxx' (cannot execute 'xxxxxxx' command)
Unable to open include file '' (cannot open include file '')
Unable to open inputfile '' (The input file cannot be opened'')
Undefined label 'xxxxxxx' (label 'xxxxxxx' is not defined)
Undefined structure 'xxxxxxxxx' (structure 'xxxxxxxxxx' is not defined)
Undefined symbol 'xxxxxxx' (symbol 'xxxxxxx' is not defined)
Unexpected end of file in comment started on line #(The source file ends unexpectedly in a comment)
Unexpected end of file in conditional stated on line # (The source file ends unexpectedly in the conditional statement starting from line #)
Unknown preprocessor directive 'xxx' (Unknown preprocessing directive: 'xxx')Untermed character constant (Untermed character constant)
Unterminated string
Unterminated string or character constant (unterminated string or character constant)
User break (User break)
Value required (assignment request)
While statement missing ( (While statement misses '(')
While statement missing ) (While statement missing ')')
Wrong number of arguments in of 'xxxxxxx' (The number of parameters is wrong when calling 'xxxxxxxx')