Created
November 29, 2016 22:51
-
-
Save seanhoughton/11dc963f3826b8ef9a4bc27c13ad26ef to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| C1250: Unable to load plug-in. | |
| C1251: Unable to load models. | |
| C1252: 'Circular or missing dependency between plugins: requires GUID' | |
| C1253: Unable to load model file. | |
| C1254: 'Plugin version mismatch : version doesn''t match the version of the PREfast driver' | |
| C1255: PCH data for plugin has incorrect length. | |
| C1256: PCH must be both written and read. | |
| C1257: Plugin Initialization Failure. | |
| C26100: Race condition. Variable <var> should be protected by lock <lock>. | |
| C26101: Failing to use interlocked operation properly for variable <var>. | |
| C26105: Lock order violation. Acquiring lock <lock> with level <level> causes order inversion. | |
| C26110: Caller failing to hold lock <lock> before calling function <func>. | |
| C26111: Caller failing to release lock <lock> before calling function <func>. | |
| C26112: Caller cannot hold any lock before calling <func>. | |
| C26115: Failing to release lock <lock> in function <func>. | |
| C26116: Failing to acquire or to hold lock <lock> in <func>. | |
| C26117: Releasing unheld lock <lock> in function <func>. | |
| C26130: Missing annotation _Requires_lock_held_(<lock>) or _No_competing_thread_ at function <func>. Otherwise it could be a race condition. Variable <var> should be protected by lock <lock>. | |
| C26135: Missing annotation <annotation> at function <func>. | |
| C26140: Undefined lock kind <lock> in annotation <annotation> on lock <lock>. | |
| C26160: Caller possibly failing to hold lock <lock> before calling function <func>. | |
| C26165: Possibly failing to release lock <lock> in function <func>. | |
| C26166: Possibly failing to acquire or to hold lock <lock> in function <func>. | |
| C26167: Possibly releasing unheld lock <lock> in function <func>. | |
| C28020: The expression <expr> is not true at this call | |
| C28021: The parameter <param> being annotated with <anno> must be a pointer | |
| C28022: The function class(es) <classlist1> on this function do not match the function class(es) <classlist2> on the typedef used to define it. | |
| C28023: 'The function being assigned or passed should have a _Function_class_ annotation for at least one of the class(es) in: <classlist>' | |
| C28024: The function pointer being assigned to is annotated with the function class <class>, which is not contained in the function class(es) <classlist>. | |
| C28039: The type of actual parameter <operand> should exactly match the type <typename> | |
| C28103: Leaking resource | |
| C28104: Resource that should have been acquired before function exit was not acquired | |
| C28105: Leaking resource due to an exception | |
| C28106: Variable already holds resource possibly causing leak | |
| C28107: Resource must be held when calling function | |
| C28108: Variable holds an unexpected resource | |
| C28109: Variable cannot be held at the time function is called | |
| C28112: A variable which is accessed via an Interlocked function must always be accessed via an Interlocked function | |
| C28113: Accessing a local variable via an Interlocked function | |
| C28125: The function must be called from within a try/except block | |
| C28137: The variable argument should instead be a (literal) constant | |
| C28138: The constant argument should instead be variable | |
| C28159: Consider using another function instead. | |
| C28160: Error annotation | |
| C28163: The function should never be called from within a try/except block | |
| C28164: The argument is being passed to a function that expects a pointer to an object (not a pointer to a pointer) | |
| C28182: Dereferencing NULL pointer. | |
| C28183: The argument could be one value, and is a copy of the value found in the pointer | |
| C28193: The variable holds a value that must be examined | |
| C28194: The function was declared as aliasing the value in variable and exited without doing so | |
| C28195: The function was declared as acquiring memory in a variable and exited without doing so | |
| C28196: The requirement is not satisfied. (The expression does not evaluate to true.) | |
| C28197: Possibly leaking memory | |
| C28198: Possibly leaking memory due to an exception. | |
| C28199: Using possibly uninitialized memory | |
| C28202: Illegal reference to non-static member | |
| C28203: Ambiguous reference to class member. Could be <name1> or <name2> | |
| C28204: '<function> : Only one of this overload and the one at <filename>(<line>) are annotated for <paramname>: both or neither must be annotated.' | |
| C28205: 'function> : _Success_ or _On_failure_ used in an illegal context: <why>' | |
| C28206: '<expression> : left operand points to a struct, use ->' | |
| C28207: '<expression>: left operand is a struct, use .' | |
| C28208: Function <function> was previously defined with a different parameter list at <file>(<line>). Some analysis tools will yield incorrect results | |
| C28209: The declaration for symbol has a conflicting declaration | |
| C28210: Annotations for the _On_failure_ context must not be in explicit pre context | |
| C28211: Static context name expected for SAL_context | |
| C28212: Pointer expression expected for annotation | |
| C28213: The _Use_decl_annotations_ annotation must be used to reference, without modification, a prior declaration. <why> | |
| C28214: Attribute parameter names must be p1...p9 | |
| C28215: The typefix cannot be applied to a parameter that already has a typefix | |
| C28216: The _Check_return_ annotation only applies to post-conditions for the specific function parameter. | |
| C28217: For function, the number of parameters to annotation does not match that found at file | |
| C28218: For function parameter, the annotation's parameter does not match that found at file | |
| C28219: Member of enumeration expected for annotation the parameter in the annotation | |
| C28220: Integer expression expected for annotation the parameter in the annotation | |
| C28221: String expression expected for the parameter in the annotation | |
| C28222: _Yes_, _No_, or _Maybe_ expected for annotation | |
| C28223: Did not find expected Token/identifier for annotation, parameter | |
| C28224: Annotation requires parameters | |
| C28225: Did not find the correct number of required parameters in annotation | |
| C28226: Annotation cannot also be a PrimOp (in current declaration) | |
| C28227: Annotation cannot also be a PrimOp (see prior declaration) | |
| C28228: 'Annotation parameter: cannot use type in annotations' | |
| C28229: Annotation does not support parameters | |
| C28230: The type of parameter has no member. | |
| C28231: Annotation is only valid on array | |
| C28232: _Pre_, _Post_, or _Deref_ not applied to any annotation | |
| C28233: pre, post, or deref applied to a block | |
| C28234: _At_ expression does not apply to current function | |
| C28235: The function cannot stand alone as an annotation | |
| C28236: The annotation cannot be used in an expression | |
| C28237: The annotation on parameter is no longer supported | |
| C28238: The annotation on parameter has more than one of value, stringValue, and longValue. Use paramn=xxx | |
| C28239: The annotation on parameter has both value, stringValue, or longValue; and paramn=xxx. Use only paramn=xxx | |
| C28240: The annotation on parameter has param2 but no param1 | |
| C28241: The annotation for function on parameter is not recognized | |
| C28243: The annotation for function on parameter requires more dereferences than the actual type annotated allows | |
| C28244: The annotation for function has an unparseable parameter/external annotation | |
| C28245: The annotation for function annotates 'this' on a non-member-function | |
| C28246: The annotation for function '<name>' - parameter '<parameter>' does not match the type of the parameter | |
| C28250: 'Inconsistent annotation for function: the prior instance has an error.' | |
| C28251: 'Inconsistent annotation for function: this instance has an error' | |
| C28252: 'Inconsistent annotation for function: parameter has another annotation on this instance' | |
| C28253: 'Inconsistent annotation for function: parameter has another annotations on this instance' | |
| C28254: dynamic_cast<>() is not supported in annotations | |
| C28262: A syntax error in the annotation was found in function <function> for annotation <name> | |
| C28263: A syntax error in a conditional annotation was found for Intrinsic annotation | |
| C28267: A syntax error in the annotations was found annotation <name> in the function <function>. | |
| C28272: The annotation for function, parameter when examining is inconsistent with the function declaration | |
| C28273: For function, the clues are inconsistent with the function declaration | |
| C28275: The parameter to _Macro_value_ is null | |
| C28278: Function name appears with no prototype in scope. | |
| C28279: For symbol, a 'begin' was found without a matching 'end' | |
| C28280: For symbol, an 'end' was found without a matching 'begin' | |
| C28282: Format Strings must be in preconditions | |
| C28283: For symbol, the specified size specification is not yet supported | |
| C28284: For symbol, Predicates are currently not supported for non-function symbols | |
| C28285: For function, syntax error in parameter | |
| C28286: For function, syntax error near the end | |
| C28287: For function, syntax Error in _At_() annotation (unrecognized parameter name) | |
| C28288: For function, syntax Error in _At_() annotation (invalid parameter name) | |
| C28289: 'For function: ReadableTo or WritableTo did not have a limit-spec as a parameter' | |
| C28290: the annotation for function contains more Externals than the actual number of parameters | |
| C28291: Post null/notnull at deref level 0 is meaningless for function <x> at param <number> | |
| C28300: '<parameter_name>: Expression operands of incompatible types for operator <operator_name>' | |
| C28301: No annotations for first declaration of <function>.<note1> See <filename>(<line>). <note2> | |
| C28302: For C++ reference-parameter <parameter_name>, an extra _Deref_ operator was found on <annotation>. | |
| C28303: For C++ reference-parameter <parameter_name>, an ambiguous _Deref_ operator was found on <annotation>. | |
| C28304: For C++ reference-parameter <parameter_name>, an improperly placed _Notref_ operator was found applied to <token>. | |
| C28305: An error while parsing <token> was discovered. | |
| C28306: The annotation on parameter is obsolescent | |
| C28307: The annotation on parameter is obsolescent | |
| C28308: The format list argument position specified by the annotation is incorrect. | |
| C28309: '<parameter_name>: Annotation operands must be integer/enum/pointer types. Void operands and C++ overloaded operators are not supported. Floats are approximated as integers. Types: <typelist>.' | |
| C28310: The <annotation_name> annotation on <function> <parameter> has no SAL version. | |
| C28311: The <annotation_name> annotation on <function> <parameter> is an obsolescent version of SAL. | |
| C28312: The <annotation_name> annotation on the repeated declaration of <function> <parameter> is an obsolescent version of SAL. | |
| C28350: The annotation <annotation> describes a situation that is not conditionally applicable. | |
| C28351: The annotation <annotation> describes where a dynamic value (a variable) cannot be used in the condition. | |
| C4001: nonstandard extension 'single line comment' was used | |
| C4002: too many actual parameters for macro 'identifier' | |
| C4003: not enough actual parameters for macro 'identifier' | |
| C4005: '''identifier'': macro redefinition' | |
| C4006: '#undef expected an identifier' | |
| C4007: '''function'': must be ''attribute''' | |
| C4008: '''function'': ''atribute'' attribute ignored' | |
| C4010: single-line comment contains line-continuation character | |
| C4013: '''function'' undefined; assuming extern returning int' | |
| C4015: '''identifer'': type of bit field must be integral' | |
| C4018: '''expression'': signed/unsigned mismatch' | |
| C4019: empty statement at global scope | |
| C4020: '''function'': too many actual parameters' | |
| C4022: '''function'': pointer mismatch for actual parameter ''parameter number''' | |
| C4023: '''function'': based pointer passed to unprototyped function: parameter ''parameter_number''' | |
| C4024: '''function'': different types for formal and actual parameter ''parameter_number''' | |
| C4025: '''function'': based pointer passed to function with variable arguments: parameter ''parameter_number''' | |
| C4026: function declared with formal parameter list | |
| C4027: function declared without formal parameter list | |
| C40288: formal parameter 'parameter_number' different from declaration | |
| C4029: declared formal parameter list different from definition | |
| C4030: first formal parameter list longer than the second list | |
| C4031: second formal parameter list longer than the first list | |
| C4032: formal parameter 'parameter_number' has different type when promoted | |
| C4033: '''function'' must return a value' | |
| C4034: sizeof returns 0 | |
| C4035: '''function'': no return value' | |
| C4036: unnamed 'type' as actual parameter | |
| C4038: '''modifier'': illegal class modifier' | |
| C4041: 'compiler limit: terminating browser output' | |
| C4042: '''identifier'': has bad storage class' | |
| C4045: '''array'': array bounds overflow' | |
| C4047: '''operator'': ''identifier1'' differs in levels of indirection from ''identifier2''' | |
| C4048: 'different array subscripts: ''identifier1'' and ''identifier2''' | |
| C4049: 'compiler limit: terminating line number emission' | |
| C4051: type conversion; possible loss of data | |
| C4052: function declarations different; one contains variable arguments | |
| C4053: one void operand for '?:' | |
| C4054: '''conversion'': from function pointer ''type1'' to data pointer ''type2''' | |
| C4055: '''conversion'': from data pointer ''type1'' to function pointer ''type2''' | |
| C4056: overflow in floating-point constant arithmetic | |
| C4057: '''operator'': ''identifier1'' differs in indirection to slightly different base types from ''identifier2''' | |
| C4060: switch statement contains no 'case' or 'default' labels | |
| C4061: enumerator 'identifier' in switch of enum 'enumeration' is not explicitly handled by a case label | |
| C4062: enumerator 'identifier' in switch of enum 'enumeration' is not handled | |
| C4063: case 'identifier' is not a valid value for switch of enum 'enumeration' | |
| C4064: switch of incomplete enum 'enumeration' | |
| C4065: switch statement contains 'default' but no 'case' labels | |
| C4066: characters beyond first in wide-character constant ignored | |
| C4067: unexpected tokens following preprocessor directive - expected a newline | |
| C4068: unknown pragma | |
| C4069: long double is the same precision as double | |
| C4073: initializers put in library initialization area | |
| C4074: initializers put in compiler reserved initialization area | |
| C4075: initializers put in unrecognized initialization area | |
| C4076: '''type_modifier'': can not be used with type ''typename''' | |
| C4077: unknown check_stack option | |
| C4079: unexpected token 'token' | |
| C4080: expected identifier for segment name; found 'symbol' | |
| C4081: expected 'token1'; found 'token2' | |
| C4083: expected 'token'; found identifier 'identifier' | |
| C4085: expected pragma parameter to be 'on' or 'off' | |
| C4086: expected pragma parameter to be '1', '2', '4', '8', or '16' | |
| C4087: '''function'': declared with ''void'' parameter list' | |
| C4088: '''function'': pointer mismatch in actual parameter ''parameter_number'', formal parameter ''parameter_number''' | |
| C4089: '''function'': different types in actual parameter ''parameter_number'', formal parameter ''parameter_number''' | |
| C4090: '''operation'': different ''modifier'' qualifiers' | |
| C4091: 'keyword'': ignored on left of ''type'' when no variable is declared' | |
| C4092: sizeof returns 'unsigned long' | |
| C4094: untagged 'token' declared no symbols | |
| C4096: '''identifier'': interface is not a COM interface; will not be emitted to IDL' | |
| C4097: expected pragma parameter to be 'restore' or 'off' | |
| C4098: '''function'': ''void'' function returning a value' | |
| C4099: '''identifier'': type name first seen using ''object_type1'' now seen using ''object_type2''' | |
| C4100: '''identifier'': unreferenced formal parameter' | |
| C4101: '''identifier'': unreferenced local variable' | |
| C4102: '''label'': unreferenced label' | |
| C4103: '''filename'': alignment changed after including header, may be due to missing #pragma pack(pop)' | |
| C4109: unexpected identifier 'identifier' | |
| C4112: '#line requires an integer between 1 and ''line_count''' | |
| C4113: '''identifier1'' differs in parameter lists from ''identifier2''' | |
| C4114: same type qualifier used more than once | |
| C4115: '''type'': named type definition in parentheses' | |
| C4116: unnamed type definition in parentheses | |
| C4117: macro name 'name' is reserved, 'command' ignored | |
| C4119: different bases 'base1' and 'base2' specified | |
| C4120: based/unbased mismatch | |
| C4121: '''symbol'': alignment of a member was sensitive to packing' | |
| C4122: '''function'': alloc_text applicable only to functions with C linkage' | |
| C4123: different base expressions specified | |
| C4124: __fastcall with stack checking is inefficient | |
| C4125: decimal digit terminates octal escape sequence | |
| C4127: conditional expression is constant | |
| C4129: '''character'': unrecognized character escape sequence' | |
| C4130: '''operator'': logical operation on address of string constant' | |
| C4131: '''function'': uses old-style declarator' | |
| C4132: '''object'': const object should be initialized' | |
| C4133: '''expression'': incompatible types - from ''type1'' to ''type2''' | |
| C4137: '''function'': no return value from floating-point function' | |
| C4138: '''*/'' found outside of comment' | |
| C4141: '''modifier'': used more than once' | |
| C4142: benign redefinition of type | |
| C4143: pragma 'same_seg' not supported; use __based allocation | |
| C4144: '''expression'': relational expression as switch expression' | |
| C4145: '''expression1'': relational expression as switch expression; possible confusion with ''expression2''' | |
| C4146: unary minus operator applied to unsigned type, result still unsigned | |
| C4150: deletion of pointer to incomplete type 'type'; no destructor called | |
| C4152: nonstandard extension, function/data pointer conversion in expression | |
| C4153: function/data pointer conversion in expression | |
| C4154: deletion of an array expression; conversion to pointer supplied | |
| C4155: deletion of an array expression without using the array form of 'delete' | |
| C4156: deletion of an array expression without using the array form of 'delete'; array form substituted | |
| C4157: pragma was ignored by C compiler | |
| C4158: 'assuming #pragma pointers_to_members(full_generality, ''inheritance_type'')' | |
| C4159: '#pragma ''pragma''(pop,...): has popped previously pushed identifier ''identifier''' | |
| C4160: '#pragma ''pragma''(pop,...): did not find previously pushed identifier ''identifier''' | |
| C4161: '#pragma ''pragma''(pop...): more pops than pushes' | |
| C4162: '''identifier'': no function with C linkage found' | |
| C4163: '''identifier'': not available as an intrinsic function' | |
| C4164: '''function'': intrinsic function not declared' | |
| C4165: '''HRESULT'' is being converted to ''bool''; are you sure this is what you want?' | |
| C4166: illegal calling convention for constructor/destructor | |
| C4167: '''function'': only available as an intrinsic function' | |
| C4168: 'compiler limit: out of debugger types, delete program database ''database'' and rebuild' | |
| C4172: returning address of local variable or temporary | |
| C4174: '''name'': not available as a #pragma component' | |
| C4175: '#pragma component(browser, on): browser info must initially be specified on the command line' | |
| C4176: '''subcomponent'': unknown subcomponent for #pragma component browser' | |
| C4177: '#pragma ''pragma'' should only be used at global scope or namespace scope' | |
| C4178: case constant 'constant' too big for the type of the switch expression | |
| C4179: '''//*'': parsed as ''/'' and ''/*'': confusion with standard ''//'' comments' | |
| C4180: qualifier applied to function type has no meaning; ignored | |
| C4181: qualifier applied to reference type; ignored | |
| C4182: '#include nesting level is ''nest_count'' deep; possible infinite recursion' | |
| C4183: '''identifier'': missing return type; assumed to be a member function returning ''int''' | |
| C4185: 'ignoring unknown #import attribute ''attribute''' | |
| C4186: '#import attribute ''attribute'' requires ''argument_count'' arguments; ignored' | |
| C4187: '#import attributes ''attribute1'' and ''attribute2'' are incompatible; both ignored' | |
| C4188: constant expression is not integral | |
| C4189: '''identifier'': local variable is initialized but not referenced' | |
| C4190: '''identifier1'' has C-linkage specified, but returns UDT ''identifier2'' which is incompatible with C' | |
| C4191: '''operator/operation'': unsafe conversion from ''type_of_expression'' to ''type_required''' | |
| C4192: automatically excluding 'identifier' while importing type library 'library' | |
| C4193: '#pragma warning(pop): no matching ''#pragma warning(push)''' | |
| C4194: '#pragma start_map_region cannot be nested; ignored' | |
| C4195: '#pragma stop_map_region used without matching #pragma start_map_region; ignored' | |
| C4196: expected '%%$L' or '%%$L'; found '%%$L' | |
| C4197: '''type'': top-level volatile in cast is ignored' | |
| C4200: 'nonstandard extension used: zero-sized array in struct/union' | |
| C4201: 'nonstandard extension used: nameless struct/union' | |
| C4202: 'nonstandard extension used: ''...'': prototype parameter in name list illegal' | |
| C4203: 'nonstandard extension used: union with static member variable' | |
| C4204: 'nonstandard extension used: non-constant aggregate initializer' | |
| C4205: 'nonstandard extension used: static function declaration in function scope' | |
| C4206: 'nonstandard extension used: translation unit is empty' | |
| C4207: 'nonstandard extension used: extended initializer form' | |
| C4208: 'nonstandard extension used: delete [exp] - exp evaluated but ignored' | |
| C4210: 'nonstandard extension used: function given file scope' | |
| C4211: 'nonstandard extension used: redefined extern to static' | |
| C4212: 'nonstandard extension used: function declaration used ellipsis' | |
| C4213: 'nonstandard extension used: cast on l-value' | |
| C4214: 'nonstandard extension used: bit field types other than int' | |
| C4215: 'nonstandard extension used: long float' | |
| C4216: 'nonstandard extension used: float long' | |
| C4218: 'nonstandard extension used: must specify at least a storage class or a type' | |
| C4220: varargs matches remaining parameters | |
| C4221: 'nonstandard extension used: ''identifier'': cannot be initialized using address of automatic variable ''variable''' | |
| C4223: 'nonstandard extension used: non-lvalue array converted to pointer' | |
| C4224: 'nonstandard extension used: formal parameter ''identifier'' was previously defined as a type' | |
| C4226: 'nonstandard extension used: ''keyword'' is an obsolete keyword' | |
| C4227: 'anachronism used: qualifiers on reference are ignored' | |
| C4228: 'nonstandard extension used: qualifiers after comma in declarator list are ignored' | |
| C4229: 'anachronism used: modifiers on data are ignored' | |
| C4230: 'anachronism used: modifiers/qualifiers interspersed; qualifier ignored' | |
| C4232: 'nonstandard extension used: ''identifier'': address of dllimport ''dllimport'' is not static, identity not guaranteed' | |
| C4233: 'nonstandard extension used: ''keyword'' keyword only supported in C++, not C' | |
| C4234: 'nonstandard extension used: ''keyword'' keyword reserved for future use' | |
| C4235: 'nonstandard extension used: ''keyword'' keyword not supported on this architecture' | |
| C4237: '''keyword'' keyword is not yet supported, but reserved for future use' | |
| C4238: 'nonstandard extension used: class rvalue used as lvalue' | |
| C4239: 'nonstandard extension used: ''token'': conversion from ''type1'' to ''type2''' | |
| C4240: 'nonstandard extension used: access to ''classname'' now defined to be ''acess_specifier1'', previously it was defined to be ''access_specifier2''' | |
| C4242: '''identfier'': conversion from ''type1'' to ''type1'', possible loss of data' | |
| C4243: '''conversion_type'' conversion from ''type1'' to ''type1'' exists, but is inaccessible' | |
| C4244: '''conversion_type'': conversion from ''type1'' to ''type2'', possible loss of data' | |
| C4245: '''conversion_type'': conversion from ''type1'' to ''type2'', signed/unsigned mismatch' | |
| C4250: '''classname'': inherits ''base_classname::member'' via dominance' | |
| C4251: '''identifier'': ''object_type1'' ''identifier1'' needs to have dll-interface to be used by clients of ''object_type'' ''identfier2''' | |
| C4254: '''operator'': conversion from ''type1:field_bits'' to ''type2:field_bits'', possible loss of data' | |
| C4255: '''function'': no function prototype given: converting ''()'' to ''(void)''' | |
| C4256: '''function'': constructor for class with virtual bases has ''...''; calls may not be compatible with older versions of Visual C++' | |
| C4258: '''variable'': definition from the for loop is ignored; the definition from the enclosing scope is used' | |
| C4263: '''function'': member function does not override any base class virtual member function' | |
| C4264: '''virtual_function'': no override available for virtual member function from base ''classname''; function is hidden' | |
| C4265: '''classname'': class has virtual functions, but destructor is not virtual instances of this class may not be destructed correctly' | |
| C4266: '''virtual_function'': no override available for virtual member function from base ''classname''; function is hidden' | |
| C4267: '''variable'': conversion from ''size_t'' to ''type'', possible loss of data' | |
| C4268: '''identifier'': ''const'' static/global data initialized with compiler generated default constructor fills the object with zeros' | |
| C4269: '''identifier'': ''const'' automatic data initialized with compiler generated default constructor produces unreliable results' | |
| C4272: '''function'': is marked __declspec(dllimport); must specify native calling convention when importing a function.' | |
| C4273: '''function'': inconsistent dll linkage' | |
| C4274: '#ident ignored; see documentation for #pragma comment(exestr, ''string'')' | |
| C4275: non dll-interface 'classkey' 'identifier1' used as base for dll-interface 'classkey' 'identifier2' | |
| C4276: '''function'': no prototype provided; assumed no parameters' | |
| C4277: imported item 'classname::member' exists as both data member and function member; data member ignored | |
| C4278: '''identifier'': identifier in type library ''library'' is already a macro; use the ''rename'' qualifier' | |
| C4279: '''identifier'': identifier in type library ''library'' is a keyword; use the ''rename'' qualifier' | |
| C4280: '''operator ->'' was self recursive through type ''type''' | |
| C4281: '''operator ->'' recursion occurred through type ''type1''' | |
| C4282: then through type 'type2' | |
| C4283: and through type 'typeN' | |
| C4285: return type for 'identifier::operator ->' is recursive if applied using infix notation | |
| C4286: '''derived_type'': is caught by base class (''base_type'') on line ''line_number''' | |
| C4287: '''operator'': unsigned/negative constant mismatch' | |
| C4288: 'nonstandard extension used: ''variable'': loop control variable declared in the for-loop is used outside the for-loop scope; it conflicts with the declaration in the outer scope' | |
| C4289: 'nonstandard extension used: ''variable'': loop control variable declared in the for-loop is used outside the for-loop scope' | |
| C4290: C++ exception specification ignored except to indicate a function is not __declspec(nothrow) | |
| C4291: '''declaration'': no matching operator delete found; memory will not be freed if initialization throws an exception' | |
| C4293: '''shift_operator'': shift count negative or too big, undefined behavior' | |
| C4295: '''array'': array is too small to include a terminating null character' | |
| C4296: '''operator'': expression is always ''boolean_value''' | |
| C4297: '''function'': function assumed not to throw an exception but does' | |
| C4298: '''identifier'': identifier in type library ''library'' is already a macro; renaming to ''__identifier''' | |
| C4299: '''identifier'': identifier in type library ''library'' is a keyword; renaming to ''__identifier''' | |
| C4301: '''derived_class::function'': overriding virtual function only differs from ''base_class:function'' by const/volatile qualifier' | |
| C4302: '''conversion'': truncation from ''type1'' to ''type2''' | |
| C4303: C-style_cast' from 'type1' to 'type2' is deprecated, use static_cast, __try_cast or dynamic_cast | |
| C4305: '''conversion'': truncation from ''type1'' to ''type2''' | |
| C4306: '''conversion'': conversion from ''type1'' to ''type2'' of greater size' | |
| C4307: '''operator'': integral constant overflow' | |
| C4308: negative integral constant converted to unsigned type | |
| C4309: '''conversion'': truncation of constant value' | |
| C4310: cast truncates constant value | |
| C4311: '''variable'': pointer truncation from ''type1'' to ''type2''' | |
| C4312: '''operation'': conversion from ''type1'' to ''type2'' of greater size' | |
| C4313: '''function'': ''format_specifier'' in format string conflicts with argument ''argument_number'' of type ''type''' | |
| C4314: expected pragma parameter to be '32' or '64' | |
| C4315: '''classname'': ''this'' pointer for member ''member'' may not be aligned ''alignment'' as expected by the constructor' | |
| C4316: '''identifier'': object allocated on the heap may not be aligned ''alignment''' | |
| C4317: '''printf_family'' : not enough arguments passed for format string' | |
| C4318: passing constant zero as the length to memset | |
| C4319: '''operator'': zero extending ''type1'' to ''type2'' of greater size' | |
| C4321: automatically generating an IID for interface '%%$S' | |
| C4322: automatically generating a CLSID for class '%%$S' | |
| C4323: re-using registered CLSID for class '%%$S' | |
| C4324: '''structname'': structure was padded due to __declspec(align())' | |
| C4325: attributes for standard section 'section' ignored | |
| C4326: return type of 'function' should be 'type1' instead of 'type2' | |
| C4327: '''assignment'': indirection alignment of LHS (''alignment1'') is greater than RHS (''alignment2'')' | |
| C4328: '''function'': indirection alignment of formal parameter parameter_number (parameter_alignment) is greater than the actual argument alignment (argument_alignment)' | |
| C4329: __declspec(align()) is ignored on enum | |
| C4330: attribute '%%s' for section '%%s' ignored | |
| C4333: '''shift_operator'': right shift by too large amount, data loss' | |
| C4334: '''shift_operator'': result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)' | |
| C4335: 'Mac file format detected: please convert the source file to either DOS or UNIX format' | |
| C4336: import cross-referenced type library 'library1' before importing 'library2' | |
| C4337: cross-referenced type library 'library1' in 'library2' is being automatically imported | |
| C4338: '#pragma %%s: standard section ''%%s'' is used' | |
| C4339: '''type'': use of undefined type detected in ''WinRT|CLR'' meta-data - use of this type may lead to a runtime exception' | |
| C4340: '''value'': value wrapped from positive to negative value' | |
| C4342: 'behavior change: ''function'' called, but a member operator was called in previous versions' | |
| C4343: '#pragma optimize("g",off) overrides /Og option' | |
| C4344: 'behavior change: use of explicit template arguments results in call to ''function''' | |
| C4346: '''name'': dependent name is not a type' | |
| C4348: '''type'': redefinition of default parameter: parameter ''parameter_number''' | |
| C4350: 'behavior change: ''member1'' called instead of ''member2''' | |
| C4351: 'new behavior: elements of array ''array'' will be default initialized' | |
| C4352: '''%%$I'': intrinsic function already defined' | |
| C4353: 'nonstandard extension used: constant 0 as function expression. Use ''__noop'' function intrinsic instead' | |
| C4355: '''this'': used in base member initializer list' | |
| C4356: '''member'': static data member cannot be initialized via derived class' | |
| C4357: param array argument found in formal argument list for delegate 'delegate' ignored when generating 'function' | |
| C4358: '''operator'': return type of combined delegates is not ''void''; returned value is undefined' | |
| C4359: '''type'': Alignment specifier is less than actual alignment (''alignment''), and will be ignored.' | |
| C4362: '''%%$S'': alignment greater than 8 bytes is not supported by CLR' | |
| C4364: '#using for assembly ''assembly'' previously seen at ''location''(''line_number'') without as_friend attribute; as_friend not applied' | |
| C4365: '''expression'': conversion from ''type1'' to ''type2'', signed/unsigned mismatch' | |
| C4366: The result of the unary 'operator' operator may be unaligned | |
| C4367: Conversion from '%%$T' to '%%$T' may cause datatype misalignment exception | |
| C4368: 'cannot define ''member'' as a member of managed ''type'': mixed types are not supported' | |
| C4369: '''enumerator'': enumerator value ''value'' cannot be represented as ''type'', value is ''new_value''' | |
| C4370: '''classname'': layout of class has changed from a previous version of the compiler due to better packing' | |
| C4371: '''classname'': layout of class may have changed from a previous version of the compiler due to better packing of member ''member''' | |
| C4373: '''derived_class::function'': virtual function overrides ''base_class::function'', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers' | |
| C4374: '''function1'': interface method will not be implemented by non-virtual method ''function2''' | |
| C4375: non-public method 'method2' does not override 'method2' | |
| C4376: 'access specifier ''old_specifier:'' is no longer supported: please use ''new_specifier:'' instead' | |
| C4377: native types are private by default; -d1PrivateNativeTypes is deprecated | |
| C4378: Must obtain function pointers to run initializers; consider System::ModuleHandle::ResolveMethodHandle | |
| C4379: Version 'version_number' of the common language runtime is not supported by this compiler. Using this version may cause unexpected results | |
| C4380: '''%%$S'': A default constructor cannot be deprecated' | |
| C4381: '''function1'': interface method will not be implemented by non-public method ''function2''' | |
| C4382: 'throwing ''type'': a type with __clrcall destructor or copy constructor can only be caught in /clr:pure module' | |
| C4383: '''instance_dereference_operator'': the meaning of dereferencing a handle can change, when a user-defined ''instance_dereference_operator'' operator exists; write the operator as a static function to be explicit about the operand' | |
| C4384: '#pragma ''make_public'' should only be used at global scope' | |
| C4387: '''%%s'': was considered' | |
| C4388: '''%%$L'': signed/unsigned mismatch' | |
| C4389: '''operator'': signed/unsigned mismatch' | |
| C4390: ''';'': empty controlled statement found; is this the intent?' | |
| C4391: '''function_signature'': incorrect return type for intrinsic function, expected ''type''' | |
| C4392: '''function_signature'': incorrect number of arguments for intrinsic function, expected ''argument_count'' arguments' | |
| C4393: '''variable'': const has no effect on ''literal'' data member; ignored' | |
| C4394: '''function'': per-appdomain symbol should not be marked with __declspec(''dllexport'')' | |
| C4395: '''function'': member function will be invoked on a copy of the initonly data member ''member''' | |
| C4396: '''%%$S'': the inline specifier cannot be used when a friend declaration refers to a specialization of a function template' | |
| C4397: DefaultCharSetAttribute is ignored | |
| C4398: '''variable'': per-process global object might not work correctly with multiple appdomains; consider using __declspec(appdomain)' | |
| C4399: '''symbol'': per-process symbol should not be marked with __declspec(''dllimport'') when compiled with /clr:pure' | |
| C4400: '''type'': const/volatile qualifiers on this type are not supported' | |
| C4401: '''bitfield'': member is bit field' | |
| C4402: must use PTR operator | |
| C4403: illegal PTR operator | |
| C4404: period on directive ignored | |
| C4405: '''identifier'': identifier is reserved word' | |
| C4406: operand on directive ignored | |
| C4407: cast between different pointer to member representations, compiler may generate incorrect code | |
| C4408: anonymous 'struct|union' did not declare any data members | |
| C4409: illegal instruction size | |
| C4410: illegal size for operand | |
| C4411: '''identifier'': symbol resolves to displacement register' | |
| C4412: '''function'': function signature contains type ''type''; C++ objects are unsafe to pass between pure code and mixed or native.' | |
| C4413: '''classname::member'': reference member is initialized to a temporary that doesn''t persist after the constructor exits' | |
| C4414: '''function'': short jump to function converted to near' | |
| C4415: duplicate __declspec(code_seg('%%$I')) | |
| C4416: '__declspec(code_seg(...)) contains empty string: ignored' | |
| C4417: 'an explicit template instantiation cannot have __declspec(code_seg(...)): ignored' | |
| C4418: __declspec(code_seg(...)) ignored on an enum | |
| C4419: '''%%$I'' has no effect when applied to private ref class ''%%$S''.' | |
| C4420: '''checked_operator'': operator not available, using ''operator'' instead; run-time checking may be compromised' | |
| C4421: '''%%$I'': a reference parameter on a resumable function is potentially unsafe' | |
| C4423: '''std::bad_alloc'': will be caught by class (''%%$T'') on line %%d' | |
| C4424: catch for '%%$T' preceded by '%%$T' on line %%d; unpredictable behavior may result if 'std::bad_alloc' is thrown | |
| C4425: A SAL annotation cannot be applied to '...' | |
| C4426: 'optimization flags changed after including header, may be due to #pragma optimize()' | |
| C4427: '''%%$L'': overflow in constant division, undefined behavior' | |
| C4429: possible incomplete or improperly formed universal-character-name | |
| C4430: 'missing type specifier - int assumed. Note: C++ does not support default-int' | |
| C4431: 'missing type specifier - int assumed. Note: C no longer supports default-int' | |
| C4434: a static constructor must have private accessibility; changing to private access | |
| C4435: '''derived_class'': Object layout under /vd2 will change due to virtual base ''base_class''' | |
| C4436: dynamic_cast from virtual base 'base_class' to 'derived_class' in constructor or destructor could fail with partially-constructed object | |
| C4437: dynamic_cast from virtual base 'base_class' to 'derived_class' could fail in some contexts | |
| C4438: '''%%$S'': cannot be called safely in /await:clrcompat mode. If ''%%$S'' calls into the CLR it may result in CLR head corruption' | |
| C4439: '''function'': function definition with a managed type in the signature must have a __clrcall calling convention' | |
| C4440: calling convention redefinition from 'calling_convention1' to 'calling_convenction2' ignored | |
| C4441: calling convention of 'calling_convention1' ignored; 'calling_convention2' used instead | |
| C4442: embedded null terminator in __annotation argument. Value will be truncated. | |
| C4443: expected pragma parameter to be '0', '1', or '2' | |
| C4444: '''identifier'': top level ''__unaligned'' is not implemented in this context' | |
| C4445: '''function'': in a ''WinRT|managed'' type a virtual method cannot be private' | |
| C4446: '''%%$S'': cannot map member ''%%$I'' into this type, due to conflict with the type name. The method was renamed to ''%%$I''' | |
| C4447: '''main'' signature found without threading model. Consider using ''int main(Platform::Array<Platform::String^>^ args)''.' | |
| C4448: '''%%$S'' does not have a default interface specified in metadata. Picking: ''%%$S'', which may fail at runtime.' | |
| C4449: '''%%$S'' an unsealed type should be marked as ''[WebHostHidden]''' | |
| C4450: '''%%$S'' should be marked as ''[WebHostHidden]'' because it derives from ''%%$S''' | |
| C4451: '''classname1::member'': Usage of ref class ''classname2::member'' inside this context can lead to invalid marshaling of object across contexts' | |
| C4452: '''identifier'': public type cannot be at global scope. It must be in a namespace that is a child of the name of the output .winmd file.' | |
| C4453: '''%%$S'': A ''[WebHostHidden]'' type should not be used on the published surface of a public type that is not ''[WebHostHidden]''' | |
| C4454: '''%%$S'' is overloaded by more than the number of input parameters without having [DefaultOverload] specified. Picking ''%%$D'' as the default overload' | |
| C4455: '''operator %%$I'': literal suffix identifiers that do not start with an underscore are reserved' | |
| C4456: declaration of 'identifier' hides previous local declaration | |
| C4457: declaration of 'identifier' hides function parameter | |
| C4458: declaration of 'identifier' hides class member | |
| C4459: declaration of 'identifier' hides global declaration | |
| C4460: '''WinRT|managed'' operator ''operator'', has parameter passed by reference. ''WinRT|managed'' operator ''operator'' has different semantics from C++ operator ''cpp_operator'', did you intend to pass by value?' | |
| C4461: '''classname'': this class has a finalizer ''!finalizer'' but no destructor ''~dtor''' | |
| C4462: '''type'' : cannot determine the GUID of the type. Program may fail at runtime.' | |
| C4463: overflow; assigning 'value' to bit-field that can only hold values from 'mi_valuen' to 'max_value' | |
| C4464: relative include path contains '..' | |
| C4470: floating-point control pragmas ignored under /clr | |
| C4471: '''enumeration'': a forward declaration of an unscoped enumeration must have an underlying type (int assumed)' | |
| C4472: '''identifier'' is a native enum: add an access specifier (private/public) to declare a ''WinRT|managed'' enum' | |
| C4480: 'nonstandard extension used: specifying underlying type for enum ''enumeration''' | |
| C4481: 'nonstandard extension used: override specifier ''keyword''' | |
| C4482: 'nonstandard extension used: enum ''enumeration'' used in qualified name' | |
| C4483: 'syntax error: expected C++ keyword' | |
| C4484: '''override_function'': matches base ref class method ''base_class_function'', but is not marked ''virtual'', ''new'' or ''override''; ''new'' (and not ''virtual'') is assumed' | |
| C4485: '''override_function'': matches base ref class method ''base_class_function'', but is not marked ''new'' or ''override''; ''new'' (and ''virtual'') is assumed' | |
| C4486: '''function'': a private virtual method of a ref class or value class should be marked ''sealed''' | |
| C4487: '''derived_class_function'': matches inherited non-virtual method ''base_class_function'' but is not explicitly marked ''new''' | |
| C4488: '''function'': requires ''keyword'' keyword to implement the interface method ''interface_method''' | |
| C4489: '''specifier'': not allowed on interface method ''method''; override specifiers are only allowed on ref class and value class methods' | |
| C4490: '''override'': incorrect use of override specifier; ''function'' does not match a base ref class method' | |
| C4491: '''%%s'': has an illegal IDL version format' | |
| C4492: '''%%$S'': matches base ref class method ''%%$S'', but is not marked ''override''' | |
| C4493: delete expression has no effect as the destructor of 'type' does not have 'public' accessibility | |
| C4494: '''%%$S'' : Ignoring __declspec(allocator) because the function return type is not a pointer or reference' | |
| C4502: '''linkage specification'' requires use of keyword ''extern'' and must precede all other specifiers' | |
| C4503: '''identifier'': decorated name length exceeded, name was truncated' | |
| C4505: '''function'': unreferenced local function has been removed' | |
| C4506: no definition for inline function 'function' | |
| C4508: '''function'': function should return a value; ''void'' return type assumed' | |
| C4509: 'nonstandard extension used: ''function'' uses SEH and ''object'' has destructor' | |
| C4510: '''class'': default constructor was implicitly defined as deleted' | |
| C4511: '''class'': copy constructor was implicitly defined as deleted' | |
| C4512: '''class'': assignment operator was implicitly defined as deleted' | |
| C4513: '''class'': destructor was implicitly defined as deleted' | |
| C4514: '''function'': unreferenced inline function has been removed' | |
| C4515: '''namespace'': namespace uses itself' | |
| C4516: '''class::symbol'': access-declarations are deprecated; member using-declarations provide a better alternative' | |
| C4517: access-declarations are deprecated; member using-declarations provide a better alternative | |
| C4518: '''specifier'': storage-class or type specifier(s) unexpected here; ignored' | |
| C4519: default template arguments are only allowed on a class template | |
| C4520: '''class'': multiple default constructors specified' | |
| C4521: '''class'': multiple copy constructors specified' | |
| C4522: '''class'': multiple assignment operators specified' | |
| C4523: '''class'': multiple destructors specified' | |
| C4526: '''function'': static member function cannot override virtual function ''virtual function'' override ignored, virtual function will be hidden' | |
| C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc | |
| C4531: C++ exception handling not available on Windows CE. Use Structured Exception Handling | |
| C4532: '''continue'': jump out of ''__finally/finally'' block has undefined behavior during termination handling' | |
| C4533: initialization of 'variable' is skipped by 'goto label' | |
| C4534: '''constructor'' will not be a default constructor for ''class|struct'' ''identifier'' due to the default argument' | |
| C4535: calling _set_se_translator() requires /EHa | |
| C4536: '''typename'': type-name exceeds meta-data limit of ''character_limit'' characters' | |
| C4537: '''object'': ''.'' applied to non-UDT type' | |
| C4538: '''type'': const/volatile qualifiers on this type are not supported' | |
| C4539: '''character'': a universal-character-name specifies an invalid character' | |
| C4540: dynamic_cast used to convert to inaccessible or ambiguous base; run-time test will fail ('type1' to 'type2') | |
| C4541: '''identifier'' used on polymorphic type ''type'' with /GR-; unpredictable behavior may result' | |
| C4542: 'Skipping generation of merged injected text file, cannot write %%$M file: ''%%s'': %%$e' | |
| C4543: Injected text suppressed by attribute 'no_injected_text' | |
| C4544: '''declaration'': default template argument ignored on this template declaration' | |
| C4545: expression before comma evaluates to a function which is missing an argument list | |
| C4546: function call before comma missing argument list | |
| C4547: '''operator'': operator before comma has no effect; expected operator with side-effect' | |
| C4548: expression before comma has no effect; expected expression with side-effect | |
| C4549: '''operator'': operator before comma has no effect; did you intend ''operator''?' | |
| C4550: expression evaluates to a function which is missing an argument list | |
| C4551: function call missing argument list | |
| C4552: '''operator'': operator has no effect; expected operator with side-effect' | |
| C4553: '''operator'': operator has no effect; did you intend ''operator?' | |
| C4554: '''operator'': check operator precedence for possible error; use parentheses to clarify precedence' | |
| C4555: expression has no effect; expected expression with side-effect | |
| C4556: value of intrinsic immediate argument 'value' is out of range 'lower_bound - upper_bound' | |
| C4557: '''__assume'' contains effect ''effect''' | |
| C4558: value of operand 'value' is out of range 'lower_bound - upper_bound' | |
| C4559: '''function'': redefinition; the function gains __declspec(modifier)' | |
| C4561: '''__fastcall'' incompatible with the ''/clr'' option: converting to ''__stdcall''' | |
| C4562: 'fully prototyped functions are required with the ''/clr'' option: converting ''()'' to ''(void)''' | |
| C4564: method 'method' of 'class' 'classname' defines unsupported default parameter 'parameter' | |
| C4565: '''function'': redefinition; the symbol was previously declared with __declspec(modifier)' | |
| C4566: character represented by universal-character-name 'char' cannot be represented in the current code page (%%d) | |
| C4568: '''%%$S'': no members match the signature of the explicit override' | |
| C4569: '''%%$S'': no members match the signature of the explicit override' | |
| C4570: '''type'': is not explicitly declared as abstract but has abstract functions' | |
| C4571: 'Informational: catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught' | |
| C4572: '[ParamArray] attribute is deprecated under /clr, use ''...'' instead' | |
| C4573: the usage of '%%$S' requires the compiler to capture 'this' but the current default capture mode does not allow it | |
| C4574: '''Identifier'' is defined to be ''0'': did you mean to use ''#if identifier''?' | |
| C4575: '''__vectorcall'' incompatible with the ''/clr'' option: converting to ''__stdcall''' | |
| C4580: '[attribute] is deprecated; instead specify System::Attribute or Platform::Metadata as a base class' | |
| C4581: 'deprecated behavior: ''"string"'' replaced with ''string'' to process attribute' | |
| C4582: '''%%$S'': constructor is not implicitly called' | |
| C4583: '''%%$S'': destructor is not implicitly called' | |
| C4584: '''class1'': base-class ''class2'' is already a base-class of ''%%class3''' | |
| C4585: '''class'': A WinRT ''public ref class'' must either be sealed or derive from an existing unsealed class' | |
| C4586: '''%%$S'': A public type cannot be declared in a top-level namespace called ''Windows''' | |
| C4587: '''anonymous_structure'': behavior change: constructor is no longer implicitly called' | |
| C4588: '''anonymous_structure'': behavior change: destructor is no longer implicitly called' | |
| C4591: '''constexpr'' call-depth limit of %%d exceeded (/constexpr:depth<NUMBER>)' | |
| C4592: '''function'': ''constexpr'' call evaluation failed; function will be called at run-time' | |
| C4593: '''function'': ''constexpr'' call evaluation step limit of ''limit'' exceeded; use /constexpr:steps<NUMBER> to increase the limit' | |
| C4594: '''%%$S'': destructor will not be implicitly called if an exception is thrown' | |
| C4595: '''%%$S'': behavior change: destructor will no longer be implicitly called if an exception is thrown' | |
| C4600: '#pragma ''macro name'': expected a valid non-empty string' | |
| C4602: '#pragma pop_macro: ''macro name'' no previous #pragma push_macro for this identifier' | |
| C4603: '''<identifier>'': macro is not defined or definition is different after precompiled header use' | |
| C4606: '#pragma warning: ''warning number'' ignored; Code Analysis warnings are not associated with warning levels' | |
| C4608: '''union_member'' has already been initialized by another union member in the initializer list, ''union_member''' | |
| C4609: '''%%$S'' derives from default interface ''%%$S'' on type ''%%$S''. Use a different default interface for ''%%$S'', or break the base/derived relationship.' | |
| C4610: object 'class' can never be instantiated - user defined constructor required | |
| C4611: interaction between 'function' and C++ object destruction is non-portable | |
| C4612: error in include filename | |
| C4613: '''%%$S'': class of segment cannot be changed' | |
| C4615: '#pragma warning: unknown user warning type' | |
| C4616: '#pragma warning: warning number ''number'' not a valid compiler warning' | |
| C4618: pragma parameters included an empty string; pragma ignored | |
| C4619: '#pragma warning: there is no warning number ''number''' | |
| C4620: no postfix form of 'operator ++' found for type 'type', using prefix form | |
| C4621: no postfix form of 'operator --' found for type 'type', using prefix form | |
| C4622: 'overwriting debug information formed during creation of the precompiled header in object file: ''file''' | |
| C4623: '''derived class'': default constructor was implicitly defined as deleted because a base class default constructor is inaccessible or deleted' | |
| C4624: '''derived class'': destructor was implicitly defined as deleted because a base class destructor is inaccessible or deleted' | |
| C4625: '''derived class'': copy constructor was implicitly defined as deleted because a base class copy constructor is inaccessible or deleted' | |
| C4626: '''derived class'': assignment operator was implicitly defined as deleted because a base class assignment operator is inaccessible or deleted' | |
| C4627: '''<identifier>'': skipped when looking for precompiled header use' | |
| C4628: digraphs not supported with -Ze. Character sequence 'digraph' not interpreted as alternate token for '%%s' | |
| C4629: digraph used, character sequence 'digraph' interpreted as token 'char' (insert a space between the two characters if this is not what you intended) | |
| C4630: '''symbol'': ''extern'' storage-class specifier illegal on member definition' | |
| C4631: MSXML or XPath unavailable, XML document comments will not be processed. reason | |
| C4632: 'XML document comment: file - access denied: reason' | |
| C4633: 'XML document comment target: error: reason' | |
| C4634: 'XML document comment target: cannot be applied: reason' | |
| C4635: 'XML document comment target: badly-formed XML: reason' | |
| C4636: 'XML document comment applied to construct: tag requires non-empty ''attribute'' attribute.' | |
| C4637: 'XML document comment target: <include> tag discarded. Reason' | |
| C4638: 'XML document comment target: reference to unknown symbol ''symbol''.' | |
| C4639: MSXML error, XML document comments will not be processed. Reason | |
| C4640: '''instance'': construction of local static object is not thread-safe' | |
| C4641: 'XML document comment has an ambiguous cross reference:' | |
| C4645: function declared with __declspec(noreturn) has a return statement | |
| C4646: function declared with __declspec(noreturn) has non-void return type | |
| C4650: debugging information not in precompiled header; only global symbols from the header will be available | |
| C4651: '''definition'' specified for precompiled header but not for current compile' | |
| C4652: compiler option 'option' inconsistent with precompiled header; current command-line option will override that defined in the precompiled header | |
| C4653: compiler option 'option' inconsistent with precompiled header; current command-line option ignored | |
| C4655: '''symbol'': variable type is new since the latest build, or is defined differently elsewhere' | |
| C4656: '''symbol'': data type is new or has changed since the latest build, or is defined differently elsewhere' | |
| C4657: expression involves a data type that is new since the latest build | |
| C4658: '''function'': function prototype is new since the latest build, or is declared differently elsewhere' | |
| C4659: '#pragma ''pragma'': use of reserved segment ''segment'' has undefined behavior, use #pragma comment(linker, ...)' | |
| C4661: '''identifier'': no suitable definition provided for explicit template instantiation request' | |
| C4662: explicit instantiation; template-class 'identifier1' has no definition from which to specialize 'identifier2' | |
| C4667: '''function'': no function template defined that matches forced instantiation' | |
| C4668: '''symbol'' is not defined as a preprocessor macro, replacing with ''0'' for ''directive''' | |
| C4669: '''cast'': unsafe conversion: ''class'' is a managed type object' | |
| C4670: '''identifier'': this base class is inaccessible' | |
| C4671: '''identifier'': the copy constructor is inaccessible' | |
| C4672: '''identifier1'': ambiguous. First seen as ''identifier2''' | |
| C4673: throwing 'identifier' the following types will not be considered at the catch site | |
| C4674: '''method'' should be declared ''static'' and have exactly one parameter' | |
| C4676: '''%%s'': the destructor is inaccessible' | |
| C4677: '''function'': signature of non-private member contains assembly private type ''private_type''' | |
| C4678: base class 'base_type' is less accessible than 'derived_type' | |
| C4679: '''member'': could not import member' | |
| C4680: '''class'': coclass does not specify a default interface' | |
| C4681: '''class'': coclass does not specify a default interface that is an event source' | |
| C4682: '''parameter'': no directional parameter attribute specified, defaulting to [in]' | |
| C4683: '''function'': event source has an ''out''-parameter; exercise caution when hooking multiple event handlers' | |
| C4684: '''attribute'': WARNING!! attribute may cause invalid code generation: use with caution' | |
| C4685: expecting '> >' found '>>' when parsing template parameters | |
| C4686: '''user-defined type'': possible change in behavior, change in UDT return calling convention' | |
| C4687: '''class'': a sealed abstract class cannot implement an interface ''interface''' | |
| C4688: '''constraint'': constraint list contains assembly private type ''type''' | |
| C4689: '''%%c'': unsupported character in #pragma detect_mismatch; #pragma ignored' | |
| C4690: '[ emitidl( pop ) ]: more pops than pushes' | |
| C4691: '''type'': type referenced was expected in unreferenced assembly ''file'', type defined in current translation unit used instead' | |
| C4692: '''function'': signature of non-private member contains assembly private native type ''native_type''' | |
| C4693: '''class'': a sealed abstract class cannot have any instance members ''instance member''' | |
| C4694: '''class'': a sealed abstract class cannot have a base-class ''base_class''' | |
| C4695: '#pragma execution_character_set: ''character set'' is not a supported argument: currently only ''UTF-8'' is supported' | |
| C4696: /ZBvalue1 option out of range; assuming 'value2' | |
| C4700: uninitialized local variable 'name' used | |
| C4701: potentially uninitialized local variable 'name' used | |
| C4702: unreachable code | |
| C4703: potentially uninitialized local pointer variable '%%s' used | |
| C4706: assignment within conditional expression | |
| C4709: comma operator within array index expression | |
| C4710: '''function'': function not inlined' | |
| C4711: function 'function' selected for automatic inline expansion | |
| C4714: function 'function' marked as __forceinline not inlined | |
| C4715: '''function'': not all control paths return a value' | |
| C4716: '''function'': must return a value' | |
| C4717: '''function'': recursive on all control paths, function will cause runtime stack overflow' | |
| C4718: '''function call'': recursive call has no side effects, deleting' | |
| C4719: Double constant found when Qfast specified - use 'f' as a suffix to indicate single precision | |
| C4720: 'in-line assembler reports: ''message''' | |
| C4721: '''function'': not available as an intrinsic' | |
| C4722: '''function'': destructor never returns, potential memory leak' | |
| C4723: potential divide by 0 | |
| C4724: potential mod by 0 | |
| C4725: instruction may be inaccurate on some Pentiums | |
| C4727: PCH named pch_file with same timestamp found in obj_file_1 and obj_file_2. Using first PCH. | |
| C4728: /Yl- option ignored because PCH reference is required | |
| C4729: function too big for flow graph based warnings | |
| C4730: '''main'': mixing _m64 and floating point expressions may result in incorrect code' | |
| C4731: '''pointer'': frame pointer register ''register'' modified by inline assembly code' | |
| C4732: intrinsic '%%s' is not supported in this architecture | |
| C4733: 'Inline asm assigning to ''FS:0'': handler not registered as safe handler' | |
| C4738: storing 32-bit float result in memory, possible loss of performance | |
| C4739: reference to variable 'var' exceeds its storage space | |
| C4740: flow in or out of inline asm code suppresses global optimization | |
| C4742: '''var'' has different alignment in ''file1'' and ''file2'': number and number' | |
| C4743: '''type'' has different size in ''file1'' and ''file2'': number and number bytes' | |
| C4744: '''var'' has different type in ''file1'' and ''file2'': ''type1'' and ''type2''' | |
| C4746: volatile access of '%%s' is subject to /volatile:<iso|ms> setting; consider using __iso_volatile_load/store intrinsic functions | |
| C4747: 'Calling managed ''entrypoint'': Managed code may not be run under loader lock, including the DLL entrypoint and calls reached from the DLL entrypoint' | |
| C4750: '''identifier'': function with _alloca() inlined into a loop' | |
| C4751: /arch:AVX does not apply to Intel(R) Streaming SIMD Extensions that are within inline ASM | |
| C4752: found Intel(R) Advanced Vector Extensions; consider using /arch:AVX | |
| C4754: Conversion rules for arithmetic operations in the comparison at %%s(%%d) mean that one branch cannot be executed. Cast '%%s' to '%%s' (or similar type of %%d bytes). | |
| C4755: Conversion rules for arithmetic operations in the comparison at %%s(%%d) mean that one branch cannot be executed in an inlined function. Cast '%%s' to '%%s' (or similar type of %%d bytes). | |
| C4756: overflow in constant arithmetic | |
| C4757: subscript is a large unsigned value, did you intend a negative constant? | |
| C4764: Can not align catch objects to greater than 16 bytes | |
| C4767: section name '%%s' is longer than 8 characters and will be truncated by the linker | |
| C4770: partially validated enum '%%s' used as index | |
| C4772: '#import referenced a type from a missing type library; ''missing_type'' used as a placeholder' | |
| C4788: '''identifier'': identifier was truncated to ''number'' characters' | |
| C4789: buffer 'identifier' of size N bytes will be overrun; M bytes will be written starting at offset L | |
| C4792: function '%%s' declared using sysimport and referenced from native code; import library required to link | |
| C4793: '''function'': function compiled as native:''reason''' | |
| C4794: segment of thread local storage variable '%%s' changed from '%%s' to '%%s' | |
| C4799: function 'function' has no EMMS instruction | |
| C4800: '''type'': forcing value to bool ''true'' or ''false'' (performance warning)' | |
| C4801: 'Return by reference is not verifiable: %%s' | |
| C4803: '''method'': the raise method has a different storage class from that of the event, ''event''' | |
| C4804: '''operation'': unsafe use of type ''bool'' in operation' | |
| C4805: '''operation'': unsafe mix of type ''type'' and type ''type'' in operation' | |
| C4806: '''operation'': unsafe operation: no value of type ''type'' promoted to type ''type'' can equal the given constant' | |
| C4807: '''operation'': unsafe mix of type ''type'' and signed bit field of type ''type''' | |
| C4808: case 'value' is not a valid value for switch condition of type 'bool' | |
| C4809: switch statement has redundant 'default' label; all possible 'case' labels are given | |
| C4810: value of pragma pack(show) == n | |
| C4811: value of pragma conform(forScope, show) == value | |
| C4812: 'obsolete declaration style: please use ''new_syntax'' instead' | |
| C4813: '''function'': a friend function of a local class must have been previously declared' | |
| C4815: '''var'': zero-sized array in stack object will have no elements (unless the object is an aggregate that has been aggregate initialized)' | |
| C4816: '''param'': parameter has a zero-sized array which will be truncated (unless the object is passed by reference)' | |
| C4817: '''member'': illegal use of ''.'' to access this member; compiler replaced with ''->''' | |
| C4819: The file contains a character that cannot be represented in the current code page (number). Save the file in Unicode format to prevent data loss | |
| C4820: '''bytes'' bytes padding added after construct ''member_name''' | |
| C4821: Unable to determine Unicode encoding type, please save the file with signature (BOM) | |
| C4822: '''member function'': local class member function does not have a body' | |
| C4823: '''function'': uses pinning pointers but unwind semantics are not enabled. Consider using /EHa' | |
| C4825: '' | |
| C4826: Conversion from 'type1' to 'type_2' is sign-extended. This may cause unexpected runtime behavior. | |
| C4827: A public 'ToString' method with 0 parameters should be marked as virtual and override | |
| C4829: Possibly incorrect parameters to function main. Consider 'int main(Platform::Array<Platform::String^>^ argv)' | |
| C4835: '''variable'': the initializer for exported data will not be run until managed code is first executed in the host assembly' | |
| C4837: 'trigraph detected: ''trigraph'' replaced by ''character''' | |
| C4838: conversion from 'type_1' to 'type_2' requires a narrowing conversion | |
| C4867: '''function'': function call missing argument list; use ''call'' to create a pointer to member' | |
| C4868: '''file(line_number)'' compiler may not enforce left-to-right evaluation order in braced initialization list' | |
| C4872: 'floating point division by zero detected when compiling the call graph for the concurrency::parallel_for_each at: ''%%s''' | |
| C4880: 'casting from ''const type_1'' to ''type_2'': casting away constness from a pointer or reference may result in undefined behavior in an amp restricted function' | |
| C4881: the constructor and/or the destructor will not be invoked for tile_static variable 'variable' | |
| C4882: passing functors with non-const call operators to concurrency::parallel_for_each is deprecated | |
| C4900: Il mismatch between 'tool1' version 'version1' and 'tool2' version 'version2' | |
| C4905: wide string literal cast to 'LPSTR' | |
| C4906: string literal cast to 'LPWSTR' | |
| C4910: '''<identifier>: ''__declspec(dllexport)'' and ''extern'' are incompatible on an explicit instantiation' | |
| C4912: '''attribute'': attribute has undefined behavior on a nested UDT' | |
| C4913: user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used | |
| C4916: 'in order to have a dispid, ''%%$S'': must be introduced by an interface' | |
| C4917: '''declarator'': a GUID can only be associated with a class, interface or namespace' | |
| C4918: '''character'': invalid character in pragma optimization list' | |
| C4920: enum enum member member_1=value_1 already seen in enum enum as member_2=value_2 | |
| C4921: '''%%s'': attribute value ''%%s'' should not be multiply specified' | |
| C4925: '''method'': dispinterface method cannot be called from script' | |
| C4926: '''identifier'': symbol is already defined: attributes ignored' | |
| C4927: illegal conversion; more than one user-defined conversion has been implicitly applied | |
| C4928: illegal copy-initialization; more than one user-defined conversion has been implicitly applied | |
| C4929: '''file'': typelibrary contains a union; ignoring the ''embedded_idl'' qualifier' | |
| C4930: '''prototype'': prototyped function not called (was a variable definition intended?)' | |
| C4931: we are assuming the type library was built for number-bit pointers | |
| C4932: __identifier(identifier) and __identifier(identifier) are indistinguishable | |
| C4934: '''__delegate(multicast)'' is deprecated, use ''__delegate'' instead' | |
| C4935: assembly access specifier modified from 'access' | |
| C4936: this __declspec is supported only when compiled with /clr or /clr:pure | |
| C4937: '''text1'' and ''text2'' are indistinguishable as arguments to ''directive''' | |
| C4938: '''var'': Floating point reduction variable may cause inconsistent results under /fp:strict or #pragma fenv_access' | |
| C4939: '#pragma vtordisp is deprecated and will be removed in a future release of Visual C++' | |
| C4944: '''symbol'': cannot import symbol from ''assembly1'': as ''symbol'' already exists in the current scope' | |
| C4945: '''symbol'': cannot import symbol from ''assembly1'': as ''symbol'' has already been imported from another assembly ''assembly2''' | |
| C4946: 'reinterpret_cast used between related classes: ''class1'' and ''class2''' | |
| C4947: '''type_or_member'': marked as obsolete' | |
| C4948: return type of 'accessor' does not match the last parameter type of the corresponding setter | |
| C4949: pragmas 'managed' and 'unmanaged' are meaningful only when compiled with '/clr[:option]' | |
| C4950: '''type_or_member'': marked as obsolete' | |
| C4951: '''function'' has been edited since profile data was collected, function profile data not used' | |
| C4952: '''function'': no profile data found in program database ''pgd_file''' | |
| C4953: Inline 'function' has been edited since profile data was collected, profile data not used | |
| C4954: '''function'': not profiled (contains __int64 switch expression)' | |
| C4955: '''import2'': import ignored; already imported from ''import1''' | |
| C4956: '''type'': this type is not verifiable' | |
| C4957: '''cast'': explicit cast from ''cast from'' to ''cast_to'' is not verifiable' | |
| C4958: '''operation'': pointer arithmetic is not verifiable' | |
| C4959: cannot define unmanaged type 'type' in /clr:safe because accessing its members yields unverifiable code | |
| C4960: '''function'' is too big to be profiled' | |
| C4961: No profile data was merged into '.pgd file', profile-guided optimizations disabled | |
| C4962: '''function'': Profile-guided optimizations disabled because optimizations caused profile data to become inconsistent' | |
| C4963: '%%s'': no profile data found; different compiler options were used in instrumented build' | |
| C4964: No optimization options were specified; profile info will not be collected | |
| C4965: implicit box of integer 0; use nullptr or explicit cast | |
| C4966: '''%%s'' has __code_seg annotation with unsupported segment name, annotation ignored' | |
| C4970: 'delegate constructor: target object ignored since ''%%$pS'' is static' | |
| C4971: 'Argument order: <target object>, <target function> for delegate constructor is deprecated, use <target function>, <target object=>' | |
| C4972: Directly modifying or treating the result of an unbox operation as an lvalue is unverifiable | |
| C4973: '''%%$S'': marked as deprecated' | |
| C4974: '''%%$S'': marked as deprecated' | |
| C4981: 'Warbird: function ''%%$pD'' marked as __forceinline not inlined because it contains exception semantics' | |
| C4985: 'symbol name'': attributes not present on previous declaration.' | |
| C4986: '''%%$pS'': exception specification does not match previous declaration' | |
| C4987: 'nonstandard extension used: ''throw (...)''' | |
| C4988: '''%%$S'': variable declared outside class/function scope' | |
| C4989: '''%%s'': type has conflicting definitions.' | |
| C4990: 'Warbird: %%s' | |
| C4991: 'Warbird: function ''%%$pD'' marked as __forceinline not inlined because protection level of inlinee is greater than the parent' | |
| C4992: 'Warbird: function ''%%$pD'' marked as __forceinline not inlined because it contains inline assembly which cannot be protected' | |
| C4995: '''function'': name was marked as #pragma deprecated' | |
| C4996: '''%%$pS'': %%$*' | |
| C4997: '''class'': coclass does not implement a COM interface or pseudo-interface' | |
| C4998: 'EXPECTATION FAILED: %%s(%%d)' | |
| C4999: UNKNOWN WARNING %%$N Please choose the Technical Support command on the Visual C++ %%$N Help menu, or open the Technical Support help file for more information | |
| C6001: using uninitialized memory <variable> | |
| C6011: dereferencing NULL pointer <name> | |
| C6014: Leaking memory. | |
| C6029: 'possible buffer overrun in call to <function>: use of unchecked value' | |
| C6031: 'return value ignored: <function> could return unexpected value' | |
| C6053: call to <function> may not zero-terminate string <variable> | |
| C6054: string <variable> may not be zero-terminated | |
| C6059: Incorrect length parameter in call to <function>. Pass the number of remaining characters, not the buffer size of <variable> | |
| C6063: missing string argument to <function> corresponding to conversion specifier <number> | |
| C6064: missing integer argument to <function> corresponding to conversion specifier <number> | |
| C6066: non-pointer passed as parameter <number> when pointer is required in call to <function> | |
| C6067: parameter <number> in call to <function> must be the address of the string | |
| C6101: Returning uninitialized memory | |
| C6102: Using <variable> from failed function call at line <location>. | |
| C6103: Returning <variable> from failed function call at line <location>. | |
| C6200: index <name> is out of valid index range <min> to <max> for non-stack buffer <variable> | |
| C6201: 'buffer overrun for <variable>, which is possibly stack allocated: index <name> is out of valid index range <min> to <max>' | |
| C6211: Leaking memory <pointer> due to an exception. Consider using a local catch block to clean up memory | |
| C6214: 'cast between semantically different integer types: HRESULT to a Boolean type' | |
| C6215: 'cast between semantically different integer types: a Boolean type to HRESULT' | |
| C6216: 'compiler-inserted cast between semantically different integral types: a Boolean type to HRESULT' | |
| C6217: 'Implicit cast between semantically different integer types: testing HRESULT with ''not''. Consider using SUCCEEDED or FAILED macro instead.' | |
| C6219: 'Implicit cast between semantically different integer types: comparing HRESULT to 1 or TRUE. Consider using SUCCEEDED or FAILED macro instead' | |
| C6220: comparing HRESULT to -1. Consider using SUCCEEDED or FAILED macro instead | |
| C6221: 'Implicit cast between semantically different integer types: comparing HRESULT to an integer. Consider using SUCCEEDED or FAILED macros instead' | |
| C6225: 'Implicit cast between semantically different integer types: assigning 1 or TRUE to HRESULT. Consider using S_FALSE instead' | |
| C6226: 'Implicit cast between semantically different integer types: assigning -1 to HRESULT. Consider using E_FAIL instead.' | |
| C6230: 'implicit cast between semantically different integer types: using HRESULT in a Boolean context' | |
| C6235: (<non-zero constant> || <expression>) is always a non-zero constant | |
| C6236: (<expression> || <non-zero constant>) is always a non-zero constant | |
| C6237: (<zero> && <expression>) is always zero. <expression> is never evaluated and may have side effects | |
| C6239: (<non-zero constant> && <expression>) always evaluates to the result of <expression>. Did you intend to use the bitwise-and operator? | |
| C6240: (<expression> && <non-zero constant>) always evaluates to the result of <expression>. Did you intend to use the bitwise-and operator? | |
| C6242: A jump out of this try-block forces local unwind. Incurs severe performance penalty | |
| C6244: local declaration of <variable> hides previous declaration at <line> of <file> | |
| C6246: 'Local declaration of <variable> hides declaration of same name in outer scope. Additional Information: See previous declaration at <location>.' | |
| C6250: Calling <function> VirtualFree without the MEM_RELEASE flag may free memory but not address descriptors (VADs); results in address space leaks | |
| C6255: _alloca indicates failure by raising a stack overflow exception. Consider using _malloca instead | |
| C6258: using TerminateThread does not allow proper thread clean up. | |
| C6259: 'labeled code is unreachable: (<expression> & <constant>) in switch-expr cannot evaluate to <case-label>' | |
| C6260: sizeof * sizeof is almost always wrong, did you intend to use a character count or a byte count? | |
| C6262: 'Function uses <constant> bytes of stack: exceeds /analyze:stacksize<constant 2>. Consider moving some data to heap' | |
| C6263: using _alloca in a loop; this can quickly overflow stack | |
| C6268: 'Incorrect order of operations: (<TYPE1>)(<TYPE2>)x + y. Possible missing parentheses in (<TYPE1>)((<TYPE2>)x + y)' | |
| C6269: 'possible incorrect order of operations: dereference ignored' | |
| C6270: 'missing float argument to <function>: add a float argument corresponding to conversion specifier <number>' | |
| C6271: 'extra argument passed to <function>: parameter <number> is not used by the format string' | |
| C6272: non-float passed as argument <number> when float is required in call to <function> | |
| C6273: if a pointer value is being passed, %p should be used | |
| C6274: non-character passed as parameter <number> when character is required in call to <function> | |
| C6276: 'Cast between semantically different string types: char* to wchar_t*. Use of invalid string can lead to undefined behavior' | |
| C6277: 'NULL application name with an unquoted path in call to <function>: results in a security vulnerability if the path contains spaces' | |
| C6278: <variable> is allocated with array new [], but deleted with scalar delete. Destructors will not be called | |
| C6279: <variable> is allocated with scalar new, deleted with array delete [] | |
| C6280: <variable> is allocated with <function>, but deleted with <function> | |
| C6281: relational operators have higher precedence than bitwise operators | |
| C6282: 'Incorrect operator: assignment of constant in Boolean context. Consider using ''=='' instead' | |
| C6283: <variable> is allocated with array new [], but deleted with scalar delete | |
| C6284: object passed as parameter '%d' when string is required in call to <function>. | |
| C6285: (<non-zero constant> || <non-zero constant>) is always a non-zero constant. Did you intend to use the bitwise-and operator? | |
| C6286: (<non-zero constant> || <expression>) is always a non-zero constant. <expression> is never evaluated and may have side effects | |
| C6287: 'redundant code: the left and right sub-expressions are identical' | |
| C6288: 'Incorrect operator: mutual inclusion over && is always zero. Did you intent to use || instead?' | |
| C6289: 'Incorrect operator: mutual exclusion over || is always a non-zero constant. Did you intend to use && instead?' | |
| C6290: 'Bitwise operation on logical result: ! has higher precedence than &. Use && or (!(x & y)) instead' | |
| C6291: 'Bitwise operation on logical result: ! has higher precedence than |. Use || or (!(x | y)) instead' | |
| C6292: 'ill-defined for-loop: counts up from maximum' | |
| C6293: 'Ill-defined for-loop: counts down from minimum' | |
| C6294: 'Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed' | |
| C6295: 'Ill-defined for-loop: <variable> values are of the range "min" to "max". Loop executed indefinitely' | |
| C6296: 'Ill-defined for-loop: Loop body only executed once' | |
| C6297: 'Arithmetic overflow: 32-bit value is shifted, then cast to 64-bit value. Result may not be an expected value' | |
| C6298: 'using a read-only string <pointer> as a writable string argument: this will attempt to write into static read-only memory and cause random crashes' | |
| C6299: explicitly comparing a bit field to a Boolean type will yield unexpected results | |
| C6302: 'format string mismatch: character string passed as parameter <number> when wide character string is required in call to <function>' | |
| C6303: 'format string mismatch: wide character string passed as parameter <number> when character string is required in call to <function>' | |
| C6305: potential mismatch between sizeof and countof quantities | |
| C6306: 'incorrect call to <function>: consider using <function> which accepts a va_list as an argument' | |
| C6308: '''realloc'' may return null pointer: assigning a null pointer to <variable>, which is passed as an argument to ''realloc'', will cause the original memory block to be leaked' | |
| C6310: illegal constant in exception filter can cause unexpected behavior | |
| C6312: 'Possible infinite loop: use of the constant EXCEPTION_CONTINUE_EXECUTION in the exception-filter expression of a try-except' | |
| C6313: 'Incorrect operator: Zero-valued flag cannot be tested with bitwise-and. Use an equality test to check for zero-valued flags' | |
| C6314: 'Incorrect order of operations: bitwise-or has higher precedence than the conditional-expression operator. Add parentheses to clarify intent' | |
| C6315: 'Incorrect order of operations: bitwise-and has higher precedence than bitwise-or. Add parentheses to clarify intent' | |
| C6316: 'Incorrect operator: tested expression is constant and non-zero. Use bitwise-and to determine whether bits are set' | |
| C6317: 'incorrect operator: logical-not (!) is not interchangeable with ones-complement (~)' | |
| C6318: 'Ill-defined __try/__except: use of the constant EXCEPTION_CONTINUE_SEARCH or another constant that evaluates to zero in the exception-filter expression. The code in the exception handler block is not executed' | |
| C6319: use of the comma-operator in a tested expression causes the left argument to be ignored when it has no side-effects | |
| C6320: exception-filter expression is the constant EXCEPTION_EXECUTE_HANDLER. This may mask exceptions that were not intended to be handled | |
| C6322: empty _except block | |
| C6323: arning C6323 - use of arithmetic operator on Boolean type(s) | |
| C6324: 'potential incorrect use of <function1>: Did you intend to use <function2>?' | |
| C6326: potential comparison of a constant with another constant | |
| C6328: 'Size mismatch: <type> passed as parameter <number> when <type> is required in call to <function>' | |
| C6329: Return value for a call to <function> should not be checked against <number> | |
| C6330: Incorrect type passed as parameter in call to function | |
| C6331: 'Invalid parameter: passing MEM_RELEASE and MEM_DECOMMIT in conjunction to <function> is not allowed. This results in the failure of this call' | |
| C6332: 'Invalid parameter: passing zero as the dwFreeType parameter to <function> is not allowed. This results in the failure of this call' | |
| C6333: 'Invalid parameter: passing MEM_RELEASE and a non-zero dwSize parameter to <function> is not allowed. This results in the failure of this call' | |
| C6334: sizeof operator applied to an expression with an operator may yield unexpected results | |
| C6335: leaking process information handle <handlename> | |
| C6336: arithmetic operator has precedence over question operator, use parentheses to clarify intent | |
| C6340: 'Mismatch on sign: Incorrect type passed as parameter in call to function' | |
| C6381: Shutdown API <function> requires a valid dwReason or lpMessage | |
| C6383: 'buffer overrun due to conversion of an element count into a byte count: an element count is expected for parameter <number> in call to <function>' | |
| C6384: dividing sizeof a pointer by another value | |
| C6385: 'invalid data: accessing <buffer name>, the readable size is <size1> bytes, but <size2> bytes may be read: Lines: x, y' | |
| C6386: 'buffer overrun: accessing <buffer name>, the writable size is <size1> bytes, but <size2> bytes may be written: Lines: x, y' | |
| C6387: '<argument> may be <value>: this does not adhere to the specification for the function <function name>: Lines: x, y' | |
| C6388: '<argument> may not be <value>: this does not adhere to the specification for the function <function name>: Lines: x, y' | |
| C6400: Using <function name> to perform a case-insensitive compare to constant string <string name>. Yields unexpected results in non-English locales | |
| C6401: Using <function name> in a default locale to perform a case-insensitive compare to constant string < string name>. Yields unexpected results in non-English locales | |
| C6411: Potentially reading invalid data from the buffer. | |
| C6412: Potential buffer overrun while writing to buffer. The writable size is write_size bytes, but write_index bytes may be written. | |
| C6500: 'invalid annotation: value for <name> property is invalid' | |
| C6501: 'annotation conflict: <name> property conflicts with previously specified property' | |
| C6503: 'Invalid annotation: references and arrays may not be marked Null=Yes or Null=Maybe' | |
| C6504: 'invalid annotation: property may only be used on values of pointer, pointer-to-member, or array type' | |
| C6505: 'invalid annotation: MustCheck property may not be used on values of void type' | |
| C6506: 'invalid annotation: <name> property may only be used on values of pointer or array types' | |
| C6508: 'invalid annotation: write access is not allowed on const values' | |
| C6509: 'invalid annotation: ''return'' cannot be referenced from a precondition' | |
| C6510: 'Invalid annotation: ''NullTerminated'' property may only be used on buffers whose elements are of integral or pointer type: Function ''<function>'' <parameter>.' | |
| C6511: 'invalid annotation: MustCheck property must be Yes or No' | |
| C6513: 'invalid annotation: ElementSizeConst requires additional size properties' | |
| C6514: 'invalid annotation: value of the <name> property exceeds the size of the array' | |
| C6515: <name> property may only be used on values of pointer type | |
| C6516: 'invalid annotation: no properties specified for <name> attribute' | |
| C6517: 'Invalid annotation: ''SAL_readableTo'' property may not be specified on buffers that are not readable: ''_Param_(1)''.' | |
| C6518: 'Invalid annotation: ''SAL_writableTo'' property may not be specified as a precondition on buffers that are not writable: ''_Param_(1)''' | |
| C6522: 'invalid size specification: expression must be of integral type' | |
| C6525: 'invalid size specification: property value may not be valid' | |
| C6527: 'Invalid annotation: NeedsRelease property may not be used on values of void type' | |
| C6530: unrecognized format string style <name> | |
| C6540: The use of attribute annotations on this function will invalidate all of its existing __declspec annotations | |
| C6551: 'Invalid size specification: expression not parsable' | |
| C6552: 'Invalid Deref= or Notref=: expression not parsable' | |
| C6701: 'The value is not a valid Yes/No/Maybe value: <string>' | |
| C6702: 'The value is not a string value: <string>' | |
| C6703: 'The value is not a number: <string>' | |
| C6704: 'Unexpected Annotation Expression Error: <annotation> [<why>]' | |
| C6705: Annotation error expected <expected_number> arguments for annotation <parameter> found <actual_number>. | |
| C6706: 'Unexpected Annotation Error for annotation <annotation>: <why>' | |
| C6707: 'Unexpected Model Error: <why>' | |
| C6993: Code analysis ignores OpenMP constructs; analyzing single-threaded code | |
| C6995: Failed to save XML Log file | |
| C6997: Annotations at this location are meaningless and will be ignored. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment