Compaq C
User's Guide for OpenVMS Systems

globaldef int var1; globalref int var2; globalvalue int var3;

Can be written as:

#pragma extern_model save #pragma extern_model strict_refdef int var1; extern int var2; #pragma extern_model globalvalue extern int var3; #pragma extern_model restore

#pragma extern_model documentation.

GOTSZOVFL, GOT table overflow for module text

HEXOCTSIGN, In VAX C mode, the compiler will give this constant a signed type for compatibility with VAX C. This differs from the behavior specified in the C standard, which would give this constant an unsigned type.

HEXOCTUNSIGN, The Compaq C compiler conforms to the C standard and will give this constant an unsigned type. Some older compilers may give this constant a signed type.

HINTNOTFUNC, The identifier "ident" is not a declared function. It will be ignored in this #pragma hint func_attrs list.

HINTTOOBIG, contextthis hint value must not be greater than one. The hint will be ignored.

IDEXPECTED, Identifier expected but not found.

IDINPARENSEXT, contextaccepting an identifier enclosed in parentheses as the second argument to va_start is a language extension.

IDPACKPOPPRAG, The identifier name from the pragma pack pop directive was not found on the top of the pragma pack stack.

IEEEASSUMED, Use of /ROUNDING_MODE qualifier implies /FLOAT=IEEE. Compilation will be performed as if /FLOAT=IEEE were specified on the command line.

IEEEASSUMED1, Use of /IEEE_MODE qualifier implies /FLOAT=IEEE. Compilation will be performed as if /FLOAT=IEEE were specified on the command line.

IGNORECALLVAL, contextthe value returned from the function "expression" is not used - if this is intended, it should be cast to "void".

IGNOREEXTRA, Spurious token(s) ignored on preprocessor directive line.

IGNORETAG, contextthe tag "name" is redeclared, but will be ignored.

IGNORETOKENS, # not in column 1 is ignored, skipping to end of line.

IGNORSYSREG, Ignoring system register specified in routine's linkage.

IMAGINARYNA, The _Imaginary keyword is not supported by Compaq C. It will be treated as an identifier in this compilation.

IMPFNCFALLOFF, The last statement in non-void function "name" is not a return statement.

IMPFNCMSSNGRET, Non-void function "name" with implicit return type int does not contain a return statement.

IMPLICITFUNC, contextthe identifier "name" is implicitly declared as a function.

INCARGTYP, Type of actual argument inconsistent with formal parameter declaration in text

INCARRAYPARM, contextusing array syntax to declare a parameter that is a pointer to an incomplete array type may not be portable.

INCARRAYPARM1, contextallowing an array parameter that has more than two unspecified element counts is a language extension.

INCLUDENOPEA, A non-default pointer size or member alignment is specified, and the header files in directory are not protected. This might yield unpredictable results. The protect_headers_setup script can help. See the protect_headers_setup(8) man page for details.

INCLUDEOPEN, An error occurred while attempting to open the include file name: problem.

INCLUDEPROEPI, Cannot include files in a prologue or epilogue file.

INCOMPARRY, contextthe member name has incomplete array type. This is not strictly conformant with the C standard and might not be portable.

INCOMPARRY1, contextthe last member of a struct or union, name, has incomplete array type. This is not strictly conformant with the C89 standard and might not be portable.

INCOMPCALL, contextthe return type of "expression" is incomplete.

INCOMPDEREF, context"expression" is a pointer to an incomplete struct or union and should not be used as the left operand of a member dereference.

INCOMPELINIT, context, an array's element type is incomplete, which precludes its initialization.

INCOMPELMNT, contextthe element type of an array type is incomplete.

INCOMPMEM, The member "name" has an incomplete type.

INCOMPNOLINK, In this declaration, "name" has no linkage and is of an incomplete type.

INCOMPPARM, In the definition of the function "function name", the parameter "parameter name" has an incomplete type.

INCOMPRETURN, In the definition of the function "name", the return type is an incomplete type other than void.

INCOMPSTAT, The static declaration of "name" is a tentative definition and specifies an incomplete type.

INCOMPSTATARR, Allowing the declaration of a static array with an incomplete type is a language extension.

INCOMPTENT, The type of the tentatively-defined variable "name" is incomplete at the end of the compilation unit.

INCOMPVALUE, context"expression" has incomplete type, and so cannot be used as an rvalue.

INCOMPVOID, contextthe element type of an array type is incomplete. The void type cannot be completed.

INCONSASSFUN, A function "name" appeared in more than one #pragma assert/hint func_attrs specifying the same assertion/hints.

INITCONFLICT, Overlapping static storage initializations detected at Psect text + number

INITOVERLAP1, context, this initializer list will provide a value for a subobject that was initialized by the earlier initializer "init". The earlier initializer will be ignored.

INITVLA, A variable-length array declaration cannot contain an initializer. The initializer will be ignored.

INLINEIG, An inline specifier may only be used to declare an identifier for a function. The inline keyword will be ignored.

INLINESTOCLSMOD, The __inline or __forceinline storage class modifier is a language extension and might not be portable.

INPTRTYPE, contextthis argument to function name is of "type name" type and is not appropriate for the conversion specifier "incorrect conversion". The value may overwrite other data or produce unexpected results.

INSUFALN, Alignment specified for extern model is insufficient for variable. Extern model alignment updated.

INTBADLINKAGE, #pragma use_linkage was applied to the intrinsic function "routine name". The function will be treated as an ordinary external function.

INTCONCASTSGN, contextcasting of the constant "constant" to type type will cause a change in sign.

INTCONCASTTRU, contextcasting of the constant "constant" to type type will cause data loss.

INTCONST, Ill-formed integer constant.

INTCONSTSIGN, contextconversion of the constant "constant" to type type will cause a change in sign.

INTCONSTSIGNED, This integer constant value will be given the type long long int. This is compatible with the C99 standard. Older versions of the compiler would have given this unsigned long int type.

INTCONSTTOOBIG, This integer constant is too large for the long long type. It will be given the unsigned long long type.

INTCONSTTRUNC, contextconversion of the constant "constant" to type type will cause data loss.

INTCONSTUNSIGN, This integer constant value will be given the type unsigned long int. This is compatible with the C89 standard and older compilers. The C99 standard requires this to be a signed long long int.

INTERNALPRAGMA, This is an internal pragma which should only be used by the compiler development team. It should not appear in user programs as it may cause unexpected behavior.

INTIMPLIED, In the declaration of "name", no type was specified. Type defaulted to int. This is a violation of the C99 standard.

INTOVERFL, contextinteger overflow occurs in evaluating the expression "expression".

INTRINSICCALL, contextan apparent invocation of intrinsic function "name", problem. It will be treated as an ordinary external call.

INTRINSICDECL, contextthe declaration for intrinsic function "name" referenced at location, problem. It will be treated as an ordinary external function.

INTRINSICDECLER, contextthe declaration for the prototyped intrinsic function "name" is incorrect: problem.

INTRINSICINT, contextthe place type for intrinsic "name" is being changed from "size_t" to "int".

INTUNDFUN, There is no function declaration visible for the identifier "name" at the point of this #pragma pragma type.

INVALIDARG, Invalid argument to pragma pragma. Pragma is ignored.

INVALIDSTR, The # operator produced an invalid string.

INVALTOKEN, Invalid token discarded.

INVCPPINARGS, Possible directive "#directive" within a macro argument list. The directive is treated as part of the argument list, and not as a preprocessing directive.

INVDUPENUM, contextthe value of the enumerator "name" conflicts with a previous declaration.

INVNOMEMPRAG, Invalid argument to nomember_alignment pragma. Pragma is ignored.

INVPACKPRAG, Invalid pack pragma. Pragma is ignored.

INVPPDIRPEA, The preprocessor directive name is not allowed in a prologue or epilogue file. The directive is ignored.

INVSTATIC1, context the keyword "static" and/or type qualifiers may appear only in the outermost array-bounds specifier of a function parameter. Keyword/qualifier ignored.

INVSTATIC3, The keyword "static" may not appear in an array-bound specifier for a declaration of an array of unknown size. Keyword ignored.

INVSTATIC4, An expression specifying the bound is required when the keyword "static" is used in an array-bounds specifer. Keyword ignored.

INVSTATIC5, context the static bound value differs from the static bound value in another declaration at location. The smaller static bound value will be used.

INVSTATIC6, context neither the keyword "static" nor a type qualifier may be used in array-bounds for old-style function parameters. Keyword/qualifiers ignored.

IVDEPNOFOR, This #pragma directive was not followed by a for statement. The directive will be ignored.

KEYCOMB, Illegal combination of keywords.

KNRFUNC, The function "name" is defined using the old style K&R syntax. The C standard has marked this syntax as obsolescent, and it is not supported in C++. Consider using the standard C prototype syntax.

LABELWOSTMT, Accepting a label without a following statement is a language extension.

LCRXCOND, Common Data Dictionary description extraction condition. msg.

LDCOMPLEXNYI, contextthe type long double _Complex is not fully supported on this platform. The type is only accepted when the compilation specifies the option to make the long double type 64-bits in size.

LEXNESTPAR, Lexically nested parallel at scope text is not supported

LISTOPEN, An error occurred while attempting to open the listing file: reason.

LOCALEXTINI, The block-level declaration of "name" includes an initializer and specifies storage class extern.

LOGICALLINE, A logical source line longer than number characters was encountered.

LONGDEBUG, The identifier name exceeds number characters; name passed to the debugger will be truncated to "truncated spelling".

LONGDOUBLENY1, contexttype long double has the same representation as type double on this platform and is treated as a synonym for type double in this compilation mode.

LONGDOUBLENYI, contexttype long double has the same representation as type double on this platform.

LONGEXTERN, The external identifier name exceeds number characters; truncated to "truncated spelling".

LONGFLOATEXT, contextlong float as a synonym for double is a language extension.

LONGLONGSUFX, The integer constant is of type "type", which is a new feature of C99 might not be portable.

LONGLONGTYPE, contexttype "type" is a new feature in C99.

LONGMODULEID, Identifier name "name" in a #pragma module or #module directive exceeds 31 characters.

LONGMODULESTR, Character-string constant string in a #pragma module or #module directive exceeds 31 characters.

LONGPREFIX, Prefix string too long. Truncated to "newprefix".

LONGPSECT, Psect name is too long (maximum is 31 characters).

LVALUECAST, contextthe result of the cast "cast" is used as an lvalue.

MACROREDEF, The redefinition of the macro "name" conflicts with a current definition because reason. The redefinition is now in effect.

MACROREDEFIN, Macro redefined.

MAINNOTINT, Strict standard C extension: The declaration of the "main" function has a return type other than int.

MAINPARM, Strict standard C extension: The declaration of the "main" function has more than two parameters.

MAINPROGEXT, MAIN_PROGRAM is a language extension.

MATHERRNO, contextfunction name is defined to set errno when a domain error or range error occurs. As an intrinsic, it may not be able to do so.

MAYHIDELOSS, context"expression" has a larger data size than "target type". The use of a cast operator can suppress the message that this assignment might result in data loss.

MAYLOSEDATA, context"expression" has a larger data size than "target type". Assignment can result in data loss.

MAYLOSEDATA2, context"expression" has a larger data size than "target type". Assignment can result in data loss.

MECHMISMATCH, Argument passing mechanism does not match formal parameter mechanism for text

MEMBERVLA, contextthe struct or union member "name" cannot be declared with a variably modified type.

MISALGNDMEM, This member is at offset offset, which is not a multiple of the member's alignment of align. Consider padding before this member, rearranging the order of member declarations, or using #pragma member_alignment.

MISALGNDSTRCT, This member requires align1 alignment for efficient access, but is contained in a struct containing align2 alignment. Consider using #pragma nomember_alignment align1.

MISDEFARG, Missing argument for "defined" operator.

MISDEFPAR, Missing right parenthesis for "defined" operator.

MISMATPARAM, contextparameter number has a different type than specified in an earlier declaration of this function.

MISMATPRSRET, "name" has a non-void return type but its linkage "name" preserves the return register(s). Standard linkage will be used.

MISMATTHREAD, contextthe __declspec(thread) storage class modifier of "name" is different from a previous declaration of "name" at location.

MISPARAMCOUNT, contextthe number of parameters differs from an earlier declaration of this function.

MISSINGCOMMA, This parameter is not preceded by a comma.

MISSINGFUNC, The function "name" has internal linkage, occurs in a context that requires its definition, and has no definition.

MISSINGLABEL, The label "label name" is the target of a goto statement within the function "function name", but has no definition within "function name".

MISSINGRETURN, Non-void function "name" does not contain a return statement.

MISSINGTYPE, Missing type specifier or type qualifier.

MIXALLOCAVLA, contextthis call to __ALLOCA occurs in a block that contains vlaallocafrag1. The storage allocated by this __ALLOCA call will vlaallocafrag2vla or aligned automatic declaration was at where.

MIXALLOCAVLAV, contextusing __ALLOCA and variable-length arrays in the same function is not allowed on this platform. The first variable-length array declaration is at where.

MIXFUNCVOID, contextcompatibility of a pointer to void and a pointer to a function is not portable under the C standard.

MIXINLINE, The function name is declared both this and that.

MIXLINKAGE, context"name" is declared with both internal and external linkage. The previous declaration is at location.

MIXLINKAGE1, context"name" is declared with both internal and external linkage. The previous declaration is at location.

MIXOLDNEW, The definition of the function name includes both a prototype and a declaration list.

MIXSTORCLS, contexta storage class has already been specified. This storage class is ignored.

MIXVLAALLOCA, Declaring vlaallocafrag1 in the same block as a call to __ALLOCA will cause the storage allocated by any __ALLOCA call to vlaallocafrag2previous call to __ALLOCA was at where.

MIXVLAALLOCAV, Using both __ALLOCA and variable-length arrays in the same function is not allowed on this platform. The first call to __ALLOCA is at where.

MODNOIDSTR, Invalid identifier or character-string constant specification.

MODSTORCLS, Storage class modifier noshare has no meaning with this storage class. Modifier is ignored.

MODULEFIRST, "#pragma module" or "#module" directive must precede any language text.

MSGPOP, This "restore" has underflowed the message stack. No corresponding "save" was found.

MSGSFRMEXLCODE, Enabling this message may cause additional messages from excluded code to be output.

MULTICHAR, A character constant includes more than one character or wide character.

MULTILINK, Multiple linkage pragmas specified for "routine name".

MULTILINKREG, The register "register" is specified more than once in the linkage pragma. Pragma is ignored.

MULTIMAIN, More than one main program has been defined.

MULTIPSECTNAME, Multiple psect_type names specified. The name "new_name" supersedes "old_name".

NAMESHORTENED, The external identifier "name" exceeds 31 characters. The name has been shortened to "shortened spelling".

NAMESLOWER, The /NAMES=LOWERCASE qualifier will be removed in a future version of the compiler. Use /NAMES=AS_IS if your application must generate global names in lowercase.

NEEDADDRCONT, context"name" does not have a constant address, but occurs in a context that requires an address constant.

NEEDARITH, context"expression" has type type, which is not arithmetic.

NEEDCONSTEXPR, context"name" is not constant, but occurs in a context that requires a constant expression.

NEEDCONSTEXT, context"name" is not constant, but occurs in a context that requires a constant expression. This is an extension of the language.

NEEDDFLOAT, The CDD description for name specifies the D_Floating data type. The data can only be represented when compiling with /FLOAT=D_FLOAT.

NEEDFUNCPTR, context"expression" points to type type, but occurs in a context that requires a pointer to a function type.

NEEDGFLOAT, The CDD description for name specifies the G_Floating data type. The data can only be represented when compiling with /FLOAT=G_FLOAT.

NEEDIEEE, The CDD description for name specifies a VAX floating data type. The data cannot be represented when compiling with /FLOAT=IEEE_FLOAT.

NEEDIEEE1, The CDD description for name specifies an IEEE floating data type. The data can only be represented when compiling with /FLOAT=IEEE_FLOAT.

NEEDINTEXPR, context"expression" has type type, which is not integral.

NEEDLVALUE, context"expression" is not an lvalue, but occurs in a context that requires one.

NEEDMEMBER, context"name" is not a member of "struct or union expression".

NEEDNONBLTIN, context"name" is a builtin and cannot be used in this context.

NEEDNONCONST, context"expression" has const-qualified type, but occurs in a context that requires a modifiable lvalue.

NEEDNONVOID, context"expression" has void type, but occurs in a context that requires a non-void result.

NEEDPOINTER, context"expression" has type type, but occurs in a context that requires a pointer.

NEEDPTROBJ, context"expression" does not point to an object type.

NEEDSCALAR, context"expression" has type type, which is not scalar.

NEEDSCALARTYP, context"source type" is type type, which is not scalar.

NEEDSIMPLEASM, This asm is unsupported or illegal.

NEEDSTRCONST, context"name" is not a legal asm string, a string constant is required.

NEEDSTRUCT, context"expression" has type type, but occurs in a context that requires a union or struct.

NEGATIVEHINT, contexta negative hint value is not allowed. The hint will be ignored.

NESTEDCOMMENT, Opening comment delimiter found inside a delimited comment; a previous comment may be missing its closing delimiter.

NESTEDENUM, The type "type" is declared nested within "enclosing type". In C, the nesting is ignored and type and its enumerator constants can be accessed as if they were not nested. However, the type and its enumerators are members in C++. Fix.

NESTEDTYPE, The type "type" is declared nested within "enclosing type". In C, the nesting is ignored and type can be accessed as if it were not nested. However, the type is a member in C++. Fix.

NESTINCL, Files included by this file are referenced. However nothing else appears to be referenced from this file.

NEWLOCALE, The compiler could not set its locale to the locale-specific native environment. This problem might be caused by an incorrect value for a name defined in your process environment such as "LC_ALL" or "LANG". The "C" locale will be used.

NLCHAR, An unexpected newline character is present in a character constant.

NLHEADER, A newline occurs inside of a header name.

NLSTRING, An unexpected newline character is present in a string literal.

NOADD, context"expression1" and "expression2" cannot be added.

NOBIFDISABLE, The function "routine name" is a builtin function reserved to the compiler, and cannot be used with #pragma function. The function will continue to be treated as a builtin.

NOBITFIELD, context"expression" is a bitfield, but occurs in a context that precludes bitfields.

NOCASEHERE, This case label occurs outside of any switch statement.

NOCDDHERE, CDD is not available on this platform. The #dictionary directive has been ignored.

NOCOLON, Missing ":".

NOCOLONINEXPR, Missing colon for conditional expression.

NOCOMMA, Missing ",".

NOCONDEXPR, Missing #if conditional expression.

NOCONVERT, context"expression" is of type "type", and cannot be converted to "target type".

NOCONVERTCLS, context"expression" is of type "type", and cannot be converted to a different "type" type.

NODCL, contextnothing is declared.

NODEFAULTHERE, This default label occurs outside of any switch statement.

NOENDIF, Missing #endif directive.

NOEQUAL, Missing "=".

NOEQUALITY, context"expression1" and "expression2" cannot be compared for equality or inequality.

NOEXCEPTFLTR, context this exception handling call is not within an exception filter of a try block.

NOFBDAT, text does not contain feedback data

NOFBFIL, Feedback file text does not exist

NOFBOPT, Compilation will proceed without feedback optimizations

NOFBRTN, Feedback inactive for text in this compilation

NOFIFILE, Cannot find include file filename specified on the command line.

NOFNTPDEFDECL, There is no identifier named "name" declared as a function or function typedef in this compilation unit.

NOFORMALPARM, Missing formal parameter specifier.

NOFUNC, There is no function named name defined in this compilation unit.

NOFUNC1, There is no definition for the inline function named name in this compilation unit.

NOIDFOUND, contextan identifier was expected but not found.

NOIDINPACKPOP, pragma pack pop directive has no identifier name which was found on the top of the pack stack.

NOINCLFILE, Cannot find file filename specified in #include directive.

NOINCLFILEF, Cannot find file filename specified in #include directive.

NOINCLUDEARG, #include directive missing argument.

NOINIT, The type of variable does not permit initialization.

NOINLFUNC, There is no definition for the inline function named name in this compilation unit.

NOINLINEM, The main function cannot be inlined.

NOINLINEREF, context "name" has internal linkage and is referenced from an an inline auxiliary function. This is a violation of the C99 Standard.

NOINLINEST, In an inline auxiliary function, the modifiable object "name" is declared with static storage duration. This is a violation of the C99 standard.

NOLEAVETARG, This leave statement is not within a try statement.

NOLEFTOPERND, Token pasting operator missing left operand.

NOLINKAGE, context"name" has no linkage and has a prior declaration in this scope at where.

NOLONGLONG, context64-bit integral types are not supported on this platform.

NOMACRONAME, #define directive is missing macro name identifier.

NOMAINUFLO, No main function encountered within module. /IEEE_MODE=UNDERFLOW_TO_ZERO is ignored.

NONAMEMEMBERS, contexta struct or union has no named members. This is undefined behavior according to the C standard.

NONATOMIC, Unable to generate code for atomic access

NONEWTYPE, The type "type" is being declared as part of context. C++ does not permit a new type to be declared in this context. Fix.

NONGRNACC, Unable to generate code for requested granularity

NONLBEFOREEOF, File does not end in unescaped newline.

NONMULTALIGN, The size of this structure is size bytes, which is not a multiple of its alignment of align. Respecify the alignment of the structure or add bytes bytes of additional padding.

NONOCTAL, An octal constant contains non-octal digits.

NONPORTDEFINED, "defined" is treated as an identifier here, not an operator.

NONPORTLINEDIR, Non-standard #line directive.

NONSTANDCAST, context"expression" of type "type", is being converted to "target type". Such a cast is not permitted by the standard.

NONULINIT, context, there is no room for the terminating '\0'. Standard C allows this, but C++ does not.

NOOPERAND, Stringization operator missing operand.

NOOPERANDS, Token pasting operator missing both operands.

NOPARENARGLST, Missing right parenthesis for macro argument list.

NOPARM, This declaration does not declare a parameter.

NOPARMLIST, The declaration of function has an empty parameter list. If the function has parameters, they should be declared here; if it has no parameters, "void" should be specified in the parameter list.

NOPRAGARG, No argument for #pragma pragma was found. Pragma is ignored.

NOPSECT, Missing psect name.

NOREGAVAIL, Unable to satisfy program register allocation requirements.

NORELATIONAL, context"expression1" and "expression2" cannot be compared with a relational operator.

NORETNONVOID, noreturn assertion of #pragma assert directive can't be specified for non-void function.

NORETURNVAL, The function "name" returns a value, but no value is given in this return statement.

NORETURNVAL1, The function "name" has an implicit return type of int, but no value is given in this return statement.

NORETVAL, routine text does not return a value

NORGHTPAREN, No right parenthesis for parameter list.

NORIGHTOPERND, Token pasting operator missing right operand.

NORIGHTPAREN, Missing ")".

NOSEHHAND, Missing exception handler.

NOSEMI, Missing ";".

NOSEMI1, Missing ";". This condition may have been caused by an open brace without a matching close brace. The compiler will attempt to identify open braces that might be missing a close brace.

NOSEMISTRUCT, Missing ";" after last structure or union member.

NOSFILE, Cannot create .s file: overlapping static storage initializations at Psect text + number

NOSHAREEXT, noshare is a language extension.

NOSHRINSHR, Noshare variable resides in shr extern model - noshare ignored.

NOSTRING, Missing string literal.

NOSUBTRACT, context"expression2" cannot be subtracted from "expression1".

NOTADDRCAST, contextthe address constant "expression" can be cast only to a pointer type, but "type" is type class type.

NOTAREDUCTION, bad reduction path from fetch of text

NOTCOMPAT, contextthe type of "name" is not compatible with the type of a previous declaration of "name" at location.

NOTCOMPATIMP, contextthe type of the function "name" is not compatible with the earlier implicit declaration of "name" at location.

NOTCOMPFUNC, context an invalid redeclaration of "name" to or from a function type is being ignored.

NOTCONSTQUAL, contextthe referenced type of the pointer value "expression" is const, but the referenced type of the target of this assignment is not.

NOTEXPECTING, Error parsing what. Found "found" when expecting expecting.

NOTINTRINSIC, The function "routine name" is not a known intrinsic function and cannot be used with #pragma function. The function is unaffected by this pragma.

NOTLOCALPARM, context"identifier" is not a local parameter.

NOTONEORZERO, contextthe value of "expression" is neither 0 nor 1.

NOTPARM, contextname is not a parameter.

NOTPOSINT, contextthe array bound "expression" is not a positive integer.

NOTRESTQUAL, contextthe referenced type of the pointer value "expression" is restrict, but the referenced type of the target of this assignment is not.

NOTRIGHTMOST, context"identifier" is not the rightmost parameter to "function".

NOTSCALARCTRL, The controlling expression "expression" has type type, which is not scalar.

NOTTYPEDEF, context"name" does not name a type.

NOTUNALQUA, contextthe referenced type of the pointer value "expression" is __unaligned, but the referenced type of the target of this assignment is not.

NOTVOLQUAL, contextthe referenced type of the pointer value "expression" is volatile, but the referenced type of the target of this assignment is not.

NOTYPES, Declaration has no type or storage class.

NOUNIQFORMALS, Non-unique formal parameter definition.

