| HI4000 |
UNKNOWN WARNING
Contact Microsoft Product Support Services |
| |
The compiler detected an unknown error condition. |
| |
Note the circumstances of the error and notify Microsoft Corporation by following the instructions on the Microsoft Product Assistance Request form at the back of one of your manuals. |
| HI4001 |
nonstandard extension used - extension |
| |
The given nonstandard language extension was used when the /Ze option was specified. |
| |
This is a level 4 warning, except in the case of a function pointer cast to data when the Quick Compile option, /qc, is in use, which produces a level 1 warning. |
| |
If the /Za option has been specified, this condition generates a syntax error. |
| HI4002 |
too many actual parameters for macro identifier |
| |
The number of actual arguments specified with the given identifier was greater than the number of formal parameters given in the macro definition of the identifier. |
| |
The additional actual parameters are collected but ignored during expansion of the macro. |
| HI4003 |
not enough actual parameters for macro identifier |
| |
The number of actual arguments specified with the given identifier was fewer than the number of formal parameters given in the macro definition of the identifier. |
| |
When a formal parameter is referenced in the definition and the corresponding actual parameter has not been provided, empty text is substituted in the macro expansion. |
| HI4004 |
missing ')' after defined |
| |
The closing parenthesis was missing from an #if defined phrase. |
| |
The compiler assumes a right parenthesis, ), after the first identifier it finds. It then attempts to compile the remainder of the line, which may result in another warning or error. |
| |
The following example causes this warning and a fatal error:
#if defined( ID1 ) || ( ID2 )
|
| |
The compiler assumed a right parenthesis after ID1, then found a mismatched parenthesis in the remainder of the line. The following avoids this problem:
#if defined( ID1 ) || defined( ID2 )
|
| HI4005 |
identifier : macro redefinition |
| |
The given identifier was defined twice. The compiler assumed the new macro definition. |
| |
To eliminate the warning, either remove one of the definitions or use an #undef directive before the second definition. |
| |
This warning is caused in situations where a macro is defined both on the command line and in the code with a #define directive. |
| HI4006 |
#undef expected an identifier |
| |
The name of the identifier whose definition was to be removed was not given with the #undef directive. The #undef was ignored. |
| HI4007 |
identifier : must be attribute |
| |
The attribute of the given function was not explicitly stated. The compiler forced the attribute. |
| |
For example, the function main must have the _cdecl attribute. |
| HI4008 |
identifier : _fastcall attribute on data ignored |
| |
The _fastcall attribute on the given data identifier was ignored. |
| HI4009 |
string too big, trailing characters truncated |
| |
A string exceeded the compiler limit of 2047 on string size. The excess characters at the end of the string were truncated. |
| |
To correct this problem, break the string into two or more strings. |
| HI4011 |
identifier truncated to identifier |
| |
Only the first 31 characters of an identifier are significant. The characters after the limit were truncated. |
| |
This may mean that two identifiers that are different before truncation may have the same identifier name after truncation. |
| HI4015 |
identifier : bit-field type must be integral |
| |
The given bit field was not declared as an integral type. The compiler assumed the base type of the bit field to be unsigned. |
| |
Bit fields must be declared as unsigned integral types. |
| HI4016 |
function : no function return type, using int as default |
| |
The given function had not yet been declared or defined, so the return type was unknown. A default return type of int was assumed. |
| HI4017 |
cast of int expression to far pointer |
| |
A far pointer represents a full segmented address. On an 8086/8088 processor, casting an int value to a far pointer may produce an address with a meaningless segment value. |
| |
The compiler extended the int expression to a four-byte value. |
| HI4020 |
function : too many actual parameters |
| |
The number of arguments specified in a function call was greater than the number of parameters specified in the function prototype or function definition. |
| |
The extra parameters were passed according to the calling convention used on the function. |
| HI4021 |
function : too few actual parameters |
| |
The number of arguments specified in a function call was less than the number of parameters specified in the function prototype or function definition. |
| |
Only the provided actual parameters are passed. If the called function references a variable that was not passed, the results are undefined and may be unexpected. |
| HI4022 |
function : pointer mismatch : parameter number |
| |
The pointer type of the given parameter was different from the pointer type specified in the argument-type list or function definition. |
| |
The parameter will be passed without change. Its value will be interpreted as a pointer within the called function. |
| HI4023 |
function : _based pointer passed to unprototyped function : parameter number |
| |
When in a near data model, only the offset portion of a _based pointer is passed to an unprototyped function. If the function expects a far pointer, the resulting code will be wrong. In any data model, if the function is defined to take a _based pointer with a different base, the resulting code may be unpredictable. |
| |
If a prototype is used before the call, the call will be generated correctly. |
| HI4024 |
function : different types : parameter number |
| |
The type of the given parameter in a function call did not agree with the type given in the argument-type list or function definition. |
| |
The parameter will be passed without change. The function will interpret the parameter's type as the type expected by the function. |
| HI4028 |
parameter number declaration different |
| |
The type of the given parameter did not agree with the corresponding type in the argument-type list or with the corresponding formal parameter. |
| |
The original declaration was used. |
| HI4030 |
first parameter list longer than the second |
| |
A function was declared more than once with different parameter lists. |
| |
The first declaration was used. |
| HI4031 |
second parameter list is longer than the first |
| |
A function was declared more than once with different parameter lists. |
| |
The first declaration was used. |
| HI4034 |
sizeof returns 0 |
| |
The sizeof operator was applied to an operand that yielded a size of zero. |
| |
This warning is informational. |
| HI4040 |
memory attribute on identifier ignored |
| |
The _near, _far, _huge, or _based keyword has no effect in the declaration of the given identifier and is ignored. |
| |
One cause of this warning is a huge array that is not declared globally. Declare huge arrays outside of main. |
| HI4042 |
identifier : has bad storage class |
| |
The storage class specified for identifier cannot be used in this context. |
| |
The default storage class for this context was used in place of the illegal class:
 If identifier was a function, the compiler assumed extern class.
