C4003not enough actual parameters for macro identifier Level 1  
  The number of actual parameters specified with the given identifier was less 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.
C4004incorrect construction after defined Level 1  
  The defined operator was incorrectly terminated, causing a warning or error to appear when the remainder of the line following defined was compiled.
  The following example generates this warning and a fatal error:

#if defined( ID1 ) || ( ID2 )

  The compiler assumed that the identifier ID1 was the only operand for the defined operator. The rest of the line could not be parsed.
  The following avoids this problem:

#if defined( ID1 ) || defined( ID2 )

C4005identifier : macro redefinition Level 1  
  The given identifier was defined twice. The compiler used the second macro definition.
  This warning can be caused by defining a macro on the command line and in the code with a #define directive. It also can be caused by macros imported from include files.
  To eliminate the warning, either remove one of the definitions or use an #undef directive before the second definition.
C4006#undef expected an identifier Level 1  
  The name of the identifier whose definition was to be removed was not given with the #undef directive. The #undef directive was ignored.
C4007identifier : must be attribute Level 2  
  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.
C4008identifier : attribute attribute ignored Levels 2 and 3  
  The __fastcall, static, or inline attribute for the given identifier was ignored.
  Data cannot be defined with the __fastcall attribute, and the main function cannot be defined with the static or inline attribute.
  This is a level 2 warning for data and a level 3 warning for functions.
C4009string too big; trailing characters truncated Level 1  
  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.
C4010single-line comment contains line-continuation character Level 3  
  A single-line comment (introduced by //) contains a line-continuation character (\). The line continuation character was ignored.
  A single-line comment causes the compiler to ignore the rest of the physical line; the compiler does not consider line-continuation characters.
C4013function undefined; assuming extern returning int Level 3  
  An undefined function was called. The compiler assumed an external function that returned an int.
  Make sure that the function name is spelled correctly. All external functions should be prototyped as extern.
C4014concatenating mismatched wide strings Level 1  
  A wide string literal was concatenated with a standard string literal.
  Make sure that all wide string literals are prefixed with an “L” character, as in:

char hello[] = L"Hello, " "world" // Warning

char hello[] = L"Hello, " L"world" // OK

C4015identifier : bit-field type must be integral Level 1  
  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.
C4016function : no function return type; using int as default Level 3  
  Since the given function had not yet been declared or defined, the return type was unknown. A default return type of int was assumed.
  This warning may be avoided by adding a prototype for the given function.
C4017cast of int expression to far pointer Level 1  
  The compiler extended the int expression to a 4-byte value.
  A far pointer represents a full segmented address; casting an int value to a far pointer may produce an address with a meaningless segment value.
C4018expression : signed/unsigned mismatch Level 3  
  There was an attempt to compare a signed and unsigned number. The signed value was converted to an unsigned type for the comparison.
  When performing an equal (==) or not equal (!=) comparison between signed and unsigned types, cast one type to the other to ensure proper comparison.
C4019empty statement at global scope Level 4  
  The compiler found a semicolon that was not preceded by a statement. This warning is generated only in global scope.
  This warning can be avoided by removing the extra semicolon.
  The following example demonstrates this warning:

#define declint( varname ) int #varname;

declint( a ); //Warning, int a;;

declint( b ) //OK, int b;

C4020function : too many actual parameters Level 1  
  The number of actual parameters specified in a function call was greater than the number of formal parameters specified in the function prototype or function definition.
  The extra actual parameters were passed according to the calling convention used on the function.
C4021function : too few actual parameters Level 1  
  The number of actual parameters specified in a function call was less than the number of formal parameters specified in the function prototype or function definition.
  Only the provided actual parameters were passed. If the called function references a variable that was not passed, the results are undefined.
C4022function : pointer mismatch for actual parameter number Level 1  
  The pointer type of the given actual parameter was different from the pointer type specified in the formal parameter list or function definition.
  The actual parameter was passed without change. Its value will be interpreted as a pointer within the called function.
C4023function : based pointer passed to unprototyped function : parameter number Level 1  
  There was an attempt to pass a based pointer to an unprototyped function.
  When using a memory model with near data, 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 all memory models, if the function is defined to take a based pointer with a different base, the resulting code may be unpredictable.
  This warning can be avoided by using a function prototype containing a reference to the proper base.
C4024function : different types for formal and actual parameter number Level 1  
  The type of the given actual parameter in a function call did not agree with the type given for the formal parameters in the function prototype or definition.
  The actual parameter will be passed without change. The function will convert the parameter's type to the type expected by the function.
C4025function : based pointer passed to function with variable arguments: parameter number Level 1  
  A based pointer cannot be passed to the varargs part of a function without losing what it is based upon.
  When using a memory model with near data, 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.
  To pass a based pointer to a function with variable arguments, cast the based pointer to a far pointer.
C4026function declared with formal parameter list Level 1  
  The function was declared to take formal parameters, but the function definition did not have formal parameters.
  Subsequent calls to this function will assume that the function takes no actual parameters.
C4027function declared without formal parameter list Level 1  
  The function was declared to take no formal parameters (the formal parameter type list consisted of the keyword void), but either formal parameters were given in the function definition or actual parameters were given in a call to the function.
  Subsequent calls to this function will assume that the function takes actual parameters of the types found in the function declaration or call.
C4028actual parameter number different from declaration Level 1  
  The type of the given actual parameter did not agree with the corresponding formal parameter in the declaration or definition.
  The type in the original declaration was used.
C4029declared formal parameter list different from definition Level 1  
  The types of formal parameters given in the function declaration did not agree with the types of the formal parameters given in the function definition.
  The formal parameter list of the definition was used.
C4030first formal parameter list longer than the second list Level 1  
  A function was declared more than once with different formal parameters.
  The formal parameters given in the first declaration were used.
C4031second formal parameter list is longer than the first list Level 1  
  A function was declared more than once with different formal parameters.
  The formal parameters given in the first declaration were used.
C4033function must return a value Level 1  
  The given function did not return a value.
  Only functions with a return type of void can use the return command without an accompanying return value.
  An undefined value will be returned when this function is called.
C4034sizeof returns 0 Level 1  
  The sizeof operator was applied to an operand that yielded a size of zero.
  This warning indicates that the operand of the sizeof operator was an empty structure, union, class, or enumerated type, or was of type void.
C4035function : no return value Level 3  
  A function did not include a return statement.
  This warning is generated for all functions (including main) that do not have return statements. Functions with a return type of void will not generate this warning.
  An undefined value will be returned when this function is called.
C4036unnamed type as actual parameter Level 1  
  The type of the structure, union, enumerated type, or class being passed as an actual parameter was not given.
  The formal parameter in the generated function prototype will be commented out.
  This warning occurs only when using the /Zg option for generating function prototypes and can be avoided by providing the appropriate type explicitly.
C4037conflicting ambient class modifiers Level 1  
  More than one ambient class modifier was specified for a class, structure, or union.
  Only one ambient class modifier can be specified for a class, structure, or union.
C4038identifier : illegal ambient class modifier Level 1  
  The given identifier was not a valid ambient class modifier.
  Valid ambient class modifiers are __far, __near, and the names of memory models.
C4039ambient class modifier on reference ignored Level 1  
  The ambient class modifier on a reference to a class, structure, or union was ignored.
  An ambient class modifier can be used only in the declaration and definition of a class, structure, or union.
C4040memory attribute on identifier ignored Level 1  
  The __near, __far, __huge, or __based keyword has no effect in the declaration of the given identifier and was ignored.
  One cause of this warning is a huge array that is not declared globally. Declare huge arrays outside of the main function.
C4041illegal modifier for the this pointer Level 1  
  The program attempted to change the this pointer to an illegal type.
  The this pointer can be overloaded to const, volatile, __near, __far, or __huge.
C4042identifier : has bad storage class Level 1  
  The storage class specified for the identifier could not be used in this context.
  A default storage class for this context was used in place of the illegal storage class. The storage class was selected using the following rules.

If the identifier was a function, the compiler assumed extern class.

If the identifier was a formal parameter or local variable, the compiler assumed auto class.

If the identifier was a global variable, the compiler assumed the variable was declared with no storage class.

C4043function specifier used more than once Level 1  
  A function specifier was used more than once for a symbol.
  The second function specifier was ignored.
  The following example generates this warning:

inline inline void no_op( void ) { };

C4044specifier __huge on identifier ignored; can only be applied to array Level 1  
  The compiler ignored the __huge memory attribute for the given identifier. Only arrays can be declared with the __huge memory attribute. For pointers, __huge must be used as a modifier, not as a memory attribute.
C4045identifier : array bounds overflow Level 1  
  Too many initializers were present for the given array. The excess initializers were ignored.
  Make sure that the array elements and initializers match in size and quantity.
C4046identifier : unsized array treated as __far Level 1  
  An unsized array was allocated in the far data segment.
  This warning occurs under the /Gx command-line option when initializing an unsized array of characters with multiple elements, as in:

char StringArray[] = {"Windows", "Windows", "Windows"};

  Since no explicit size was given, the data size threshold cannot be used.
C4047operator : different levels of indirection Level 1  
  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 array or pointer), then they are used without change. However, the compiler may DS-extend one of the operands if one is __far and the other is __near. If one operand is arithmetic, but the other is not, the arithmetic operator is converted to the type of the other operator.
  For example, the following code generates this warning but is compiled without change:

char **p;

char *q;

p = q; // Warning

C4048different declared array subscripts Level 1  
  An expression involved pointers to arrays of different size. The pointers were used without conversion.
  This warning can be avoided by explicitly casting the arrays to the same or equivalent type.
C4049operator : indirection to different types Level 1  
  The pointer expressions used with the given operator had different base types.
  The pointer expressions were used without conversion.
  For example, the following code generates this warning:

struct ts1 *s1;

struct ts2 *s2;

s2 = s1; // Warning

C4050operator : different code attributes Level 4  
  The function-pointer expressions used with the given operator had different code attributes, one of which 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.
C4051type conversion; possible loss of data Level 2  
  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.
  This warning can be avoided by casting the data items to the appropriate type.
C4052function declarations different; one contains variable arguments Level 1  
  One declaration of the function did not contain variable arguments, but another did.
  The declaration containing the variable arguments was used.
C4053one void operand for '?:' Level 1  
  An expression of type void was used as an operand.
  The expression was evaluated using an undefined value for the void operand.
C4054function pointer cast to a data pointer Level 1  
  A function pointer was cast to a data pointer.
  Make sure that the correct cast is being used.
  This condition generates an error with the C compiler with the /Za ANSI-compatibility command-line option or under the medium memory model.
C4055data pointer cast to a function pointer Level 1  
  A data pointer was cast to a function pointer.
  Make sure that the correct cast is being used.
  This condition generates an error with the C compiler with the /Za ANSI-compatibility command-line option or under the compact memory model.
C4067unexpected characters following directive directive—newline expected Level 1  
  Extra characters followed a preprocessor directive and were ignored. This warning appears only when compiling with the /Za ANSI-compatibility option.
  For example, the following code generates this warning:

#endif NO_EXT_KEYS

  To remove the warning, compile with /Ze or use comment delimiters, as in:

#endif /* NO_EXT_KEYS */

C4068unknown pragma Level 1  
  The compiler did not recognize a pragma and ignored it.
  Make sure that the given pragma is allowed by the type of compiler being used.
C4071function : no function prototype given Level 2  
  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.
C4072function : no function prototype on __fastcall function Level 1  
  The given __fastcall 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.
C4073initializers put in library initialization area Level 3  
  The #pragma init_seg( lib ) statement was used. The library initialization area should be used only by third-party library developers.
  This warning is informational.
C4074initializers put in compiler reserved initialization area Level 1  
  The #pragma init_seg( compiler ) statement was used. The compiler initialization area is reserved by Microsoft.
  Code in this area may be executed before C run-time library initialization.
C4075initializers put in unrecognized initialization area Level 1  
  An explicit segment name was used as the actual parameter for #pragma init_seg. No compiler or C run-time library support was provided.
  User-defined startup code must be supplied to execute the initializers.
C4076type : may be used on integral types only Level 1  
  The signed or unsigned type modifier was used with a nonintegral type.
  The given qualifier was ignored.
  The following example generates this warning:

unsigned double x;

C4077unknown check_stack option Level 1  
  An unknown option was given with the old form of the check_stack pragma. With the old form, the argument to the pragma must be empty, +, or –.
  The current state of stack checking was left unchanged.
  For example, the following generates this warning:

#pragma check_stack yes

  The following code corrects this situation:

#pragma check_stack + // Old form

  or

#pragma check_stack ( on ) // New form

C4078case constant value too big for the type of the switch expression Level 1  
  A value appearing in a case statement was larger than the size of the type used in the switch expression. The compiler cast the type of the case constant to that of the switch expression.
  A problem can occur when two case constants have different values before being cast but the same value afterward.
C4079unexpected token token Level 1  
  An unexpected separator token was found in the argument list of a pragma.
  The remainder of the pragma was ignored.
  The following example generates this warning:

#pragma comment( "Kilroy was here", )

C4080expected identifier for segment name; found token Level 1  
  The first actual parameter given to the alloc_text pragma was missing a segment name. This happens if the first token in the argument list was not an identifier.
  The pragma was ignored.
C4081expected a comma; found token Level 1  
  A comma (,) was missing between two arguments of a pragma.
  The pragma was ignored.
  The following example generates this warning:

#pragma optimize( "l" on )

C4082expected an identifier; found token Level 1  
  An identifier was missing from the argument list.
  The remainder of the pragma was ignored.
C4083expected '('; found token Level 1  
  A left parenthesis was missing from a pragma's argument list.
  The pragma was ignored.
  The following example generates this warning:

#pragma check_pointer on )

C4084expected a pragma keyword, found token Level 1  
  The token following #pragma was not recognized as a directive.
  The pragma was ignored.
  The following example generates this warning:

#pragma (on)

C4085expected on or off Level 1  
  The pragma expected an on or off parameter, but the specified parameter was unrecognized or missing.
  The pragma was ignored.
  The following example generates this warning:

#pragma optimize( "t", maybe )

C4086expected '1', '2', '4', or '8' Level 1  
  The pragma expected a parameter of either 1, 2, 4, or 8, but the specifed parameter was not recognized or was missing.
  The pack pragma will not accept an 8 when generating 16-bit code.
  The following example generates this warning:

#pragma pack( 3 )

C4087function : declared with void parameter list Level 1  
  The given function was declared with no formal 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 generates this warning:

int f1( void );

f1( 10 );

C4088function : pointer mismatch in actual parameter number, formal parameter number Level 1  
  The actual parameter passed to the given function had a different level of indirection than the corresponding formal parameter.
  The actual parameter will be passed without change. Its value will be interpreted as a pointer by the called function.
C4089function : different types in actual parameter number, formal parameter number Level 1  
  The actual parameter passed to the given function had a different type than the corresponding formal parameter.
  The actual parameter will be passed without change. The function will cast the actual parameter to the type specified in the function definition.
C4090operation : different const or volatile qualifiers Level 1  
  The given operation was performed on a variable that was defined as being const or volatile. As a result, the const or volatile item could be modified without being detected by the compiler.
  This warning often occurs when a pointer to an item declared as const or volatile is assigned to a pointer that was not declared as pointing to either of these type modifiers.
  The expression was compiled without modification.
  The following example generates this warning:

const char *p = "abcde";

int str( char *s );

str( p );

C4091no symbols were declared Level 2  
  The compiler detected an empty declaration, as in the following example:

int ;

  The declaration was ignored.
C4092sizeof returns unsigned long Level 4  
  The operand of the sizeof operator was very large, so the sizeof operator returned an unsigned long.
  This warning occurs only under the default /Ze Microsoft extensions. Under the /Za ANSI-compatibility option, this condition truncates the result of the sizeof operator.
C4093unescaped newline in character constant in inactive code Level 3  
  The constant expression of an #if, #elif, #ifdef, or #ifndef preprocessor directive evaluated to zero, 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.
C4094untagged token declared no symbols Level 2  
  The compiler detected an empty declaration using an untagged structure, union, or class.
  The declaration was ignored.
  The following example generates this warning:

struct { };

  This condition generates an error with the /Za ANSI-compatibility command-line option.
C4095expected ')'; found token Level 1  
  More than one argument was given for a pragma that can take only one argument.
  The compiler assumed the expected right parenthesis and ignored the remainder of the line.
  The following example generates this warning:

#pragma skip( 10, 18, 67 )

C4096attribute1 must be used with attribute2 Level 2  
  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 the attribute1 attribute for the function.
C4098function : void function returning a value Level 1  
  A function that was declared with a return type of void contained a return statement that returned a value.
  The compiler assumed the function returned a value of type int.
C4099type declared with objecttype1 is defined with objecttype2 Level 2  
  An object was declared as either a structure or a class but was defined as a class or a structure, respectively.
  The object type given in the definition was used.
C4100identifier : unreferenced formal parameter Level 3 and 4  
  The given formal parameter was never referenced in the body of the function for which it was declared.
  With a C++ program, this warning is level 3. Under the /Za ANSI-compatibility command-line option, this is a level 4 warning.
  This warning is informational.
C4101identifier : unreferenced local variable Level 3  
  The given local variable was never used.
  This warning is informational.
C4102label : unreferenced label Level 3  
  The given label was defined but never referenced.
  This warning is informational.
C4103filename : used #pragma pack to change alignment Level 1  
  The given include file used the pack pragma to change the default structure alignment.
  This warning is informational.
C4104identifier : near data in same_seg pragma; ignored Level 1  
  The given near variable was specified in a same_seg pragma.
  The same_seg pragma applies only to external far variables.
  The identifier was ignored.
C4105identifier : code modifiers only on function or pointer to function Level 1  
  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.
C4106pragma requires an integer between 1 and 127 Level 1  
  An integer constant between 1 and 127 must be specified with the page and skip pragmas.
  The compiler assumed a value of 1.
  The following example generates this warning:

#pragma skip( 0 )

C4107pragma requires an integer between 15 and 255 Level 1  
  An integer constant between 15 and 255 must be specified with the pagesize pragma.
  The compiler assumed a value of 63.
  The following example generates this warning:

#pragma pagesize( 10 )

C4108pragma requires an integer between 79 and 132 Level 1  
  An integer constant between 79 and 132 must be specified with the linesize pragma.
  The compiler assumed a value of 79.
  The following example generates this warning:

#pragma linesize( 42 )

C4109unexpected identifier identifier Level 1  
  The pragma contained an unexpected token.
  The pragma was ignored.
  The following example generates this warning:

#pragma optimize( on, off )

C4110unexpected token number Level 1  
  The pragma contained an unexpected integer constant.
  The pragma was ignored.
  The following example generates this warning:

#pragma title( 1984 )

C4111unexpected token string Level 1  
  The pragma contained an unexpected string.
  The pragma was ignored.
  The following example generates this warning:

#pragma linesize( "92" )

C4112#line requires an integer between 1 and 32,767 Levels 1 and 4  
  The #line directive specified an integer outside the permitted range.
  If the given line number is less than 1, the line counter is reset to 1. If the given line number is greater than 32,767, it is used as is.
  This is a level 1 warning under the /Za ANSI-compatibility command-line option and a level 4 warning with the default /Ze Microsoft extensions.
C4113function formal parameter lists differed Level 1  
  A function pointer was assigned to another function pointer, but the formal parameter lists of the functions do not agree.
  The assignment was compiled without modification.
C4114same type qualifier used more than once Level 1  
  A type qualifier (const, volatile, signed, or unsigned) was used more than once in the same type declaration or definition.
  The second occurrence of the qualifier was ignored.
C4115symbol : named type definition in parentheses Levels 1 and 3  
  The given symbol was used to define a structure, union, or enumerated type inside a parenthetical expression. The scope of this definition may be unexpected.
  In a C function call, the definition has global scope. In a C++ function call, the definition has the same scope as the function being called.
  This is a level 1 warning with C++ programs or under the /Za ANSI-compatibility command-line option. It is level 3 otherwise.
C4116unnamed type definition in parentheses Level 1  
  A structure, union, or enumerated type with no name was defined in a parenthetical expression. The type definition is meaningless.
  In a C function call, the definition has global scope. In a C++ function call, the definition has the same scope as the function being called.
C4117macro name name is reserved; command ignored Level 1  
  The given command attempted to define or undefine the predefined macro name or the preprocessor operator defined.
  The given command is displayed in the warning message as either #define or #undef, even if the attempt was made using command-line options.
  The command was ignored.
C4118pragma not supported Levels 1 and 3  
  The pragma was not supported by the compiler. The pragma was ignored.
  This is a level 1 warning, except with #pragma comment(), which causes a level 3 warning.
C4119different bases name1 and name2 specified Level 1  
  The based pointers in the expression have different symbolic bases. This may cause truncation or loss in generated code.
  To avoid this warning, cast both based pointers to far pointers.
C4120based/unbased mismatch Level 1  
  The expression contains a conversion between a based pointer and another pointer that is not based. Some information may have been truncated.
  This warning commonly occurs when a based pointer is passed to a function that expects a near or far pointer.
C4121symbol : alignment of a member was sensitive to packing Level 4  
  The given symbol was aligned to the current packing alignment.
  The default alignment of structures can be specified with the pack pragma or the /Zp command-line option.
C4122function : alloc_text applicable only to functions with C linkage Level 1  
  The alloc_text pragma can be applied only to functions declared with extern c. This pragma cannot be used with external C++ functions.
  The alloc_text pragma was ignored.
C4123different base expressions specified Level 1  
  The expression contained a conversion between based pointers, but the base expressions of the based pointers were different. Some of the based pointer conversions may be unexpected.
C4124__fastcall with stack checking is inefficient Level 1  
  The __fastcall keyword was used when stack checking was enabled.
  The __fastcall calling convention is used for generating faster code, but stack checking causes slower code to be generated. Use the /Gs option or the check_stack pragma to turn off stack checking when using __fastcall.
  This warning is informational and is issued only for the first function declared under these conditions.
C4125decimal digit terminates octal escape sequence Level 4  
  An octal escape sequence in a character or string constant was terminated by a decimal digit.
  The compiler evaluated the octal number without the decimal digit and assumed the decimal digit was a character.
  The following example generates 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" */

C4128storage-class specifier after type Level 4  
  A storage-class specifier (auto, extern, register, or static) appears after a type specifier in a declaration. The compiler assumed the storage-class specifier occurred before the type specifier.
  New-style code places the storage-class specifier first.
C4129character : unrecognized character escape sequence Level 1  
  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 (\\).
C4130operator : logical operation on address of string constant Level 4  
  The operator was used with the address of a string literal. Unexpected code was generated.
  For example, the following code generates 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 allocated separately each time the string occurs in the code. The if statement does not compare the string pointed to by pc with the string Hello.
  To compare strings, use the strcmp function.
C4131function : uses old-style declarator Level 4  
  The specified function declaration is not in prototype form.
  Old-style function declarations should be converted to prototype form.
  An example of an old-style declaration is:

int addrec( name, id )

char *name;

int id;

{ }

  The new-style prototype form is:

int addrec( char *name, int id )

{ }

C4132object : const object should be initialized Level 4  
  The constant was not initialized.
  Since the value of a symbol with the const attribute cannot be changed after its definition, it should be given an initialization value.
  It will not be possible to assign a value to object.
C4133type : incompatible types—void pointer combined with nonvoid pointer Level 3  
  An attempt was made to subtract two pointers, one of which is a pointer to a void type.
  This warning can be avoided by providing the appropriate type cast.
C4134conversion between pointers to members of same class Level 4  
  A pointer to one member of a class was converted to a pointer to another member of the class. This is necessary because void pointers to members are not allowed.
  This warning is informational.
C4135conversion between different integral types Level 3  
  Information was lost between two integral types.
  This warning can be avoided by providing the appropriate type cast.
  For example, the following code generates this warning:

int intvar;

long longvar;

intvar = longvar;

C4136conversion between different floating-point types Level 3  
  Information was lost or truncated in the conversion between two floating-point types.
  For example, the following code generates this warning:

double doublevar;

float floatvar;

floatvar = doublevar;

  Note that unsuffixed floating-point constants have type double, so the following code generates this warning:

floatvar = 1.0;

  If the floating-point constant should be treated as type float, use the F (or f) suffix on the constant to prevent the warning:

floatvar = 1.0F;

C4137function : no return value from floating-point function Level 1  
  The given function had no return statement.
  A long double function returns its value on the floating-point stack or the emulation stack. If the function does not return a value, a run-time floating-point stack underflow error may occur.
  Make sure that all floating-point functions return a floating-point value.
C4138*/ found outside of comment Level 1  
  The compiler found a closing comment delimiter (*/) without a preceding opening delimiter. The compiler assumed a space between the asterisk (*) and the forward slash (/).
  The following example generates this warning:

int */*comment*/ptr;

  In this example, the first comment delimiter is ambiguous.
  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

C4139hexnumber : hex escape sequence is out of range Level 1  
  A hexadecimal escape sequence appearing in a character or string constant was too large to be converted to a character.
  If the hexadecimal escape sequence is in a string constant, the compiler casts 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 the program was compiled with the /J command-line option, the compiler cast the value to an unsigned char.
  Note that the following code generates this warning:

printf("\x7Bell\n");

  The compiler reads the characters 7Be as a legal hexadecimal number, but it is too large to fit in a character. To correct this example, use three hexadecimal digits:

printf("\007Bell\n");

C4140function redefined : preceding references may be invalid Level 1  
  The compiler issues this warning when a function definition changes between incremental compilations while compiling with the /f, /Gi, or /qc command-line options.
  References previous to the redefinition use the previous definition. Subsequent references use the new definition.
  For example:

main()

{

func1 ();

}

int func1 ()

{ }

  If this program is compiled with the /f, /Gi, or /qc option and later the func1 definition is changed to long func1, the compiler will issue this message to warn that calls to func1 may be of the wrong type.
  To avoid the problem, use function prototypes.
C4142benign redefinition of type Level 1  
  A type was redefined, but the redefinition had no effect on the code generated.
  This warning commonly occurs in these cases:

The return type of a member function of a derived class differed from the return type of the corresponding overridden member function.

A type defined with the typedef command is redefined using different syntax. For example, the following code causes this warning when generating 16-bit code:

typedef unsigned int WORD;

typedef unsigned short WORD;

  This warning is informational.
C4143pragma same_seg not supported; use __based allocation Level 1  
  The same_seg pragma is not supported with the /f or /qc fast-compilation command-line options.
  To avoid this warning, use based pointers to specify the segment for external far variables. This warning can also be avoided by removing the /f or /qc command-line option.
C4144expression : relational expression as switch expression Level 1  
  The given relational expression was used as the control expression of a switch statement. The associated case statements will be offered boolean values.
  This warning is informational.
C4145expression1 : relational expression as switch expression; possible confusion with expression2 Level 1  
  The given relational expression expression1 was used as the control expression of a switch statement. The associated case statements will be offered boolean values.
  The given expression expression2 is a suggested case expression.
  This warning is informational.
C4149class1 : different ambient model than base class class2 Level 3  
  The given derived class has a different ambient memory model than its base class.
  This warning is informational.
C4150deletion of pointer to incomplete type type; no destructor called Level 2  
  The delete operator was called to delete the given type, which was declared but not defined. The compiler was unable to find any destructors for the given type.
  Make sure that the class, structure, or union is defined before using the delete operator.
  The following example generates this warning:

class IncClass;

void NoDestruct( IncClass* pIncClass )

{

delete pIncClass;

}

C4151operator : operator should be explicitly model Level 1  
  The new operator was overloaded, but there was not an appropriate function for either __based or __huge.
  To avoid this warning, write versions of the new operator to cover this case.
C4184near call to thunk for function in a different segment Level 1  
  A near member function was overridden by a near member function in another segment.
  The compiler extended the near call to a far call.
  This warning can be avoided by making both functions far or by making sure that the overriding member function is in the same segment as the original member function.
C4241member : member access is restricted Level 3  
  There was an attempt to access a private or protected member function or data.
  If the program needs to access this member, change the object access level or make the member a friend of the function that needs to be accessed.
C4245friend specified for nonexistent function function Level 1  
  A nonfunction was declared to be a friend. The compiler ignored the statement.
  Make sure that the friend function is accessible within the current scope.
C4247member not accessible because class1 uses access to inherit from class2 Level 3  
  There was an attempt to access a member of a class that was inherited from another class with the private or protected attribute.
  This is a warning instead of an error, because the access violation occurred due to a type cast.
C4248class1 : cannot access member member declared in class class2 Level 3  
  The given member cannot be accessed from this class because it did not have access rights. The member was not accessed.
  This warning can be avoided by giving class1 access to members of class2 by changing the class access specifier or using the friend specifier.
C4249class1 : no path to member member declared in virtual base class2 Level 3  
  The given member of the virtual base class cannot be accessed from the derived class because it did not have access rights. The member was not accessed.
  This warning can be avoided by giving class1 access to members of class2 by changing the class access specifier or using the friend specifier.
C4250class1 : inherits class2::member via dominance Level 2  
  There were two or more members with the same name. The one in class2 was inherited since it was a base class for the other classes that contained this member.
  This warning is informational.
C4300conversion of pointer to nonintegral type Level 1  
  A pointer was cast to a nonintegral type (such as float).
  The cast pointer address may no longer be valid.
  This warning is generated by the following example:

int i = 24;

printf( "Address: %f\n", ( float ) &i );

C4301truncation during conversion of pointer to integral type Level 4  
  A pointer was converted to a smaller integral type. Information was lost in the casting.
  The cast pointer address may no longer be valid.
  This warning is generated by the following example:

int i = 24;

printf( "Address: %hi\n", ( short ) &i );

C4302truncation during conversion of pointer to function Level 4  
  A function pointer was converted to a smaller function pointer type. Information was lost in the casting.
  This warning is generated by the following example:

typedef void * ( *TYPE1 )( void );

typedef void * ( __far *TYPE2 )( void );

TYPE1 ptr1;

TYPE2 ptr2;

ptr1 = ( TYPE1 ) ptr2;

C4303truncation during conversion of pointer to function to pointer to object Level 4  
  A function pointer was converted to a smaller object or data pointer type. Information was lost in the casting.
  This condition is an error with the C compiler.
  This warning is generated by the following C++ example:

void __far myfunc( void ) {};

void * ptr;

ptr = ( void * ) myfunc;

C4304truncation during pointer conversion Level 4  
  A function pointer was converted to a smaller object or data pointer type. Information was lost in the casting.
  This warning is generated by the following example:

int __far * j;

int * k;

k = ( int * ) j;

C4305truncation during conversion of integral type to pointer Level 1  
  An integral type was converted to a smaller pointer type. Information was lost in the casting.
  This warning is generated by the following example:

long j;

long * k;

k = ( long * ) j;

C4306conversion of integral type to pointer of greater size Level 3  
  An integral type was cast to a larger pointer. The unfilled high bits of the new type will be zero-filled.
  This warning may indicate an unwanted conversion. The resulting pointer may not be valid.
C4341signed value out of range for enum constant Level 3  
  A given enumerated constant exceeded the limit for an int. The value of the illegal constant is undefined.
  Make sure that the given constants resolve to integers between –32,768 and +32,767 (signed) or 0 and +65,535 (unsigned).
  The following example generates this warning:

enum ELEMENTS

{

Hydrogen = 1,

Helium,

Lithium,

Beryllium,

Impossibillium = 500000

} ;

C4342precision lost in initialization of enum constant Level 1  
  An enumerated constant was given in an expression too complex for the compiler to resolve accurately to an integer.
  Make sure that the compiler can resolve the constant by simplifying the expression.
C4354reference : initialization of reference member requires a temporary variable Level 1  
  There was an attempt to initialize a member that was a reference. This condition causes an error under the default /Ze command-line option.
  The compiler created a temporary stack variable to perform the initialization. Since the stack variable will be eliminated after the termination of the constructor, the pointer will be invalid.
  This warning may be avoided by initializing the member instead of its reference.
C4401identifier : member is bit field Level 1  
  An attempt was made to access the given bit-field member within inline assembler code.
  The identifier is a bit field. A bit-field member cannot be accessed within inline assembler code. The last packing boundary before the bit-field member was used.
  To avoid this warning, cast the bit field to an appropriate type before making the reference in inline assembler code.
C4402must use PTR operator Level 1  
  A type was used on an operand without a PTR operator.
  The compiler assumed the PTR operator.
  The PTR operator is required when referring to or casting to a type in inline assembler code.
C4403illegal PTR operator Level 1  
  A PTR operator was used inappropriately in inline assembler code.
  The compiler ignored the PTR operator.
C4404period on directive ignored Level 3  
  The optional period preceding the directive was ignored.
  This warning is informational.
C4405identifier : identifier is reserved word Level 1  
  A reserved word was used as the name of the identifier.
  Use of the identifier in this way may cause unpredictable results.
  This warning can be avoided by not using reserved words as idenitifiers.
C4406operand on directive ignored Level 1  
  The directive does not take any operands, but an operand was specified.
  The compiler ignored the given operand or operands.
C4409illegal instruction size Level 1  
  The instruction did not have a form with the specified size. The smallest legal size was used.
  Make sure that the proper form of the instruction is being used.
C4410illegal size for operand Level 1  
  One of the operands on the instruction had an incorrect size. The smallest legal size for the operand was used.
  Make sure that an operand of the proper size is being used.
C4411identifier : symbol resolves to displacement register Level 1  
  The identifier is a local symbol that resolves to a displacement register and therefore may be used on an operand with another symbol.
  This warning is informational.
C4414function : short jump to function converted to near Level 3  
  Short jumps generate a 1-byte instruction. The instruction includes a short offset that represents the distance between the jump and the function definition. The compiler must generate a special record for the jump, which requires the jmp instruction to be either NEAR or FAR, but not SHORT. The compiler made the conversion.
  For example, the following code generates this warning:

main()

{

_asm jmp SHORT main

}

C4500class : class has private/protected data members; user-defined constructor advised Level 2  
  The given class, structure, or union contains private or protected data. As this data is unavailable to many parts of the program, a user-defined constructor should be used.
C4501identifier : use of '::' unnecessary here Level 1  
  The given identifier was local in scope, so the scope resolution operator (::) was not required.
  The compiler ignored the optional scope resolution operator.
C4502linkage requires use of keyword extern Level 1  
  A linkage was specified without the extern keyword. Linkage is not relevant to non-extern types.
  The compiler assumed the extern keyword.
C4505function : unreferenced local function has been removed Level 4  
  The given function is local and not referenced in the body of the module; therefore, the function is dead code.
  The compiler did not generate code for this dead function.
C4506no definition for inline function function Level 1  
  The given function was declared and marked for inlining but was not defined.
  The compiler did not inline the function.
  Make sure that external functions to be inlined are declared with the extern keyword.
C4507explicit linkage specified after default linkage was used Level 4  
  After an identifier was declared with the default C++ linkage, it was explicitly declared as having C++ linkage.
  The following code generates this warning:

void WhereProhibited( void );

extern "C++" { void WhereProhibited( void ); }; //Warning

C4508function : function should return a value; void return type assumed Level 1  
  The given function did not specify a return type; the compiler assumed that the return statement returned type void.
  This warning can be avoided by declaring functions void that do not return a value.
C4510class : default constructor could not be generated Level 3  
  The compiler was unable to generate a default constructor for the given class. No constructor was created.
  This warning can be caused by having a default constructor for the base class that is not accessible by the derived class. An inherited constructor from a base class with a different ambient memory model can also cause this warning.
  This warning can be avoided by specifying a user-defined default constructor for the class.
C4511class : copy constructor could not be generated Level 3  
  The compiler was unable to generate a copy constructor for the given class. No constructor was created.
  This warning can be caused by having a copy constructor for the base class that is not accessible by the derived class. An inherited copy constructor from a base class with a different ambient memory model can also cause this warning.
  This warning can be avoided by specifying a user-defined copy constructor for the class.