NOWHILE, Missing "while".

OBJECTTOOBIG, The size of "name" exceeds the maximum size of an object allowed on this platform which is size bytes.

OKCPPINARGS, "#directive" directive within a macro argument list is not portable.

OPENBRACE, Missing "{".

OPENCOMMENT, A comment is not terminated.

OPENPAREN, Missing "(".

OPTIMIZEPOP, This "restore" has underflowed the pragma optimize stack. No corresponding "save" was found.

OPTLEVEL, Invalid optimization level number, defaulted to number.

OTHERDECLUSED, context"name" is not declared in a scope active at this point in the compilation. However, there is a declaration of this identifer with extern storage class in another scope at where. This declaration will be used.

OTHERMEMBER, context"name" is a member of another struct or union.

OUTARGPREC, contextthe type of this argument to function name is not appropriate for the precision argument of the conversion specifier "incorrect conversion". Behavior can be unpredictable.

OUTARGWIDTH, contextthe type of this argument to function name is not appropriate for the width argument of the conversion specifier "incorrect conversion". Behavior can be unpredictable.

OUTFLOATINT, contextthis argument to function name and conversion specifier "incorrect conversion" combine integer and floating-point types. Behavior can be unpredictable.

OUTSTRINGTYPE, contextthis argument to function name is of "type name" type and is not appropriate for the conversion specifier "incorrect conversion". The value will be formatted in an unintended manner.

OUTTOOFEW, contextthe number of conversion specifiers to function name exceeds the number of values to be converted. Conversion specifiers from "last valid conversion" onward will process meaningless and perhaps invalid data.

OUTTOOMANY, contextadditional arguments to function name are provided for which there are no conversion specifiers in the format string. Arguments from "last expression" onward will be evaluated, but not processed by function name.

OUTTYPELEN, contextthis argument to function name is of "typeclass" type and is not appropriate for the conversion specifier "incorrect conversion". The value might be truncated or formatted in an unintended manner.

OUTVARORDER, contextvariable ordering is used in a conversion specifier for function name. If variable ordering is used, it must be specified for all conversions.

PACKSTACKPOP, This "pop" has underflowed the pragma stack name stack. No corresponding "push" was found.

PARAMREDECL, context"name" overrides a formal parameter declared at where.

PARENLITERAL, contextaccepting a string literal in parentheses as the initializer for a character array is a language extension.

PARMINCOMP, contextthe parameter name has an incomplete type.

PARMINIT, contexta parameter declaration cannot include an initializer.

PARMSTORCLS, contexta parameter has an explicit storage class other than "register".

PARMSTORMOD, contexta parameter cannot have a storage class modifier.

PARMTYPLIST, Ill-formed parameter type list.

PARNOIDENT, Missing identifier.

PDBOPERR, Error opening PDB file text: text

PDBTYPERR, Error adding type record to PDB file: text

PDOINDEXNOTPRIV, index variable of PDO text is not a private variable

PDONEINSTATIC, pdone text in statically-scheduled PDO will be ignored

PDONENOTINPDO, pdone text is not nested in a PDO

PLUSWSTOCLS, The use of the spelling option has prevented this redeclaration of "variable" from changing its linkage. The linkage will be that specified by the earlier declaration at location.

POINTERINTCAST, contextthe 64-bit pointer "expression" is being cast to an integer type that is only size bits in size. This behavior is undefined.

POPMISMATCH, The member alignment popped/restored with pragma pragma name was saved using pragma pragma name. The member alignment restored will take effect.

PRAGIGNORE, The pointer size control name pragma is not active. Pragma is ignored.

PRAGMA, Strict standard C extension: A #pragma directive was encountered.

PRAGMAIDENT, Please use the preferred "#pragma ident" directive in place of the "#ident" directive.

PRAGMAINBLK, The pragma name cannot be used inside a function block.

PRAGMAMOD, Please use the preferred "#pragma module" directive in place of the "#module" directive.

PRAGMAOPTDUP, This #pragma optimize has already modified this optimization setting. This setting will replace the old.

PRAGMAOPTLVL, The level set by a #pragma optimize directive must be between 0 and 5. Pragma is ignored.

PRAGMAOPTSPEC, Setting speculation control is not available on this platform. The setting will be ignored.

PRAGMAOPTZERO, If a #pragma optimize specifies level=0, that must be the only optimization setting specified by the pragma. Pragma is ignored.

PREOPTE, An error was detected in the processing of a option spelling option: #define or #undefine problem

PREOPTW, A problem was detected in the processing of a option spelling option: #define or #undefine problem

PREPROCOUT, An error occurred while attempting to open either the preprocessor output file or the dependency file: problem.

PRIVATENOTSHARE, variable text on a local or lastlocal list is not declared in a shared scope.

PROMOTMATCH, contextthe promoted type of name is incompatible with the type of the corresponding parameter in a prior declaration.

PROMOTMATCHW, contextthe promoted type of name is incompatible with the type of the corresponding parameter in a prior declaration.

PROTOF, An error occurred while attempting to open the prototype output file: problem.

PROTOSCOPE, The type "type" has been declared within and is limited to a function prototype scope. It will not be compatible with an identical type declared in another scope. This might not be what you intended.

PROTOSCOPE2, contextthe struct type was previously declared with prototype scope in this function. Now it is declared with a different prototype scope.

PROTOSCOPE3, contextthe struct type was previously declared in this function with prototype scope. Now it is declared with file scope.

PROTOSTATIC, The extracted header file contains prototypes for static functions, which should be removed before including the header in a source file other than the originator.

PROTOTAG, The extracted header file contains prototypes with tag names, which should be moved to after the tag name declaration.

PROTOTYPEDEF, The extracted header file contains prototypes with typedefs, which should be moved to after the typedef declaration.

PROTOVLA, The extracted header file contains prototypes for functions which have formal parameters with variably modified type. All variable length bound specifiers have been replaced by a "*" signifying a variable length array of unspecified size.

PSECTFIRST, "#pragma psect_type" directive must precede any declarations.

PSECTTOOLONG, Psect name is too long (maximum is 31 characters). Pragma is ignored.

PTRINTTOLONG, context"expression", a pointer to a 32-bit integer, is being cast to a pointer to a 64-bit integer. This may lead to unintended results.

PTRLONGTOINT, context"expression", a pointer to a 64-bit integer, is being cast to a pointer to a 32-bit integer. This may lead to unintended results.