If identifier was a formal parameter or local variable, the compiler assumed auto class.
If identifier was a global variable, the compiler assumed that the variable was declared with no storage class.
|
| HI4044 |
_huge on identifier ignored, must be an array |
| |
The compiler ignored the _huge memory attribute on the given identifier. Only arrays may be declared with the _huge memory attribute. On pointers, _huge must be used as a modifier, not as a memory attribute. |
| HI4047 |
operator : different levels of indirection |
| |
An expression involving the specified operator had inconsistent levels of indirection. |
| |
If both operands are of arithmetic type, or if both are not (such as two arrays or pointers), then they are used without change, though the compiler may DS-extend one of the operands if one is far and one is near. If one is arithmetic and one is not, the arithmetic operator is converted to the type of the other operator. |
| |
For example, the following code causes this warning but is compiled without change:
char **p;
char *q;
p = q; /* Warning */
|
| HI4048 |
array's declared subscripts different |
| |
An expression involved pointers to arrays of different size. |
| |
The pointers were used without conversion. |
| HI4049 |
operator : indirection to different types |
| |
The pointer expressions used with the given operator had different base types. |
| |
The expressions were used without conversion. |
| |
For example, the following code causes this warning:
struct ts1 *s1;
struct ts2 *s2;
s2 = s1; /* Warning */
|
| HI4050 |
operator : different code attributes |
| |
The function-pointer expressions used with operator had different code attributes. The attribute involved is either _export or _loadds. |
| |
This is a warning and not an error, because _export and _loadds affect only entry sequences and not calling conventions. |
| HI4051 |
type conversion, possible loss of data |
| |
Two data items in an expression had different base types, causing the type of one item to be converted. During the conversion, a data item was truncated. |
| HI4053 |
at least one void operand |
| |
An expression with type void was used as an operand. |
| |
The expression was evaluated using an undefined value for the void operand. |
| HI4063 |
function : function too large for post-optimizer |
| |
Not enough space was available to optimize the given function. |
| |
One of the following may be a solution:
Recompile with fewer optimizations.
Divide the function into two or more smaller functions.
In OS/2, recompile using the /B3 C3L option to invoke the large-model version of the third pass of the compiler.
|
| HI4066 |
local symbol-table overflow - some local symbols may be missing in listings |
| |
The listing generator ran out of heap space for local variables, so the source listing may not contain symbol-table information for all local variables. |
| HI4067 |
unexpected characters following directive directive - newline expected |
| |
Extra characters followed a preprocessor directive and were ignored. This warning appears only when compiling with the /Za option. |
| |
For example, the following code causes this warning:
#endif NO_EXT_KEYS
|
| |
To remove the warning, compile with /Ze or use comment delimiters:
#endif /* NO_EXT_KEYS */
|
| HI4071 |
function : no function prototype given |
| |
The given function was called before the compiler found the corresponding function prototype. |
| |
The function will be called using the default rules for calling a function without a prototype. |
| HI4072 |
function : no function prototype on _fastcall function |
| |
A _fastcall function was called without first being prototyped. |
| |
Functions that are _fastcall should be prototyped to guarantee that the registers assigned at each point of call are the same as the registers assumed when the function is defined. A function defined in the new ANSI style is a prototype. |
| |
A prototype must be added when this warning appears, unless the function takes no arguments or takes only arguments that cannot be passed in the general-purpose registers. |
| HI4073 |
scoping too deep, deepest scoping merged when debugging |
| |
Declarations appeared at a static nesting level greater than 13. As a result, all declarations beyond this level will seem to appear at the same level. |
| HI4076 |
type : may be used on integral types only |
| |
The signed or unsigned type modifier was used with a nonintegral type. |
| |
The given qualifier was ignored. |
| |
The following example causes this warning:
unsigned double x;
|
| HI4079 |
unexpected token token |
| |
An unexpected separator token was found in the argument list of a pragma. |
| |
The remainder of the pragma was ignored. |
| HI4082 |
expected an identifier, found token |
| |
An identifier was missing from the argument list. |
| |
The remainder of the pragma was ignored. |
| HI4083 |
expected '(', found token |
| |
A left parenthesis, (, was missing from a pragma's argument list. |
| |
The pragma was ignored. |
| |
The following example causes this warning:
#pragma check_pointer on)
|
| HI4084 |
expected a pragma keyword, found token |
| |
The token following #pragma was not recognized as a directive. |
| |
The pragma was ignored. |
| |
The following example causes this warning:
#pragma (on)
|
| HI4085 |
expected [on | off] |
| |
The pragma expected an on or off parameter, but the specified parameter was unrecognized or missing. |
| |
The pragma was ignored. |
| HI4086 |
expected [1 | 2 | 4] |
| |
The pragma expected a parameter of either 1, 2, or 4, but the specified parameter was unrecognized or missing. |
| HI4087 |
function : declared with void parameter list |
| |
The given function was declared as taking no parameters, but a call to the function specified actual parameters. |
| |
The extra parameters were passed according to the calling convention used on the function. |
| |
The following example causes this warning:
int f1(void);
f1(10);
|
| HI4088 |
function : pointer mismatch : parameter number, parameter list number |
| |
The argument passed to the given function had a different level of indirection from the given parameter in the function definition. |
| |
The parameter will be passed without change. Its value will be interpreted as a pointer within the called function. |
| HI4089 |
function : different types : parameter number, parameter list number |
| |
The argument passed to the given function did not have the same type as the given parameter in the function definition. |
| |
The parameter will be passed without change. The function will interpret the parameter's type as the type expected by the function. |
| HI4090 |
different const/volatile qualifiers |
| |
A pointer to an item declared as const was assigned to a pointer that was not declared as const. As a result, the const item pointed to could be modified without being detected. |
| |
The expression was compiled without modification. |
| |
The following example causes this warning:
const char *p = "abcde";
int str(char *s);
str(p);
|
| HI4091 |
no symbols were declared |
| |
The compiler detected an empty declaration, as in the following example:
int ;
|
| |
The declaration was ignored. |
| HI4092 |
untagged enum/struct/union declared no symbols |
| |
The compiler detected an empty declaration using an untagged structure, union, or enumerated variable. The declaration was ignored. |
| |
For example, the following code causes this warning:
struct { . . . };
|
| HI4093 |
unescaped newline in character constant in inactive code |
| |
The constant expression of an #if, #elif, #ifdef, or #ifndef preprocessor directive evaluated to 0, making the code that follows inactive. Within that inactive code, a newline character appeared within a set of single or double quotation marks. |
| |
All text until the next double quotation mark was considered to be within a character constant. |
| HI4095 |
expected ')', found token |
| |
More than one argument was given for a pragma that can take only one argument. |
| |
The compiler assumed the expected parenthesis and ignored the remainder of the line. |
| HI4096 |
attribute1 must be used with attribute2 |
| |
The use of attribute2 requires the use of attribute1. |
| |
For example, using a variable number of arguments (...) requires that _cdecl be used. Also, _interrupt functions must be _far and _cdecl. |
| |
The compiler assumed attribute1 for the function. |
| HI4098 |
void function returning a value |
| |
A function declared with a void return type also returned a value. |
| |
A function was declared with a void return type but was defined as a value. |
| |
The compiler assumed the function returns a value of type int. |
| HI4104 |
identifier : near data in same_seg pragma, ignored |
| |
The given near variable was specified in a same_seg pragma. |
| |
The identifier was ignored. |
| HI4105 |
identifier : code modifiers only on function or pointer to function |
| |
The given identifier was declared with a code modifier that can be used only with a function or function pointer. |
| |
The code modifier was ignored. |
| HI4109 |
unexpected identifier identifier |
| |
The pragma contained an unexpected token. |
| |
The pragma was ignored. |
| HI4110 |
unexpected token int constant |
| |
The pragma contained an unexpected integer constant. |
| |
The pragma was ignored. |
| HI4111 |
unexpected token string |
| |
The pragma contained an unexpected string. |
| |
The pragma was ignored. |
| HI4112 |
macro name name is reserved, command ignored |
| |
The given command attempted to define or undefine the predefined macro name or the preprocessor operator defined. The given command is displayed as either #define or #undef, even if the attempt was made using command-line options. |
| |
The command was ignored. |
| HI4113 |
function parameter lists differed |
| |
A function pointer was assigned to a function pointer, but the parameter lists of the functions do not agree. |
| |
The expression was compiled without modification. |
| HI4114 |
same type qualifier used more than once |
| |
A type qualifier (const, volatile, signed, or unsigned) was used more than once in the same type. |
| |
The second occurrence of the qualifier was ignored. |
| HI4115 |
tag : type definition in formal parameter list |
| |
The given tag was used to define a struct, union, or enum in the formal parameter list of a function. |
| |
The compiler assumed the definition was at the global level. |
| HI4116 |
(no tag) : type definition in formal parameter list |
| |
A struct, union, or enum type with no tag was defined in the formal parameter list of a function. |
| |
The compiler assumed the definition was at the global level. |
| HI4119 |
different bases name1 and name2 specified |
| |
The _based pointers in the expression have different symbolic bases. There may be truncation or loss in the code generated. |
| HI4120 |
_based/unbased mismatch |
| |
The expression contains a conversion between a _based pointer and another pointer that is unbased. Some information may have been truncated. |
| |
This warning commonly occurs when a _based pointer is passed to a function that accepts a near or far pointer. |
| HI4123 |
different base expressions specified |
| |
The expression contains a conversion between _based pointers, but the base expressions of the _based pointers are different. Some of the _based conversions may be unexpected. |
| HI4125 |
decimal digit terminates octal escape sequence |
| |
An octal escape sequence in a character or string constant was terminated with a decimal digit. |
| |
The compiler evaluated the octal number without the decimal digit and assumed the decimal digit was a character. |
| |
The following example causes this warning:
char array1[] = "\709";
|
| |
If the digit 9 was intended as a character and was not a typing error, correct the example as follows:
char array[] = "\0709"; /* String containing "89" */
|
| HI4126 |
flag : unknown memory model flag |
| |
The flag used with the /A option was not recognized and was ignored. |
| HI4128 |
storage-class specifier after type |
| |
A storage-class specifier (auto, extern, register, static) appears after a type in a declaration. The compiler assumed that the storage class specifier occurred before the type. |
| |
New-style code places the storage-class specifier first. |
| HI4129 |
character : unrecognized character escape sequence |
| |
The character following a backslash in a character or string constant was not recognized as a valid escape sequence. |
| |
As a result, the backslash is ignored and not printed, and the character following the backslash is printed. |
| |
To print a single backslash (\), specify a double backslash (\\). |
| HI4130 |
operator : logical operation on address of string constant |
| |
The operator was used with the address of a string literal. Unexpected code was generated. |
| |
For example, the following code causes this warning:
char *pc;
pc = "Hello";
if (pc == "Hello") ...
|
| |
The if statement compares the value stored in the pointer pc to the address of the string "Hello", which is separately allocated each time it occurs in the code. It does not compare the string pointed to by pc with the string "Hello". |
| |
To compare strings, use the strcmp function. |
| HI4131 |
function : uses old-style declarator |
| |
The function declaration or definition is not a prototype. |
| |
New-style function declarations are in prototype form.
old style
int addrec( name, id )
char *name;
int id;
{ }
new style
int addrec( char *name, int id )
{ }
|
| HI4132 |
object : const object should be initialized |
| |
The value of a const object cannot be changed, so the only way to give the const object a value is to initialize it. |
| |
It will not be possible to assign a value to object. |
| HI4135 |
conversion between different integral types |
| |
Information was lost between two integral types. |
| |
For example, the following code causes this warning:
int intvar;
long longvar;
intvar = longvar;
|
| |
If the information is merely interpreted differently, this warning is not given, as in the following example:
unsigned uintvar = intvar;
|
| HI4136 |
conversion between different floating types |
| |
Information was lost or truncated between two floating types. |
| |
For example, the following code causes this warning:
double doublevar;
float floatvar;
floatvar = doublevar;
|
| |
Note that unsuffixed floating-point constants have type double, so the following code causes this warning:
floatvar = 1.0;
|
| |
If the floating-point constant should be treated as float type, use the F (or f) suffix on the constant to prevent the following warning:
floatvar = 1.0F;
|
| HI4138 |
*/ found outside of comment |
| |
The compiler found a closing comment delimiter (*/) without a preceding opening delimiter. It assumed a space between the asterisk (*) and the forward slash (/). |
| |
The following example causes this warning:
int */*comment*/ptr;
|
| |
In this example, the compiler assumed a space before the first comment delimiter (/*) and issued the warning but compiled the line normally. To remove the warning, insert the assumed space. |
| |
Usually, the cause of this warning is an attempt to nest comments. |
| |
To comment out sections of code that may contain comments, enclose the code in an #if/#endif block and set the controlling expression to zero, as in:
#if 0
int my_variable; /* Declaration currently not needed */
#endif
|
| HI4139 |
hexnumber : hex escape sequence is out of range |
| |
A hex escape sequence appearing in a character or string constant was too large to be converted to a character. |
| |
If in a string constant, the compiler cast the low byte of the hexadecimal number to a char. If in a char constant, the compiler made the cast and then sign extended the result. If in a char constant and compiled with /J, the compiler cast the value to an unsigned char. |
| |
For example, \x1ff is out of range for a character. Note that the following code causes this warning:
printf("\x7Bell\n");
|
| |
The number 7be is a legal hex number but is too large for a character. To correct this example, use three hex digits:
printf("\x007Bell\n");
|
| HI4186 |
string too long - truncated to 40 characters |
| |
The string argument for a title or subtitle pragma exceeded the maximum allowable length and was truncated. |
| HI4200 |
local variable identifier used without having been initialized |
| |
A reference was made to a local variable that had not been assigned a value. As a result, the value of the variable is unpredictable. |
| |
This warning is given only when compiling with global register allocation on (/Oe). |
| HI4201 |
local variable identifier may be used without having been initialized |
| |
A reference was made to a local variable that might not have been assigned a value. As a result, the value of the variable may be unpredictable. |
| |
This warning is given only when compiling with the global register allocation on (/Oe). |
| HI4202 |
unreachable code |
| |
The flow of control can never reach the indicated line. |
| |
This warning is given only when compiling with one of the global optimizations (/Oe, /Og, or /Ol). |
| HI4203 |
function : function too large for global optimizations |
| |
The named function was too large to fit in memory and be compiled with the selected optimization. The compiler did not perform any global optimizations (/Oe, /Og, or /Ol). Other /O optimizations, such as /Oa and /Oi, are still performed. |
| |
One of the following may remove this warning:
Recompile with fewer optimizations.
Divide the function into two or more smaller functions.
In OS/2, recompile using the /B2 C2L option to invoke the large-model version of the second pass of the compiler.
|
| HI4204 |
function : in-line assembler precludes global optimizations |
| |
The use of in-line assembler in the named function prevented the specified global optimizations (/Oe, /Og, or /Ol) from being performed. |
| HI4205 |
statement has no effect |
| |
The indicated statement will have no effect on the program execution. |
| |
Some examples of statements with no effect:
1;
a + 1;
b == c;
|
| HI4209 |
comma operator within array index expression |
| |
The value used as an index into an array was the last one of multiple expressions separated by the comma operator. |
| |
An array index legally may be the value of the last expression in a series of expressions separated by the comma operator. However, the intent may have been to use the expressions to specify multiple indexes into a multidimensional array. |
| |
For example, the following line, which causes this warning, is legal in C, and specifies the index c into array a:
a[b,c]
|
| |
However, the following line uses both b and c as indexes into a two-dimensional array:
a[b][c]
|
| HI4300 |
insufficient memory to process debugging information |
| |
The program was compiled with the /Zi option, but not enough memory was available to create the required debugging information. |
| |
One of the following may be a solution:
Split the current file into two or more files and compile them separately.
Remove other programs or drivers running in the system which could be consuming significant amounts of memory.
In OS/2, recompile using the /B3 C3L option to invoke the large-model version of the third pass of the compiler.
|
| HI4301 |
loss of debugging information caused by optimization |
| |
Some optimizations, such as code motion, cause references to nested variables to be moved. The information about the level at which the variables are declared may be lost. As a result, all declarations will seem to be at nesting level 1. |
| HI4323 |
potential divide by 0 |
| |
The second operand in a divide operation evaluated to zero at compile time, giving undefined results. |
| |
The 0 operand may have been generated by the compiler, as in the following example:
func1() { int i,j,k; i /= j && k; }
|
| HI4324 |
potential mod by 0 |
| |
The second operand in a remainder operation evaluated to zero at compile time, giving undefined results. |
| HI4800 |
more than one memory model specified |
| |
There was more than one memory model given at the command line. The /AT, /AS, /AM, /AC, /AL, and /AH options specify the memory model. |
| |
This error is caused by conflicting options specified at the command line and in the CL and H2INC environment variables. |
| HI4801 |
more than one target processor specified |
| |
There was more than one processor type given at the command line. The /G0, /G1, and /G2 options specify the processor type. |
| |
This error is caused by conflicting options specified at the command line and in the CL and H2INC environment variables. |
| HI4802 |
ignoring invalid /Zp value value |
| |
The alignment value specified to the /Zp option was not 1, 2, or 4. The default of 1 was assumed. |
| HI4810 |
untranslatable basic type size |
| |
H2INC could not translate the item to a MASM type. |
| |
The C void type cannot be translated to a similar MASM type. |
| HI4811 |
static function prototype not translated |
| |
H2INC does not translate static items, as they are not visible outside the C source file. |
| HI4812 |
static variable declaration not accepted with /Mn switch |
| |
H2INC does not translate static items, as they are not visible outside the C source file. |
| HI4815 |
string : EQU string truncated to 254 characters |
| |
A #define statement exceeded 254 characters, the maximum length of a MASM EQU statement. The string was truncated. |
| HI4816 |
ignoring _fastcall function definition |
| |
H2INC does not translate function declarations or prototypes with the _fastcall attribute. The _fastcall calling convention cannot be used directly with MASM. See the documentation with your C compiler for details on _fastcall. |
| HI4820 |
ignoring function definition : function() |
| |
H2INC does not translate function bodies. |
| |
H2INC translates header information only; it cannot convert program code. |