C4512class : assignment operator could not be generated Level 3  
  The compiler was unable to generate a default constructor for the given class. No constructor was created.
  This warning can be caused by having an assignment operator for the base class that is not accessible by the derived class. An inherited assignment operator from a base class with a different ambient memory model can also cause this warning.
  This warning can be avoided by specifying a user-defined assignment operator for the class.
C4513class : destructor could not be generated Level 3  
  The compiler was unable to generate a default constructor for the given class. No constructor was created.
  This warning can be caused by having an assignment operator for the base class that is not accessible by the derived class. An inherited assignment operator from a base class with a different ambient memory model can also cause this warning.
  This warning can be avoided by specifying a user-defined destructor for the class.
C4520class : multiple default constructors specified Level 3  
  There were multiple default constructors specified for the given class. The first constructor was used.
  Make sure that there is only one default constructor defined for a distance.
C4521class : multiple copy constructors specified Level 3  
  There were multiple copy constructors of a single type specified for the given class. The first constructor was used.
  Make sure that there is only one copy constructor defined for a type and distance.
C4522class : multiple assignment operators specified Level 3  
  There were multiple assignment operators of a single type specified for the given class. The first constructor was used.
  Make sure that there is only one assignment operator defined for a type and distance.
C4523class : multiple destructors specified Level 3  
  There were multiple destructors specified for the given class. The first destructor was used.
  Make sure that there is only one destructor defined for a distance.
C4524class : redundant use of friend on destructor Level 3  
  The friend access specifier was given for a destructor. Since the destructor is automatically a member function of the given class, this specification is irrelevant.
  The extraneous friend specifier was ignored.
C4525class : redundant use of friend on constructor Level 3  
  The friend access specifier was given for a constructor. Since the constructor is automatically a member function of the given class, this specification is irrelevant.
  The extraneous friend specifier was ignored.
C4527instances of type class can never be destroyed—user-defined destructor required Level 3  
  The given derived class did not include a destructor, and the compiler could not generate one. The class cannot be destroyed.
  This warning can be avoided by including a user-defined destructor for the given class.
C4607const : must be initialized in constructor base/member initializer list Level 1  
  The given constant was not initialized with an initializer list in the object constructor. The compiler left the constant undefined.
  If a const member variable is not given a value when initialized, it must be given a value in the object constructor.
C4610object class can never be instantiated—user-defined constructor required Level 1  
  The given class had neither user-defined nor default constructors; it cannot be instantiated. No instantiation was performed.
  Make sure that all classes have valid user-defined or default constructors.
C4612bad #pragma syntax, pragma ignored Level 1  
  There was a syntax error in the warning pragma.
  Make sure that all values and parentheses for this pragma are correct.
C4613segment : class of segment cannot be changed Level 1  
  There was an attempt to create a segment with the same class name as a segment used by the compiler.
  No new segment class was created.
  This warning is generated only when compiling 32-bit programs.
C4615#pragma warning : unknown user warning type Level 1  
  An illegal warning type was used with the warning pragma.
  Valid warning types are “1”, “2”, “3”, “4”, “default”, “off”, and “error”.
C4616#pragma warning : warning number number1 out of range, must be between number2 and number3 Level 1  
  The warning number that was specified in the warning pragma was not in the range of assignable warnings. Only warnings between number2 and number3 can be reassigned.
  The pragma was ignored.
C4617#pragma warning : invalid warning number Level 1  
  An illegal warning number was used with the warning pragma.
  Make sure that the warning number that is supplied to the warning pragma corresponds to a valid warning.
C4620no postfix form of operator ++ found for type type, using prefix form Level 1  
  There was no postfix incrememnt operator defined for the given type. The compiler used the overloaded prefix operator.
  This warning can be avoided by defining a postfix ++ operator. This is done by creating a two-argument version of the ++ operator as shown below:

class prepost

{

public:

prepost operator++ ()

{

/* inline prefix routine */

};

prepost operator++ ( int )

{

/* inline postfix routine */

};

}

C4621no postfix form of operator –– found for type type, using prefix form Level 1  
  There was no postfix decrement operator defined for the given type. The compiler used the overloaded prefix operator.
  This warning can be avoided by defining a postfix –– operator. This is done by creating a two-argument version of the –– operator as shown below:

class prepost

{

public:

prepost operator-- ()

{

/* inline prefix routine */

};

prepost operator-- ( int )

{

/* inline postfix routine */

};

}

C4630symbol : extern storage class specifier illegal on member definition Level 1  
  The given data member or member function was defined as external. Members cannot be declared as extern.
  The compiler ignored the extern keyword.
  Only entire objects can be made external.
C4650debugging information not in precompiled header; only global symbols from the header will be available Level 1  
  The precompiled header file was not compiled with Microsoft symbolic debugging information.
  When linked, the resulting executable or dynamic-link library file will not include debugging information for local symbols contained in the precompiled header.
  This warning can be avoided by recompiling the precompiled header file with the /Zi command-line option.
C4651definition specified for precompiled header but not for current compile Level 1  
  The given definition was specified when the precompiled header was generated, but not in this compilation.
  The definition will be in effect inside the precompiled header, but not in the rest of the code.
C4652command-line option option inconsistent with precompiled header; PCH option ignored Level 1  
  The given command-line option differed from that given when the precompiled header (.PCH) was created. The option specified in the current command line was used.
  This warning may be avoided by regenerating the precompiled header with the given command-line option.
C4700local variable identifier used without having been initialized Level 1  
  A reference was made to a local variable that had not been assigned a value. As a result, the value of the variable is undefined.
  This warning is given only when compiling with the /Oe global register allocation command-line option.
C4701local variable identifier may be used without having been initialized Level 3  
  A reference was made to a local variable that may 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 /Oe global register allocation command-line option.
C4702unreachable code Level 4  
  The flow of control can never reach the indicated line.
  This warning is given only when compiling with one of the global optimization options (/Oe, /Og, or /Ol).
C4703function : function too large for global optimizations Level 1  
  The named function was too large to fit in memory and be compiled with the selected optimization option. The compiler did not perform any global optimizations (/Oe, /Og, or /Ol). Other /Ox optimization options, such as /Oa and /Oi, are still performed.
  One of the following may remove this warning:

Divide the function into two or more smaller functions.

Recompile with fewer optimizations.

C4704function : inline assembler precludes global optimizations Level 3  
  The use of inline assembler in the named function prevented the specified global optimizations (/Oe, /Og, or /Ol) from being performed.
C4705statement has no effect Level 4  
  The indicated statement will have no effect on the program execution.
  Each of these statements will generate this warning:

1;

a + 1;

b == c;

C4706assignment within conditional expression Level 4  
  The test value in a conditional expression was the result of an assignment.
  This warning is informational.
  An assignment has a value (the value on the left side of the assignment) that can be used legally in another expression, including a test expression. However, the intention may have been to test a relation, not to make an assignment.
  For example, the following line, which generates this warning, assigns b to a and compares the value of a with 0:

if ( a = b ) ...

  However, the following line tests whether a and b are equal:

if ( a == b ) ...

C4709comma operator within array index expression Level 4  
  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 generates 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]

C4710function function not expanded Level 4  
  The given function was selected for inline expansion, but the compiler did not perform the inlining.
  Inlining is performed at the compiler's discretion. The inline keyword, like the register keyword, is used as a hint for the compiler.
C4711function function selected for inline expansion Level 1  
  The compiler performed inlining on the given function, although it was not marked for inlining by the user.
  Inlining is performed at the compiler's discretion. This warning is informational.
C4712symbol : used as register—loss of debugging information Level 2  
  The given symbol was based on another symbol that was converted to a register, thereby losing debugging information.
  This warning can be avoided by not using the /Oe register-allocation command-line option.
C4723potential divide by 0 Level 3  
  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:

int i, j, k = 42;

i /= ( j && k );

C4724potential mod by 0 Level 3  
  The second operand in a remainder operation evaluated to zero at compile time, giving undefined results.
C4726option : unknown memory-model command-line option Level 1  
  The character (or characters) used with the /A option was not recognized as a valid memory-model specifier.
  The option was ignored.
C4727conditional expression is constant Level 4  
  The controlling expression of an if statement or while loop evaluated to a constant.
  As a result, the code in the body of the if statement or while loop either always executes or never executes.
  This warning is informational.
C4741/Oq option ignored for __fastcall or __saveregs function function Level 1  
  The fastcall and saveregs calling convention is not allowed for p-code functions. The function was compiled into native code.
  This warning can be avoided by using a different calling convention or by turning p-code generation off during the definition of fastcall and saveregs functions, as in:

#pragma optimize( "q", off ) //Turn p-code on

int __fastcall FastFunc( void )

{...};

#pragma optimize( "q" ) //Return to default p-code mode

C4746identifier : unsized array treated as __far Level 1  
  An unsized array was allocated in the far data segment.
  This warning occurs under the /Gx command-line option when initializing an unsized array of characters with multiple elements, as in:

char StringArray[] = {"Windows", "Windows", "Windows"};

  Since no explicit size was given, the data size threshold cannot be used.
C4756overflow in constant arithmetic Level 2  
  The compiler generated a floating-point exception while doing constant arithmetic on floating-point items during compilation.
  For example:

float fp_val = 1.0e100;

  In this example, the floating-point constant 1.0e100 exceeds the maximum allowable value for a double-precision data item.
C4758address of automatic (local) variable taken; DS != SS Level 1  
  The program was compiled with the default data segment (DS) not equal to the stack segment (SS), and the program tried to point to an automatic (local) variable with a near pointer.
  Dereferencing a pointer to that address is illegal when DS != SS and will give an unpredictable result.
C4759segment lost in conversion Level 2  
  The conversion of a far pointer (a full segmented address) or based pointer to a near pointer (a segment offset) or a different based pointer resulted in the loss of the segment address.
  This warning is informational.
C4761integral size mismatch in argument; conversion supplied Level 1  
  The base types of the actual and formal parameters of a function were different.
  The compiler converted the actual parameter to the type of the formal parameter.
C4762near/far mismatch in argument; conversion supplied Level 1  
  The pointer sizes of the actual and formal parameters of a function were different.
  The compiler converted the actual parameter to the type of the formal parameter.
C4763function : function too large for postoptimizer Level 2  
  Not enough space was available to optimize the given function.
  One of the following may be a solution:

Divide the function into two or more smaller functions.

Recompile with fewer optimizations.

C4765recoverable heap overflow in postoptimizer Level 2  
  The postoptimizing pass ran out of memory but was able to recover. Some optimization options may have been ignored.
  One of the following may be a solution:

Divide the function into two or more smaller functions.

Recompile with fewer optimizations.

C4766local symbol-table overflow Level 2  
  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.
  One of the following may be a solution:

Divide the function into two or more smaller functions.

Recompile with fewer optimizations.

C4769conversion of near pointer to long integer Level 2  
  The compiler converted a 16-bit near pointer to a long integer by extending the high-order word with the current data segment value, not with zeros.
  This warning is informational.
C4773scoping too deep; deepest scoping merged when debugging Level 1  
  Declarations appeared at a static nesting level greater than 16. As a result, all declarations beyond this level will seem to appear at the same level when being viewed by the debugger.
C4785near call to function in different segment Level 1  
  The given function was specified in an alloc_text pragma without being declared with __far, and then the function was called from the text segment.
  The compiler generated a near call.
  Although this is a warning message rather than an error message, the resulting code will not work correctly.
C4786string too long—truncated to 255 characters Level 1  
  The string for a title or subtitle pragma exceeded the maximum allowable length and was truncated.
C4788identifier : identifier was truncated to number characters Level 1  
  Only the first 31 characters of an identifier are significant in C. In C++, the first 247 characters (after name decoration) 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.
C4790insufficient memory to process debugging information Level 2  
  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 that could be consuming significant amounts of memory.

C4791loss of debugging information caused by optimization Level 2  
  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.
  This warning can be eliminated by turning off the optimization options for debugging purposes.
C4792long double type not supported by alternate math library Level 1  
  The long double numeric type is not supported by the /FPa alternate math emulation library. This can cause unresolved external errors from the linker.
  This warning can be avoided by using another emulation library (such as /FPi) or by avoiding the long double type.
  Ignore this warning if a special handler for the long double type is included in the link process.