PTRMISMATCH, contextthe referenced type of the pointer value "expression" is "type", which is not compatible with "target type".

PTRMISMATCH1, contextthe referenced type of the pointer value "expression" is "type", which is not compatible with "target type" because they differ by signed/unsigned attribute.

QUALAFTCOMMA, Type qualifier(s) after a comma ignored.

QUALFUNCRET, The return type of "name" is a qualified type. Type qualifiers have no meaning for function return values.

QUALISPTR, context"expression" has a pointer type, but occurs in a context that expects a struct or union.

QUALNOTUS, contextthe qualifier for "name" is not a struct or union.

QUESTCOMPARE, contextthe unsigned expression "expr" is being compared with a relational operator to a constant whose value is not greater than zero. This might not be what you intended.

QUESTCOMPARE1, contextthe unsigned expression "expr" is being compared with an equality operator to a constant whose value is negative. This might not be what you intended.

QUESTCOMPARE2, contextthe unsigned expression "expr" is being tested to see if it is greater than zero. This might not be what you intended.

READONLYEXT, readonly is a language extension.

REDECLNOPARAM, contextthe declaration of the function "name" containing no parameter information replaces an earlier declaration of "name" at location.

REDEF, This declaration contains a redefinition of "name". The previous declaration is at location.

REDEFSTRUCT, contextthe struct "name" is redefined.

REDEFTAG, contextthe tag "name" is redeclared.

REDEFUNION, contextthe union "name" is redefined.

REFBEFORETLS, contextthe reference to the variable "var" lexically precedes its use in a #pragma omp threadprivate directive. This is not allowed.

REGCONFLICT, Conflicting required uses of register(s): text

REGNOSHARE, contextnoshare cannot be used with the register storage class. Modifier noshare is ignored.

RELOCALIGNMENT, An initialization requiring relocation is not correctly aligned at Psect text + number

RESMISMATCH, The pointer size restored with pragma pragma name was saved using pragma pragma name. The pointer size restored will take effect.

RESTRICTEXT, The __restrict type qualifier is a language extension.

RESTRICTEXT1, Placement of the __restrict qualifier within the array-bound specifier of a formal parameter declaration is a language extension.

RESTRICTEXT2, The restrict type qualifier is a new feature in C99. Other C compilers might not successfully compile a program that uses this feature.

RESTRICTNOP, The restrict type qualifier can only be applied to a pointer type that points to an object or incomplete type. Qualifier is ignored.

RETLOCALADDR, This return statement returns the address of a local variable. The address returned cannot be used by the caller in any meaningful way.

RETVALTOOBIG, The size of return value of "name" exceeds the maximum size of an object allowed on this platform which is size bytes.

RIGHTSHIFTOVR, contextthe right shift count "number" is greater than or equal to the size of the unpromoted operand "expression".

RTEXCEPT, contextthe floating-point constant named "name" will cause an exception at runtime.

RTLMAPNOTFOUND, C RTL mapping information for RTL name not found. Could not access image_name.

RTLMISMATCH, Compaq C RTL prefix table version mismatch: RTL table is Vmajor.minor, compiler needs Vmajor.minor.

SAMEASTYPEDEF, contextthe extern has the same name as a file-scope typedef. This is a language extension.

SCACALL, This function contains too many parameters for SCA to handle. Function parameter info will be truncated.

SCAID2LONG, The identifier exceeds the SCA limit of number characters. In the SCA file the name will be truncated to "truncated spelling".

SCALEFACTOR, The CDD description for name specifies a scale factor of number. The scale factor is being ignored.

SCAOVFLO, Compiler Internal Error: SCA event buffer overflowed. Please submit an SPR.

SEQUENCEEXT, contextallowing a comma operator is a language extension.

SESEMULTIEXITS, parallel directive scope text has multiple exits

SESEMULTIPREDS, parallel directive scope text has multiple entry paths

SESEVFLOW, parallel directive scope text is crossed by a VBRANCH

SHARECONST, In this declaration, noshare has been ignored due to the presence of const or readonly.

SHIFTCOUNT, contextthe shift count "number" is negative or is greater than or equal to the promoted size of the operand "expression".

SHORTCIRCUIT, contextpotential side effects from the evaluation of "operand" will not take place. This is because the first operand of a logical operator is a constant whose value requires that this expression must not be evaluated.

SIGNEDKNOWN, contextCompaq C recognizes the standard keyword "signed". This differs from the VAX C behavior.

SIGNEDMEMBER, contextCompaq C recognizes the standard C keyword "signed" in member declarations. The VAX C compiler does not and would treat the member as unsigned.

SIMPLEMESSAGE, user text

SIZEBIT, context"expression" is a bitfield, and so has no size.

SIZEINCOMP, context"expression" is of an incomplete type, and so has no size.

SIZEINCOMPTYP, context"type" is an incomplete type, and so has no size.

SIZFUNVOIDTYP, context"type" has function or void type and may not appear in this context. The compiler will treat the type as if it were char.

STACKPOP, This "restore" has underflowed the pragma stack name stack. No corresponding "save" was found.

STATICIFLOAT, contextconversion of a link-time address constant to a floating type is required. This is not allowed.

STATICVLA, contextthe static object "name" cannot be a variable length array.

STATINITWARN, contextthe linker will be unable to perform this static initialization if the initializer is defined in a sharable image.

STDARG, contextstdarg.h macros might be required if the address of the parameter name is used to index through a parameter list.

STKALLEXC, Allocations to stack exceeded maximum stack size

STOALNERR, Psect text alignment is insufficient for allocation of text

STONOTFIRST, The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.

STORCLSDCL, contexta storage class without a declarator is meaningless.

STOREQEXC, Allocations to text section exceeded growth bounds

STORISSTAT, This redeclaration of the static initialized variable "name" will have static storage class that differs from the VAX C behavior. The previous declaration is at location.

STORMODDCL, contexta storage class modifier without a declarator is meaningless.

STRCTPADDING, An additional number bytes of padding have been implicitly inserted prior to this member for proper alignment of this member.

STRINGCONST, Ill-formed string constant.

STRUCTBRACE, context a required set of braces is missing.

STRUCTININIT, context, allowing struct/union expression as part of a struct/union initializer is a language extension.

STRUCTLIMITSUP, contextCompaq C provides only limited support for struct/union types larger than n bytes.

STRUCTOVERFLOW, Integer overflow occurred when computing the size of a struct or union type.

SUBINVALIDCHR, Parameter substitution produced an invalid character constant.

