Error message of Turbo C (V2.0) Compilation

Http://www.vcworld.net/news/200909/092714.html

 

Description of compilation errors: source program errors of Turbo C are classified into three types: fatal errors, General errors, and warnings. A fatal error is usually an internal compilation error. A general error is a program syntax error, a disk or memory access error, or a command line error. A warning only indicates some suspicious situations, it does not prevent compilation.
The following is a ~ in alphabetical order ~ Z lists the critical and general error information, English-Chinese Comparison and handling methods:
(1) English-Chinese Comparison of fatal errors and solutions:
A-B fatal error
Bad call of in-line function (invalid internal function call)
Analysis and Processing: an internal function defined by a macro cannot be called correctly. An internal function starts and ends with two underscores.
Ircompcable Expression Tree)
Analysis and Processing: this error indicates that the expressions in the file lines are too complex to generate code for the Code Generator program. This expression must be avoided.
Register Allocation failure (memory allocation failed)
Analysis and Processing: this error indicates that the expression in the file line is too complex and the Code Generator cannot generate code for it. In this case, you should simplify this complicated expression or simply avoid using it.
(2) English-Chinese photos of general error messages and Solutions
# Operator not followed by MACO argument name (# The Meta name is not changed with the macro after the operator)
Analysis and Processing: In macro definition, # is used to identify a macro variable string. "#" Must be renamed with a macro.
'Xxxx' not anargument ('xxxxxx' is not a function parameter)
Analysis and Processing: This identifier is defined as a function parameter in the source program, but this identifier does not appear in the function.
Ambiguous symbol 'xxxxxx' (Binary symbol 'xxxxxx ')
Analysis and Processing: a domain name with two or more structures is the same, but has different offsets and types. When this field is referenced in a variable or expression without a structure name, it produces ambiguity. In this case, you need to modify a domain name or add a structure name When referencing it.
Argument # missing name (parameter # name missing)
Analysis and Processing: The parameter name has been removed from the function prototype used to define the function. If a function is defined as a prototype, it must contain all parameter names. Argument list syntax error (syntax error in parameter table)
Analysis and Processing: function call parameters must be separated by commas (,) and end with a right parenthesis. An error occurs if the source file contains a parameter that is not followed by a comma or is not in parentheses.
Array Bounds missing (array delimiter "]" missing)
Analysis and Processing: An array is defined in the source file, but the array does not end with the following right square brackets.
Array size too large (array is too large)
Analysis and Processing: the defined array is too large to exceed the available memory space.
Extends er statement too long (Assembly statement is too long)
Analysis and Processing: the length of an internal Assembly statement cannot exceed 480 bytes.
Bad configuration file (incorrect configuration file)
Analysis and Processing: The turboc. cfg configuration file contains non-annotated text that is not an appropriate option for command line selection. The configuration file command selection item must start with a dash.
Bad file name format in include Directive (the file name format in the include command is incorrect)
Analysis and Processing: the file name must be enclosed by quotation marks ("filename. H") or angle brackets (<FILENAME>). Otherwise, this type of error will occur. If macros are used, the generated Extended text is incorrect, because no quotation marks are available for identification.
Bad ifdef directive syntax (ifdef command syntax error)
Analysis and Processing: # ifdef must use a single identifier (only one) as the body of the instruction.
Bad ifndef directive syntax (ifndef command syntax error)
Analysis and Processing: # ifndef must use a single identifier (only one) as the body of the instruction.
Bad UNDEF directive syntax (UNDEF command syntax error)
Analysis and Processing: # the UNDEF command must use a single identifier (only one) as the body of the command.
Bad file size syntax (Bit Field Length syntax error)
Analysis and Processing: a single-digit field must be 1-16-bit constant expressions.
Call of non-functin (call undefined function)
Analysis and Processing: The called function is not defined. It is usually caused by incorrect function declaration or function name spelling.
Cannot modify a const object (a long object cannot be modified)
Analysis and Processing: this error is caused by illegal operations (such as constant assignment) on objects defined as constants.
Case outside of switch (case appears outside switch)
Analysis and Processing: the compiler finds that the case statement exists outside the switch statement, which is usually caused by the mismatch of parentheses.
Case statement missing (case statement missing)
Analysis and Processing: case must contain a constant expression ending with a colon. This type of error occurs if a colon is missing or other symbols are added before the colon.
Character constant too long (character constant is too long)
Analysis and Processing: the length of a character constant can only be one or two characters long. If the length is exceeded, this error occurs.
Compound statement missing (compound statement missing)
Analysis and Processing: no ending symbol (braces) is found when the source file is not scanned by the compiler. This type of fault is usually caused by mismatched braces.
Conflicting type modifiers (type modifier conflict)
Analysis and Processing: For the same pointer, only one address 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 provided ).
Constant expression required (constant expression required)
Analysis and Processing: the array size must be a constant. This error is usually caused by the spelling error of # define constant.
Cocould not find file 'xxxxxx. XXX' (the 'xxxxxx. xx' file cannot be found)
Analysis and Processing: The compiled program cannot find the file provided on the command line.
Declaration Missing (missing description)
Analysis and Processing: This type of error occurs when the source file contains a struct or union domain declaration with a semicolon missing.
Declaration needs type or storage class (Description: the type or storage class must be provided)
Analysis and Processing: the correct description of variables must indicate the type of the variables. Otherwise, such errors may occur.
Declaration syntax error (indicating a syntax error)
Analysis and Processing: In the source file, if some symbols are lost or redundant characters are entered, such errors may occur.
Default outside of switch (the default statement appears outside the switch statement)
Analysis and Handling: This type of error is usually caused by mismatched parentheses.
Define directive needs an identifier (the define command 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 type of error may occur.
Division by zero (divisor 0)
Analysis and Processing: This type of error occurs when the constant expression of the source file has a division of zero.
Do statement must have while (the while keyword must exist in the DO statement)
Analysis and Processing: if the source file contains a DO statement without the while keyword, this error occurs.
Do while statement missing (The do while statement misses the symbol "(")
Analysis and Processing: In the DO statement, if the while keyword is not followed by left brackets, this error occurs. Do while statement missing; (the semicolon is dropped in the do while Statement)
Analysis and Processing: In the condition expression of the DO statement, this type of error occurs if there is no semicolon after the right parenthesis.
Duplicate case (case is not unique)
Analysis and Processing: each case of a switch statement must have a unique constant expression value. Otherwise, this type of error occurs.
Enum syntax error (Enum syntax error)
Analysis and Processing: If the table format of the identifier described by Enum is incorrect, such errors 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 type of error will occur.
Error directive: xxxx (error command: XXXX)
Analysis and Processing: when the source file processing # error command, the information indicated by this command is displayed.
Error writing output file (write output file error)
Analysis and Processing: This type of error is usually caused by the failure to write because the disk space is full.
Expression syntax error (expression syntax error)
Analysis and Processing: this error is usually caused by two consecutive operators, which do not match or contain parentheses. The semicolon is missing in the previous statement.
Extra parameter in call)
Analysis and Handling: this error occurs when a function is called, the actual number of parameters is greater than the number of parameters defined in the function.
Extra parameter in call to xxxxxx (additional parameters are displayed when the XXXXXXXX function is called)
File Name Too Long (the file name is too long)
Analysis and Processing: # this type of error occurs when the file name provided by the include command is too long to be processed by the Compilation Program. Generally, the file name in DOS cannot exceed 64 characters.
For statement missing) (for language name missing ")")
Analysis and Processing: In a for statement, if the right brackets are missing after the control expression, this type of error occurs.
For statement missing (for statement missing "(")
For statement missing; (for statement missing ";")
Analysis and Processing: In a for statement, this type of error occurs when a semicolon is missing after an expression.
Function call Missing) (function call lacks ")")
Analysis and Processing: If the parameter table of the function call misses the right-hand brackets or the parentheses do not match, this type of error occurs.
Function Definition out ofplace (Function Definition Location Error)
Function doesn' t take a variable number of argument (the function does not accept the number of variable parameters)
GOTO statement missing label (the GOTO statement lacks a label)
If statement missing (if statement missing "(")
If statement missing) (if statement missing ")")
Lllegal initalization (illegal initialization)
Lllegal octal digit (invalid eight-digit number)
Analysis and Handling: This type of error is usually caused by the octal constant containing a non-octal number.
Lllegal pointer subtraction (Invalid Pointer subtraction)
Lllegal structure operation (invalid structure operation)
Lllegal use of floating point (the floating point operation is invalid)
Lllegal use of pointer (Invalid Pointer usage)
Improper use of a typedef symbol (incorrect use of typedef)
Incompatible Storage Class (incompatible storage type)
Incompatible type conversion (incompatible type conversion)
Incorrect commadn line argument: xxxxxx (incorrect command line parameter: xxxxxxx)
Incorrect commadn file argument: xxxxxx (incorrect configuration file parameter: xxxxxxx)
Incorrect Number Format (incorrect data format)
Incorrect use of default (deflult is incorrectly used)
Initializer syntax error (initialization syntax error)
Invaild indrection (invalid indirect operation)
Invalid macro argument separator (invalid macro parameter separator)
Invalid Pointer addition (Invalid Pointer addition)
Invalid use of dot (point usage error)
Macro argument syntax error (macro parameter syntax error)
Macro expansion too long (macro extension is too long)
Mismatch number of parameters in definition (the number of parameters in the definition does not match)
Misplaced break (incorrect break position)
Misplaced continue (location error)
Misplaced decimal point (the decimal point is incorrect)
Misplaced else (else Location Error)
Misplaced else driective (clse command Location Error)
Misplaced endif Directive (the location of the endif command is incorrect)
Must be addressable (must be Addressable)
Must take address of memory location (must be a memory address)
No file name ending (no file Terminator)
No file names given (no file name is provided)
Non-protable pointer assignment (assign values to non-portable pointers)
Non-protable pointer comparison (comparison of Non-portable pointers)
Non-protable return type conversion (non-portable return type conversion)
Not an allowed type (the type is not allowed)
Out of memory (insufficient memory)
Pointer required on left side of (the left side of the operator must be a pointer)
Redeclaration of 'xxxxxx' ('xxxxxx)
Size of structure or array not known (the size of the structure or array is not fixed)
Statement missing; (the statement lacks ";")
Structure or union syntax error (structure or union syntax error)
Structure size too large (the structure is too large)
Submerge missing] (the subscript lacks ']')
Switch statement missing (the switch statement is missing "(")
Switch statement missing) (the switch statement lacks ")")
Too few parameters in Call (function call parameters are too few)
Too few parameter in call to 'xxxxxx' (too few parameters are called when 'xxxxxx)
Too too cases (too many cases)
Too hour decimal points (too many decimal places)
Too merge default cases (too many defaut)
Too orders exponents (too many Order Codes)
Too initialize initializers (too many initialization tasks)
Too stored storage classes in Declaration (meaning there are too many storage classes)
Too polictypes in decleration (meaning there are too many types)
Too much auto memory in function (too many automatically stored functions)
Too much global define in file (there are too many global data defined in the file)
Two consecutive DOTS (two consecutive points)
Type mismatch in parameter # (parameter "#" Type mismatch)
Type mismatch in parameter # In call to 'xxxxxxxxx' (parameter # Type Mismatch when 'xxxxxxx' is called)
Type missmatch in parameter 'xxxxxxx' (the 'xxxxxxxxx' parameter type does not match)
Type mismatch in parameter 'yyyyyy' in call to 'yyyyyy' (the 'xxxxxxxxxx' parameter does not match when 'yyyyyy' is called)
Type mismatch in redeclaration of 'xxx' (redefinition Type mismatch)
Unable to creat output file 'xxxxxxxx. XXX' (the output file 'xxxxxxxx. XXX' cannot be created ')
Unable to create turboc. lnk (turboc. lnk cannot be created)
Unable to execute command 'xxxxxxxx' (the 'xxxxxxxx' command cannot be executed)
Unable to open include file 'xxxxxxx. XXX' (the file 'xxxxxxxx. XXX' cannot be opened ')
Unable to open inputfile 'xxxxxxx. XXX' (the input file 'xxxxxxxx. XXX' cannot be opened ')
Undefined label 'xxxxxxxxx' (the number 'xxxxxxxxx' is not defined)
Undefined structure 'xxxxxxxxxxxxxx' (Structure 'xxxxxxxxxxxxxxxx' is not defined)
Undefined symbol 'xxxxxxxxx' (the symbol 'xxxxxxxxxx' is not defined)
Unexpected end of file in comment started on line # (the source file ended unexpectedly in a comment)
Unexpected end of file in conditional stated on line # (the source file ends unexpectedly in the # condition statement at the beginning of the line)
Unknown Preprocessor directive 'xxx' (unknown preprocessing command: 'xxx') untermimated character constant (unterminated character constant)
Unterminated string (unterminated string)
Unterminated string or character constant (unterminated string or character constant)
User break (User interrupted)
Value required (Value assignment request)
While statement missing (while statement misses '(')
While statement missing) (while statement misses ')')
Wrong number of arguments in of 'xxxxxxxx' (the number of parameters is incorrect when 'xxxxxxxxxx' is called)