SUBINVALIDSTR, Parameter substitution produced an invalid string literal.

SUBSCRBOUNDS, contextan array is being accessed outside the bounds specified for the array type.

SUBSCRBOUNDS1, contextan array type declared with one element is being accessed beyond the end of the array.

SUBSCRBOUNDS2, contextaccessing the address of an array element that is exactly one beyond the end of the array might not be what you intended.

SWITCHLONG, The signed or unsigned long expression "expression" is used in a switch statement.

SYSREGUSED, System register specified as external register.

SYSTEM, text

TAGDIFFER, contextthe tag "name" differs from the tag "name" used in an earlier declaration of this function.

TAGORBRACE, Missing tag or "{".

TENTREDEF, This definition or tentative definition of "name" is redefining the definition or tentative definition on location. This is not allowed in C++. compiler__declare_tent_redef1.

TEXTARRAY, The CDD description for name specifies that it is text 1; It has been translated into an array of char.

TEXTARRAYN, The CDD description for name specified that it is text 1; It has been translated into an array of char because null_terminate was used.

TEXTCHAR, The CDD description for name specified that it is text 1; It has been translated into a type char.

TEXTMODULE, The text library module form of #include is an extension.

THREADFUNC, contextthe __declspec(thread) storage class modifier cannot be used with a function type. Modifier is ignored.

THREADNYI, contextthe __declspec(thread) storage class modifier is not implemented on this platform. It will be ignored except to verify correct compile-time usage.

THREADSTO1, contextthe __declspec(thread) storage class modifier requires a storage class of extern, static, or none. Modifier is ignored.

THREADSTO2, contextthe __declspec(thread) storage class modifier requires a storage class of extern, or static. Modifier is ignored.

TLSANDSTATIC, contextthe storage class modifier __declspec(thread) cannot be used with the -static option. The storage class modifier is ignored.

TOOFEWACTUALS, Too few actual parameters in the invocation of the macro "name".

TOOFEWARGS, context"function expression" expects correct number arguments, but actual number are supplied.

TOOFEWARGSO, context"function expression", which was declared with an old-style function definition, expects correct number arguments, but actual number are supplied.

TOOLONG, context, "expression" is too long by count character(s).

TOOMANY, context, there are actual number elements, which is extra number too many. The extra initializers will be ignored.

TOOMANYACTLS, Too many actual parameters in the invocation of the macro "name".

TOOMANYARGS, context"function expression" expects correct number arguments, but actual number are supplied.

TOOMANYARGSO, context"function expression", which was declared with an old-style function definition, expects correct number arguments, but actual number are supplied.

TOOMANYERR, More than number errors were encountered in the course of compilation.

TOOMANYGATES, only 64 gates maybe be used within a parallel region

TOOMANYTOKENS, Too many tokens in macro expansion.

TOOMANYTXTLIB, Too many text libraries. Library library name and subsequent will not be searched.

TOOMNYREL, Object file section text has number relocations; maximum allowed is number

TRAILCOMMA, Trailing comma found in enumerator list.

TRUNCFLTASN, context"expression" has more precision than "target type". Assignment might result in loss of precision and/or range.

TRUNCFLTINT, context"expression" is a floating-point type being assigned to an integer type. The assignment might result in data loss.

TRUNCINTASN, context"expression" has a larger data size than "target type". Assignment might result in data loss.

TRUNCINTCAST, context"expression" has a larger data size than "target type". Cast might result in data loss.

TRUNCLONGCAST, context"expression", a 64-bit integer, is being cast to a 32-bit integer. The cast might result in data loss.

TRUNCLONGINT, context"expression", a 64-bit integer, is being assigned to a 32-bit integer. Assignment might result in data loss.

TUNEOVERRIDE, tune setting text overridden by arch setting text, tune forced to text

TYPEALIGN, context_align cannot be used with the typedef storage class. Modifier _align is ignored.

TYPECONFLICT, context"typespec1" cannot be combined with "typespec2".

TYPEDEFFUNC, In this function definition, "name" acquires its type from a typedef.

TYPEDEFINIT, The declaration of the typedef "name" contains an initializer. The initializer is ignored.

TYPEDEFNA, Accepting an old-style parameter name that matches a typedef is a language extension.

TYPEDEFNOTDEF, In this declaration, "name" appears to be used as if it named a type, but there is no declared type of that name visible.

TYPEEXPR, context"name" is declared as a label, tag, or typedef, and so cannot occur as an expression.

TYPEOFEXT, The use of __typeof__ is a language extension.

TYPQUALNOT, A type qualifier is not allowed in this context.

TYPQUALNOT2, Use of the keyword "static" or a type qualifier within the outermost array-bounds specifier of a formal parameter declaration is a new feature in the C99 standard.

TYPQUALNOT3, Use of the keyword "static" or a type qualifier in an array-bounds specifier is invalid in this compilation mode. Keyword/qualifier ignored.

TYPQUALNOT4, Use of this type qualifier in an array-bounds specifier is invalid. Qualifier ignored.

UABORT, Compilation terminated by user.

UCNICONVOPN, The call iconv_open(CODESET, "UCS-4") failed because: STRERROR. UCNs will not be mapped to the native character set.

UCNNOMAP, A UCN escape sequence was recognized, but there was no translation for it into the current codeset. The escape sequence will be used verbatim.

UCNONVAX, UCNs not supported on VAX.

UCNUNSUPP, An apparent UCN escape sequence was encountered, but UCNs are not supported in this language mode. The backslash will be ignored.

UCNUSED, A UCN escape sequence was encountered.

UNALIGNEDFUNC, Ignoring __unaligned type qualifier in declaration of name.

UNALIGNEXT, The __unaligned type qualifier is a language extension.

UNAVAILPRAGMA, The pragma "pragma name" is not available on this platform.

UNAVOLACC, volatile access appears unaligned, but must be aligned at run-time to ensure atomicity and byte granularity

UNCALLED, routine text can never be called

UNDECLARED, context"name" is not declared.

UNDECLFUN, There is no function declaration for the identifier "name" at the point of this #pragma pragma type attributes.

UNDECLVAR, There is no global declaration visible for the variable "name" at the point of this #pragma assert global_status_variable.

UNDEFENUM, contextthe enum "name" is not defined.

UNDEFESCAP, An undefined escape sequence was encountered; the backslash is being ignored.

UNDEFINEDTYPE, The compiler was expecting a "token", but one was not found. This condition could have occured because "id" is used in what might be a type cast, but there is no declared type of that name visible.

UNDEFVARFETCH, contextthe expression "expr" modifies "var", and fetches its value in a computation that is not used to produce the modified value without an intervening sequence point. This behavior is undefined.

UNDEFVARMOD, contextthe expression "expr" modifies the variable "var" more than once without an intervening sequence point. This behavior is undefined.

UNDERFLOW, contextunderflow occurs in evaluating the expression "expression".

UNINIT1, The scalar variable "var"declared in is fetched but not initializedinlineinfo. And there may be other such fetches of this variable that have not been reported in this compilation.

UNINIT2, Part or all of the non-scalar variable "var"declared in is fetched but not initializedinlineinfo. And there may be other such fetches of this variable that have not been reported in this compilation.

UNINIT3, Variable "var"declared in is fetched but not initializedinlineinfo. And there may be other such fetches of this field that have not been reported in this compilation.

UNINIT4, Byte offsets start to end of "var"declared in are fetched but not initializedinlineinfo. And there may be other such fetches of this field that have not been reported in this compilation.

UNINIT5, fragment uninit5ainlineinfo. Also the variable itself is not initialized. And there may be other fetches of this variable that have not been reported in this compilation.

UNIONBRACE, context a required set of braces is missing.

UNKEXTMOD, Unknown extern model. Pragma is ignored.

UNKINTRIN, The function "routine name" is not a known intrinsic function and cannot be used with #pragma intrinsic. Pragma not applied to this function.

UNKMSGCMD, Bad or missing command in pragma message. Pragma is ignored.

UNKMSGID, Unknown message id or group "id" is ignored.

UNKNOWNLINK, The specified linkage is undefined. Pragma is ignored.

UNKNOWNMACRO, "name" is not currently defined as a macro. It has been replaced by the constant zero.

UNKNOWNPRAGMA, The pragma "pragma text" is unrecognized.

UNKNOWNPRGMA, Unrecognized #pragma directive.

UNKPSECTATTR, Unknown psect attribute for extern model. Attribute is ignored.

UNMATCHENDIF, Out of place #endif directive ignored.

UNNAMEDMEM, An unnamed member does not have a bitfield, struct, or union type. Member is ignored.

UNNAMEPARM, In the definition of the function name, a parameter has no name.

UNNECCDD, It is not necessary to include this dictionary directive, if other unused dictionary directives and unused include directives are removed.

UNNECINCL, It is not necessary to include this file, if other unused include directives are removed.

UNREACHCODE, Code at or just after this location can never be executedinline info.

UNREFADECL, This local identifier is declared but not referenced in this module.

UNREFDECL, This identifier is declared but not defined or referenced in this module.

UNREFSDECL, A static variable is declared but never referenced in this module.

UNREFSFUNC, A static function definition or prototype is found, but never referenced.

UNREFTYP, This type is never referenced in this module.

UNRLINKATTR, Unrecognized attribute for linkage pragma. Pragma is ignored.

UNSIGNEDPRES, contextthe conversion of the unsigned char/short value "expression" to unsigned int shows one example of this program's use of unsigned-preserving integral promotion. This differs from the value-preserving semantics of standard C compilers.

UNSTRUCTMEM, The declaration of a member that is an unnamed struct or union type is an extension and might not be portable.

UNSUPCONV, Hexadecimal floating point constants are not yet implemented.

UNSUPCONVSPEC, contextthis argument to function name has a conversion specification "incorrect conversion" that is not supported or not fully supported on this platform.

UNSUPCONVV, Hexadecimal floating point constants are not supported on this platform.

UNSUPIEEE, The _FASTMATH version of this function has been specified, but _FASTMATH routines do not support the IEEE behaviors requested and will simply trap and terminate when given arguments or computing values outside the normal range.

UNSUPPTYPE, The CDD description for name specifies a data type not supported in C.

UNUSEDCDD, This CDD record appears to be unused.

UNUSEDINCL, This nested include file appears to be unused.

UNUSEDTOP, This include directive does not contribute to the compilation, perhaps because the file has already been included.

USELESSALIGN, context_align cannot be used with the class storage class. Modifier _align is ignored.

USELESSSTOMOD, contextnoshare or readonly cannot be used with the typedef storage class. Modifier is ignored.

USELESSTYPED, This typedef declaration is useless because it does not declare a typedef name.

USELESSTYPEQUAL, contextthis type qualifier will have no effect.

VAARGSBODY, __VA_ARGS__ may not appear except in a function-like macro that uses the ellipsis notation in the parameters.

VAARGSFORMAL, __VA_ARGS__ may not be used as a formal parameter.

VALUENOTSUP, contextthe floating-point constant named "name" is not supported in "fpmode" representation.

VALUEPRES, contextthe conversion of the unsigned char/short value "expression" to signed int shows one example of this program's use of value-preserving integral promotion. This differs from the unsigned-preserving semantics of some older C compilers.

VARIANTDCL, A declaration of a variant struct or variant union must have a single declarator that is an identifier.

VARIANTDUP, The anonymous struct or union member "member name" duplicates the name of a member in the enclosing struct or union.

VARIANTEXT, variant struct or union is a language extension.

VARIANTTAG, A variant struct or union cannot have a tag.

VARNOMEM, A variant struct or variant union can occur only as a member of a struct or union.

VERTICALSPDIR, Vertical whitespace within pp directive.

VLAEXTENSION, contextvariable length arrays are a new feature in the C99 standard. Other C compilers may not support this extension.

VOIDRETURN, The function "name" has return type void, and so must not contain a return statement with an expression.

VOIDRETURN1, The function "name" has return type void. The return statement must not specify a return value even if the return expression has void type.

VOLATILEFUNC, Ignoring volatile type qualifier in declaration of name.

WCHARCAT, A character string literal was concatenated with a wide string literal.

WRTINNOWRT, Writable variable resides in nowrt extern model.

XFERINTOVLA, This statement performs an invalid transfer into a block that declares a variably modified type or object. The identifier "name" is variably modified, and declared at where.

XTRALARGE, Line number is greater than the 32767 specified by the C standard and might not be portable.

ZERODIV, contextdivision by zero occurs in evaluating the expression "expression".

ZERODIVIDE, Division by zero in expression.

ZEROELEMENTS, contextzero cannot be used as an element count specifier. The specifier will be ignored, (leaving the member/parameter with an incomplete array type) in this context.

ZEROELEMENTS1, contextzero cannot be used as an element count specifier. It will be replaced with the constant one in this context.