═══ 1. Compiler Messages and Return Codes ═══ These panels contain information about the compile-time messages and should not be used as programming interface information. For every compilation job or job step, the compiler generates a return code that indicates to the operating system the degree of success or failure it achieved. The meanings of the return codes are: Code Meaning 0 No error detected; compilation completed; successful execution anticipated. OR Possible error (warning) detected; compilation completed; successful execution probable. 12 Error detected; compilation may have been completed; successful execution impossible. 16 Severe error detected; compilation terminated abnormally; successful execution impossible. 20 Fatal error detected; compilation terminated abnormally and abruptly; successful execution impossible. The compiler message format is: filename.ext(line:col): ss EDCnnnn: text where: filename.ext - file name (with extension) where the error occurred line - line where the error occurred col - column where the error occurred ss - error severity: 00 - informational 10 - warning 30 - error 40 - severe error 50 - fatal error nnnn - error message number text - message text, which may contain substitution text indicated by &n The message text is prefixed with the severity string (for example, warning), not with the severity number. Message numbers in the range of 0001 to 2999 are generated for C code. Message numbers in the range of 3000 to 3999 are generated for C++ code. Message numbers in the 4000 range are generated for both C and C++ code. Messages other than those in the 4000 range are prefixed with the name of the file and the line and column number where the message was generated. For messages in the 4000 range, the file name and line number where the error occurred follow the message text. The severity of errors for these messages is determined dynamically as the error occurs. If the error is unrecognized by the compiler, it is prefaced by unknown error. If one of these messages is generated, contact your IBM Service representative. There are four messages that are generated if the message files cannot be accessed. They are:  Cannot find the message.  Cannot access the message file.  The message file format is not valid.  Cannot find the message file. If one of these messages is generated, ensure that  The DPATH variable is set in your CONFIG.SYS file  The message files are in a directory in the DPATH  The DPATH allows read access to the directories specified  The file system is functioning properly  The message files are not corrupted. Reinstall the message files if any have been corrupted. Reboot the system. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 2. EDC0001 - EDC0499 ═══ ═══ 2.1. EDC0001 ═══ EDC0001 INTERNAL COMPILER ERROR: Procedure &1. An internal compiler error occurred during compilation. Recovery: Contact VisualAge C++ Service and Support. ═══ 2.2. EDC0002 ═══ EDC0002 COMPILER ERROR: Unimplemented feature: &1. An error occurred during compilation. Recovery: See the C/C++ Language Reference for a description of supported features. ═══ 2.3. EDC0003 ═══ EDC0003 Width of a bit field of type "&1" cannot exceed &2. The length of the bit field must not exceed the maximum bit size of the bit field's length. Recovery: Define the bit-field length to be less than or equal to the maximum bit size of the bit-field type. ═══ 2.4. EDC0004 ═══ EDC0004 #pragma must appear before use of identifier &1. #pragma ignored. The identifier is modified by the #pragma after the #pragma is seen. Recovery: Move the #pragma so that it appears before the the identifier is used. ═══ 2.5. EDC0006 ═══ EDC0006 Label &1 is undefined. A label must be visible in the current function scope if it is used in an expression. Recovery: Declare a label of that name in the current function scope. ═══ 2.6. EDC0007 ═══ EDC0007 "&1" is undefined. A C identifier must be declared before it is used in an expression. Recovery: Declare an identifier of that name in the current scope or in a higher scope. ═══ 2.7. EDC0008 ═══ EDC0008 The argument is not valid for the #pragma directive. #pragma does not recognize the argument. Recovery: Remove the argument or change its format. ═══ 2.8. EDC0009 ═══ EDC0009 Bit-field &1 must be of type signed int, unsigned int or int. The type of the bit-field is not a signed int, unsigned int nor an int. Recovery: Define the bit-field with a type signed int or unsigned int. ═══ 2.9. EDC0010 ═══ EDC0010 Macro &1 invoked with a null argument for parameter &2. No argument was specified for parameter. Recovery: Specify arguments for all macro parameters. ═══ 2.10. EDC0012 ═══ EDC0012 Operand of bitwise complement must be an integral type. The operand of the bitwise complement operator does not have an integral type. Valid integral types include: signed and unsigned char; signed and unsigned short, long, and int; and enum. Recovery: Change the type of the operand, or use a different operand. ═══ 2.11. EDC0013 ═══ EDC0013 Operand of unary + or - operator must be an arithmetic type. The operand of the unary + or - operator does not have an arithmetic type. Valid arithmetic types include: signed and unsigned char; signed and unsigned short, long, and int; enum, float, double, and long double. Recovery: Change the type of the operand, or use a different operand. ═══ 2.12. EDC0014 ═══ EDC0014 Operand of logical negation must be a scalar type. The operand of the logical negation operator (!) does not have a scalar type. Valid scalar types include: signed and unsigned char; signed and unsigned short, long, and int; enum, float, double, long double, and pointers. Recovery: Change the type of the operand, or use a different operand. ═══ 2.13. EDC0017 ═══ EDC0017 Operand of address operator must be an lvalue or function designator. The operand of the address operator (unary &) is not valid. The operand must be either a function designator or an lvalue that designates an object that is not a bit-field and is not declared with register storage class. Recovery: Change the operand. ═══ 2.14. EDC0018 ═══ EDC0018 Operand of indirection operator must be a pointer expression. The operand of the indirection operator (unary *) is not a pointer. Recovery: Change the operand to a pointer. ═══ 2.15. EDC0019 ═══ EDC0019 Expecting an array or a pointer to object type. Index operator (э∙) operates only on arrays or pointer to objects. Recovery: Change the operand. ═══ 2.16. EDC0020 ═══ EDC0020 Expression must be an integral type. The expression does not evalute to an integral type. Valid integral types include: signed, unsigned and plain char, signed and unsigned short, int, long, and enum. Recovery: Change the type of the operand. ═══ 2.17. EDC0021 ═══ EDC0021 Expecting struct or union. The left hand operand of the dot operator (.) must have a struct or union type. Recovery: Change the operand. ═══ 2.18. EDC0022 ═══ EDC0022 "&1" is not a member of "&2". The specified member does not belong to the structure or union given. One of the following has occurred: 1. The right hand operand of the dot (.) operator is not a member of the structure or union specified on the left hand side of the operator. 2. The right hand operand of the arrow (->) operator is not a member of the structure or union pointed to by the pointer on the left hand side of the operator. Recovery: Change the identifier. ═══ 2.19. EDC0023 ═══ EDC0023 Expecting function or pointer to function. The expression is followed by an argument list but does not evaluate to a function designator. Recovery: Change the expression to be a function or a pointer to a function. ═══ 2.20. EDC0025 ═══ EDC0025 Operand must be a modifiable lvalue. A modifiable lvalue is an expression representing an object that can be changed. Recovery: Change the operand. ═══ 2.21. EDC0026 ═══ EDC0026 Number of initializers cannot be greater than the number of aggregate members. Too many initializers were found in the initializer list for the indicated declaration. Recovery: Check the number of initializers and change it to correspond to the number of declared members. Make sure the closing brace at the end of the initializer list is positioned correctly. ═══ 2.22. EDC0027 ═══ EDC0027 Function &1 cannot be initialized. An attempt was made to assign an initial value to a function identifier. You can not assign a value to a function identifier. Recovery: Remove the assignment operator and the initializer. ═══ 2.23. EDC0028 ═══ EDC0028 Storage class &1 cannot be used with external data. The storage class is not appropriate for this declaration. Restrictions include: 1) Storage class specifier not allowed on aggregate members, casts, sizeof or offsetof declarations. 2) Declarations at file scope cannot have 'register' or 'auto' storage class. Recovery: Specify a different storage class. ═══ 2.24. EDC0029 ═══ EDC0029 #pragma ignored, identifiers are already disjoint. The identifiers that are specified in the pragma are already known to be disjoint so the pragma is ignored. Recovery: Nothing, or remove the pragma as it is redundant. ═══ 2.25. EDC0030 ═══ EDC0030 Identifier &1 cannot be redeclared. The identifier has already been declared. Recovery: Remove one of the declarations. ═══ 2.26. EDC0031 ═══ EDC0031 All dimensions except the first must be specified for a multi-dimensional array. Only the first dimension of an initialized array can be unspecified. All the other dimensions must be specified on the declaration. Recovery: Specify all the other dimensions in the array declaration. ═══ 2.27. EDC0032 ═══ EDC0032 Elements of an array cannot be functions. An array must be composed of elements that are an object type. Functions are not object types and thus cannot be elements of an array. Recovery: Use a pointer to the function, or change the type of the element. ═══ 2.28. EDC0033 ═══ EDC0033 Function &1 is not valid. Function cannot return a function. A function cannot have a return type of function. Recovery: Return a pointer to the function or specify a different return type. ═══ 2.29. EDC0034 ═══ EDC0034 Function &1 is not valid. Function cannot return an array. A function cannot return an array and the specified return type of the function is an array. Recovery: Return a pointer to the array or specify a different return type. ═══ 2.30. EDC0035 ═══ EDC0035 Storage class &1 cannot be used with functions. A function can only have a storage class of extern or static. Recovery: Remove the storage class specifier for the function identifier, or change it to either extern or static. ═══ 2.31. EDC0036 ═══ EDC0036 Range error. The value is outside of the valid range. Recovery: Change value to be within the required limits. ═══ 2.32. EDC0037 ═══ EDC0037 Member of struct or union cannot be a function. Members of structs or unions must have object type. Functions do not have object type and cannot be members of a struct or union. Recovery: Use a pointer to the function or remove the function from the member list. ═══ 2.33. EDC0039 ═══ EDC0039 Expecting a parameter after # operator. The # preprocessor operator can only be applied to a macro parameter. Recovery: Place a parameter after the # token, or remove the token. ═══ 2.34. EDC0041 ═══ EDC0041 The invocation of macro &1 contains fewer arguments than required by the macro definition. The number of arguments supplied to the macro must match the number of parameters in the macro definition. There are not enough arguments supplied. Recovery: Complete the specification of the macro argument list. ═══ 2.35. EDC0042 ═══ EDC0042 The output file name cannot be the same as the input file name. Writing and reading from the same file will corrupt the input file. Recovery: Rename the output file to a name which is different than the input file. ═══ 2.36. EDC0043 ═══ EDC0043 The operand of the sizeof operator is not valid. Sizeof operator cannot be used with functions, void types, bit fields, incomplete types, or arrays of unknown size. The sizeof operator cannot be applied to an expression that has a function type or an incomplete type, to the parenthesized name of such a type, or to an lvalue that designates a bit-field object. Recovery: Change the operand. ═══ 2.37. EDC0044 ═══ EDC0044 Expression must be a non-negative integer constant. The supplied expression must evaluate to a non-negative integer constant. Recovery: Change the constant expression to yield a non-negative value. ═══ 2.38. EDC0045 ═══ EDC0045 Undeclared identifier &1. You must declare a C identifier before you use it in an expression. Recovery: Declare an identifier of that name in the current scope or in a higher scope. ═══ 2.39. EDC0046 ═══ EDC0046 Syntax error. See the C/C++ Language Reference for a complete description of C syntax rules. Recovery: Correct the syntax error and compile again. ═══ 2.40. EDC0047 ═══ EDC0047 Incorrect hexadecimal escape sequence \x. \ ignored. \x is used to indicate an hexadecimal excape sequence but the sequence immediately following is not a valid hexadecimal number. Recovery: Change the sequence to a valid hexadecimal number. ═══ 2.41. EDC0050 ═══ EDC0050 Return type "&1" in redeclaration is not compatible with the previous return type "&2". The second declaration of the function declares a different return type from the first. The declaration must be identical. When you redeclare a fnction, the return type and parameter types must be the same in both declarations. Recovery: Change the declaration of one or both functions so that their return types are compatible. ═══ 2.42. EDC0051 ═══ EDC0051 Case expression must be a valid integral constant. The expression in the case statement must be a constant integral expression. Valid integral expressions are: char, signed and unsigned int, and enum. Recovery: Change the expression. ═══ 2.43. EDC0052 ═══ EDC0052 Duplicate case label for value &1. Labels must be unique. Two case labels in the same switch statement cannot evaluate to the same integer value. Recovery: Change one of the labels. ═══ 2.44. EDC0053 ═══ EDC0053 Default label cannot be placed outside a switch statement. A statement is labeled with default, which can only be used as a statement label within a switch statement. Recovery: Remove the default case label, or place it inside a switch statement. Check for misplaced braces on a previous switch statement. ═══ 2.45. EDC0054 ═══ EDC0054 Switch statement cannot contain more than one default label. Only one default label is allowed within a switch statement. Nested switch statements may each have one default label. This error may have been caused by a default label that is not properly placed within a nested switch statement. Recovery: Remove one of the default labels or check for misplaced braces on nested switch statements.. ═══ 2.46. EDC0055 ═══ EDC0055 Case label cannot be placed outside a switch statement. Case labels are only allowed within a switch statement. Recovery: Remove the case label, or place it within a switch statement group. Check for misplaced braces on the previous switch statement. ═══ 2.47. EDC0056 ═══ EDC0056 Break statement cannot be placed outside a while, do, for, or switch statement. Recovery: Remove the break statement or place it inside a while, do, for or switch statement. Check for misplaced braces on a previous statement. ═══ 2.48. EDC0057 ═══ EDC0057 Continue cannot be placed outside a while, do, or for statement. Continue is only valid as, or within, a loop body. Recovery: Remove the continue statement or place it inside a while, do or for loop. Check for misplaced braces on a previous loop. ═══ 2.49. EDC0058 ═══ EDC0058 Label &1 has already been defined on line &2 of "&3". You already used the label to identify a section of code in the file indicated. You cannot redefine a label. Recovery: Change the name of one of the labels. ═══ 2.50. EDC0059 ═══ EDC0059 Comment that started on line &1 must end before the end of file. A comment that was not terminated has been detected. The comment started on the line indicated. of the comment was on the specified line. Recovery: End the comment before the file ends. ═══ 2.51. EDC0062 ═══ EDC0062 Escape sequence &1 is out of the range 0-&2. Value is truncated. Character constants specified in an escape sequence exceeded the decimal value of 255, or the octal equivalent of 377, or the hexadecimal equivalent of FF. Recovery: Change the escape sequence so that the value does not exceed the maximum value. ═══ 2.52. EDC0068 ═══ EDC0068 Operation between types "&1" and "&2" is not allowed. The operation specified is not valid between the operands having the given types. Recovery: Either change the operator or the operands. ═══ 2.53. EDC0070 ═══ EDC0070 Register is the only storage class that can be used with parameters. Recovery: Remove the storage class specified in the parameter declaration or use the register storage class. ═══ 2.54. EDC0073 ═══ EDC0073 Empty character constant. An empty character constant is not valid. There must be at least one character between the single quotation marks. Recovery: Put at least one character inside the pair of single quotation marks. ═══ 2.55. EDC0076 ═══ EDC0076 Character constant &1 has more than one character. Rightmost four characters are used. A character constant can only have up to four bytes. Recovery: Change the character constant to contain four bytes or less. ═══ 2.56. EDC0077 ═══ EDC0077 The wchar_t value &1 is not valid. The value is not a valid wchar_t value. See the C/C++ Language Reference for information on wide characters. Recovery: Change character to a valid wchar_t. See the C/C++ Language Reference for information about the wchar_t type. ═══ 2.57. EDC0085 ═══ EDC0085 Predefined macro &1 cannot be undefined. The macro is predefined. You cannot undefine predefined macros. Recovery: Remove the statement that undefines the macro. ═══ 2.58. EDC0095 ═══ EDC0095 Unexpected parameter &1. A parameter was declared in the parameter declaration list of the K&R function definition. The parameter did not appear in the parameter identifier list. It is also possible that the K&R function definition had more parameters than the function prototype. Recovery: Change the number of parameters. ═══ 2.59. EDC0098 ═══ EDC0098 Missing argument(s). The function call contains fewer arguments than specified in the parameter list of the function prototype. Recovery: Make sure the function call has the same number of arguments as the function prototype has parameters. ═══ 2.60. EDC0099 ═══ EDC0099 Unexpected argument. The function call contains more arguments than specified in the parameter list of the function prototype. Recovery: Change the number of arguments in the function call or change the function prototype. ═══ 2.61. EDC0103 ═══ EDC0103 Tag &1 requires a complete definition before it is used. Only pointer declarations can include incomplete types. A struct or union tag is undefined if the list describing the name and type of its members has not been specified. Recovery: Define the tag before it is used in the declaration of an identifier or complete the declaration. ═══ 2.62. EDC0104 ═══ EDC0104 The value of an enumeration constant must be an integral constant expression. If an enum constant is initialized in the definition of an enum tag, the initial value that the constant is initialized to must be an integral expression that has a value representable as an int. Recovery: Remove the initial value, or ensure that the initial value is an integral constant expression with a value representable as an int. ═══ 2.63. EDC0108 ═══ EDC0108 Bit fields with zero width must be unnamed bit fields. A named bit field must have a positive length; a zero length bit field is used for alignment only and must not be named. Recovery: Redefine the bit field with a length greater than zero or remove the name of the bit-field. ═══ 2.64. EDC0112 ═══ EDC0112 Duplicate type qualifier &1 ignored. The indicated qualifier appears more than once in the type declaration. Recovery: Remove of the duplicate qualifiers. ═══ 2.65. EDC0115 ═══ EDC0115 Duplicate type specifier &1 ignored. A duplicate type specifier appears in the type declaration. Recovery: Remove one of the duplicate type specifiers. ═══ 2.66. EDC0117 ═══ EDC0117 Operand must be a scalar type. Valid scalar types include: signed and unsigned char; signed and unsigned short, long, and int; enum, float, double, long double, and pointers. Recovery: Change the type of the operand, or use a different operator. ═══ 2.67. EDC0119 ═══ EDC0119 Duplicate storage class specifier &1 ignored. A duplicate storage class specifier appears in the declaration. Recovery: Remove one of the duplicate storage class specifiers. ═══ 2.68. EDC0120 ═══ EDC0120 Function cannot return a &1 qualified type. The const or volatile qualifier cannot be used to qualify a function's return type. Recovery: Remove the qualifier or return a pointer to the qualified type. ═══ 2.69. EDC0122 ═══ EDC0122 Expecting pointer to struct or union. The left hand operand of the arrow operator (->) must have type pointer to structure or pointer to union. Recovery: Change the operand. ═══ 2.70. EDC0127 ═══ EDC0127 The second and third operands of the conditional operator must have compatible struct or union types. If one operand in the conditional expression has type struct or union, the other operand must also have type struct or union. Recovery: Make the operands compatible. ═══ 2.71. EDC0131 ═══ EDC0131 Explicit dimension specification or initializer required for an auto or static array. For arrays of automatic or static storage class, all dimensions of the array must be specified in the declaration. If the declaration provides an initialization, the first dimensions may be unspecified because the initialization will determine the size needed. Recovery: Specify all of the dimensions in the array declaration. ═══ 2.72. EDC0134 ═══ EDC0134 Array bound is too large. The size of the array is too large for the compiler to represent internally. Recovery: Reduce the size of the array. ═══ 2.73. EDC0137 ═══ EDC0137 Declaration must declare at least one declarator, tag, or the members of an enumeration. The declaration specifier was the only component of the declaration. eg. int ; Recovery: Specify at least one declarator, tag, or member of an enumeration. ═══ 2.74. EDC0155 ═══ EDC0155 Option &1 requires suboption(s). The option is not completely specified; a sub-option is required. Recovery: Add a sub-option. ═══ 2.75. EDC0159 ═══ EDC0159 Bit-field type specified for &1 is not valid. Type unsigned assumed. The type of a bit-field must be a (possibly qualified) version of int, signed int or unsigned int. Recovery: Define the bit-field with a type signed int or unsigned int. ═══ 2.76. EDC0160 ═══ EDC0160 Object &1 cannot be declared as type void. The type void can only be used as the return type or parameter list of a function, or with a pointer. No other object can be of type void. Recovery: Ensure that the declaration uses type void correctly. ═══ 2.77. EDC0162 ═══ EDC0162 No definition was found for function &1. Storage class changed to extern. A static function was declared and referenced in this file. The definition of the function was not found before the end of the file. When a function is declared to be static, the function definition must appear in the same file. Recovery: Change the storage class to extern or provide a function definition in this file. ═══ 2.78. EDC0164 ═══ EDC0164 Expression must be a scalar type. Valid scalar types include: signed and unsigned char; signed and unsigned short, long, and int; enum, float, double, long double, and pointers. Recovery: Change the expression. ═══ 2.79. EDC0166 ═══ EDC0166 Definition of function &1 requires parentheses. The syntax of the declaration is not correct. The compiler assumes it is the declaration of a function in which the parentheses surrounding the parameters are missing. Recovery: Check the syntax of the declaration. Ensure the object name and type are properly specified. Check for incorrect spelling or missing parentheses. ═══ 2.80. EDC0167 ═══ EDC0167 String literal is longer than target array. Literal is truncated on the right. An attempt was made to initialize an array with a string that is too long. The largest possible prefix of the string has been placed in the array. Recovery: Increase the size of the array. Make sure you include space for the terminating null character. ═══ 2.81. EDC0168 ═══ EDC0168 Initializer must be enclosed in braces. The initializer list for a declarator must be enclosed in braces. Recovery: Check for misplaced or missing braces. ═══ 2.82. EDC0169 ═══ EDC0169 Too many suboptions specified for option FLAG. Specify only two suboptions. The FLAG option takes two suboptions separated by ':', the suboptions indicating the level of errors to be reported in the source listing and to stderr, respectively. Recovery: Only specify two suboptions to the FLAG option. ═══ 2.83. EDC0170 ═══ EDC0170 Parameter &2 has already been defined on line &3 of &4 A parameter can only be defined once but more than one definition for the parameter has been specified. Parameters names must be unique. Recovery: Remove one of the parameter declarations or change the name of the identifier. ═══ 2.84. EDC0172 ═══ EDC0172 Parameter type list for function &1 contains parameters without identifiers. In a C function definition, all parameters must be named in the parameter list. The only exceptions are parameters of type void. Recovery: Name the parameter or remove it. ═══ 2.85. EDC0173 ═══ EDC0173 Option "/&1" is not recognized. An invalid option was specified. Recovery: Correct the spelling of the option. ═══ 2.86. EDC0174 ═══ EDC0174 Option &1 must be specified on the command line. The option can only be specified on the command line and is not valid as part of an options pragma. Recovery: Specify option on command line. ═══ 2.87. EDC0175 ═══ EDC0175 Option &1 must be specified on the command line or before the first C statement in the program. The option is specified in a pragma options after the first C token in the compilation unit. It must be specified before the first token. Recovery: Specify the option on the command line or move the pragma options before the first token. ═══ 2.88. EDC0176 ═══ EDC0176 Option &1 cannot take more than one suboption. More than one suboption was specified for an option that can only accept one suboption. Recovery: Remove the extra suboptions. ═══ 2.89. EDC0178 ═══ EDC0178 Unexpected argument for built-in function &1. The function call contains more arguments than specified in the parameter list of the built-in function. Recovery: Change the number of arguments in the function call. ═══ 2.90. EDC0180 ═══ EDC0180 Redeclaration of built-in function &1 ignored. Built-in functions are declared by the compiler and cannot be redeclared. Recovery: Remove the declaration. ═══ 2.91. EDC0181 ═══ EDC0181 Definition of built-in function &1 ignored. Built-in functions are defined by the compiler and cannot be redefined. Recovery: Remove the function definition. ═══ 2.92. EDC0182 ═══ EDC0182 Arguments missing for built-in function &1. The function call contains fewer arguments than specified in the parameter list of the built-in function. Recovery: Change the number of arguments in the function call. ═══ 2.93. EDC0184 ═══ EDC0184 Too few suboptions specified for option FLAG. Specify two suboptions. The FLAG option takes two suboptions separated by ':', the suboptions indicating the level of errors to be reported in the source listing and to stderr, respectively. Recovery: Specify two suboptions to the FLAG option. ═══ 2.94. EDC0185 ═══ EDC0185 line number &2 must be greater than zero The #line directive tells the compiler to treat the following source lines as starting from the specified line. This number must be a non-negative offset from the beginning of the file. Recovery: Change line number to be a non-negative integer. ═══ 2.95. EDC0186 ═══ EDC0186 String literal must be ended before the end of line. String literals must end before the end of the line. To create a string literal longer than one line, use the line continuation sequence (a backslash (\) at the end of the line), or concatenate adjacent string literal. Recovery: End the string with a quotation mark before the end of the line or use the continuation sequence. ═══ 2.96. EDC0188 ═══ EDC0188 Reserved name &1 cannot be defined as a macro name. The indicated name is reserved for the compiler's use. Recovery: Choose another name. ═══ 2.97. EDC0189 ═══ EDC0189 Floating point constant &1 is not valid. See the C/C++ Language Reference Guide for a description of a floating-point constant. Recovery: Ensure that the floating-point constant does not contain any characters that are not valid. ═══ 2.98. EDC0190 ═══ EDC0190 Automatic constant &1 does not have a value. Zero is being assumed. Const qualified variable declarations should contain an initializer. Otherwise you cannot assign the variable a value. Recovery: Initialize the const variable when you declare it. ═══ 2.99. EDC0191 ═══ EDC0191 The character &1 is not a valid C source character. Refer to the C/C++ Language Reference for information on valid characters. Recovery: Change the character. ═══ 2.100. EDC0192 ═══ EDC0192 Cannot take address of built-in function &1. You cannot take the address of a built-in fuction or declare a pointer to a built-in fuction. Recovery: Remove the operation that takes the address of the built-in function. ═══ 2.101. EDC0194 ═══ EDC0194 Incomplete type is not allowed. Except for pointers, you cannot declare an object of incomplete type. Recovery: Complete the type declaration. ═══ 2.102. EDC0195 ═══ EDC0195 Integral constant expression with a value greater than zero is required. The size of an array must be an expression that evaluates to a compile-time integer constant that is larger than zero. Recovery: Change the expression. ═══ 2.103. EDC0196 ═══ EDC0196 Initialization between types "&1" and "&2" is not allowed. An attempt was made to initialize a variable with an incompatible type. Recovery: Ensure types are compatible. ═══ 2.104. EDC0197 ═══ EDC0197 Expecting header file name in #include directive. There was no header filename after the #include directive. Recovery: Specify the header file name. Enclose system header names in angle brackets and user header names in double quotes. ═══ 2.105. EDC0198 ═══ EDC0198 #if, #else, #elif, #ifdef, #ifndef block must be ended with #endif. Every #if, #ifdef, and #ifndef must have a corresponding #endif. Recovery: End the conditional preprocessor statements with a #endif. ═══ 2.106. EDC0199 ═══ EDC0199 #&1 directive requires a macro name. There must be a macro name after every #define, #undef, #ifdef or #ifndef. Recovery: Ensure that a macro name follows the #define, #undef, #ifdef, or #ifndef preprocessor directive. ═══ 2.107. EDC0200 ═══ EDC0200 #elif can only appear within a #if, #elif, #ifdef, or #ifndef block. #elif is only valid within a conditional preprocessor block. Recovery: Remove the #elif statement, or place it within a conditional preprocessor block. ═══ 2.108. EDC0201 ═══ EDC0201 #else can only appear within a #if, #elif, #ifdef or #ifndef block. #else is only valid within a conditional preprocessor block. Recovery: Remove the #else statement, or place it within a conditional preprocessor block. ═══ 2.109. EDC0202 ═══ EDC0202 #endif can only appear at the end of a #if, #elif, #ifdef or #ifndef block. Every #endif must have a corresponding #if, #ifdef, or #ifndef. Recovery: Remove the #endif statement, or place it after a conditional preprocessor block. ═══ 2.110. EDC0204 ═══ EDC0204 Unexpected end of file. The end of the source file has been encountered prematurely. Recovery: Check for misplaced braces. ═══ 2.111. EDC0205 ═══ EDC0205 &1 The #error directive was encountered. Compilation terminated. Recovery: Recompile with different macro definitions. ═══ 2.112. EDC0206 ═══ EDC0206 Suffix of integer constant &1 is not valid. Valid integer suffixes are u or U for unsigned, or l or L for long. Unsuffixed constants are given the smallest data type that can hold the value. Refer to the C/C++ Language Reference. Recovery: Change or remove the suffix. ═══ 2.113. EDC0207 ═══ EDC0207 Integer constant &1 out of range. The specified constant is too large to be represented by an unsigned long int. Recovery: The constant integer must have a value less than UINT_MAX defined in . ═══ 2.114. EDC0209 ═══ EDC0209 Character constants must end before the end of a line. Character literals must be terminated before the end of the line. Recovery: End the character literal before the end of the line. Check for misplaced quotation marks. ═══ 2.115. EDC0210 ═══ EDC0210 The ## operator requires two operands. The ## operator must be preceded and followed by valid tokens in the macro replacement list. Refer to the C/C++ Language Reference for information on the ## operator. Recovery: Provide both operands for the ## operator. ═══ 2.116. EDC0211 ═══ EDC0211 Parameter list must be empty, or consist of one or more identifiers separated by commas. The macro parameter list must be empty, contain a single identifier, or contain a list of identifiers separated by commas. Recovery: Correct the parameter list. ═══ 2.117. EDC0212 ═══ EDC0212 Duplicate parameter &2 in definition of macro &1. The identifiers in the macro parameter list must be unique. Recovery: Change the identifier name in the parameter list. ═══ 2.118. EDC0213 ═══ EDC0213 Macro name &1 cannot be redefined. You can define a macro multiple times only if the definitions are identical except for white space separating the tokens. Recovery: Change the macro definition to be identical to the preceding one, or remove it. ═══ 2.119. EDC0215 ═══ EDC0215 Too many arguments specified for macro &1. The number of arguments specified in the macro invocation is different from the number of parameters specified in the macro definition. Recovery: Make the number of arguments consistent with the macro definition. ═══ 2.120. EDC0218 ═══ EDC0218 Unknown preprocessing directive #&1. An unrecognized preprocessing directive has been encountered. Recovery: Check the spelling and syntax or remove the directive. ═══ 2.121. EDC0219 ═══ EDC0219 #line value &1 too large. The value for a #line directive must not exceed 32767. Recovery: Ensure that the #line value does not exceed the maximum value for short integers (SHRT_MAX) defined in ═══ 2.122. EDC0220 ═══ EDC0220 #line value &1 must contain only decimal digits. A non-numeric character was encountered in the #line value. Recovery: Check the syntax of the value given. ═══ 2.123. EDC0221 ═══ EDC0221 Initializer must be a valid constant expression. The initializers for objects of static storage duration, for elements of an array, or for members of a structure or union must be valid constant expressions. Recovery: Remove the initialization or change the indicated initializer to a valid constant expression. ═══ 2.124. EDC0224 ═══ EDC0224 Incorrect #pragma ignored. An unrecognized #pragma directive was encountered. See the C/C++ Language Reference Manual for the list of valid #pragma directives. Recovery: Change or remove the #pragma directive. ═══ 2.125. EDC0226 ═══ EDC0226 The ":" operator is not allowed between "&1" and "&2". The operands must be of compatible type. Recovery: Change the type of the operands. ═══ 2.126. EDC0229 ═══ EDC0229 File is empty. The source file contains no code. Recovery: Check that the file name and path are correct. Add source code to the file. ═══ 2.127. EDC0231 ═══ EDC0231 Error occured while opening preprocessor output file. The preprocessor was unsuccessful in attempting to open the output file. Recovery: Ensure you have write access to the file. ═══ 2.128. EDC0232 ═══ EDC0232 Divisor for modulus or division operator cannot be zero. The value of the divisor expression cannot be zero. Recovery: Change the expression used as the divisor. ═══ 2.129. EDC0234 ═══ EDC0234 Expecting a new-line character on #&1 directive. A character sequence was encountered when the preprocessor required a new-line character. Recovery: Put a new-line character after the preprocessor. ═══ 2.130. EDC0235 ═══ EDC0235 Incorrect escape sequence &1. \ ignored. An escape sequence that is not valid has been encountered in a string literal or a character literal. It is replaced by the character following the backslash (\). Recovery: Change or remove the escape sequence. ═══ 2.131. EDC0236 ═══ EDC0236 Macro name &1 has been redefined. You can define a macro multiple times in extended mode. In ANSI mode macro redefinitions are ignored. Recovery: Change the language level to extended (with the /Se compiler option or #pragma langlvl directive), or remove the macro redefinitions. ═══ 2.132. EDC0238 ═══ EDC0238 Function argument cannot be type void. The void type cannot appear in the argument list of a function call. The void type can appear in a parameter list only if it is a non-variable argument function,the only parameter in the list, and it is unnamed. Recovery: Ensure that the use of void as a argument conforms to the above rules or remove the argument. ═══ 2.133. EDC0242 ═══ EDC0242 An object with external linkage declared at block scope cannot be initialized. You cannot declare a variable at block scope with the storage class extern and give it an explicit initializer. Recovery: Initialize the external object in the external declaration. ═══ 2.134. EDC0243 ═══ EDC0243 Value of enumeration constant must be in range of signed integer. If an enum constant is initialized in the definition of an enum tag, the initial value must be an integral expression that has a value representable as an int. Recovery: Remove the initial value, or ensure that it is an integral constant expression that has a value representable as an int. ═══ 2.135. EDC0245 ═══ EDC0245 Incompatible sign adjective &1. Adjectives "signed" and unsigned can only modify integer type specifiers. Recovery: Either remove the sign adjective or use a different type specifier. ═══ 2.136. EDC0246 ═══ EDC0246 Incompatible length adjective &1. Length adjectives short and long can only be applied to particular scalar types. See the C/C++ Language Reference for valid types. Recovery: Either remove the length adjective or use a different type specifier. ═══ 2.137. EDC0247 ═══ EDC0247 Incompatible type specifier &1. The type specifier is not compatible with the type adjectives used. See the C/C++ Language Reference for valid combinations of type specifiers and adjectives. Recovery: Either remove the adjective or use a different type specifier. ═══ 2.138. EDC0248 ═══ EDC0248 More than one storage class specifier &1. A C declaration must only have one storage class specifier. Recovery: Ensure only one storage class is specified. ═══ 2.139. EDC0249 ═══ EDC0249 Identifier contains a $ character. You cannot use the $ character in an identifier. An identifier can contain alphanumeric characters and underscores. An identifier must start with either an underscore or alphabetic character. Recovery: Remove the $ character. ═══ 2.140. EDC0250 ═══ EDC0250 Floating point constant &1 out of range. The compiler detected a floating-point overflow either in scanning a floating-point constant, or in performing constant arithmetic folding. Recovery: Change the floating-point constant so that it does not exceed the maximum value. ═══ 2.141. EDC0251 ═══ EDC0251 Static function &1 is undefined. A static function was declared and referenced in this file. The definition of the function was not found before the end of the file. When a function is declared to be static, the function definition must appear in the same file. Recovery: Define the function in the file or remove the static storage class. ═══ 2.142. EDC0258 ═══ EDC0258 Hexadecimal integer constant &1 is not valid. An invalid hexadecimal integer constant was specified. See the C/C++ Language Reference for details on specifying hexadecimal characters. Recovery: Change the value to a valid hexadecimal integer constant. ═══ 2.143. EDC0260 ═══ EDC0260 Octal integer constant &1 is not valid. An invalid octal integer constant was specified. See the C/C++ Language Reference for details on specifying octal characters. Recovery: Change the value to a valid octal integer constant. ═══ 2.144. EDC0261 ═══ EDC0261 Suboption &1 is not valid for option &2. An invalid suboption was specified for some option. Recovery: Change the suboption. ═══ 2.145. EDC0262 ═══ EDC0262 #pragma &1 must occur before first C statement in program. #pragma ignored. This pragma must be specified before the first C token in the input (including header files). Recovery: Place the #pragma directive in the file before any C code, or remove it. ═══ 2.146. EDC0263 ═══ EDC0263 #pragma strings directive can be specified only once per source file. #pragma ignored. This #pragma specifies whether string literals are placed in read-only memory. It must appear only once and before any C code. Recovery: Change the location of the directive and ensure that it appears only once in the translation unit. ═══ 2.147. EDC0264 ═══ EDC0264 #pragma comment(copyright) directive can be specified only once per source file. There can only be one #pragma comment(copyright) per source file. Recovery: Ensure that it occurs only once in the translation unit. ═══ 2.148. EDC0266 ═══ EDC0266 Parameter(s) for #pragma are out of range. The #pragma parameters were invalid. See the C/C++ Language Reference for details on valid #pragma parameters. Recovery: Change the parameter. ═══ 2.149. EDC0267 ═══ EDC0267 Unrecognized #pragma ignored. An invalid pragma was encountered and ignored. Recovery: Ensure that the #pragma name is spelled correctly. A #pragma with equivalent functionality but different name may exist. See the C/C++ Language Reference for a list of #pragma directives. ═══ 2.150. EDC0268 ═══ EDC0268 Macro &1 invoked with an incomplete argument for parameter &2. The parameter for the macro invocation must have a complete argument. Recovery: Complete the specification of the macro argument list. Check for missing commas. ═══ 2.151. EDC0271 ═══ EDC0271 The indirection operator cannot be applied to a void pointer. The indirection operator requires a pointer to a complete type. A void pointer is an incomplete type that can never be completed. Recovery: Cast the pointer to a type other than void before this operation. ═══ 2.152. EDC0272 ═══ EDC0272 Identifier not allowed in cast or sizeof declarations. Only abstract declarators can appear in cast or sizeof expressions. Recovery: Remove the identifier from the cast or sizeof expression and replace it with an abstract declarator. ═══ 2.153. EDC0273 ═══ EDC0273 Missing type in declaration of &1. A declaration was made without a type specifier. Recovery: Insert a type specifier into the declaration. ═══ 2.154. EDC0274 ═══ EDC0274 Missing declarator in structure member declaration. A struct or union member declaration must specify a name. A type cannot be followed by a semicolon. Recovery: Declare the member with a name. ═══ 2.155. EDC0275 ═══ EDC0275 Unexpected text &1 encountered. A syntax error has occurred. This message lists the tokens that were discarded by the parser when it tried to recover from the syntax error. Recovery: Correct the syntax error and compile again. ═══ 2.156. EDC0276 ═══ EDC0276 Syntax error: possible missing &1? A syntax error has occurred. This message lists the token that the parser expected and did not find. Recovery: Correct the syntax error and compile again. ═══ 2.157. EDC0277 ═══ EDC0277 Syntax error: possible missing &1 or &2? A syntax error has occurred. This message lists the tokens that the parser expected and did not find. Recovery: Correct the syntax error and compile again. ═══ 2.158. EDC0278 ═══ EDC0278 The structure definition must specify a member list. The declaration of a struct or a union that includes an empty member list enclosed between braces is not a valid struct or union definition. Recovery: Specify the members of the struct or union in the definition or remove the empty braces to make it a simple struct or union tag declaration. ═══ 2.159. EDC0279 ═══ EDC0279 A function declarator cannot have a parameter identifier list if it is not a function definition. A function declarator that is not also a function definition may not have a K&R style parameter identifier list. An example is the "x,y" in "int (*fred(a,b)) (x,y) {}". Recovery: Remove the parameter identifier list. ═══ 2.160. EDC0280 ═══ EDC0280 Function argument assignment between types "&1" and "&2" is not allowed. The type of the argument in the function call should match the corresponding parameter type in the function declaration. Recovery: Cast the argument to a different type, change the type or change the function prototype. ═══ 2.161. EDC0281 ═══ EDC0281 Prefix and postfix increment and decrement operators cannot be applied to "&1". Increment and decrement operators cannot operate on pointers to function or pointers to void. Recovery: Change the pointer to point to an object type. ═══ 2.162. EDC0282 ═══ EDC0282 The type of the parameters must be specified in a prototype. A prototype specifies the number and the type of the parameters that a function requires. A prototype that does not specify the type of the parameters is not correct, for example, fred(a,b); Recovery: Specify the type of the parameters in the function prototype. ═══ 2.163. EDC0283 ═══ EDC0283 The static storage class cannot be used with functions declared at block scope. Functions declared at block scope can only have extern as an explicit storage class specifier. Recovery: Place the declaration of the static function at file scope, or remove the storage class specifier. ═══ 2.164. EDC0285 ═══ EDC0285 The indirection operator cannot be applied to a pointer to an incomplete struct or union. A structure or union type is completed when the definition of its tag is specified. A struct or union tag is defined when the list describing the name and type of its members is specified. Recovery: Complete the struct or union definition. ═══ 2.165. EDC0286 ═══ EDC0286 A struct or union with no named members cannot be explicitly initialized. Only aggregates containing named members can be explicitly initialized. Recovery: Name the members of the struct or union. ═══ 2.166. EDC0287 ═══ EDC0287 The parameter list on the definition of macro &1 is not complete. There is a problem with the parameter list in the definition of the macro. Recovery: Complete the parameter list. Look for misplaced or extra commas. ═══ 2.167. EDC0288 ═══ EDC0288 Expecting file name or new-line character on #line directive. The #line directive requires a line number argument as its first parameter and a file name as an optional second parameter. No other arguments are allowed. A new-line character must be present after the argument list. Recovery: Change the directive syntax. ═══ 2.168. EDC0289 ═══ EDC0289 Macro &1 redefined with identical definition. Identical macro redefinitions are allowed but not neccessary. The amount of white space separating the tokens have no bearing on whether macros are considered identical. ═══ 2.169. EDC0290 ═══ EDC0290 Unknown macro name &1 on #undef directive. An attempt is being made to undefine a macro that has not been previously defined. Recovery: Check the spelling of the macro name or remove the #undef directive. ═══ 2.170. EDC0291 ═══ EDC0291 Expecting decimal constant on #line directive. The value for a #line directive must be a decimal constant. Recovery: Specify a line number on the #line directive. ═══ 2.171. EDC0292 ═══ EDC0292 Multibyte character literal not allowed on #&1 directive. The directive does not allow a multibyte character literal. Recovery: Remove the multibyte character literal. ═══ 2.172. EDC0293 ═══ EDC0293 Identifier &1 assigned default value of zero on &2 directive. The indicated identifier in a #if or #elif expression was assigned the default value of zero. The identifier may have been intended to be expanded as a macro. Recovery: Add a #define for the macro before using it in a preprocessor conditional. ═══ 2.173. EDC0294 ═══ EDC0294 Syntax error in expression on #&1 directive. The expression for a preprocessor directive contains a syntax error. Recovery: Replace the expression that controls the directive by a constant integral expression. ═══ 2.174. EDC0295 ═══ EDC0295 File ended with a continuation sequence. The file ended expectedly with a backslash character followed by a new-line character. Recovery: Remove the continuation character from the last line of the file, or add code after the continuation character. ═══ 2.175. EDC0296 ═══ EDC0296 #include file &1 not found. The file specified on the #include directive could not be found. See the C/C++ Language Reference for file search order. Recovery: Ensure the #include file name and the search path are correct. ═══ 2.176. EDC0297 ═══ EDC0297 Unable to open input file &1. &2. The compiler was unable to open the input file. Recovery: Ensure the file exists and that the compiler can access it. ═══ 2.177. EDC0298 ═══ EDC0298 Unable to read input file &1. &2. The compiler was unable to read the input file. Recovery: Ensure file exists and is accessable by compiler. ═══ 2.178. EDC0299 ═══ EDC0299 Maximum #include nesting depth of &1 has been exceeded. The included files have been nested too deeply. Recovery: Reduce the number of nested include files. ═══ 2.179. EDC0300 ═══ EDC0300 Insufficient storage available. The compiler ran out of memory trying to compile the file. This sometimes happens with large files or programs with large functions. Note that very large programs limit the amount of optimization that can be done. Recovery: Shut down any large processes that are running, ensure your swap path is large enough, turn off optimization, or limit the optimizers working set maximum. You can also divide the file into several small sections or shorten the function. ═══ 2.180. EDC0301 ═══ EDC0301 Redeclaration cannot specify fewer parameters than previous declaration. The function definition has fewer parameters than the prototype. Recovery: Modify one of the function declarations so that the number and types of the parameters match. ═══ 2.181. EDC0302 ═══ EDC0302 The declarations of the function &1 must be consistent in their use of the ellipsis. The prototyped redeclaration of the function is not correct. Fewer parameters appear before the ellipsis in this function redeclaration than the previous declaration. Recovery: Ensure that the redeclaration is consistent with the previous declaration. ═══ 2.182. EDC0303 ═══ EDC0303 The type of the parameter &1 cannot conflict with the previous declaration of function &2. Nonprototype function declarations, popularly known as K&R prototypes, specify only the function return type. The function parentheses are empty; no information about the parameters is given. Nonprototype function definitions specify a list of parameter names appearing between the function parentheses followed by a list of declarations (located between the parentheses and the opening left brace of the function) that indicates the type of the parameters. A nonprototype function definition is also known as a K&R function definition. A prototype function declaration or definition specifies the type and the number of the parameters in the parameter declaration list that appears inside the function parenthesis. A prototype function declaration is better known as an ANSI prototype, and a prototype function definition is better known as an ANSI function definition. When the nonprototype function declarations/definitions are mixed with prototype declarations, the type of each prototype parameter must be compatible with the type that results from the application of the default argument promotions. Most types are already compatible with their default argument promotions. The only ones that aren't are char, short, and float. Their promoted versions are, respectively, int, int, and double. This message can occur in several situations. The most common is when mixing ANSI prototypes with K&R function definitions. If a function is defined using a K&R-style header, then its prototype, if present, must specify widened versions of the parameter types. Here is an example. int fn(short); int fn(x) short x; {} This is not valid because the function has a K&R-style definition and the prototype does not specify the widened version of the parameter. To be correct, the prototype should be int fn(int); because int is the widened version of short. Another possible solution is to change the function definition to use ANSI syntax. This particular example would be changed to int fn(short); int fn(short x) {} This second solution is preferable, but either solution is equally valid. Recovery: Give a promoted type to the parameter in the prototype function declaration. ═══ 2.183. EDC0304 ═══ EDC0304 No function prototype given for '&1'. A prototype declaration of the function specifying the number and type of the parameters was not found before the function was used. Errors may occur if the function call does not respect the function definition. Recovery: Add an appropriate function prototype before calling the function. ═══ 2.184. EDC0306 ═══ EDC0306 Subscript operator requires an array operand in the offsetof macro. A subscript was specified in the offsetofmacro but the operand is not an array. Recovery: Either change the operand to be an array type or remove the subscript operator. ═══ 2.185. EDC0307 ═══ EDC0307 Array index must be a constant expression in the offsetof macro. The offsetof macro is evaluated at compile time. Thus all arguments must be constant expressions. Recovery: Change the expression. ═══ 2.186. EDC0308 ═══ EDC0308 Operand of the offsetof macro must be a struct or a union. The first operand of the offsetof macro must be a structure or union type. Recovery: Change the operand. ═══ 2.187. EDC0309 ═══ EDC0309 The offsetof macro cannot be used with an incomplete struct or union. An incomplete struct or union is not a valid argument to the offsetof macro. A structure or union type is completed when the definition of its tag is specified. Recovery: Ensure the struct or union is a complete type. ═══ 2.188. EDC0310 ═══ EDC0310 The type "&1 &2" was introduced in a parameter list, and will go out of scope at the end of the function declaration or definition. The tag will be added to parameter scope in ANSI mode. Thus it will go out of scope at the end of the declaration or function definition. In extended mode, the tag is added to the closest enclosing block scope. Recovery: If the tag is needed for declarations outside its scope, move the tag declaration outside of parameter scope. ═══ 2.189. EDC0311 ═══ EDC0311 Wide character constant &1 has more than one character. Last character is used. All but the last character in the constant will be discarded. Recovery: Remove all but one character or change the character constant into a string literal. ═══ 2.190. EDC0312 ═══ EDC0312 Compiler internal name &1 has been defined as a macro. Do not redefine internal compiler names. Recovery: Remove the macro definition or change the name of the macro being defined. ═══ 2.191. EDC0313 ═══ EDC0313 Compiler internal name &1 has been undefined as a macro. Do not redefine internal compiler names. Recovery: Remove the macro undefinition. ═══ 2.192. EDC0315 ═══ EDC0315 Error writing to test coverage data file. The compiler is unable to write to the .d file. Recovery: Change access permissions for .d ═══ 2.193. EDC0316 ═══ EDC0316 Error opening test coverage data file. The compiler is unable to open the .d file. Recovery: Change access permissions for .d ═══ 2.194. EDC0317 ═══ EDC0317 Line too long for test coverage. The line is too long for the test coverage tool to handle. Recovery: Divide line into multiple lines. ═══ 2.195. EDC0318 ═══ EDC0318 Too many statements for test coverage. The compilation unit contains too many statements for test coverage. Recovery: Divide the compilation unit into several compilation units. ═══ 2.196. EDC0319 ═══ EDC0319 Redefinition of atexit() incompatible with test coverage. The tcov run-time system must use atexit() and the user redefinition of atexit() is incompatible with the tcov run-time support. Recovery: Do not use tcov on a program that uses atexit(). ═══ 2.197. EDC0320 ═══ EDC0320 Operation is not allowed because the size of &1 is unknown. The operand must be a complete type for the compiler to determine its size. Recovery: Provide complete definition of type. ═══ 2.198. EDC0321 ═══ EDC0321 You can specify an initializer only for the first named member of a union. There can only be an initializer for the first named member of a union. Recovery: Remove all union initializers other than the one attached to the first named member. ═══ 2.199. EDC0322 ═══ EDC0322 Illegal multibyte character &1. The multibyte character specified is not valid. Recovery: Correct the multibyte character. ═══ 2.200. EDC0323 ═══ EDC0323 "double" should be used instead of "long float". The type long float is not valid; it is treated as a double. Recovery: Remove the long type specifier or use double instead of float. ═══ 2.201. EDC0324 ═══ EDC0324 "&1" cannot be converted to "&2". The cast between the two types is not allowed. Recovery: Remove the cast. ═══ 2.202. EDC0325 ═══ EDC0325 #line directive may cause problems with test coverage. #line directives in conjunction with test coverage may cause misleading results since the line numbers do not necessarily correspond with the textual positions of the code. Recovery: Do not use test coverage with files containing #line directives. ═══ 2.203. EDC0326 ═══ EDC0326 #line directive may cause problems with browser usage. Browsing files that contain #line directives may have misleading results because the line numbers do not necessarily correspond with the textual positions of the code. Recovery: Remove the #line directives if you plan to browse the file. ═══ 2.204. EDC0327 ═══ EDC0327 An error occurred while opening the listing file, &1. The compiler was unable to open the listing file. Recovery: Ensure the file exists and that the compiler can access it. ═══ 2.205. EDC0328 ═══ EDC0328 "&1" is not a valid hex digit. Valid hex digits include the letters A,B,C,D,E,F,0,1,2,3,4,5,6,7,8,9. Recovery: Change the digit. ═══ 2.206. EDC0329 ═══ EDC0329 Byte string must have an even length. The byte string for a #pragma mcfunc must be of even length. Recovery: Ensure that the machine code string is of even length. ═══ 2.207. EDC0330 ═══ EDC0330 Option -qstrict only valid when -qoptimize=3 specified. The strict option is only valid when used in conjunction with optimization level 3. Recovery: Compile with -qopt=3. ═══ 2.208. EDC0333 ═══ EDC0333 License failure: &1. The compilation has been aborted because of a license failure. Recovery: Contact system administrator. ═══ 2.209. EDC0334 ═══ EDC0334 Identifier &1 has already been defined on line &2 of "&3". There is more than one definition of an identifier. Recovery: Remove one of the definitions or change the name of the identifier. ═══ 2.210. EDC0335 ═══ EDC0335 Parameter identifier list contains multiple occurrences of &1. Identifier names in a parameter list must be unique. Recovery: Change the name of the identifier or remove the parameter. ═══ 2.211. EDC0336 ═══ EDC0336 A Pascal string is too long; the length has been set to 255. Pascal strings have a length limit of 255 characters. Recovery: Shorten the length of the string. ═══ 2.212. EDC0337 ═══ EDC0337 The result of string concatenation is a pascal string. A Pascal string is prefixed with a "\P". The string length is encoded in the string and it is not null terminated. A 'C' string is a null terminated string. The two are not compatible. Concatenation requires that both strings be of the same type. ═══ 2.213. EDC0338 ═══ EDC0338 The result of string concatenation is a non-pascal string. A pascal string is prefixed with a "\P". The string length is encoded in the string and it is not null terminated. A 'C' string is a null terminated string. The two are not compatible. Concatenation requires that both strings be of the same type. ═══ 2.214. EDC0339 ═══ EDC0339 A character string literal cannot be concatenated with a wide string literal. A string that has a prefix L cannot be concatenated with a string that is not prefixed. Concatenation requires that both strings be of the same type. Recovery: Check the syntax of the value given. ═══ 2.215. EDC0340 ═══ EDC0340 A pascal string literal cannot be concatenated with a wide string literal. A string that has a prefix L cannot be concatenated with a string that is not prefixed. Recovery: Check the syntax of the value given. ═══ 2.216. EDC0341 ═══ EDC0341 #include header must be ended before the end of the line. A #include directive was specified across two or more lines. Recovery: Ensure that the #include directive and its arguments are contained on a single line. ═══ 2.217. EDC0342 ═══ EDC0342 "/*" detected in comment. You can ignore this message if you intended "/*" to be part of the comment. If you intended it to start a new comment, move it out of the enclosing comment. Recovery: Remove "/*" or ensure that "/*" was intended in the comment. ═══ 2.218. EDC0343 ═══ EDC0343 Redeclaration of &1 differs from previous declaration on line &2 of "&3". The redeclaration is not compatible with the previous declaration. Recovery: Either remove one declaration or make the types compatible. ═══ 2.219. EDC0344 ═══ EDC0344 Member &1 has already been defined on line &2 of "&3". Member names must be unique within the same aggregate. Recovery: Change the name. ═══ 2.220. EDC0345 ═══ EDC0345 The data in precompiled header file &1 does not have the correct format. The precompiled header file may have become corrupt and is ignored. Recovery: Regenerate the precompiled header files. ═══ 2.221. EDC0346 ═══ EDC0346 Unable to open precompiled header file &1 for input. The original header will be used. The compiler was unable to open the precompiled header file for reading and will use the original header. Recovery: Regenerate the precompiled header files. ═══ 2.222. EDC0347 ═══ EDC0347 Precompiled header file &1 was created by a later release of the compiler. The original header will be used. The original header will be used because the precompiled header file was generated with a later release of the compiler. Recovery: Regenerate the precompiled header files. ═══ 2.223. EDC0348 ═══ EDC0348 Unable to write to precompiled header file &1. The compiler was unable to write to the precompiled header files. Recovery: Ensure that the compiler has write access to the precompiled header files. ═══ 2.224. EDC0349 ═══ EDC0349 Value of enumeration constant must be in range of unsigned integer. If an enum constant is initialized in the definition of an enum tag, the value that it is initialized to must be an integral expression that has a value representable as an int. Recovery: Remove the initial value, or ensure that it is an integral constant expression that has a value representable as an int. ═══ 2.225. EDC0350 ═══ EDC0350 Error writing to intermediate files. &1. An error occurred during compilation. Ensure the compiler has write access to the directory specified by the TMP environment variable and that there is enough disk space free. Recovery: Ensure the compiler has write access to the directory specified by the TMP environment variable and that there is enough disk space free. Recompile the module. ═══ 2.226. EDC0351 ═══ EDC0351 Error opening intermediate files. An error occurred during compilation. Ensure the compiler has write access to the directory specified by the TMP environment variable and that there is enough disk space free. Recovery: Recompile module. ═══ 2.227. EDC0352 ═══ EDC0352 Incompatible specifications for options -qarch and -qtune. The values specified for the arch and tune options are not compatible. Recovery: Change option values. ═══ 2.228. EDC0353 ═══ EDC0353 Waiting for license. The compilation is suspended until a license can be obtained. Recovery: Wait for compiler to obtain license. ═══ 2.229. EDC0354 ═══ EDC0354 The -qmacpstr option is ignored when supplied with the -qmbcs/dbcs options. Pascal strings are not compatible with multibyte characters. Recovery: Do not combine pascal strings with multibyte characters. ═══ 2.230. EDC0355 ═══ EDC0355 The option ENUM is not allowed in the middle of a declaration of an enum. This option is ignored. An attempt has been made to change the ENUM option inside of an enum declaration. This is not allowed because it would make the storage type of the enumerated values inconsistent. Recovery: Move the option to before or after the enum declaration. ═══ 2.231. EDC0356 ═══ EDC0356 Compilation unit is empty. There is no code in the compilation unit. Recovery: Ensure the correct source file is specified. Recompile. ═══ 2.232. EDC0357 ═══ EDC0357 Unable to generate prototype for "&1" because one or more enum, struct, or union specifiers did not have a tag. A prototype could not be generated for the function because the enum, struct or union declaration did not have a tag. Recovery: Specify a tag. ═══ 2.233. EDC0358 ═══ EDC0358 "&1" is defined on line &2 of &3. This message indicates where a previous definition is located. Recovery: Remove one of the definitions or change the name of the identifier. ═══ 2.234. EDC0359 ═══ EDC0359 Automatic variable &1 contains a const member and is not initialized. It will be initialized to zero. An automatic variable that has a const member is not initialized. The compiler is using zero as the initializer. Recovery: Initialize the const member. ═══ 2.235. EDC0360 ═══ EDC0360 Same #pragma &1 has already been specified for object "&2"; this specification is ignored. The repetition of the #pragma is redundant and is ignored. Recovery: Remove the duplicate #pragma. ═══ 2.236. EDC0361 ═══ EDC0361 A different #pragma &1 has already been specified for object "&2", this specification is ignored. A previous #pragma for the object is taking precedence over this #pragma. Recovery: Remove one of the #pragma directives. ═══ 2.237. EDC0363 ═══ EDC0363 Packing boundary must be specified as one of 1, 2, or 4. Objects must be packed on 1, 2, or 4 byte boundaries. Recovery: Change the packing specifier. ═══ 2.238. EDC0364 ═══ EDC0364 The calling convention type of main must be either _System or _Optlink. An inappropriate calling convention has been specified for the main function. This function is the starting point of the program so only _System and _Optlink calling conventions are allowed. Recovery: Give main an appropriate calling convention by qualifying it with the _System or _Optlink keyword, or by specifying /Ms or /Mp to make _System or _Optlink the default (respectively). ═══ 2.239. EDC0366 ═══ EDC0366 Declaration cannot specify multiple calling convention specifiers. A declaration can specify only one calling convention. Valid calling conventions include: _System, _Optlink, _Far16, _Cdecl, _Pascal, and _Fastcall. Recovery: Remove extra calling convention specifiers. ═══ 2.240. EDC0367 ═══ EDC0367 Only functions or typedefs of functions can be given a calling convention. A calling convention protocol keyword has been applied to an identifier that is not a function type or a typedef to a function type. Recovery: Check that correct identifier is specified or remove #pragma. ═══ 2.241. EDC0368 ═══ EDC0368 A calling convention must appear to the left of the identifier to which it applies. A declaration has been discovered which resembles int foo _System (); The keyword _System must appear immediately to the left of the identifier "foo". Recovery: Correct the declaration. ═══ 2.242. EDC0369 ═══ EDC0369 The function cannot be redeclared with a different calling convention. The redeclaration of this function cannot have a different calling convention than the previous declaration. The function could have been given a calling convention through a typedef, or via a previous declaration. Recovery: Make sure all declarations of the function specify the same calling convention. ═══ 2.243. EDC0370 ═══ EDC0370 A _fastcall function cannot be defined in a 32-bit program. A callback function cannot have a 16-bit fastcall calling convention. However, you can call 16-bit fastcall functions. Recovery: Change the calling convention. ═══ 2.244. EDC0371 ═══ EDC0371 Functions taking a variable number of parameters cannot have _Pascal calling convention. A function with _Pascal calling convention cannot have a variable number of parameters. Recovery: Change the calling convention protocol specification or change the declaration to be a fixed parameter function. ═══ 2.245. EDC0372 ═══ EDC0372 Precompiled header files may cause inaccuracies for &1. &2 option ignored. Precompiled header files are not compatible with some utilities so the precompiled header files may not be used. Recovery: Do not use precompiled headers with the specified utility. ═══ 2.246. EDC0373 ═══ EDC0373 &1 option ignored because &2 option ignored in previous conflict. When there is a conflict between options and precompiled header files, the option to generate precompiled header files is also ignored to avoid refreshing the precompiled header files. Recovery: Do not use precompiled header files with the specified utility. ═══ 2.247. EDC0374 ═══ EDC0374 Pointer types "&1" and "&2" are not compatible. The types pointed to by the two pointers are not compatible. Recovery: Change the types to be compatible. ═══ 2.248. EDC0375 ═══ EDC0375 /Gr+ must be specified to use the _Far32 _Pascal calling convention. Recovery: Specify the ring zero option (/Gr) on the command line or change the calling convention. ═══ 2.249. EDC0376 ═══ EDC0376 Redeclaration of &1 has a different number of fixed parameters than the previous declaration. The number of fixed parameters in the redeclaration of the function does not match the original number of fixed parameters. Recovery: Change the declarations to have the same number of parameters, or rename or remove one of the declarations. ═══ 2.250. EDC0377 ═══ EDC0377 The type "&1" of parameter &2 differs from the previous type "&3". The type of the corresponding parameter in the previous function declaration is not compatible. Recovery: Change the parameter declaration or rename the function declaration. ═══ 2.251. EDC0378 ═══ EDC0378 Prototype for function &1 cannot contain "..." when mixed with a nonprototype declaration. A function prototype and a nonprototype declaration can not be compatible if one contains "...". Recovery: Convert nonprototype declaration to a prototyped one or remove the "...". ═══ 2.252. EDC0379 ═══ EDC0379 Prototype for function &1 must contain only promoted types if prototype and nonprototype declarations are mixed. Nonprototype declarations have their parameters automatically promoted. Integral widening conversions are applied to integral types and float is converted into double. Recovery: Promote the parameter types in the prototyped declaration. ═══ 2.253. EDC0380 ═══ EDC0380 Parameter &1 has type "&2" which promotes to "&3". Nonprototype declarations have their parameters automatically promoted. Integral widening conversions are applied to integral types and float is converted into double. Recovery: Promote the parameter types in the prototyped declaration. ═══ 2.254. EDC0381 ═══ EDC0381 The type "&1" of parameter &2 in the prototype declaration is not compatible with the corresponding parameter type "&3" in the nonprototype declaration. The types of the parameters must be compatible. Recovery: Change the parameters so that they are compatible. ═══ 2.255. EDC0382 ═══ EDC0382 The type "&1" of identifier &2 differs from previous type "&3". The two types are not compatible. Recovery: Change the parameter types so that they are compatible. ═══ 2.256. EDC0383 ═══ EDC0383 Expecting "&1" to be an external identifier. The identifier must have external linkage. Recovery: Change the storage class to extern. ═══ 2.257. EDC0384 ═══ EDC0384 Expecting "&1" to be a function name. "&1" should be a function symbol. Recovery: Specify a different name or change the type of the symbol. ═══ 2.258. EDC0385 ═══ EDC0385 User segment &1 has already been declared. The user segment has already been specified as being another type of segment. Data segments and text segments must have distinct names. Recovery: Remove one of the declarations for the segment. ═══ 2.259. EDC0386 ═══ EDC0386 The maximum number of user-defined segments has been exceeded. There can only be a certain number of user-defined segments and this limit has been exceeded. Recovery: Reduce the number of user-defined segments. ═══ 2.260. EDC0387 ═══ EDC0387 The enum cannot be packed to the requested size. Use a larger value for /Su. Enums may be 1, 2, or 4 bytes in size. Recovery: Change the value specified for the enum packing option (/Sp). ═══ 2.261. EDC0388 ═══ EDC0388 Value &1 specified in #pragma &2 is out of range. Refer to the C/C++ Language Reference for more information about the valid values for the #pragmas. Recovery: Specify a different value. ═══ 2.262. EDC0389 ═══ EDC0389 Some program text was not scanned due to &1 option or #pragma &2. A compiler option or #pragma directive was used to limit the valid text region in a source file. Recovery: Remove the /Sg or /Sq option, or remove the #pragma margins or sequence, or specify a more inclusive text region. ═══ 2.263. EDC0390 ═══ EDC0390 Function or variable &1 was previously defined and should not be redeclared as an import. An identifier has already been defined and the #pragma is redeclaring the identifier as an import. Recovery: Rename the function or variable. ═══ 2.264. EDC0391 ═══ EDC0391 Variable &1 cannot be defined with use of #pragma import. You cannot define the function or variable if it is used in a #pragma import. Recovery: Rename the variable. ═══ 2.265. EDC0392 ═══ EDC0392 A DLL module name must be specified in #pragma import. Module name is the name of the DLL where the entry point of the import function exists. It must be specified in the parameter list of #pragma import. Recovery: Name the DLL in the parameter list. ═══ 2.266. EDC0393 ═══ EDC0393 &1 value must contain only decimal digits. A non-numeric character was encountered in the &1 value. Recovery: Check the syntax of the value given. ═══ 2.267. EDC0394 ═══ EDC0394 Ordinal value on #pragma &1 is out of range. The specified ordinal number should be between 0 and 65535, inclusive. Recovery: Change the value accordingly. ═══ 2.268. EDC0395 ═══ EDC0395 Variable &1 must be an external object or a function name for use with #pragma import. The identifier specified by the pragma is not a function or external object. Recovery: Declare the object with storage class "extern". ═══ 2.269. EDC0397 ═══ EDC0397 Undefined function or variable &1 cannot have a #pragma export or _Export. Only defined variables or functions can be specified as an export. Recovery: Define the function or variable. ═══ 2.270. EDC0398 ═══ EDC0398 Bit-field type specified for &1 is non-portable. The type should be signed int, unsigned int or int. The specification of the bit-field type may cause problems with porting the code to another system. Recovery: Change the type specifier. ═══ 2.271. EDC0399 ═══ EDC0399 The alignment of a structure/union is determined at the left brace of the definition. The alignment of an aggregate is constant throughout its definition. ═══ 2.272. EDC0400 ═══ EDC0400 #pragma &1 must appear only once in any C file. Recovery: Remove all but one of the specified #pragma directives. ═══ 2.273. EDC0401 ═══ EDC0401 Function &1 must be defined for #pragma entry. The function must be defined for it to be specified using #pragma entry. Recovery: Define the function. ═══ 2.274. EDC0402 ═══ EDC0402 &1 must be an externally-defined function for use with #pragma entry. The identifier must be defined as a function with external linkage for it to be specified using #pragma entry. Recovery: Define the function. ═══ 2.275. EDC0403 ═══ EDC0403 Cannot use the _Seg16 qualifier with pointers to _Far32 _Pascal functions. The pointer types are not compatible. Recovery: Remove the _Seg16 type qualifier. ═══ 2.276. EDC0404 ═══ EDC0404 _Seg16 can only qualify a pointer type. An attempt was made to qualify an identifier with _Seg16 but the identifier is not a pointer. Recovery: Remove the _Seg16 type qualifier from the declaration or definition, or ensure it qualifies a pointer. ═══ 2.277. EDC0405 ═══ EDC0405 A 16-bit function cannot have a structure or union as a parameter. Passing a structure or union by value to a 16-bit function is not supported. Recovery: Change the parameter to a pointer to a structure or union. ═══ 2.278. EDC0406 ═══ EDC0406 A 16-bit function cannot have a structure or union as a return type. Passing a structure or union by value from a 16-bit function is not supported. Recovery: Change the return type to a pointer to a structure or union. ═══ 2.279. EDC0407 ═══ EDC0407 _Seg16 pointers are not supported on the target platform. The _Seg16 qualifier is not allowed on the target platform. Recovery: Remove the _Seg16 type qualifier. ═══ 2.280. EDC0409 ═══ EDC0409 The static variable '&1' is defined but never referenced. A variable that is defined but never used probably serves no purpose. Recovery: Remove the variable definition if you are not going to use the variable. ═══ 2.281. EDC0410 ═══ EDC0410 The automatic variable '&1' is defined but never referenced. A variable that is defined but never used likely serves no purpose. Recovery: Remove the variable definition. ═══ 2.282. EDC0411 ═══ EDC0411 An array that is not an lvalue cannot be subscipted. A non-lvalue array is created when a function returns a structure that contains an array. This array cannot be dereferenced. Recovery: Remove the subscript. ═══ 2.283. EDC0412 ═══ EDC0412 The variable '&1' is referenced before being initialized. Because the variable has not been initialized, its value is undefined. The results of using an undefined variable are unpredictable. Recovery: Initialize the variable before its first reference. ═══ 2.284. EDC0413 ═══ EDC0413 A goto statement is used. The use of goto statements may result in code that is more difficult to trace. Recovery: Replace the goto statement with equivalent structured-programming constructs. ═══ 2.285. EDC0414 ═══ EDC0414 The parameter '&1' is never referenced. The parameter is passed to the function, but is not referenced anywhere within the function body. Recovery: Remove the parameter from the function prototype. ═══ 2.286. EDC0415 ═══ EDC0415 The external function definition '&1' is never referenced. A function that is defined but never used likely serves no purpose. Recovery: Remove the function definition, unless needed in another compilation unit. ═══ 2.287. EDC0416 ═══ EDC0416 Taking the negative of the most negative value, '&1', of a signed type will cause truncation. The negative of the most negative value cannot be represented as a positive value of the same type. Recovery: Change the value or use a larger data type. ═══ 2.288. EDC0418 ═══ EDC0418 '&1' does not evaluate to a constant that fits in its signed type. The expression evaluates to a number that is not within the range that can be stored by the target. Recovery: Change the expression so it evaluates to a value in the valid range. ═══ 2.289. EDC0419 ═══ EDC0419 Converting &1 to type "&2" does not preserve its value. The user cast converts &1 to a type that cannot contain the value of the original type. Recovery: Change the cast. ═══ 2.290. EDC0420 ═══ EDC0420 An unsigned comparison is performed between an unsigned value and a negative constant. Comparing an unsigned value with a signed value may produce unexpected results. Recovery: Type-cast the unsigned value to a signed type if a signed comparison is desired, or type-cast the negative constant to an unsigned type if an unsigned comparison is desired. ═══ 2.291. EDC0421 ═══ EDC0421 The comparison is always true. The type specifiers of the values being compared result in a constant result. Recovery: Simplify or remove the conditional expression. ═══ 2.292. EDC0422 ═══ EDC0422 The comparison is always false. The type specifiers of the values being compared result in a constant result. Recovery: Simplify or remove the conditional expression. ═══ 2.293. EDC0423 ═══ EDC0423 The comparison may be rewritten as '&1'. The type specifiers of the values being compared may allow the expression to be simplified. Recovery: Simplify the comparision expression. ═══ 2.294. EDC0424 ═══ EDC0424 The condition is always true. Because the value of the conditional expression is constant, it may be possible to simplify or remove the conditional test. Recovery: Change the conditional expression or remove the conditional test. ═══ 2.295. EDC0425 ═══ EDC0425 The condition is always false. Because the value of the conditional expression is constant, it may be possible to simplify or remove the conditional test. Recovery: Change the conditional expression or remove the conditional test. ═══ 2.296. EDC0426 ═══ EDC0426 An assignment expression is used as a condition. An equality comparison (==) may have been intended. A single equal sign '=' is often mistakenly used as an equality comparison operator. Recovery: Ensure an assignment operation was intended. ═══ 2.297. EDC0427 ═══ EDC0427 A constant expression is used as a switch condition. The same code path will be taken through every execution of the switch statement. Recovery: Change the switch expression to be a non-constant value or remove the unused portions of the switch structure. ═══ 2.298. EDC0428 ═══ EDC0428 The left-hand side of a shift expression is an unparenthesized arithmetic expression which has a higher precedence. The left-hand expression is evaluated before the shift operator. Recovery: Place parentheses around the left-hand expression to make the order of operations explicit. ═══ 2.299. EDC0429 ═══ EDC0429 The right-hand side of a shift expression is an unparenthesized arithmetic expression which has a higher precedence. The right-hand expression is evaluated before the shift operator. Recovery: Place parentheses around the right-hand expression to make the order of operations explicit. ═══ 2.300. EDC0430 ═══ EDC0430 The result of a comparison is either 0 or 1, and may not be appropriate as operand for another comparison operation. The comparison expression may be malformed. Recovery: Ensure that the resulting value from the comparision is appropriate for use in the following comparision. ═══ 2.301. EDC0431 ═══ EDC0431 The left-hand side of a bitwise &, |, or к expression is an unparenthesized relational, shift, or arithmetic expression which has a higher precedence. The left-hand expression is evaluated before the bitwise operator. Recovery: Place parentheses around the left-hand expression to make the order of operations explicit. ═══ 2.302. EDC0432 ═══ EDC0432 The right-hand side of a bitwise &, |, or к expression is an unparenthesized relational, shift, or arithmetic expression which has a higher precedence. The right-hand expression is evaluated before the bitwise operator. Recovery: Place parentheses around the right-hand expression to make the order of operations explicit. ═══ 2.303. EDC0433 ═══ EDC0433 The right-hand side of a bitwise shift expression should be positive and less than the width in bits of the promoted left operand. This expression may not be portable. Recovery: Change the shift expression. ═══ 2.304. EDC0434 ═══ EDC0434 The left-hand side of a bitwise right shift expression has a signed promoted type. This expression may not be portable. Recovery: Change the shift expression. ═══ 2.305. EDC0435 ═══ EDC0435 An expression statement should have some side effects because its value is discarded. If an expression statement has no side effects, then it may be possible to remove the statement with no change in program behaviour. Recovery: Change or remove the expression statement. ═══ 2.306. EDC0436 ═══ EDC0436 Left-hand side of comma expression should have side effects because its value is discarded. A comma expression evaluates to its right-hand operand. Recovery: Change the expression. ═══ 2.307. EDC0437 ═══ EDC0437 The init or re-init expression of a for statement should have some side effects because its value is discarded. If the init and/or the re-init expression of a for statement have no side effects, the the loop may not execute as desired. Recovery: Change the init and/or re-init expressions. ═══ 2.308. EDC0438 ═══ EDC0438 The value of the variable '&1' may be used before being set. Because the variable has not been initialized, its value is undefined. The results of using an undefined variable are unpredictable. Recovery: Add an initialization statement or change the expression. ═══ 2.309. EDC0439 ═══ EDC0439 Assigning enum type '&1' to enum type '&2' may not be correct. The values of the enumerated types may be incompatible. Recovery: Change the types of the values being assigned. ═══ 2.310. EDC0440 ═══ EDC0440 Cannot assign an invalid enumerator value to enum type '&1'. The value being assigned is not a member of the enumeration. Recovery: Change the value being assigned, or make it an enumeration member. ═══ 2.311. EDC0441 ═══ EDC0441 The macro definition will override the keyword '&1'. Overriding a C keyword with a preprocessor macro may cause unexpected results. Recovery: Change the name of the macro or remove it. ═══ 2.312. EDC0442 ═══ EDC0442 A trigraph sequence occurs in a character literal. The trigraph sequence will be converted. A literal interpretation may have been desired. Recovery: Change the value of the character literal. ═══ 2.313. EDC0443 ═══ EDC0443 A trigraph sequence occurs in a string literal. The trigraph sequence will be converted. A literal interpretation may have been desired. Recovery: Change the value of the string literal. ═══ 2.314. EDC0444 ═══ EDC0444 The opening brace is redundant. The initialization expression contains extra, possibly unnecessary, braces. Recovery: Remove the extra braces. ═══ 2.315. EDC0445 ═══ EDC0445 The closing brace is redundant. The initialization expression contains extra, possibly unnecessary, braces. Recovery: Remove the extra braces. ═══ 2.316. EDC0446 ═══ EDC0446 Array element(s) э&1∙ will be initialized with a default value of 0. Some array elements were not explicitly initialized. They will be assigned the default value. Recovery: Add initializations if necessary. ═══ 2.317. EDC0447 ═══ EDC0447 The member(s) starting from '&1' will be initialized with a default value of 0. Some members were not explicitly initialized. They will be assigned the default value. Recovery: Add initializations if necessary. ═══ 2.318. EDC0448 ═══ EDC0448 Assigning a packed struct to an unpacked struct, or vice versa, requires remapping. Assignments between packed/unpacked structures may produce incorrect results. Recovery: Change the type qualifiers of the values in the assignment. ═══ 2.319. EDC0449 ═══ EDC0449 Missing return expression. If a function has a non-void return type, then all return statements must have a return expression of the correct type. Recovery: Add a return expression. ═══ 2.320. EDC0450 ═══ EDC0450 Obsolete non-prototype-style function declaration. The KNR-style function declaration is obsolete. Recovery: Change the function declaration to the prototyped style. ═══ 2.321. EDC0451 ═══ EDC0451 The target integral type cannot hold all possible values of the source integral type. Data loss or truncation may occur because of the type conversions. Recovery: Change the types of the values in the expression. ═══ 2.322. EDC0452 ═══ EDC0452 Assigning a floating point type to an integral type may result in truncation. Data loss or truncation may occur because of the type conversions. Recovery: Change the types of the values in the expression. ═══ 2.323. EDC0453 ═══ EDC0453 Assigning a floating point type to another floating point type with less precision. Data loss or truncation may occur because of the type conversions. Recovery: Change the types of the values in the expression. ═══ 2.324. EDC0454 ═══ EDC0454 &1 condition evaluates to &2. This message traces preprocessor expression evaluation. Recovery: No response required. ═══ 2.325. EDC0455 ═══ EDC0455 defined(&1) evaluates to &2. This message traces preprocessor #ifdef and #ifndef evaluation. Recovery: No response required. ═══ 2.326. EDC0456 ═══ EDC0456 Stop skipping tokens. This messages traces conditional compilation activity. Recovery: No response required. ═══ 2.327. EDC0457 ═══ EDC0457 File &1 has already been included. This #include directive is redundant. Recovery: Remove the #include directive. ═══ 2.328. EDC0458 ═══ EDC0458 #line directive changing line to &1 and file to &2. This message traces #line directive evaluation. Recovery: No response required. ═══ 2.329. EDC0459 ═══ EDC0459 #line directive changing line to &1. This message traces #line directive evaluation. Recovery: No response required. ═══ 2.330. EDC0460 ═══ EDC0460 &1 nesting level is &2. This message traces conditional compilation activity. Recovery: No response required. ═══ 2.331. EDC0461 ═══ EDC0461 Generating precompiled header file &1. This message traces precompiled header generation activity. Recovery: No response required. ═══ 2.332. EDC0462 ═══ EDC0462 Precompiled header file &1 is found but not used because it is not up to date. This message traces precompiled header file generation activity. Recovery: No response required. ═══ 2.333. EDC0463 ═══ EDC0463 Using precompiled header file &1. This message traces precompiled header file generation activity. Recovery: No response required. ═══ 2.334. EDC0464 ═══ EDC0464 Begin skipping tokens. This messages traces conditional compilation activity. Recovery: No response required. ═══ 2.335. EDC0465 ═══ EDC0465 #undef undefining macro name &1. This message traces #undef preprocessor directive evaluation. Recovery: No response required. ═══ 2.336. EDC0466 ═══ EDC0466 Unary minus applied to an unsigned type. The negation operator is inappropriate for unsigned types. Recovery: Remove the operator or change the type of the operand. ═══ 2.337. EDC0467 ═══ EDC0467 String literals concatenated. Two string literals, each delimited by quotation marks, have been combined into a single literal. Recovery: No response is necessary. This is an informational message. ═══ 2.338. EDC0468 ═══ EDC0468 Macro name &1 on #define is also an identifier. The name of the macro has already been used. Recovery: Change the name of the macro. ═══ 2.339. EDC0469 ═══ EDC0469 The static function '&1' is declared or defined but never referenced. A function that is defined but never used serves no purpose. Recovery: Remove the function definition. ═══ 2.340. EDC0470 ═══ EDC0470 Function 'main' should return int, not void. According to the ANSI/ISO standard, main should return int not void. Earlier standards (such as k&R) allowed a void return type for main. Recovery: Change the return type of the function. ═══ 2.341. EDC0471 ═══ EDC0471 Case label is not a member of enum type '&1' Case labels must be members of the type of the switch expression. Recovery: Change the value of the case label. ═══ 2.342. EDC0472 ═══ EDC0472 Statement is unreachable. The flow of execution causes this statement to never be reached. Recovery: Change the control flow in the program, or remove the unreachable statement. ═══ 2.343. EDC0473 ═══ EDC0473 An unintended semi-colon may have created an empty loop body. The loop body has no statements, and the conditional expression has no side effects. Recovery: If this is what was intended, use '{}' instead of a semi-colon as empty loop body to avoid this message. ═══ 2.344. EDC0474 ═══ EDC0474 Loop may be infinite. The value of the conditional expression and/or the lack of exit points may result in an infinite loop. Recovery: Adjust the conditional expression or add loop exit statements. ═══ 2.345. EDC0475 ═══ EDC0475 The real constant arithmetic expression folds to positive infinity. Constant folding results in an overflow. Recovery: Change the expression. ═══ 2.346. EDC0476 ═══ EDC0476 The real constant arithmetic expression folds to negative infinity. Constant folding results in an overflow. Recovery: Change the expression. ═══ 2.347. EDC0477 ═══ EDC0477 The real constant arithmetic expression folds to a NaN. Constant folding results in Not-a-Number (NaN). Recovery: Change the expression. ═══ 2.348. EDC0478 ═══ EDC0478 The then branch of conditional is an empty statement. If the condition is true, then no statement is executed. Recovery: Add a statement to be executed, or remove the condtional statement. ═══ 2.349. EDC0479 ═══ EDC0479 Both branches of conditional statement are empty statements. A conditional statement with empty branches is possibly degenerate. Recovery: Add code to the conditional branches. ═══ 2.350. EDC0480 ═══ EDC0480 Missing break statement allows fall-through to this case. The preceding case did not end with a break, return, or goto statement, allowing the path of execution to fall-through to the code in this case. Recovery: Add an appropriate terminating statement to the previous case, unless the fall-through was intentional. ═══ 2.351. EDC0481 ═══ EDC0481 The end of the function may be reached without returning a value. A return statement should be used to exit any function whose return type is non-void. Recovery: Add a return statement, or change the function to return void. ═══ 2.352. EDC0482 ═══ EDC0482 The opening brace before this point is redundant. The initialization expression contains extra, possibly unnecessary, braces. Recovery: Remove the extra braces. ═══ 2.353. EDC0483 ═══ EDC0483 Switch statement contains no cases or default. Code within a switch statement block that is not preceded by either 'default' or 'case' is never executed, and may be removed. Switch statements with neither 'default' or 'case' are probably incorrect. Recovery: Change the switch statement to include cases. ═══ 2.354. EDC0484 ═══ EDC0484 External name &1 has been truncated to &2. The external name exceeds the maximum length and has been truncated. This may result in unexpected behavior if two different names become the same after truncation. Recovery: Reduce the length of the external name. ═══ 2.355. EDC0485 ═══ EDC0485 Parameter declaration list is incompatible with declarator for &1. An attempt has been made to attach a parameter declaration list with a declarator which cannot have one. Recovery: Change declarator or remove parameter declaration list. ═══ 2.356. EDC0486 ═══ EDC0486 A pointer to an incomplete type cannot be indexed. An index has been used with a pointer to an incomplete type. Recovery: Declare the type that is pointed at or remove the index. ═══ 2.357. EDC0487 ═══ EDC0487 An argument cannot be an incomplete struct or union. An incomplete aggregate cannot be used as an argument to a function. Recovery: Declare the type that is pointed at or use a pointer to the aggregate. ═══ 2.358. EDC0488 ═══ EDC0488 A call to __parmdwords can only be made inside a function with _System calling convention. A call to __parmdwords has been made inside of a function that does not have _System calling convention. Recovery: Change the function so that it has _System calling convention or remove the call to __parmdwords. ═══ 2.359. EDC0489 ═══ EDC0489 The incomplete struct or union tag &1 was not completed before going out of scope. A struct or union tag was declared inside a parameter list or a function body, but no member declaration list was provided. Recovery: If the struct or union tag was declared inside a parameter list, provide a member declaration list at file scope. If the tag was declared inside a function body, provide a member declaration list within that function body. ═══ 2.360. EDC0490 ═══ EDC0490 The static variable '&1' is set but never referenced. A variable that is initialized but never used serves no purpose. Recovery: Remove the variable definition if you do not intend to use it. ═══ 2.361. EDC0491 ═══ EDC0491 The automatic variable '&1' is set but never referenced. A variable that is initialized but never used likely serves no purpose. Recovery: Remove the variable definition if you do not intend to use it. ═══ 2.362. EDC0492 ═══ EDC0492 Redefinition of &1 hides previous definition. The definition within the current scope hides a definition with the same name in an enclosing scope. Recovery: Change the name to avoid redefining it. ═══ 2.363. EDC0493 ═══ EDC0493 The external variable '&1' is defined but never referenced. A variable that is defined but never used likely serves no purpose. Recovery: Remove the variable definition, unless needed in another compilation unit. ═══ 2.364. EDC0494 ═══ EDC0494 The external variable '&1' is set but never referenced. A variable that is initialized but never used serves no purpose. Recovery: Remove the variable definition, unless needed in another compilation unit. ═══ 2.365. EDC0495 ═══ EDC0495 Pointer type conversion found. An attempt is being made to convert a pointer to one type to a pointer of another type. Recovery: Check the types of the values involved in the expression, and make them compatible. ═══ 2.366. EDC0496 ═══ EDC0496 Parameter(s) for #pragma &1 are of the wrong type. The parameter for the pragma is incorrect and of the wrong type. Recovery: Look up correct type in the C Language Reference. ═══ 2.367. EDC0497 ═══ EDC0497 Incomplete enum type not allowed. An incomplete enum is being used in a situation where a complete enum type is required. Recovery: Complete the type declaration. ═══ 2.368. EDC0498 ═══ EDC0498 Member of struct or union cannot be incomplete type. An incomplete aggregate is being used in a situation where a complete struct or union is required. Recovery: Complete the type declaration. ═══ 2.369. EDC0499 ═══ EDC0499 Function 'main' should return int. A return type other than int was specified for function main. Recovery: Change the return type to int. ═══ 3. EDC0500 - EDC0999 ═══ ═══ 3.1. EDC0500 ═══ EDC0500 Unexpected compiler error #&1&2 occurred. An error occurred that the compiler was not able to recover from. Recovery: Contact VisualAge C++ Service and Support. ═══ 3.2. EDC0501 ═══ EDC0501 Compilation aborted by user. Ctrl-Break or Ctrl-C was pressed to stop the compiler. Recovery: None. ═══ 3.3. EDC0502 ═══ EDC0502 Compilation terminated by external signal. OS/2 has killed the process in which the compiler was running. This might mean that OS/2 has run out of swap space. Recovery: If you intended to stop the process, no response is needed. If your process was killed because OS/2 ran out of swap space, free up space on the partition where SWAPPER.DAT resides, and perform the compilation again. ═══ 3.4. EDC0503 ═══ EDC0503 Option "&1" is not supported for &2. The option specified is not supported on this operating system. Recovery: Remove the option. ═══ 3.5. EDC0504 ═══ EDC0504 Illegal conversion between functions with 16-bit and 48-bit calling convention. A 16-bit function or function pointer cannot be cast to a 48-bit function pointer, and vice-versa. Recovery: Remove the conversion. ═══ 3.6. EDC0505 ═══ EDC0505 Type "&1" of identifier "&2" was incomplete at the end of its scope. A incomplete declaration was made of some identifier and it is still incomplete at the end of its scope. Recovery: Complete the declaration. ═══ 3.7. EDC0506 ═══ EDC0506 Address of automatic variable taken when DS may not be equal to SS. The address of an auto was taken when the current data segment may not be equal to the stack segment Recovery: Ensure that this will produce correct results. ═══ 3.8. EDC0507 ═══ EDC0507 No licenses available. Contact your program supplier to add additional users. Compilation will proceed shortly. Compilation has been temporarily suspended due to lack of available licenses. Compilation will restart when a license becomes available. Recovery: Wait until license becomes available. ═══ 3.9. EDC0508 ═══ EDC0508 Option &1 for #pragma &2 is not supported. For a list of all valid options for #pragma directives, see the C/C++ Language Reference. Recovery: Ensure the #pragma syntax and options are correct. ═══ 3.10. EDC0509 ═══ EDC0509 Symbol &1 on #pragma &2 was not found. For a list of all valid options for #pragma directives, see the C/C++ Language Reference. Recovery: Ensure the #pragma syntax and options are correct. ═══ 3.11. EDC0510 ═══ EDC0510 #pragma data_seg is ignored for object &1 because #pragma seg16 was specified A seg16 object is placed in a specific data segment. You cannot change the data segment name or give it different attributes. Recovery: Remove the conflicting #pragma data_seg for the object. ═══ 3.12. EDC0511 ═══ EDC0511 An object declared as compatible with 16-bit applications is larger than 64K. The /Gt compiler option or #pragma seg16 directive was used with a data object declared as larger than 64K. The object will cross 64K boundaries and is therefore not safe to use in 16-bit code. Recovery: Change the data object so that it is less than 64K in size, or remove the /Gt option and/or the #pragma seg16 directive. ═══ 3.13. EDC0512 ═══ EDC0512 An initializer is not allowed for "&1". An attempt was made to initialize an identifer whose type does not permit initialization. Recovery: Remove the initializer. ═══ 3.14. EDC0513 ═══ EDC0513 Array element designator exceeds the array dimension. Designator will be ignored. The value of the designator was larger than the dimension declared for the array object. Recovery: Change the expression forming the array index. ═══ 3.15. EDC0514 ═══ EDC0514 Array element designator cannot be applied to an object of type "&1". An array element designator can only be applied to an object of array type. Recovery: Remove subscript. ═══ 3.16. EDC0515 ═══ EDC0515 Member designator cannot be applied to an object of type "&1". A member designator can only be applied to an object of type struct or union. Recovery: Remove member designator. ═══ 3.17. EDC0516 ═══ EDC0516 The __loadds keyword can only be used with a function. The __loadds keyword can only be used in a function definition or function declaration. Recovery: Change declaration of object so that it is a function. ═══ 3.18. EDC0517 ═══ EDC0517 Option &1 for #pragma is not supported. For a list of all valid options for #pragma directives, see the C/C++ Language Reference. Recovery: Ensure the #pragma syntax and options are correct. ═══ 3.19. EDC0518 ═══ EDC0518 Option(s) for #pragma &1 are missing or incorrectly specified. #pragma &1 is not correctly specified. Recovery: Ensure the #pragma syntax and options are correct. ═══ 3.20. EDC0519 ═══ EDC0519 Index operator (э∙) cannot be applied to pointer to void. Index operator (э∙) can only be applied to arrays or pointers to objects. Recovery: Change the operand. ═══ 3.21. EDC0520 ═══ EDC0520 Switch block begins with declarations or unlabeled statements that are unreachable. Code within a switch block must be labeled with either 'case' or 'default' to be reachable. Recovery: Add a label or remove the unreachable code. ═══ 3.22. EDC0521 ═══ EDC0521 Pointer arithmetic can only be applied to a arrays that are lvalues. Because the array is compiler-generated, it is not an lvalue. Therefore, you cannot apply pointer arithmetic to it. Recovery: Change the expression. ═══ 3.23. EDC0522 ═══ EDC0522 Unable to open precompiled header &1 for output. The compiler was unable to open the precompiled header file. Recovery: Enusre that the compiler has write access to the precompiled header files. ═══ 3.24. EDC0523 ═══ EDC0523 Obsolete #pragma checkout ignored. Use #pragma info or the /W options. Recovery: #pragma checkout is not supported in this release. Use #pragma info or the /W options for similar diagnostic information. ═══ 3.25. EDC0524 ═══ EDC0524 The _Packed qualifier can only qualify a struct or union. The _Packed qualifier is only valid for structures and unions. Recovery: Remove _Packed qualifier. ═══ 3.26. EDC0525 ═══ EDC0525 The use of the _loadds keyword does not match the previous declaration of &1. If the _loadds keyword is used with a function, then it must be consistent in all prototypes and declarations. Recovery: Change the function declaration and/or prototype. ═══ 3.27. EDC0526 ═══ EDC0526 Calling convention specifier &1 incompatible with function taking variable number of parameters. Variable length parameter lists cannot be used when calling between 16 and 32 bit functions. This is a permanent restriction. Recovery: Change the calling convention protocol specification or change the declaration to be a function with a fixed number of parameters. ═══ 3.28. EDC0527 ═══ EDC0527 Header &1 included again because it is never empty. The referenced header file has already been #included and will be physically #included again because there is no conditional compilation path in it which results in an empty file. Recovery: If desired, at the top of the header, test a macro name which is defined by the header to prevent subequent inclusions. ═══ 3.29. EDC0528 ═══ EDC0528 Header &1 not included again because it is empty. The referenced header file has already been #included. Because it is empty, it will not be #included again. Recovery: If desired, do not #include the header because it is empty. ═══ 3.30. EDC0529 ═══ EDC0529 Header &1 included again because conditional compilation analysis is incomplete. The referenced header file has already been #included. It wiill be physically #included again because the inclusion is recursive and the conditional compilation analysis of the header is incomplete. Recovery: If desired, test a macro name which is defined by the header at the point of inclustion to prevent subequent inclusions. ═══ 3.31. EDC0530 ═══ EDC0530 Header &1 not included again because it would have no effect due to conditional compilation. The referenced header file has already been #included and will not be physically #included again because conditional compilation would expose no additional source to the compiler. Recovery: If desired, do not #include the header because it is redundant. ═══ 3.32. EDC0531 ═══ EDC0531 End of precompiled header processing. The compiler has finished processing a precompiled header. Recovery: No response required. This message merely traces the activity of the precompiled header processing. ═══ 3.33. EDC0532 ═══ EDC0532 Macro "&1" is required by the precompiled header and is defined differently than when the precompiled header was created. The referenced macro was expanded during the creation of the precompiled header and is now defined differently. This prevents the precompiled header from being used for this compilation. Recovery: If necessary, redefine the macro, or regenerate the precompiled header using the new macro definition. ═══ 3.34. EDC0533 ═══ EDC0533 One or more assertions are defined that were not defined when the precompiled header was created. An assertion is defined that was not defined when the precompiled header was generated. Because the effect of the new assertion is unknown, the precompiled header cannot be used for this compilation. Recovery: Do not define the assertion, or regenerate the precompiled header with the new assertion. ═══ 3.35. EDC0534 ═══ EDC0534 One or more macros are defined that were not defined when the precompiled header was created. A macro is defined that was not defined when the precompiled header was generated. Because the effect of the new macro is unknown, the precompiled header cannot be used for this compilation. Recovery: Do not define the macro or regenerate the precompiled header with the new macro. ═══ 3.36. EDC0535 ═══ EDC0535 Compiler options do not match those in effect when the precompiled header was created. The compiler options in use are not compatible with those used when the precompiled header was generated. The precompiled header cannot be used. Recovery: Use the same options as when the precompiled header was generated or regenerate the precompiled header with the new options. ═══ 3.37. EDC0536 ═══ EDC0536 Assertion "&1" is required by the precompiled header and is not defined. The referenced assertion was tested during the creation of the precompiled header and is not defined. This prevents the precompiled header from being used for this compilation. Recovery: If necessary, redefine the assertion, or regenerate the precompiled header without the assertion. ═══ 3.38. EDC0537 ═══ EDC0537 Macro "&1" is required by the precompiled header and is not defined. The referenced macro was expanded during the creation of the precompiled header and is not defined. This prevents the precompiled header from being used for this compilation. Recovery: If necessary, redefine the macro, or regenerate the precompiled header without the macro. ═══ 3.39. EDC0538 ═══ EDC0538 Unable to use precompiled header &1. The precompiled header cannot be used for this compilation. A subsequent message will explain the reason. Recovery: Correct the problem indicated by the subsequent message. ═══ 3.40. EDC0539 ═══ EDC0539 Expecting &1 and found &2. The header file being included is not the next header in the sequence used to generate the precompiled header. The precompiled header cannot be used for this compilation. Recovery: #include the correct header or regenerate the precompiled header using the new sequence of #include directives. ═══ 3.41. EDC0540 ═══ EDC0540 The weak function specified in #pragma weak should not be defined or referenced in this compilation unit. The weak function specified in #pragma weak should only be defined externally and should not be referenced in this compilation unit. Recovery: Split the function definition and the function reference into a separate compilation unit. ═══ 3.42. EDC0541 ═══ EDC0541 Precompiled header file cannot be generated because a declaration was not complete when the last header file ended. A declaration may not begin in a header file and end in the main program file. No precompiled header file is generated. Recovery: Complete the declaration before the end of the header file. ═══ 3.43. EDC0601 ═══ EDC0601 Definition of "&1" is not allowed. ═══ 3.44. EDC0602 ═══ EDC0602 Identifier "&1" is not a class name. ═══ 3.45. EDC0603 ═══ EDC0603 "&1" must be a class member. Conversion functions and certain operator functions must be class members. They cannot be defined globally. Recovery: Remove the global definition or make "&1" a class member. ═══ 3.46. EDC0604 ═══ EDC0604 Storage class "&1" is not allowed for member functions. ═══ 3.47. EDC0605 ═══ EDC0605 Declaration of "&1" must be a function definition. A declaration of a member function outside its member list must be a function definition. A method of a class that has already been declared inside a class declaration cannot be redeclared outside the class. Recovery: Either remove the member function declaration outside the member list or change it to a definition. ═══ 3.48. EDC0606 ═══ EDC0606 "&1" has the same name as its containing class. A class contained within another class cannot have the same name. Recovery: Rename one of the classes. ═══ 3.49. EDC0607 ═══ EDC0607 "&1" is not allowed for a constructor. An invalid keyword was used in the declaration of a constructor. Qualifiers such as const and volatile are not allowed, nor are storage class keywords. Recovery: Remove the offending keyword. ═══ 3.50. EDC0608 ═══ EDC0608 The "this" keyword is only valid in class scope. An attempt to use the C++ keyword "this" was detected outside class scope. The keyword "this" cannot be used outside a class member function body. Recovery: Remove or move the "this" keyword. ═══ 3.51. EDC0609 ═══ EDC0609 The type of "reference" cannot be "&1". ═══ 3.52. EDC0610 ═══ EDC0610 "&1" is not allowed as an array element type. ═══ 3.53. EDC0611 ═══ EDC0611 The type of "pointer" cannot be "&1". ═══ 3.54. EDC0612 ═══ EDC0612 The reference variable "&1" is uninitialized. ═══ 3.55. EDC0613 ═══ EDC0613 Duplicate function specifier "&1" ignored. ═══ 3.56. EDC0614 ═══ EDC0614 "&1" conflicts with "&2". ═══ 3.57. EDC0615 ═══ EDC0615 Keyword "&1" is not allowed. ═══ 3.58. EDC0616 ═══ EDC0616 "&1" must already be declared. ═══ 3.59. EDC0617 ═══ EDC0617 "&1" was previously declared as "&2". ═══ 3.60. EDC0618 ═══ EDC0618 "&1" is not allowed. ═══ 3.61. EDC0619 ═══ EDC0619 The arguments passed using the ellipsis may not be accessible. ═══ 3.62. EDC0620 ═══ EDC0620 "&1" is only valid for non-static member functions. "const" and "volatile" are only significant for non-static member functions because they are applied to the "this" pointer. Recovery: Remove the "const" or "volatile" keyword. ═══ 3.63. EDC0621 ═══ EDC0621 Ellipsis (...) cannot be used for "&1". Recovery: Remove the ellipsis. ═══ 3.64. EDC0622 ═══ EDC0622 Wrong number of parameters for "&1". The operator cannot be declared with the given number of parameters. Recovery: Use the correct number of parameters. ═══ 3.65. EDC0623 ═══ EDC0623 At least one parameter of "&1" must accept class or enum type. The non-member operator function must have at least one argument which is of class or enum type. Recovery: Add a parameter or change a parameter to accept class or enum type. ═══ 3.66. EDC0624 ═══ EDC0624 Ambiguous reference to "&1". A reference of a member of a class was ambiguous, because it was found in more than one base class. ═══ 3.67. EDC0625 ═══ EDC0625 "&1" was declared in base class "&2". ═══ 3.68. EDC0626 ═══ EDC0626 Non-static member "&1" must be associated with an object or a pointer to an object. The compiler detected a non-static member that makes reference to a specific object that has not been instantiated. Only static members can be referenced without associating them with an instance of the containing class. Recovery: Check the spelling and the class definition. Change the name of the class or function, or define the function as static in that class. ═══ 3.69. EDC0627 ═══ EDC0627 extern "&1" is not a recognized linkage; extern "C" is assumed. The linkage string in a linkage declaration is not one of the linkages supported by this compiler. Recovery: Change the linkage string to a valid value or make it "C". ═══ 3.70. EDC0628 ═══ EDC0628 Linkage for "&1" cannot be redefined. The specified name has already been declared with a different linkage than the current declaration. Recovery: Remove the redefinition or change one of the names. ═══ 3.71. EDC0629 ═══ EDC0629 More than one function "&1" has non-C++ linkage. If a function is overloaded, at most one of its variants can have non-C++ linkage. Recovery: Remove one of the non-C++ linkages or do not overload the function. ═══ 3.72. EDC0630 ═══ EDC0630 The previous declaration of "&1" did not have a linkage specification. A function declaration without a linkage specification must not precede the first linkage specification for that function. Recovery: Add a linkage specification to the first declaration of the function ═══ 3.73. EDC0631 ═══ EDC0631 "catch(&1)" will never be reached because of previous "catch(&2)". The catch clause can never be reached because any exception type that matches it will also be matched by the specified previous catch clause. Recovery: Change or remove one of the catch clauses. ═══ 3.74. EDC0632 ═══ EDC0632 Call does not match any argument list for "&1". No variant of the overloaded function matches the argument list on the call any better than all other variants. The argument mismatch could be by type or by the number of arguments. Recovery: Change the argument list on the call to the overloaded function or change the argument list on one of the overloaded function variants so that a match is found. ═══ 3.75. EDC0633 ═══ EDC0633 Call to "&1" matches more than one function. More than one variant of the overloaded function matches equally well with the argument list specified on the call. Recovery: Change the argument list on the call to the overloaded function or change the argument list on one of the overloaded function variants so that one match is found. ═══ 3.76. EDC0634 ═══ EDC0634 Call matches "&1". The compiler detected an overloaded function or operator that is similar to another and is providing additional information. Recovery: Ensure this is the desired match. ═══ 3.77. EDC0635 ═══ EDC0635 Ambiguous conversion from class "&1". There is more than one possible conversion from the specified class. Recovery: Use a cast to select the desired conversion. ═══ 3.78. EDC0636 ═══ EDC0636 Return type may not be specified for a type conversion operator. The return type of a type conversion operator is implicitly the same as the type to which it converts. A return type is never needed for type conversion operators. Recovery: Remove the return type specification. ═══ 3.79. EDC0637 ═══ EDC0637 "&1" may not be specified for a type conversion operator. The const/volatile qualification of the type to which the conversion operator returns is implicit in the declaration of the conversion operator. All const/volatile qualifiers must appear after the keyword "operator". Recovery: Remove the qualifier. ═══ 3.80. EDC0638 ═══ EDC0638 Parameter &1 for "&2" must be of type "&3". For this type of function, the specified argument must be of the specified type. Recovery: Ensure that the argument is of the correct type. ═══ 3.81. EDC0639 ═══ EDC0639 Return type for "&1" must be "&2". For this type of function, the return type must be of the specified type. Recovery: Ensure that the return type is of the correct type. ═══ 3.82. EDC0640 ═══ EDC0640 "&1" is not allowed as a conversion function type. A conversion function cannot be declared to convert to the specified type because the type cannot be returned from the function. Recovery: Change the conversion operator's type to a permitted type. ═══ 3.83. EDC0641 ═══ EDC0641 The "operator->" function must return either a class type, a reference to a class type or a pointer to class type and the class type must itself have an "operator->" function. Recovery: Change the return value of the "operator" function. ═══ 3.84. EDC0642 ═══ EDC0642 The return type for the "operator->" cannot be the containing class. Recovery: Change the return type for the "operator->". ═══ 3.85. EDC0643 ═══ EDC0643 Class qualification for "&1" is not allowed. Recovery: Remove the qualification. ═══ 3.86. EDC0644 ═══ EDC0644 "&1" is neither an immediate base class nor a non-static data member of class "&2". ═══ 3.87. EDC0645 ═══ EDC0645 "&1" cannot be initialized multiple times. ═══ 3.88. EDC0646 ═══ EDC0646 There are too many initializers in the initializer list. ═══ 3.89. EDC0647 ═══ EDC0647 The const member "&1" must be initialized in the constructor's initializer list. ═══ 3.90. EDC0648 ═══ EDC0648 The reference member "&1" must be initialized in the constructor's initializer list. ═══ 3.91. EDC0649 ═══ EDC0649 A namespace alias may not be used to extend a namespace. ═══ 3.92. EDC0650 ═══ EDC0650 "&1" is not a namespace or namespace alias. ═══ 3.93. EDC0651 ═══ EDC0651 "&1" operator is not allowed for type "&2". The specified operator cannot be used with operands of this type. Recovery: Change either the operator or the operands. ═══ 3.94. EDC0652 ═══ EDC0652 Expecting struct or class. The left-hand operand of the (.*) operator must have type "structure" or "class". Recovery: Change either the operator or the operands. ═══ 3.95. EDC0653 ═══ EDC0653 Expecting pointer to struct or class. The left-hand operand of the (->*) operator must have type "pointer to structure" or "pointer to class". Recovery: Change either the operator or the operands. ═══ 3.96. EDC0654 ═══ EDC0654 Expecting pointer to member. The right-hand operand of the (.*) and (->*) operator must have type "pointer to member". Recovery: Change either the operator or the operands. ═══ 3.97. EDC0655 ═══ EDC0655 Namespace "&1" was not defined within the scope of namespace "&2". ═══ 3.98. EDC0656 ═══ EDC0656 Pointer to member "&2" cannot bind to "&1". The right-hand operand must be of type "pointer to member of T", the left hand operand must be of class T or of a class of which T is an unambiguous and accessible base class. Recovery: Change either the operator or the operands. ═══ 3.99. EDC0657 ═══ EDC0657 Using declaration cannot declare class member "&1" in a non class scope. ═══ 3.100. EDC0658 ═══ EDC0658 A declaration has been made without a type specification. The compiler detected a typedef specification that did not have a type associated with it. Recovery: Add a type specification to the declaration. ═══ 3.101. EDC0659 ═══ EDC0659 "&1" is not a base class of "&2". A derived class can only access elements of its base class or base classes. Recovery: Ensure the class names are correct and the classes are derived properly. ═══ 3.102. EDC0660 ═══ EDC0660 Default initializers cannot be followed by uninitialized arguments. If default initializers are specified in an argument list, there must be default initializers for all later arguments. Recovery: Remove the default initializers, or provide them for all later arguments, or move the arguments to the end of the list. ═══ 3.103. EDC0661 ═══ EDC0661 Declarations of the same &1 must not specify default initializers for the same argument. The compiler has detected an overloaded function or template that was declared with the same argument having default initializers. Recovery: Ensure that you wanted to declare the same function or template. If that is the case, remove one of the default initializers. Otherwise, remove one of the declarations or overload the function. ═══ 3.104. EDC0662 ═══ EDC0662 Local variable "&1" is inaccessible from "&2". An automatic variable within a function is not accessible from local classes declared within the function. Recovery: Remove the reference to the local variable. ═══ 3.105. EDC0663 ═══ EDC0663 Ambiguous reference to "&1" Recovery: Change one of the names, or always fully qualify the name. ═══ 3.106. EDC0664 ═══ EDC0664 A virtual function initializer must be 0. Recovery: Set the virtual function initializer to 0. ═══ 3.107. EDC0665 ═══ EDC0665 "&1" is not declared at namespace scope. ═══ 3.108. EDC0666 ═══ EDC0666 Enumeration type clash with the "&1" operator. Operands from two different enumerations are used in an operation. Recovery: Ensure both operands are from the same enumeration. ═══ 3.109. EDC0667 ═══ EDC0667 "&1" has been used more than once in the same base class list. A base class may only be specified once in the base class list for a derived class. Recovery: Remove one of the specifications. ═══ 3.110. EDC0668 ═══ EDC0668 Variable "&1" is not allowed in an argument initializer. The compiler has detected an illegal variable in an argument initializer. Recovery: Remove the variable from the argument initializer. ═══ 3.111. EDC0669 ═══ EDC0669 Wrong number of arguments for "&1". Either a function or an explicit cast has been specified with the wrong number of arguments. Recovery: Use the correct number of arguments. Ensure that overloaded functions have the correct number and type of arguments. ═══ 3.112. EDC0670 ═══ EDC0670 The type of "pointer to member" cannot be "&1". ═══ 3.113. EDC0671 ═══ EDC0671 The header file name in the #include directive cannot be empty. Recovery: Specify a non-empty header file name in the #include directive. ═══ 3.114. EDC0672 ═══ EDC0672 The number of errors has reached the limit of &1. The number of errors has reached the number specified on the /N option. Recovery: Fix the errors or increase the error limit on the /N option. ═══ 3.115. EDC0673 ═══ EDC0673 Template has too many arguments. ═══ 3.116. EDC0674 ═══ EDC0674 Template parameter &1 expects a type argument. ═══ 4. EDC1000 - EDC1499 ═══ ═══ 4.1. EDC1001 ═══ EDC1001 Internal error &1 : &2 : &3. An error ocurred during compilation. Recovery: Contact your IBM C Set ++ Service and Support. ═══ 4.2. EDC1002 ═══ EDC1002 Response file &1 not found. The response file doess not exist, was not in the search path, or its name was typed incorrectly. Recovery: Check read access for the response file. ═══ 4.3. EDC1003 ═══ EDC1003 Option &1 followed by &2 is ignored. The option was ignored because its parameter was not valid. You can specify the option with a plus (+), minus (-), or without parameters (equivalent to specifying +). Recovery: Specify the option followed by a + or -, or specify the option without a parameter. ═══ 4.4. EDC1004 ═══ EDC1004 Option "/&1" is not recognized. The option specified does not exist or was typed incorrectly. Recovery: Remove or correct the option. ═══ 4.5. EDC1005 ═══ EDC1005 Option /&1 needs suboption string. A string is required following this option. Recovery: Add the string to be defined or undefined following the option. ═══ 4.6. EDC1006 ═══ EDC1006 Macro &1 used in /D option has a bad character &2. Macro names must begin with an alphabetic character or an underscore. Recovery: Correct the macro name. ═══ 4.7. EDC1008 ═══ EDC1008 Error &1 &2 in searching for &3. The executable was not found in the specified path, the current directory, or the PATH environment variable. Recovery: Ensure the executable is in the path specified in the PATH environment variable, the current directory, or the path specified in the command-line. ═══ 4.8. EDC1009 ═══ EDC1009 Missing terminating " in &1. This option requires a terminating quotation mark (") for the string. Recovery: Add the missing quote to the end of the string. ═══ 4.9. EDC1010 ═══ EDC1010 Bad or non-existent path or file name encountered in option /&1. The path or file name specified in option /&1 cannot be found. Recovery: Correct the path or file name. ═══ 4.10. EDC1011 ═══ EDC1011 Bad number &1 has been ignored in option /&2. The (indicated) option requires a valid integer. Recovery: Change the number to a valid integer. ═══ 4.11. EDC1012 ═══ EDC1012 Rest of the command line after /? is not processed. The /? option displays help for options. It cannot be mixed with other options. Anything on the command line after this option is ignored, and the option itself does not take effect. Recovery: Specify /? on its own, or remove it from the command line. ═══ 4.12. EDC1013 ═══ EDC1013 /? is processed only as the first option on the command line. The /? option displays help for options. It cannot be mixed with other options. Unless you specify it as the first option, it does not take effect. Any options after it are ignored. Recovery: Specify /? on its own, or remove it from the command line. ═══ 4.13. EDC1014 ═══ EDC1014 Suboption &1 of /&2 is out of range. The specified value of the suboption is not within the range of valid values. Recovery: Specify a valid value, or remove the suboption. ═══ 4.14. EDC1015 ═══ EDC1015 /Q is processed only if used before any file name or response file name. If you specify /Q after you have specified a filename, the option is ignored. Recovery: Specify /Q before any filename or response filename. ═══ 4.15. EDC1016 ═══ EDC1016 Option /&1 does not apply to C source programs. The (indicated) option is only valid for compiling C++ programs. It is ignored when you compile C programs. Recovery: Remove the option. ═══ 4.16. EDC1017 ═══ EDC1017 Option /&1 does not apply to C++ source programs. Option /&1 is only valid for compiling C programs. It is ignored when you compile C++ programs. Recovery: Remove the option. ═══ 4.17. EDC1018 ═══ EDC1018 Option /&1 ignored because option /&2 specified. One option, which is either specified on the compilation command line or is a default option, is causing another command-line option to have no effect. You cannot have both options in effect at the same time. Recovery: Change or remove one of the two options. ═══ 4.18. EDC1019 ═══ EDC1019 Incorrect escape sequence &1. \ ignored. An escape sequence that is not valid has been encountered in a string literal or a character literal. It is replaced by the character following the backslash (\). Recovery: Change or remove the escape sequence. ═══ 4.19. EDC1020 ═══ EDC1020 Excess text &1 ignored on /&2 option. The text for the specified option is not valid. Recovery: Remove excess text. ═══ 4.20. EDC1021 ═══ EDC1021 Compilation aborted by user. Ctrl-Break or Ctrl-C was pressed to stop the compiler. Recovery: Correct the situation that required you to abort the compile, and recompile. ═══ 4.21. EDC1022 ═══ EDC1022 Unable to open or read response file &1. The compiler could not open or read the response file. Recovery: Check that the compiler has read access to the file. ═══ 4.22. EDC1023 ═══ EDC1023 Unable to find source file &1. The source file does not exist or the name was typed incorrectly. Recovery: Check that the file exists in the directory/path specified. ═══ 4.23. EDC1024 ═══ EDC1024 Option /&1 requires that option /&2 be specified. The second option must be specified for the first option to have effect. Recovery: Specify the second option, or remove the first. ═══ 4.24. EDC1025 ═══ EDC1025 All /K options are obsolete. Use equivalent /Wgrp options instead. Refer to the User's Guide for information on /Wgrp options. Recovery: Remove /K options. ═══ 4.25. EDC1026 ═══ EDC1026 Option /&1 is no longer global, and was not applied to files that preceded it on the command line. This option now applies only to files specified after it on the command line. Recovery: Make sure you specify the option before the files you want it to apply to. ═══ 4.26. EDC1027 ═══ EDC1027 A module definition (.DEF) file must be specified to create a DLL. You specified the /Ge- option to create a DLL, but did not provide a .DEF file for the linker. Recovery: Provide a module definition (.DEF) file, and specify it on the command line, in the ICC environment variable, or in WorkFrame/2. ═══ 4.27. EDC1028 ═══ EDC1028 Missing source or object file. No source or object file was specified. You must specify at least one source or object file. Recovery: Specify a source or object file. ═══ 4.28. EDC1029 ═══ EDC1029 The &1 option has not been completely specified. The indicated option was missing a parameter or suboption. Recovery: Complete or remove the option. ═══ 4.29. EDC1030 ═══ EDC1030 Unable to execute &1. Recovery: Ensure the compiler executable file is in the current directory or is specified in your PATH, and that there is enough memory available. ═══ 5. EDC1500 - EDC1999 ═══ ═══ 5.1. EDC1500 ═══ EDC1500 Unexpected compiler error #&1&2 occurred. An error occurred that the compiler was not able to recover from. Recovery: Contact your IBM C Set ++ Service and Support. ═══ 5.2. EDC1501 ═══ EDC1501 Compilation aborted by user. Ctrl-Break or Ctrl-C was pressed to stop the compiler. Recovery: Correct the situation that required you to abort the compile, and recompile. ═══ 5.3. EDC1502 ═══ EDC1502 Compilation terminated by external signal. OS/2 has killed the process in which the compiler was running. This might mean that OS/2 has run out of swap space. Recovery: If you intended to have the process killed, there is no recovery needed. If your process was killed because OS/2 ran out of swap space, free up space on the partition where SWAPPER.DAT resides, and perform the compilation again. ═══ 5.4. EDC1503 ═══ EDC1503 Option "/&1" is not support on target platform. Recovery: Remove or correct the option. ═══ 6. EDC3000 - EDC3499 ═══ ═══ 6.1. EDC3000 ═══ EDC3000 Message file version 1.334.1.10. warning : The message file DDE45.MSG is out of date (version &1 expected). The message file found is not the correct version for the compiler being invoked. The compiler requires a specific version of the message file DDE45.MSG in the help directory to display messages. Recovery: Check the DPATH environment variable and/or update the message file. If you have copied over the files in the the \ibmcpp\help or the \ibmcpp\bin directories, then the message files may be out of date. Or get the updated messages files from the CSD installed. ═══ 6.2. EDC3001 ═══ EDC3001 "private" assumed for base class "&1". No access specifier has been provided for a base class. A base class can be declared with the access specifier "public" or "private". The C++ language specification requires that "private" becomes the default when no access specifier is present. It is good coding practice to explicitly provide the access specifier for the base class. Recovery: Provide an access specifier or accept the default. ═══ 6.3. EDC3002 ═══ EDC3002 "&1" is not used in function "&2". The specified symbol has been declared within a function but it has not been set or used. This is only an informational message because you can declare symbols that are not unused, but it is probably undesirable. Recovery: Ignore the message, use the symbol, or remove the symbol. ═══ 6.4. EDC3003 ═══ EDC3003 Ambiguous conversion between "&1" and "&2". The compiler was not able to find a single type common to the two specified types and was therefore unable to convert from one to the other. Recovery: Explicitly cast the type to an intermediate type and then convert to requested type. ═══ 6.5. EDC3004 ═══ EDC3004 "&1" statement is not allowed in this scope. The specified statement was found outside the valid scope for such a statement. This typically means that it is outside any function. Recovery: Place the statement in the correct scope or remove it. ═══ 6.6. EDC3005 ═══ EDC3005 Duplicate "default" statement in switch. Only one "default" label is allowed in a "switch" statement. This "default" label is not the first in the switch statement. Recovery: If you have nested switch statements, check that the braces match correctly. If they do not match, remove one of the "default" labels. ═══ 6.7. EDC3006 ═══ EDC3006 Duplicate definition of label "&1". The specified label has already been defined in the current function. A label can only be declared once within a function. Recovery: Remove or rename one of the label definitions. ═══ 6.8. EDC3007 ═══ EDC3007 The "#line" macro directive may cause information for the browser to be corrupted. The compiler generates information for the class browser. Using the "#line" preprocessor directive may cause that information to be corrupted. Recovery: Remove the "#line" macro directive or note the possible corruption. ═══ 6.9. EDC3008 ═══ EDC3008 Source file &1 cannot be opened. The compiler could not open the specified source file. Recovery: Ensure the source file name is correct. Ensure that the correct file is being read and has not been corrupted. If the file is located on a LAN drive, ensure the LAN is working properly. Also, the file may be locked by another process or access may be denied because of insufficient permission. ═══ 6.10. EDC3009 ═══ EDC3009 An error occurred while reading file "&1". The compiler detected an error while reading from the specified file. Recovery: Ensure the correct file is being read. If the file resides on a LAN drive, ensure that the LAN is working correctly. ═══ 6.11. EDC3010 ═══ EDC3010 Source file name is missing. The name of the source file to be compiled was missing from the compiler invocation. Recovery: Ensure that you specify the source file name. Ensure the compiler options are specified correctly as well; the compiler may misinterpret the command line if the options are specified incorrectly. ═══ 6.12. EDC3011 ═══ EDC3011 "&1" is unmatched at end of file. The end of the source file was reached and the comment or block was not closed. It is also possible that there was a typographical error earlier in the source file. Recovery: Check the source file for typographical errors. End the comment or block before the end of the file. ═══ 6.13. EDC3012 ═══ EDC3012 A return value is not allowed for this function. A function with a return type of "void" cannot return a value. Recovery: Remove the value or expression from the return statement, remove the return statement, or change the return type of the function. ═══ 6.14. EDC3013 ═══ EDC3013 Identifier "&1" is undefined. The specified identifier is used but has not been defined. Recovery: Define the identifier before using it. Check its spelling. If the identifier has been defined in a header file, check that any required macros have been defined. ═══ 6.15. EDC3014 ═══ EDC3014 Wrong number of arguments for macro "&1". The specified macro was defined with a different number of arguments than are used in this macro call. Recovery: Ensure that the macro call corresponds to the macro definition. Check the number and levels of corresponding braces in the macro. ═══ 6.16. EDC3015 ═══ EDC3015 The compiler could not open the output file "&1". Recovery: Ensure the output file name is correct. Also, ensure that the location of the output file has sufficient storage available. If using a LAN drive, ensure that the LAN is working properly and you have permission to write to the disk. ═══ 6.17. EDC3016 ═══ EDC3016 &1 member "&2" cannot be accessed. The specified member is private, protected, or is a member of a private base class and cannot be accessed from the current scope. Recovery: Check the access specification rules for the member function and change the access specifier if necessary. If the member function belongs to a base class, check the access specifier of the base class where the current class is defined. ═══ 6.18. EDC3017 ═══ EDC3017 Return value of type "&1" is expected. No value is returned from the current function, but the function is expecting a non-void return value. The function was declared with a return type but the compiler did not detect a return statement. Only functions with a void return type may have no return statement or have a return statement with no return value. Recovery: Return a value from the function or change the functions's return type to void. ═══ 6.19. EDC3018 ═══ EDC3018 "&1" cannot be made a &2 member. An attempt is made to give private access to a base class member or to give an access that is different from the access the member was declared with. A derived class can only change the access of a base class member to public or protected if the access of that member was not private in the base class. Recovery: Remove the invalid access statement or change the access specifier in the base class. ═══ 6.20. EDC3019 ═══ EDC3019 Case expression is not an integral constant expression. The expression in a "case" statement must be an integral constant expression followed by a colon (:). A constant expression has a value that can be determined during compilation and does not change during execution. Recovery: Use an integral constant expression. ═══ 6.21. EDC3020 ═══ EDC3020 "asm" keyword declaration is not supported. The compiler does not support "asm" declarations. The declaration is ignored. Recovery: Remove the "asm" keyword. ═══ 6.22. EDC3021 ═══ EDC3021 Expected "end of line" and found "&1" in preprocessor directive. The compiler detected a preprocessor directive at the beginning of this line, then found an error in the directive. The rest of the line in the preprocessor directive is ignored. Recovery: Remove the unexpected token so that only the preprocessor directive appears on the line. ═══ 6.23. EDC3022 ═══ EDC3022 "&1" was previously declared as "&2". The declaration conflicts with a previous declaration of the same name. Recovery: Change one of the names or eliminate one of the declarations. ═══ 6.24. EDC3023 ═══ EDC3023 "&1" has already been defined. An attempt is being made to define a name that has already been defined. Recovery: Change one of the names or remove one of the definitions. Check the spelling and the scope of the two variables. ═══ 6.25. EDC3024 ═══ EDC3024 Declaration of "&1" must be a function definition. A declaration of a member function outside its member list must be a function definition. Once you declare a member function inside a class declaration, you cannot redeclare it outside the class. Recovery: Either remove the member function declaration outside the member list or change it to a definition. ═══ 6.26. EDC3025 ═══ EDC3025 "&1" conflicts with "&2". These two attributes cannot both be specified in the same declaration. Recovery: Remove one of the specified attributes. ═══ 6.27. EDC3026 ═══ EDC3026 Keyword "&1" is not allowed. The specified keyword is not allowed in this context. Recovery: Remove the keyword. ═══ 6.28. EDC3027 ═══ EDC3027 Preprocessor directive "#&1" is not recognized. The compiler identified a # character at the start of a line and did not recognize the preprocessor directive following it. Recovery: Check the spelling of the preprocessor directive. ═══ 6.29. EDC3028 ═══ EDC3028 The syntax of the file name in the "#include" directive is not valid. The compiler detected an #include preprocessor directive but could not parse the file name. The file name in the #include directive must be within double quotation marks ("") or angle brackets (<>). Recovery: Correct the syntax of the file name. ═══ 6.30. EDC3029 ═══ EDC3029 Expected integer line number and found "&1". The operand of the "#line" directive must be an integer line number. Recovery: Ensure that the "#line" directive contains an integer line number operand. ═══ 6.31. EDC3030 ═══ EDC3030 The macro "&1" has already been defined. An active definition already exists for the macro name being defined. The second definition will be ignored. Recovery: Remove or rename one of the macro definitions. ═══ 6.32. EDC3032 ═══ EDC3032 Unexpected preprocessor directive "#&1". An "#else", "#elif" or "#endif" preprocessor directive was found out of context. Recovery: Remove or move the preprocessor directive. Check nesting of #if, #else, #elif, and #endif. ═══ 6.33. EDC3033 ═══ EDC3033 The for-init-statement must be a declaration or expression. The initializer statement within a "for" statement must be a declaration or expression. Recovery: Change the for-init-statement to a declaration or an expression. ═══ 6.34. EDC3034 ═══ EDC3034 "&1" has a function body but is not a function. The name is not declared as a function; there may be parentheses missing after the function name. Recovery: Correct the declaration. ═══ 6.35. EDC3035 ═══ EDC3035 The array boundary in "&1" is missing. An array must be defined with at least one element. Use a pointer if you want to dynamically allocate memory for the array. Recovery: Add an array bound. ═══ 6.36. EDC3036 ═══ EDC3036 The bit-field length must be an integral constant expression. The bit-field length, which is the value to the right of the colon, must be an integer. A constant expression has a value that can be determined during compilation and does not change during execution. Recovery: Change the bit-field length to an integral constant expression. ═══ 6.37. EDC3037 ═══ EDC3037 "&1" is not a base class of "&2". A derived class attempted to access elements of a class it did not inherit from. A derived class can only access elements of its base class or base classes. Recovery: Ensure the class names are correct and the classes are derived properly. ═══ 6.38. EDC3038 ═══ EDC3038 The array bound must be a positive integral constant expression. The compiler detected an array declaration that did not have a constant that is greater than 0 for the array bounds. Use pointers if you want to dynamically allocate storage for arrays. Recovery: Change the array bound to an integral constant expression or change it to a pointer. A constant expression has a value that can be determined during compilation and does not change during execution. ═══ 6.39. EDC3039 ═══ EDC3039 "&1" has the same name as its containing class. The compiler has detected conflicting names for objects within a class declaration. Nested class declarations must have different names. Recovery: Change the name of the conflicting class. ═══ 6.40. EDC3040 ═══ EDC3040 A destructor can only be used in a function declaration or in a function call. The compiler has detected an incorrect destructor call. Recovery: Check the call to the destructor to ensure no braces are missing. If the braces are correct, remove the destructor call. ═══ 6.41. EDC3041 ═══ EDC3041 An initializer is not allowed for "&1". The compiler detected an initializer where one is not permitted. For example, a class member declarator cannot contain an initializer. Recovery: Remove the initializer. ═══ 6.42. EDC3042 ═══ EDC3042 Function "&1" is nested within another function. You cannot nest functions in C++. Recovery: Ensure that a "}" is not missing before the start of the function. Remove the nested function. ═══ 6.43. EDC3043 ═══ EDC3043 The string must be terminated before the end of the line. The compiler detected a string that was not terminated before an end-of-line character was found. Recovery: End the string before the end of the line, or use "\" to continue the string on the next line. The "\" must be the last character on the line. ═══ 6.44. EDC3044 ═══ EDC3044 extern "&1" is not a recognized linkage; extern "C" is assumed. The linkage string in a linkage declaration is not one of the linkages supported by this compiler. Recovery: Change the linkage string to a valid value. ═══ 6.45. EDC3045 ═══ EDC3045 Syntax error in directive - expected "&1" and found "&2". A syntax error was found during preprocessing. The message identifies what the compiler expected and what it actually found. Recovery: Correct the syntax. ═══ 6.46. EDC3047 ═══ EDC3047 An expression of type "&1" cannot be followed by the function call operator (). The compiler detected an expression followed by the function call operator. The expression must be of type function, pointer to function, or reference to function. Recovery: Change the type of expression or remove the function call operator. ═══ 6.47. EDC3048 ═══ EDC3048 The "this" keyword is only valid in class scope. An attempt to use the C++ keyword "this" was detected outside class scope. The keyword "this" cannot be used outside a class member function body. Recovery: Remove or move the "this" keyword. ═══ 6.48. EDC3049 ═══ EDC3049 The option "&1" is not supported. The command line contained an option that is not supported. Note that some option parameters must not have spaces between the option and the parameter. Recovery: Remove the option. Check the syntax of the options. ═══ 6.49. EDC3050 ═══ EDC3050 A destructor cannot have arguments. Recovery: Remove the arguments from the destructor. ═══ 6.50. EDC3051 ═══ EDC3051 A declaration has been made without a type specification. The compiler detected a typedef specification that did not have a type associated with it. Recovery: Add a type specification to the declaration. ═══ 6.51. EDC3052 ═══ EDC3052 Return type cannot be specified for "&1". The compiler detected a return type where one is not permitted. For example, putting a return type on a constructor is not permitted. Recovery: Remove the return type specification for the function. ═══ 6.52. EDC3053 ═══ EDC3053 Class qualification for "&1" is not allowed. Explicit class qualification is not allowed in this context. Recovery: Remove the class qualification. ═══ 6.53. EDC3054 ═══ EDC3054 The "&1" operator is not allowed between "&2" and "&3". The compiler detected an illegal operator between two operands. For user-defined types, you must overload the operator to accept the user-defined types. Recovery: Change the operator or change the operands. ═══ 6.54. EDC3055 ═══ EDC3055 "&1" cannot be converted to "&2". The type conversion cannot be performed because there is no conversion between the types. This can occur in an initialization, assignment, or expression statement. Recovery: Change one of the types or overload the operator. ═══ 6.55. EDC3056 ═══ EDC3056 Operand for "&1" must be a pointer or an array. The specified operator must have an operand which is a pointer or an array. Recovery: Change the operand to either a pointer or an array. ═══ 6.56. EDC3057 ═══ EDC3057 Syntax error - "&1" is not a class name. A class name must be specified in this context. Recovery: Specify a class name. Check the spelling. ═══ 6.57. EDC3058 ═══ EDC3058 Operand of "&1" operator must be an lvalue. The compiler detected an operand that is not an lvalue. An lvalue is an expression that represents an object. For example, the left hand side of an assignment statement must be an lvalue. Recovery: Change the operand to an lvalue. ═══ 6.58. EDC3059 ═══ EDC3059 const expression cannot be modified. You can initialize a const object, but its value cannot change afterwards. Recovery: Eliminate the const type qualifier from the expression or do not use it with the increment/decrement operators. ═══ 6.59. EDC3060 ═══ EDC3060 An expression of type "&1" is not allowed on the left side of "&2&3". The compiler detected a mismatch between the operands of an operator. Recovery: Change the operand type or use a different operator. ═══ 6.60. EDC3061 ═══ EDC3061 "&1" is neither an immediate base class nor a non-static data member of class "&2". The compiler has detected an element of the initializer list that is not an element of the member list. In the constructor initializer list, you can only initialize immediate base classes and data members not inherited from a base class. Recovery: Change the constructor initializer list. ═══ 6.61. EDC3062 ═══ EDC3062 Constructor initializer list is not allowed for non-constructor function. An attempt is being made to give a constructor initializer list to a non-constructor function. A constructor initializer list is only allowed for a constructor function. Recovery: Remove the constructor initializer list. ═══ 6.62. EDC3063 ═══ EDC3063 Variable "&1" is not allowed in an argument initializer. The compiler has detected a default argument initialized by a parameter. Recovery: Remove the parameter from the default argument initialization. ═══ 6.63. EDC3064 ═══ EDC3064 There are too many initializers in the initializer list. The compiler detected more initializers than were present in the function declaration. Recovery: Remove one or more initializers from the initializer list. Make sure the number of initializers in the initializer list corresponds to the number of arguments in the function declaration. ═══ 6.64. EDC3065 ═══ EDC3065 An initializer is not allowed for an array allocated by "new". Recovery: Remove the initializer or remove the "new" allocation. ═══ 6.65. EDC3066 ═══ EDC3066 The bit-field length must not be more than &1. The bit-field length must not exceed the maximum bit size of the bit-field type. Recovery: Reduce the bit-field length. ═══ 6.66. EDC3067 ═══ EDC3067 The type of "&1" cannot be "&2". The compiler detected a conflict in a type declaration. Recovery: Change the type. ═══ 6.67. EDC3068 ═══ EDC3068 Function overloading conflict between "&1" and "&2". The compiler detected function argument types that did not match. Recovery: Change the argument declarations of the functions. ═══ 6.68. EDC3069 ═══ EDC3069 Declarations of the same &1 must not specify default initializers for the same argument. The compiler has detected a duplicate default initializer value for the same argument in both overloaded functions or in both templates. Recovery: Ensure that you wanted to declare the same function or template. If that is the case, remove one of the default initializers. Otherwise, remove one of the declarations or overload the function. ═══ 6.69. EDC3070 ═══ EDC3070 Call does not match any argument list for "&1". No variant of the overloaded function matches the argument list. The argument mismatch could be by type or number of arguments. Recovery: Change the argument list on the call to the overloaded function or change the argument list on one of the overloaded function variants so that a match is found. ═══ 6.70. EDC3071 ═══ EDC3071 Call to "&1" matches more than one function. More than one variant of the overloaded function matches equally well with the argument list specified on the call. Recovery: Change the argument list on the call to the overloaded function or change the argument list on one of the overloaded function variants so that only one match is found. ═══ 6.71. EDC3072 ═══ EDC3072 Linkage for "&1" cannot be redefined. The specified name has already been declared with a different linkage than the current declaration. Recovery: Remove the redefinition or change one of the names. ═══ 6.72. EDC3073 ═══ EDC3073 The "operator" declaration must declare a function. The keyword "operator" can only be used to declare an operator function. Recovery: Check the declaration of the operator and make sure the function declarator () appears after it. Use the "operator" keyword to declare an operator function or remove it. ═══ 6.73. EDC3074 ═══ EDC3074 Operand for "&1" is of type "&2" which is not of type pointer to member. The specified operator must have an operand which is of type pointer to member. Recovery: Change the operand to type pointer to member. ═══ 6.74. EDC3075 ═══ EDC3075 "&1" is not allowed as a function return type. You cannot declare a function with a function or an array as its return type. Recovery: Declare the function to return a pointer to the function or the array element type. ═══ 6.75. EDC3076 ═══ EDC3076 "&1" is not allowed as an array element type. The C++ language does not allow the declaration of an array of functions or references, or an array of type void. Recovery: Remove the declaration or change the declaration so that it is an array of pointer to functions, pointers to references, or pointers to void. ═══ 6.76. EDC3077 ═══ EDC3077 const variable "&1" does not have an initializer. You can only assign a value to a const variable using an initializer. This variable has no initializer, so it can never be given a value. Recovery: Initialize the variable or remove the "const" keyword. ═══ 6.77. EDC3078 ═══ EDC3078 Non-static member "&1" must be associated with an object or a pointer to an object. The compiler detected a non-static member making a reference to an object that has not been instantiated. You can reference only static members without associating them with an instance of the containing class. Recovery: Check the spelling and the class definition. Change the name of the class or function, or define the function as static in that class. ═══ 6.78. EDC3079 ═══ EDC3079 "&1" is not a member of "&2". The class is used explicitly as the scope qualifier of the member name, but the class does not contain a member of that name. Recovery: Check the spelling of the scope qualifier. Change the scope qualifier to the class containing that member, or remove it. ═══ 6.79. EDC3080 ═══ EDC3080 Wrong number of arguments for "&1". A function or an explicit cast has been specified with the wrong number of arguments. Recovery: Use the correct number of arguments. Ensure that overloaded functions have the correct number and type of arguments. ═══ 6.80. EDC3081 ═══ EDC3081 "&1" must be a class member. Conversion functions and certain operator functions must be class members. They cannot be defined globally. Recovery: Remove the global definition or make the function a class member. ═══ 6.81. EDC3082 ═══ EDC3082 An argument type of "&1" is not allowed for "&2". The function being declared has restrictions on what types its arguments can have. The specified type is not allowed for this argument. Recovery: Change the argument type. ═══ 6.82. EDC3083 ═══ EDC3083 "&2" cannot have a return type of "&1". The specified operator function has the wrong return type. Recovery: Change the return type. ═══ 6.83. EDC3084 ═══ EDC3084 The array operator must have one operand of pointer type and one of integral type. This error may result from the incorrect use of the array operator. Recovery: Change the operands of the array operator. ═══ 6.84. EDC3085 ═══ EDC3085 Wrong number of arguments specified in the function call. The number of arguments in the function call does not match the number of arguments in the function declaration. Recovery: Ensure the function declaration and function call specify the same number of arguments. ═══ 6.85. EDC3086 ═══ EDC3086 &1 This message has been generated by the "#error" preprocessor directive, which is a user-defined error message placed in the source code. ═══ 6.86. EDC3087 ═══ EDC3087 "&1" operator is not allowed for type "&2". The specified operator cannot be used with operands of this type. Recovery: Change either the operator or the operands. ═══ 6.87. EDC3088 ═══ EDC3088 Insufficient memory. The compiler ran out of memory during compilation. Recovery: End unnecessary processes and recompile. ═══ 6.88. EDC3089 ═══ EDC3089 More than one function "&1" has non-C++ linkage. If a function is overloaded, at most one of its variants can have non-C++ linkage. Recovery: Remove one of the non-C++ linkages or do not overload the function. ═══ 6.89. EDC3090 ═══ EDC3090 Syntax error - expected "&1" and found "&2". A syntax error was found while parsing the program. The message identifies what the compiler expected and what it actually found. Often the source of the error is an unmatched parenthesis or a missing semicolon. Recovery: Correct the syntax. ═══ 6.90. EDC3091 ═══ EDC3091 "&1" is not allowed for &2. The attribute or name cannot be specified in the given context. The compiler detected incompatible names that conflict with the language definition. Recovery: Remove the attribute or name. ═══ 6.91. EDC3092 ═══ EDC3092 "&1" conflicts with previous "&2" declaration. The declaration conflicts with a previous declaration of the same symbol. Recovery: Remove one of the declarations or make them identical. ═══ 6.92. EDC3093 ═══ EDC3093 Initializer is too long. The string initializer for a character or wide-character array has more characters than the array. Note that the trailing null character is treated as part of the initializer. Recovery: Increase the size of the array or reduce the size of the initializer. ═══ 6.93. EDC3094 ═══ EDC3094 The "operator->" function must return a class type that contains an "operator->" function. The "operator->" function must return either a class type, a reference to a class type, or a pointer to class type, and the class type must itself have an "operator->" function. Recovery: Change the return value of the "operator->" function. ═══ 6.94. EDC3095 ═══ EDC3095 Unused "&1" definition. An unnamed class or struct definition was found that has no object associated with it. The definition can never be referenced. A class can be unnamed, but it cannot be passed as an argument or returned as a value. An unnamed class cannot have any constructors or destructors. Recovery: Create an object for the class or struct, or remove the definition. ═══ 6.95. EDC3096 ═══ EDC3096 Internal compiler error at line &1 in module "&2": &3. The compiler detected an error that it is not able to recover from. The error was found within the compiler itself. Recovery: Note the line and module references in this message. Contact your IBM Representative. ═══ 6.96. EDC3097 ═══ EDC3097 Reference to member "&1" of undefined class "&2". The member has been explicitly given the specified class as a scope qualifier but the class (and hence the member) has not been defined. Recovery: Check for a missing #include file. Define the class and member. ═══ 6.97. EDC3098 ═══ EDC3098 Pointer conversion may be wrong if the classes are related in a multiple inheritance hierarchy. The relationship between the classes in a pointer conversion is not known. If the target class is later defined as a base class of the source class in a multiple inheritance, this conversion will be wrong if the value of the pointer should have been modified by the conversion. Recovery: Change the ambiguous reference in the conversion. ═══ 6.98. EDC3099 ═══ EDC3099 "&1" is used but not set in function "&2". The specified symbol is being used but has not been assigned a valid value. Its value will be undefined. Recovery: Define or initialize the symbol before using it. ═══ 6.99. EDC3100 ═══ EDC3100 "&1" is set but not used in function "&2". The specified symbol was given a value but was never used. Recovery: Use the symbol or remove it. ═══ 6.100. EDC3101 ═══ EDC3101 "&1" is used before it is set. The specified symbol is being used before it has been assigned a value. The value of the symbol is undefined. Recovery: Define or initialize the symbol before using it. ═══ 6.101. EDC3102 ═══ EDC3102 The reference variable "&1" is uninitialized. Reference variables must be initialized. Recovery: Initialize the reference variable or remove it. ═══ 6.102. EDC3103 ═══ EDC3103 "&1" must already be declared. The specified class or enum name must have been declared before this use of the name. Recovery: Declare the class or enum name before you use it. Check the correct spelling of the name. ═══ 6.103. EDC3104 ═══ EDC3104 Unrecognized source character "&1", code point &2. The specified character is not a valid character in a C++ program. The code point represents the ASCII value of the character displayed in hexadecimal format. Recovery: Remove the character. ═══ 6.104. EDC3105 ═══ EDC3105 A local class cannot have a non-inline member function "&1". A class declared within a function must have all of its member functions defined inline, because the class will be out of scope before non-inline functions can be defined. Recovery: Define the functions inline, or move the class definition out of the scope of the function. ═══ 6.105. EDC3106 ═══ EDC3106 The size of "&1" is unknown in "&2" expression. The operation cannot be performed because the size of the specified type is not known. Recovery: Ensure the size of the type is known before this expression. ═══ 6.106. EDC3107 ═══ EDC3107 Assignment in logical expression. The logical expression contains an assignment (=). An equality comparison (==) may have been intended. Recovery: Change the operator or the expression. ═══ 6.107. EDC3108 ═══ EDC3108 Conversion from "&1" to "&2" may cause truncation. The specified conversion from a wider to a narrower type may cause the loss of significant data. Recovery: Remove the conversion from a wider to a narrower type. ═══ 6.108. EDC3109 ═══ EDC3109 "goto &1" bypasses initialization of "&2". Jumping past a declaration with an explicit or implicit initializer is not valid unless the declaration is in an inner block or unless the jump is from a point where the variable has already been initialized. Recovery: Enclose the initialization in a block statement. ═══ 6.109. EDC3110 ═══ EDC3110 References to "&1" may be ambiguous. The name is declared in base classes "&2" and "&3". The compiler detected the base classes of a derived class have members with the same names. This will cause ambiguity when the member name is used. This is only an informational message because the declaration of a member with an ambiguous name in a derived class is not an error. The ambiguity is only flagged as an error if you use the ambiguous member name. Recovery: Change one of the names, or always fully qualify the name. ═══ 6.110. EDC3111 ═══ EDC3111 Ambiguous reference to "&1", declared in base classes "&2" and "&3". The derived class made a reference to a member that is declared in more than one of its base classes and the compiler cannot determine which base class member to choose. Recovery: Change one of the names, or always fully qualify the name. ═══ 6.111. EDC3112 ═══ EDC3112 Conversion from "&1" to "&2" is ambiguous. There is more than one way to perform the specified conversion. This ambiguity may be caused by an overloaded function. Recovery: Change or remove the conversion. ═══ 6.112. EDC3113 ═══ EDC3113 "&1" is only valid for non-static member functions. const and volatile are only significant for non-static member functions, since they are applied to the "this" pointer. Recovery: Remove const and volatile from all static members. ═══ 6.113. EDC3114 ═══ EDC3114 Duplicate case value. Case values must be unique within each "switch" statement. Recovery: Change or remove one of the duplicate case values. Check the braces if you have nested case statements. ═══ 6.114. EDC3115 ═══ EDC3115 Character literal is null. An empty character literal has been specified. A string literal may have been intended. Recovery: Remove the character literal, change it to a string literal, or give it a value. ═══ 6.115. EDC3116 ═══ EDC3116 "&1" is given wider scope for compatibility reasons. A type defined in class scope has been given the scope of the enclosing function or file because of a compiler option. Recovery: Ensure this is correct scope. ═══ 6.116. EDC3117 ═══ EDC3117 "&1" has more than one base class "&2". A derived class has inherited the same base class in more than one path and the compiler cannot determine which one to choose. Recovery: Remove one of the inheritances. ═══ 6.117. EDC3118 ═══ EDC3118 "&1" is a &2 base class of "&3". An attempt is being made to convert a pointer to a derived class into a pointer to a private or protected base class. Recovery: Remove the pointer conversion. ═══ 6.118. EDC3119 ═══ EDC3119 The statement is unreachable. The flow of control in the program never allows the statement to be be reached. Recovery: Ensure that the statement is accessible to the flow of control, or remove the statement. ═══ 6.119. EDC3120 ═══ EDC3120 &1 "&2" is not allowed in a union. Unions must not be declared with base classes, virtual functions, static data members, members with constructors, members with destructors, or members with class copying assignment operators. Recovery: Remove any such members from the union declaration. ═══ 6.120. EDC3121 ═══ EDC3121 union "&1" cannot be used as a base class. Unions cannot be used as base classes for other class declarations. Recovery: Remove the union as a base class for other class declarations. ═══ 6.121. EDC3122 ═══ EDC3122 Local variable "&1" is inaccessible from "&2". An automatic variable within a function is not accessible from local classes declared within the function. Recovery: Remove the reference to the local variable, or move the variable to a different scope. ═══ 6.122. EDC3123 ═══ EDC3123 Value of enumerator "&1" is too large. The value of an enumerator must be a constant expression that is promotable to a signed integer value. Recovery: Reduce the value of the enumerator. ═══ 6.123. EDC3124 ═══ EDC3124 Missing path name in include directive. Recovery: Add the path name to file specified in the #include directive. ═══ 6.124. EDC3125 ═══ EDC3125 Missing "#define" or "#undef". Recovery: Add "#define" or "#undef". ═══ 6.125. EDC3126 ═══ EDC3126 Argument "&1" is not used in function "&2". The argument has been declared in a function but has not been set or used. Recovery: Use the argument or remove it. ═══ 6.126. EDC3127 ═══ EDC3127 Global symbol "&1" is not used. The specified symbol has been declared as a global symbol but has not been set or used. Recovery: Use the symbol or remove it. ═══ 6.127. EDC3129 ═══ EDC3129 Default initializers are not allowed in local friend functions. You cannot use default arguments in the friend functions of the local class. Recovery: Remove the default initializers from the local friend function. ═══ 6.128. EDC3130 ═══ EDC3130 A constant is being used as a conditional expression. The condition to an if, for, or switch is constant and therefore, that condition will always hold. Recovery: No response is necessary. ═══ 6.129. EDC3131 ═══ EDC3131 The argument to a not (!) operator is constant. The compiler has detected a constant after the ! operator which may be a coding error. Recovery: Remove the constant or ignore this message. ═══ 6.130. EDC3132 ═══ EDC3132 There is more than one character in a character constant. Using more than one character in a character constant (for example, 'ab') may not be portable across machines. Recovery: Remove the extra character(s) or change the character constant to a string constant. ═══ 6.131. EDC3133 ═══ EDC3133 Possible pointer alignment problem with the "&1" operator. A pointer that points to a type with less strict alignment requirements is being assigned, cast, returned or passed as a parameter to a pointer that is a more strictly aligned type. This is a potential portability problem. Recovery: Remove the pointer reference or change the alignment. ═══ 6.132. EDC3134 ═══ EDC3134 A constant expression is being cast to a pointer. Casting a constant value to a pointer is not portable to other platforms. Recovery: Remove the constant expression from the cast expression. ═══ 6.133. EDC3135 ═══ EDC3135 Precision will be lost in assignment to (possibly sign-extended) bit-field "&1". A constant is being assigned to a signed bit field that cannot represent the constant. Precision may be lost and the stored value will be incorrect. Recovery: Increase the size of the bit field. ═══ 6.134. EDC3136 ═══ EDC3136 Precision will be lost in assignment to bit-field "&1". A constant is being assigned to a bit field, and because the bit field has a smaller size, the precision will be lost. Recovery: Change the assignment expression. ═══ 6.135. EDC3137 ═══ EDC3137 Enumeration type clash with the "&1" operator. Operands from two different enumerations are used in an operation. Recovery: Ensure both operands are from the same enumeration. ═══ 6.136. EDC3138 ═══ EDC3138 Comparison of an unsigned value with a negative constant. An unsigned value is being compared to a negative number. The unsigned value will always compare greater than the negative number. This may be a programming error. Recovery: Remove the comparison or change the type. ═══ 6.137. EDC3139 ═══ EDC3139 Unsigned comparison is always true or always false. The comparison is either "unsigned >= 0", which is always true, or "unsigned < 0", which is always false. Recovery: Remove or change the comparison. ═══ 6.138. EDC3140 ═══ EDC3140 Comparison is equivalent to "unsigned value &1 0". The comparison is either "unsigned > 0" or "unsigned <= 0", and could be written as "unsigned != 0" or "unsigned == 0". Recovery: Change the comparison. ═══ 6.139. EDC3141 ═══ EDC3141 Argument &1 for "&2" must be of type "&3". The indicated function requires an argument of a particular type. However, the argument specified is of a different type than the type required. Recovery: Ensure that the argument is of the correct type. ═══ 6.140. EDC3142 ═══ EDC3142 The operand for the "#line" directive must be an integer in the range 1 to 32767. The operand of the "#line" directive must be an integer in the specified range. Recovery: Ensure that the operand is in the specified range. ═══ 6.141. EDC3143 ═══ EDC3143 Definition of "&1" is not allowed. You cannot define a type in a type cast or a conversion function declaration. Recovery: Move the definition to a new location, or remove it. ═══ 6.142. EDC3144 ═══ EDC3144 Reference to "&1" is not allowed. The name has a special meaning in a C++ program and cannot be referenced in this way. Recovery: Remove the reference. ═══ 6.143. EDC3145 ═══ EDC3145 Escape sequence &1 is out of the range 0-&2. Value is truncated. Recovery: Make the escape sequence small enough to fit the specified range. ═══ 6.144. EDC3146 ═══ EDC3146 A wide character constant is larger than the size of a "wchar_t". Only the last character is used. A wide character constant can only contain one character. This error may be caused by a literal containing a multibyte character if the multibyte character compile option is not used. Recovery: Make the wide character constant smaller. ═══ 6.145. EDC3147 ═══ EDC3147 A character constant is larger than the size of an "int". Only the rightmost &1 characters are used. Recovery: Make the character constant smaller. ═══ 6.146. EDC3148 ═══ EDC3148 Linkage specification must be at file scope. A linkage specification may only be defined at file scope, that is, outside all functions and classes. Recovery: Move the linkage specification or remove it. ═══ 6.147. EDC3149 ═══ EDC3149 Default initializers cannot be followed by uninitialized arguments. If a default initializer is specified in an argument list, all following arguments must also have default initializers. Recovery: Remove the default initializers, or provide them for the following arguments, or move the arguments to the end of the list. ═══ 6.148. EDC3150 ═══ EDC3150 You cannot take the address of "&1". You cannot take the address of a constructor, a destructor or a reference member. Recovery: Remove the address operator (&) from the expression or remove the expression. ═══ 6.149. EDC3151 ═══ EDC3151 &1 compiler temporary of type "&2" has been generated. The compiler has generated a temporary variable. This variable will be destroyed automatically when it goes out of scope. This messages is generated for your information only, it does not necessarily indicate a problem with your program. Recovery: Ensure that your program does not attempt to reference the temporary variable outside of its scope. ═══ 6.150. EDC3152 ═══ EDC3152 An error was detected while writing to file "&1". The compiler detected an error while writing to the specified file. Recovery: Ensure the file name is correct and that the disk is ready to be written to. ═══ 6.151. EDC3153 ═══ EDC3153 Duplicate qualifier "&1" ignored. The keyword has been specified more than once. Extra occurrences are ignored. Recovery: Remove one of the duplicate qualifiers. ═══ 6.152. EDC3154 ═══ EDC3154 "&1" operator cannot be overloaded. The specified operator cannot be overloaded using an operator function. Recovery: Remove the overloading declaration or definition. ═══ 6.153. EDC3155 ═══ EDC3155 At least one argument of "&1" must be of class or enum type. The non-member operator function must have at least one argument which is of class or enum type. Recovery: Add an argument of class or enum type. ═══ 6.154. EDC3156 ═══ EDC3156 Call matches built-in operator. The compiler detected an operator that is similar to the built-in one, and is providing additional information. Recovery: Ensure this is the desired match. ═══ 6.155. EDC3157 ═══ EDC3157 The divisor for the modulus or division operator cannot be zero. Recovery: Change the expression used in the divisor. ═══ 6.156. EDC3158 ═══ EDC3158 The address of the bit-field "&1" cannot be taken. An expression attempts to take the address of a bit-field, or to use the bit-field to initialize a reference variable or argument. Recovery: Remove the expression causing the error. ═══ 6.157. EDC3159 ═══ EDC3159 "&1" must not have default initializers. Default initializers are not allowed within the declaration of an operator function or a template function. Recovery: Remove the default initializers. ═══ 6.158. EDC3160 ═══ EDC3160 The &1 "&2" cannot be initialized because it does not have a default constructor. The specified base class or member cannot be constructed since it is not initialized in the constructor initializer list and its class has no default constructor. Recovery: Specify a default constructor for the class or initialize it in the constructor initializer list. ═══ 6.159. EDC3161 ═══ EDC3161 Line is too long for proper generation of test coverage information. To generate test coverage information, statements cannot start to the right of column 65536. Recovery: Shorten the line. ═══ 6.160. EDC3162 ═══ EDC3162 There are too many statements for proper generation of test coverage information. There can be no more than 65536 statements (not source lines) in a module when test coverage information is to be generated. Recovery: Reduce the number of statements. ═══ 6.161. EDC3163 ═══ EDC3163 Template class "&1" has the wrong number of arguments. A template class instantiation has a different number of template arguments than the template declaration. Recovery: Ensure that the template class has the same number of declarations as the template declaration. ═══ 6.162. EDC3164 ═══ EDC3164 Non-&1 member function "&2" cannot be called for a &1 object. The member function is being called for a const or volatile object but the member function has not been declared with the const or volatile qualifier. Recovery: Supply a version of the member function with the correct set of "const" and "volatile" qualifiers. ═══ 6.163. EDC3165 ═══ EDC3165 Null statement. Possible extraneous semi-colon has been specified. Recovery: Check for extra semi-colons in statement. ═══ 6.164. EDC3166 ═══ EDC3166 Bit-field "&1" cannot be used in a conditional expression that is to be modified. The bit-field is part of a conditional expression that is to be modified. Only objects that can have their address taken are allowed as part of such an expression, and you cannot take the address of a bit field. Recovery: Remove the bit-field from the conditional expression. ═══ 6.165. EDC3167 ═══ EDC3167 The "&1" qualifier cannot be applied to "&2". The qualifier is being applied to a name or a type for which it is not valid. Recovery: Remove the qualifier. ═══ 6.166. EDC3168 ═══ EDC3168 Local type "&1" cannot be used as a &2 argument. The type cannot be used as a function argument or in the instantiation of a template because the scope of the type is limited to the current function. Recovery: Remove the local type. ═══ 6.167. EDC3169 ═══ EDC3169 Exception specification for function "&1" does not match previous declaration. If an exception specification is given in more than one declaration of a function, it must be the same in all such declarations. Recovery: Ensure that all exception specifications match. ═══ 6.168. EDC3170 ═══ EDC3170 Default initializers for non-type template arguments are only allowed for class templates. Default initializers have been given for non-type template arguments, but the template is not declaring a class. Recovery: Remove the default initializers. ═══ 6.169. EDC3171 ═══ EDC3171 A function argument must not have type "void". A function argument may be an expression of any object type. However, "void" is not the type of any object, and cannot be used as an argument type. Recovery: Change the type of the function argument. ═══ 6.170. EDC3172 ═══ EDC3172 Insufficient memory in line &1 of file "&2". The compiler ran out of memory during compilation. Recovery: End unnecessary processes and recompile. ═══ 6.171. EDC3174 ═══ EDC3174 An object of abstract class "&1" cannot be created. You cannot create instances of abstract classes. An abstract class is a class that has or inherits at least one pure virtual function. Recovery: Derive another object from the abstract class. ═══ 6.172. EDC3175 ═══ EDC3175 Invalid use of an abstract class. An abstract class must not be used as an argument type, as a function return type, or as the type of an explicit conversion. Recovery: Derive another class from the abstract, instantiate it so it becomes a concrete object, and then use it instead. ═══ 6.173. EDC3176 ═══ EDC3176 "&1" has been used more than once in the same base class list. A base class may only be specified once in the base class list for a derived class. Recovery: Remove one of the specifications. ═══ 6.174. EDC3177 ═══ EDC3177 Template argument &1 of type "&2" does not match declared type "&3". A non-type template argument must have a type that exactly matches the type of the corresponding argument in the template declaration. Recovery: Ensure that the types match. ═══ 6.175. EDC3178 ═══ EDC3178 Template argument &1 of type "&2" is not an allowable constant value or address. A non-type template argument must be a constant value or the address of an object, function, or static data member that has external linkage. String literals cannot be used as template arguments because they have no name, and therefore no linkage. Recovery: Change the template argument. ═══ 6.176. EDC3179 ═══ EDC3179 Template argument list is empty. At least one template argument must be specified in a template declaration. Recovery: Specify a template argument in the declaration. ═══ 6.177. EDC3180 ═══ EDC3180 Formal template argument &1 is of type "&2" which is not an allowable integral, or enumeration, or pointer type. A non-type template argument must be of integral, or enumeration, or pointer type, so that it can be matched with a constant integral value. Recovery: Change the template argument. ═══ 6.178. EDC3181 ═══ EDC3181 "&1" is defined in a template declaration but it is not a static member. A member of a template class defined in a template declaration must be a static member. Recovery: Make the member static or remove it from the template declaration. ═══ 6.179. EDC3182 ═══ EDC3182 Template argument "&1" is not used in the declaration of the name or the argument list of "&2". All template arguments for a non-class template must be used in the declaration of the name or the function argument list. Recovery: Ensure all template arguments are used in the declaration of the name or the function argument list. ═══ 6.180. EDC3183 ═══ EDC3183 Template declaration does not declare a class, a function, or a template class member. Following the template argument, a template declaration must declare a class, a function, or a static data member of a template class. Recovery: Change the template declaration to declare a class, a function, or a template class member. ═══ 6.181. EDC3184 ═══ EDC3184 Return type "&1" for function "&2" differs from previous return type of "&3". The declaration of the function differs from a previous declaration in only the return type. Recovery: Change the return type so that it matches the previous return type. ═══ 6.182. EDC3185 ═══ EDC3185 "&1" is a member of "&2" and cannot be used without qualification. The specified name is a class member, but no class qualification has been used to reference it. Recovery: Add a class qualification to the class member. ═══ 6.183. EDC3186 ═══ EDC3186 The expression is not a valid preprocessor constant expression. The expression in an "#if" or "#elif" preprocessor directive is either not a valid expression or not a constant expression. No keywords are recognized in such an expression and non-macro identifiers are replaced by the constant 0. Recovery: Change the expression for the preprocessor directive. ═══ 6.184. EDC3187 ═══ EDC3187 "&1" cannot be initialized multiple times. An initializer was already specified in the constructor definition. Recovery: Remove the additional initializer. ═══ 6.185. EDC3188 ═══ EDC3188 A macro parameter is expected after the "#" operator. The "#" operator in a macro replacement list must be followed by a macro parameter. Recovery: Add a macro parameter after the "#" operator. ═══ 6.186. EDC3189 ═══ EDC3189 "##" operator is at the start or end of the replacement list. The "##" operator must be preceded and followed by valid tokens in the macro replacement list. Recovery: Move the "##" operator in the replacement list. ═══ 6.187. EDC3190 ═══ EDC3190 One or more "#endif" statements are missing at end of file. The end of file has been reached and there are still "#if", "#ifdef" or "#ifndef" statements without a matching "#endif" statement. Recovery: Ensure that all "#if", "#ifdef", and "#ifndef" statements have matching "#endif" statements. ═══ 6.188. EDC3191 ═══ EDC3191 No suitable copy assignment operator exists to perform the assignment. A copy assignment operator exists but it does not accept the type of the given parameter. Recovery: Change the copy assignment operator. ═══ 6.189. EDC3192 ═══ EDC3192 Identifier "&1" in preprocessor expression is assigned 0. Identifiers are not recognized in a preprocessor expression. The specified identifier has been treated as a non-macro identifier and assigned the constant 0. ═══ 6.190. EDC3193 ═══ EDC3193 Explicit call to constructor "&1" is not allowed. You cannot call a constructor explicitly. It is called implicitly when an object of the class is created. Recovery: Remove the call to the constructor. ═══ 6.191. EDC3194 ═══ EDC3194 "catch(&1)" will never be reached because of previous "catch(&2)". The catch clause can never be reached since any exception type that matches it will also be matched by the specified previous catch clause. Recovery: Change or remove one of the catch clauses. ═══ 6.192. EDC3195 ═══ EDC3195 No default constructor exists for "&1". An array of class objects must be initialized by calling the default constructor, but one has not been declared. Recovery: Declare a default constructor for the array. ═══ 6.193. EDC3196 ═══ EDC3196 More than one default constructor exists for "&1". An array of class objects must be initialized by calling the default constructor, but the call is ambiguous. Recovery: Ensure that only one default constructor exists. ═══ 6.194. EDC3197 ═══ EDC3197 It is invalid to have a throw expression with type "&1". You cannot throw a function or an expression of type "void". Recovery: Change the type or remove the throw expression. ═══ 6.195. EDC3198 ═══ EDC3198 The exception specification is ignored in this declaration. The declaration contains a function declarator with an exception specification but is not the declaration of a function. The exception specification is ignored. Recovery: Change the function declarator so that it is the declaration of a function. ═══ 6.196. EDC3199 ═══ EDC3199 The compiler cannot generate a default copy constructor for "&1". The default copy constructor cannot be generated for this class because there exists a member or base class that has a private copy constructor, or there are ambiguous base classes, or this class has no name. Recovery: Ensure that a member or base class does not have a private copy constructor. If not then ensure the class is named and there are no ambiguous references to base classes. ═══ 6.197. EDC3200 ═══ EDC3200 The compiler cannot generate a default copy assignment operator for "&1". The default copy assignment operator cannot be generated for this class because it has a const member or a reference member or a member (or base class) with a private copy assignment operator. Recovery: Ensure there are no const members, reference members or members with a private copy assignment operator. ═══ 6.198. EDC3201 ═══ EDC3201 &1 too few non-option arguments. You can generate this message only when you are running the compiler passes manually. Recovery: Add non-option arguments. ═══ 6.199. EDC3202 ═══ EDC3202 "main" must not be declared inline or static. Although "main" is not a keyword, it is a special function that cannot be inlined or declared as static. Recovery: Remove the inline or static specifier from the declaration of main. ═══ 6.200. EDC3203 ═══ EDC3203 Pure virtual function called. A call has been made to a pure virtual function from a constructor or destructor. In such functions, the pure virtual function would not have been overridden by a derived class and a runtime error would occur. Recovery: Remove the call to the pure virtual function. ═══ 6.201. EDC3204 ═══ EDC3204 "&1" is not allowed as a conversion function type. A conversion function cannot be declared with a function or an array as its conversion type, since the type cannot be returned from the function. Recovery: Declare the function as converting to a pointer to the function or the array element type. ═══ 6.202. EDC3205 ═══ EDC3205 Syntax error - "&1" is followed by "&3" but is not the name of a &2. The name is not a class or template name but the context implies that it should be. Recovery: Change the name to a class or template name. ═══ 6.203. EDC3206 ═══ EDC3206 The previous &1 messages apply to the definition of template "&2". The instantiation of the specified template caused the messages, even though the line numbers in the messages refer to the original template declaration. Recovery: This message supplies additional information for previously emitted messages. Refer to the descriptions of those messages for recovery information. ═══ 6.204. EDC3207 ═══ EDC3207 The previous message applies to the definition of template "&1". The instantiation of the specified template caused the message, even though the line number in the message refers to the original template declaration. Recovery: This message supplies additional information for previously emitted messages. Refer to the descriptions of those messages for recovery information. ═══ 6.205. EDC3208 ═══ EDC3208 No suitable constructor exists for conversion from "&1" to "&2". A constructor is required for the class but no user-defined constructor exists and the compiler could not generate one. Recovery: Create a suitable constructor for conversion. ═══ 6.206. EDC3209 ═══ EDC3209 class "&1" does not have a copy assignment operator. A copy assignment operator is required for the class but no user-defined copy assignment operator exists and the compiler could not generate one. Recovery: Create a copy assignment operator. ═══ 6.207. EDC3210 ═══ EDC3210 "&1" cannot be used as a template name since it is already known in this scope. A template name must not match the name of an existing template, class, function, object, value or type. Recovery: Change one of the template names. ═══ 6.208. EDC3211 ═══ EDC3211 "&1" is expected for template argument &2. Either the argument is a type and the template has a non-type argument, or the argument is an expression and the template has a type argument. Recovery: Ensure the argument matches the template. ═══ 6.209. EDC3212 ═══ EDC3212 "&1" cannot be defined before the template definition of which it is an instance. An explicit definition of a template class cannot be given before the corresponding template definition. Recovery: Move the template definition so that it occurs before any template class definitions. ═══ 6.210. EDC3213 ═══ EDC3213 An ellipsis (...) cannot be used in the argument list of a template function. Since an exact match is needed for template functions, an ellipsis cannot be used in the function argument list. Recovery: Remove the ellipsis from the argument list. ═══ 6.211. EDC3214 ═══ EDC3214 The suffix for the floating point constant is not valid. You have provided an incorrect suffix for the floating point constant. Valid suffixes for floating point constants are L and F. Recovery: Change the suffix for the floating point constant. ═══ 6.212. EDC3215 ═══ EDC3215 Statement has no effect. The expression has no side effects and produces a result that is not used. Recovery: Remove the statement or use its result. ═══ 6.213. EDC3216 ═══ EDC3216 "/*" detected in comment. "/*" has been detected within a "/*" type comment. Nested comments are not allowed. Recovery: Remove the imbedded "/*" and ensure that you are not missing the end of the other comment. ═══ 6.214. EDC3217 ═══ EDC3217 Predefined macro name "&1" cannot be redefined or undefined. The specified macro name is predefined by the compiler and cannot be redefined with #define or undefined with #undef. Recovery: Remove the definition expression or change the macro name. ═══ 6.215. EDC3218 ═══ EDC3218 The suffix for the integer constant is not valid. The integer constant is a suffix letter that is not recognized as a valid suffix. Recovery: Change the suffix to either "u" or "l". ═══ 6.216. EDC3219 ═══ EDC3219 The expression contains a division by zero. Recovery: Remove the division by zero from the expression. ═══ 6.217. EDC3220 ═══ EDC3220 The expression contains a modulus by zero. Recovery: Remove the modulus by zero from the expression. ═══ 6.218. EDC3221 ═══ EDC3221 Static member "&1" can only be defined at file scope. Recovery: Move the static member so that it is defined at file scope. ═══ 6.219. EDC3222 ═══ EDC3222 "&1" needs a constructor because &2 "&3" needs a constructor initializer. You have not provided a constructor for the class, because the member or base class does not have a default constructor. Recovery: Add a constructor. ═══ 6.220. EDC3223 ═══ EDC3223 "&1" cannot be redeclared since it has already been used in this scope. The name is being declared in a member list but was previously declared outside the member list and then used in the member list. Recovery: Change or remove one of the occurrences. ═══ 6.221. EDC3224 ═══ EDC3224 Conversion from "&1" to a reference to a non-const type "&2" requires a temporary. A temporary may only be used for conversion to a reference type when the reference is to a const type. Recovery: Change to a const type. ═══ 6.222. EDC3225 ═══ EDC3225 "&2" is too small to hold a value of type "&1". A conversion from a pointer type to an integral type is only valid if the integral type is large enough to hold the pointer value. Recovery: Remove the conversion from a pointer type to an integral type or use a larger integral type. ═══ 6.223. EDC3226 ═══ EDC3226 Object of type "&1" cannot be constructed from "&2" expression. There is no constructor taking a single argument that can be called using the given expression. Recovery: Change the expression. ═══ 6.224. EDC3227 ═══ EDC3227 The compiler cannot generate a copy constructor for conversion to "&1". A copy constructor is required for the conversion. No suitable user-defined copy constructor exists and the compiler could not generate one. Recovery: Create a copy constructor for the conversion. ═══ 6.225. EDC3228 ═══ EDC3228 No suitable constructor or conversion function exists for conversion from "&1" to "&2". A constructor or conversion function is required for the conversion but no such constructor or function exists. Recovery: Create a constructor or conversion function for the conversion. ═══ 6.226. EDC3229 ═══ EDC3229 The file is empty. An empty source or include file has been encountered while reading source. The source file name or include file name may not be spelled correctly. Recovery: Check the file name. ═══ 6.227. EDC3230 ═══ EDC3230 Syntax error - "&1" has been inserted before "&2". A syntax error was found while parsing the program. The message identifies what the compiler expected and what it actually found. The compiler inserts the expected value and compilation continues. Recovery: Correct the syntax. ═══ 6.228. EDC3231 ═══ EDC3231 Call to "&1" matches some functions best in some arguments, but no function is a best match for all arguments. No function matches each call argument as well as or better than all other functions. Recovery: Change the function call so that it matches only one function. ═══ 6.229. EDC3232 ═══ EDC3232 Call matches "&1". The compiler detected an overloaded function or operator that is similar to another and is providing additional information. Recovery: Ensure this is the desired match. ═══ 6.230. EDC3233 ═══ EDC3233 Cannot adjust access of "&1::&2" because a member in "&3" hides it. You cannot modify the access of the specified member because a member of the same name in the specified class hides it. Recovery: Remove the access adjustment expression or unhide the member. ═══ 6.231. EDC3234 ═══ EDC3234 "&1" cannot be redeclared. The specified name cannot be redeclared because it has already been used. Recovery: Change or remove one of the declarations. ═══ 6.232. EDC3235 ═══ EDC3235 Syntax error - "&1" is not allowed; "&2" has already been specified. You cannot use both of the specified attributes in the same declaration. Recovery: Remove the attributes. ═══ 6.233. EDC3236 ═══ EDC3236 Missing option to "#pragma &1"; the directive is ignored. A required option of the specified pragma directive is missing. Recovery: Ensure all options for the pragma are present. ═══ 6.234. EDC3237 ═══ EDC3237 Invalid option "&1" specified for "#pragma options"; the option is ignored. Recovery: Remove the invalid option. ═══ 6.235. EDC3238 ═══ EDC3238 Invalid or out of range pragma parameter; parameter is ignored. The pragma parameter specified is either not a valid parameter, or is out of range. Recovery: Remove the parameter or replace it with one within the range. ═══ 6.236. EDC3239 ═══ EDC3239 Function "&1" has internal linkage but is undefined. If a static function or inline member function is referenced in this compilation unit, it must be defined in the same compilation unit. Recovery: Define the function in the same compilation unit it is referenced in. ═══ 6.237. EDC3240 ═══ EDC3240 Call to "&1" matches more than one template function. More than one template for the function matches equally well with the argument list specified on the call. Recovery: Change the call so that it matches only one template function. ═══ 6.238. EDC3241 ═══ EDC3241 "&1" was declared with external linkage and called or defined before being declared as inline. When no inline specifier is used, linkage will be external unless an inline declaration appears before the first call or the definition. Recovery: Declare the function as inline before the first call to it. ═══ 6.239. EDC3242 ═══ EDC3242 Non-&1 member function called for a &1 object via pointer of type "&2". The member function is being called indirectly for a const or volatile object but it has not been declared with the corresponding const or volatile attribute. Recovery: Ensure that the function call and the function declaration match. ═══ 6.240. EDC3243 ═══ EDC3243 "&1" cannot be a base of "&2" because "&3" contains the type name "&2". A class cannot inherit a type name that is the same as the class name. Recovery: Change the name of either the derived class or the inherited class. ═══ 6.241. EDC3244 ═══ EDC3244 "&1" cannot be a base of "&2" because "&3" contains the enumerator "&2". A class cannot inherit an enumerator with the same name as the class name. Recovery: Change the name of either the derived class or the inherited enumerator. ═══ 6.242. EDC3245 ═══ EDC3245 "&1" cannot be a base of "&2" because "&3" contains an anonymous union member "&2". A class cannot inherit an anonymous union member with the same name as the class name. Recovery: Change either the name of the derived class or the inherited anonymous union member. ═══ 6.243. EDC3246 ═══ EDC3246 Symbol length of &1 exceeds limit of &2 bytes. The compiler limit for the length of a symbol has been exceeded. Recovery: Shorten the symbol length. ═══ 6.244. EDC3247 ═══ EDC3247 The result of this pointer to member operator can be used only as the operand of the function call operator (). If the result of the .* or ->* is a function, then that result can be used only as the operand for the function call operator (). Recovery: Make the result the operand of the function call operator (). ═══ 6.245. EDC3248 ═══ EDC3248 When "&1" is used as an operand to the arrow or dot operator, the result must be used with the function call operator (). If the result of the dot or arrow operator is a function, then that result can be used only as the operand for the function call operator (). Recovery: Make the result the operand of the function call operator (). ═══ 6.246. EDC3249 ═══ EDC3249 A class with a reference or const member needs a constructor. const and reference members must be initialized in a constructor initializer list. Recovery: Add a constructor to the class. ═══ 6.247. EDC3250 ═══ EDC3250 Base class initializers cannot contain virtual function calls. The virtual function table pointers are not set up until after the base classes are initialized. Recovery: Remove the call to a virtual function in the base class initializer. ═══ 6.248. EDC3251 ═══ EDC3251 The previous declaration of "&1" did not have a linkage specification. If you want to declare a linkage specification for a function, it must appear in the first declaration of the function. Recovery: Add a linkage specification to the first declaration of the function ═══ 6.249. EDC3252 ═══ EDC3252 The destructor for "&1" does not exist. The call is ignored. The destructor call is for a type that does not have a destructor. The call is ignored. Recovery: Add a destructor to the type. ═══ 6.250. EDC3253 ═══ EDC3253 "&1" has been added to the scope of "&2". Because the friend class has not been declared yet, its name has been added to the scope of the class containing the friend declaration. Recovery: If this is not intended, move the declaration of the friend class so that it appears before it is declared as a friend. ═══ 6.251. EDC3254 ═══ EDC3254 The body of friend member function "&1" cannot be defined in the member list of "&2". A friend function that is a member of another class cannot be defined inline in the member list. Recovery: Define the body of the friend function at file scope. ═══ 6.252. EDC3255 ═══ EDC3255 The initializer list must be complete because "&1" does not have a default constructor. An array of objects of a class with constructors uses the constructors in initialization. If there are fewer initializers in the list than elements in the array, the default constructor is used. If there is no default constructor the initializer list must be complete. Recovery: Complete the initializer list or add a default constructor to the class. ═══ 6.253. EDC3256 ═══ EDC3256 "&1" cannot be opened. The nested include file limit of &2 has been exceeded. The compiler limit for nested include files has been reached. Recovery: Remove the nesting of one or more of the include files. ═══ 6.254. EDC3257 ═══ EDC3257 An anonymous union at file scope must have a storage class of static. Recovery: Change the storage class of the anonymous union to static. ═══ 6.255. EDC3258 ═══ EDC3258 A pure virtual destructor needs an out-of-line definition in order for its class to be a base of another class. Recovery: Move the definition of the pure virtual destructor so that it is not inline. ═══ 6.256. EDC3259 ═══ EDC3259 The braces in the initializer are incorrect. Recovery: Correct the braces on the initializer. ═══ 6.257. EDC3260 ═══ EDC3260 Invalid octal integer constant. The octal integer constant contains an '8' or a '9'. Octal numbers include 0 through 7. Recovery: Ensure that the octal integer constant is valid. ═══ 6.258. EDC3261 ═══ EDC3261 All the arguments must be specified for "&1" because its default arguments have not been checked yet. For member functions, names in default argument expressions are bound at the end of the class declaration. Calling a member function as part of a second member function's default argument is an error if the first member function's default arguments have not been checked and the call does not specify all of the arguments. Recovery: Specify all the arguments for the function. ═══ 6.259. EDC3262 ═══ EDC3262 Ellipsis (...) cannot be used for "&1". An operator function has been specified with an ellipsis (...), but since the number of operands of an operator are fixed, an ellipsis is not allowed. Recovery: Remove the ellipsis, and specify the correct number of operands. ═══ 6.260. EDC3263 ═══ EDC3263 Syntax error - expected "&1" or "&2" and found "&3". A syntax error was found while parsing the program. The message identifies what the compiler expected and what it actually found. Recovery: Correct the syntax error. ═══ 6.261. EDC3264 ═══ EDC3264 A character constant must end before the end of the line. The compiler detected a character constant that was not terminated before an end-of-line character was found. Recovery: End the character constant or use "\" to continue it on the next line. The "\" must be the last character on the line. ═══ 6.262. EDC3265 ═══ EDC3265 A pure virtual function initializer must be 0. To declare a pure virtual function use an initializer of 0. Recovery: Set the virtual function initializer to 0. ═══ 6.263. EDC3266 ═══ EDC3266 "&1" is given "&2" access. Access of the class has changed. Recovery: Ensure this change is as intended. ═══ 6.264. EDC3267 ═══ EDC3267 "&1" has been qualified with the "this" pointer. Recovery: Ensure this qualification is intended. ═══ 6.265. EDC3268 ═══ EDC3268 Invalid escape sequence; the backslash is ignored. You have provided invalid character(s) after the backslash that does not represent an escape sequence. Therefore, the backslash is ignored and the rest of the escape sequence is read as is. Recovery: Ensure the escape sequence is valid. ═══ 6.266. EDC3269 ═══ EDC3269 The result of an address expression is being deleted. Recovery: Ensure this action is intended. ═══ 6.267. EDC3270 ═══ EDC3270 Conversion from "&1" to "&2" matches more than one conversion function. More than one conversion function could be used to perform the specified conversion. Recovery: Create a new conversion function for this conversion or change one of the types. ═══ 6.268. EDC3271 ═══ EDC3271 Conversion matches "&1". Recovery: Ensure this is the intended match. ═══ 6.269. EDC3272 ═══ EDC3272 "&1" cannot be initialized with an initializer list. Only an object of a class with no constructors, no private or protected members, no virtual functions and no base classes can be initialized with an initializer list. Recovery: Remove the class from the initializer list. ═══ 6.270. EDC3273 ═══ EDC3273 A pointer to a virtual base "&1" cannot be converted to a pointer to a derived class "&2". A pointer to a class B may be explicitly converted to a pointer to a class D that has B as a direct or indirect base class, only if an unambiguous conversion from D to B exists, and B is not a virtual base class. Recovery: Remove the conversion of the pointer. ═══ 6.271. EDC3274 ═══ EDC3274 The arguments passed using the ellipsis may not be accessible. Arguments passed using an ellipsis are only accessible if there is an argument preceding the ellipsis and the preceding argument is not passed by reference. Recovery: Ensure that there is an argument preceding the ellipsis and that the preceding argument is not passed by reference. ═══ 6.272. EDC3275 ═══ EDC3275 Member function "&1" has already been declared. A member function cannot be redeclared in the class definition. Recovery: Remove one of the declarations. ═══ 6.273. EDC3276 ═══ EDC3276 Assignment to a constant expression is not allowed. The left hand side of the assignment operator is an expression referring to a "const" location. For example, in "a.b", either "b" is a "const" member or "a" is a "const" variable. Recovery: Remove the assignment. ═══ 6.274. EDC3277 ═══ EDC3277 Assignment to const variable "&1" is not allowed. The left hand side of the assignment operator is a variable with the "const" attribute. "const" variables may be initialized once at the point where they are declared, but may not be subsequently assigned new values. Recovery: Remove the assignment to the const variable. ═══ 6.275. EDC3278 ═══ EDC3278 Syntax error found while parsing the bit-field declarator. The part of this member declaration up to the colon ":" appears to be a declaration of a bit-field, but the constant expression expected after the colon was either not found or incorrectly formed. Recovery: Correct the syntax error. ═══ 6.276. EDC3279 ═══ EDC3279 The return type for the "operator->" cannot be the containing class. The return type for the "operator->" must be a pointer to a class type, a class type, or a reference to a class type. If it is a class or reference, the class must be previously defined and must contain an "operator->" function. Recovery: Change the return type for the "operator->". ═══ 6.277. EDC3280 ═══ EDC3280 The virtual function table for "&1" is defined with "&2" linkage. The class has one or more virtual function tables. A definition of each table will be generated in the current compilation. Recovery: Ensure this is the desired result. ═══ 6.278. EDC3281 ═══ EDC3281 The virtual function table for "&1" will be defined where "&2" is defined. The class has one or more virtual function tables. None will be defined in the current compilation, but will be defined in the compilation containing the definition of the specified member function. Recovery: Ensure this is the desired result. ═══ 6.279. EDC3282 ═══ EDC3282 The virtual function table for "&1" will be defined in a file specified by the user. Recovery: Ensure this is the desired result. ═══ 6.280. EDC3283 ═══ EDC3283 The previous message applies to function argument &1. The previous message applies to the specified argument number. This message does not indicate another error or warning, it indicates which argument of the function call is the subject of the previous message. ═══ 6.281. EDC3284 ═══ EDC3284 Conversion from "&1" to a reference to a non-const type "&2" requires a temporary. A temporary may only be used for conversion to a reference type when the reference is to a const type. This is a warning rather than an error message because the "compat" language level is active. Recovery: Change the reference so that it is to a const type. ═══ 6.282. EDC3285 ═══ EDC3285 The address of a local variable or compiler temporary is being used in a return expression. The address of a local variable may not be valid once control is passed out of the function. Recovery: Declare the variable in the calling function or as a global variable, or change the return expression to not use the variable. ═══ 6.283. EDC3286 ═══ EDC3286 Keyword "&1" cannot be used with a function definition. Recovery: Remove the keyword. ═══ 6.284. EDC3287 ═══ EDC3287 The directive must occur before the first C++ statement in program; "#pragma" is ignored. Recovery: Remove the directive or place it before the first C++ statement in the program. ═══ 6.285. EDC3288 ═══ EDC3288 The pointer to member function must be bound to an object when it is used with the function call operator (). The pointer to member function must be associated with an object or a pointer to an object when it is used with the function call operator (). Recovery: Remove the pointer or associate it with an object. ═══ 6.286. EDC3289 ═══ EDC3289 The static data member "&1" has already been declared. Recovery: Remove or change one of the declarations. ═══ 6.287. EDC3290 ═══ EDC3290 Option "&1" must be specified on the command line or before the first C++ statement in the program. Recovery: Remove the option or place it before the first statement in the C++ program. ═══ 6.288. EDC3291 ═══ EDC3291 The direct base "&1" of class "&2" is ignored because "&1" is also an indirect base of "&2". A reference to a member of "&1" will be ambiguous because it is inherited from two different paths. Recovery: Remove the indirect inheritance. ═══ 6.289. EDC3292 ═══ EDC3292 The "&1" operator cannot be applied to undefined class "&2". A class is undefined until the definition of its tag has been completed. A class tag is undefined when the list describing the name and type of its members has not been specified. The definition of the tag must be given before the operator is applied to the class. Recovery: Complete the definition of the class before applying an operator to it. ═══ 6.290. EDC3293 ═══ EDC3293 "&1" hides the &2 "&3". A member in the derived class hides a virtual function member in a base class. Recovery: Ensure the hiding of the virtual function member is intended. ═══ 6.291. EDC3294 ═══ EDC3294 "&1" is not the name of a function. A function name is required in this context. The specified name has been declared but it is not the name of a function. Recovery: Check the spelling. If necessary, change to a function name. ═══ 6.292. EDC3296 ═══ EDC3296 The virtual functions "&1" and "&2" are ambiguous since they override the same function in virtual base class "&3". The two functions are ambiguous and the virtual function call mechanism will not be able to choose the correct one at runtime. Recovery: Remove one of the virtual functions. ═══ 6.293. EDC3297 ═══ EDC3297 The "this" address for "&1" is ambiguous because there are multiple instances of "&2". Two or more "this" addresses are possible for this virtual function. The virtual function call mechanism will not be able to determine the correct address at runtime. Recovery: Remove the "this" expression or change the function name. ═══ 6.294. EDC3298 ═══ EDC3298 Conversion from "&1" matches more than one conversion function. More than one conversion function could be applied to perform the conversion from the specified type. Recovery: Create a new conversion function or remove the conversion. ═══ 6.295. EDC3299 ═══ EDC3299 Function "&1" must not be declared as "&2". The specified function has a storage class that is not allowed in the context that the function is declared in. Recovery: Remove the declaration or change the storage class of the function. ═══ 6.296. EDC3300 ═══ EDC3300 The declaration of "&1" must initialize the const member "&2". Recovery: Initialize the member in the declaration. ═══ 6.297. EDC3301 ═══ EDC3301 The declaration of "&1" must initialize the reference member "&2". Recovery: Initialize the member in the declaration. ═══ 6.298. EDC3302 ═══ EDC3302 "&1" is not allowed as a function return type. There may be a ";" missing after a "}". A class or enum definition must not be specified as a function return type. A semicolon may be missing after the definition. Recovery: Ensure that a semicolon is not missing after the definition or change the return type. ═══ 6.299. EDC3303 ═══ EDC3303 "&1" cannot be a base of "&2" because "&3" contains a member function called "&2". A class cannot inherit a function that has the same as the class. Recovery: Change the name of either the base class or the inherited function. ═══ 6.300. EDC3304 ═══ EDC3304 Forward declaration of the enumeration "&1" is not allowed. The declaration of an enumeration must contain its member list. Recovery: Fully declare the enumeration. ═══ 6.301. EDC3305 ═══ EDC3305 Unrecognized value "&1" specified with option "&2". Recovery: Remove the unrecognized value. ═══ 6.302. EDC3306 ═══ EDC3306 The previous message applies to argument &1 of function "&2". The previous message applies to the specified argument number. This message does not indicate another error or warning, it indicates which argument of the function call is the subject of the previous message. ═══ 6.303. EDC3307 ═══ EDC3307 Unrecognized pragma "&1". The pragma is not supported by this compiler. Recovery: Change or remove the #pragma directive. ═══ 6.304. EDC3308 ═══ EDC3308 The nested class object "&1" needs a constructor so that its &2 members can be initialized. Recovery: Create a constructor for the nested class object. ═══ 6.305. EDC3309 ═══ EDC3309 The integer constant is out of range. You have provided an integer constant that is out of range. For the range of integer constants check limits.h. Recovery: Ensure the integer constant is in range. ═══ 6.306. EDC3310 ═══ EDC3310 The floating point constant is out of range. You have provided a floating point constant that is out of range. For the range of floating point constants check float.h. Recovery: Ensure the floating point constant is in range. ═══ 6.307. EDC3311 ═══ EDC3311 The &1 member "&2" must be initialized in the constructor's initializer list. Using the constructor's member initializer list is the only way to initialize nonstatic const and reference members. Recovery: Initialize the member in the constructor's initializer list. ═══ 6.308. EDC3312 ═══ EDC3312 Unexpected end of file: newline expected. The file did not end with a new-line character. Recovery: Ensure the file ends with a new-line character. ═══ 6.309. EDC3313 ═══ EDC3313 Constructors and conversion functions are not considered when resolving an explicit cast to a reference type. You cannot resolve an explicit cast to a reference type using constructors or conversion functions. Recovery: Cast the type to a temporary type and then take the reference to it. ═══ 6.310. EDC3314 ═══ EDC3314 A character string literal cannot be concatenated with a wide string literal. A string that has a prefix L cannot be concatenated with a string that is not prefixed. Recovery: Ensure both strings have the same prefix, or no prefix at all. ═══ 6.311. EDC3315 ═══ EDC3315 All members of type "&1" must be explicitly initialized with all default arguments specified. Default arguments for member functions are not checked until the end of the class definition. Default arguments for member functions of nested classes are not semantically checked until the containing class is defined. A call to a member function must specify all of the arguments before the default arguments have been checked. Recovery: Specify all default arguments with all members of the type. ═══ 6.312. EDC3316 ═══ EDC3316 The nested class "&1" is undefined and cannot be defined later. A class must be defined in the scope that it was introduced. Recovery: Define the class in the scope in which it was introduced. ═══ 6.313. EDC3317 ═══ EDC3317 The address of an overloaded function can be taken only in an initialization or an assignment. Recovery: Ensure the address of an overloaded function is used on an initialization or an assignment, or remove the expression. ═══ 6.314. EDC3319 ═══ EDC3319 The mangled name for "&1" contains a compiler-generated name. It will not be visible from other compilation units. ═══ 6.315. EDC3320 ═══ EDC3320 Syntax error - found "&1 &2" : "&1" is not a type name. The compiler detected a non-type symbol where a type is required. A type must be used to declare an object. Recovery: Change to a type name or remove the expression. ═══ 6.316. EDC3321 ═══ EDC3321 A temporary of type "&1" is needed: "&2" is an abstract class. The compiler has determined that it must use a temporary to store the result of the expression, but the result is an abstract base type. An abstract base type cannot be used to create an object. Recovery: Change the type of the result. ═══ 6.317. EDC3322 ═══ EDC3322 Nesting level of template class definitions may cause the compiler to fail. Template class definitions are nested in such a way that the compiler may not be able to continue. Recovery: Reduce the number of nesting levels of template class definitions. ═══ 6.318. EDC3323 ═══ EDC3323 "&1" hides pure virtual function "&2" in the nonvirtual base "&3". The pure virtual function in a nonvirtual base cannot be overridden once it has been hidden. Recovery: Make the pure virtual function visible, or make the base it is derived from virtual. ═══ 6.319. EDC3324 ═══ EDC3324 The class qualifier "&1" for "&2" must be a template class that uses the template arguments. A non-class template can only declare a global function or a member of a template class. If it declares a member of a template class, the template class arguments must include at least one of the non-class template arguments. Recovery: Change the template declaration so that it either declares a global function or a member of a template class that uses the non-class template arguments. ═══ 6.320. EDC3325 ═══ EDC3325 The class "&1" cannot be passed by value because it does not have a copy constructor. The compiler needs to generate a temporary to hold the return value of the function. To generate the temporary object, a copy constructor is needed to copy the contents of the object being returned into the temporary object. Recovery: Create a copy constructor for the class or change the argument to pass by value. ═══ 6.321. EDC3326 ═══ EDC3326 The previous &1 messages show situations that could arise if the corresponding template definitions were instantiated. During the processing of a class template, possible errors were found in the class declaration. These errors may occur when the template is instantiated. Recovery: Ensure that the errors will not occur when the template is instantiated. ═══ 6.322. EDC3327 ═══ EDC3327 The previous message shows a situation that could arise if the corresponding template definition was instantiated. During the processing of a class template, a possible error was found in the class declaration. This error may occur when the template is instantiated. Recovery: Ensure that the error will not occur when the template is instantiated. ═══ 6.323. EDC3328 ═══ EDC3328 The output file name "&1" cannot be the same as the input file name. The compiler detected a condition where the name of the input source file is the same as an output file being generated by the compiler. Recovery: Change either the input file name or the output file name. ═══ 6.324. EDC3329 ═══ EDC3329 The external variable "&1" cannot be defined at block scope. The compiler has detected the declaration of an automatic variable that was previously defined as having external linkage. Recovery: Move, remove, or change the external variable definition. ═══ 6.325. EDC3330 ═══ EDC3330 "&1" cannot have an initializer list. A member function that is not a constructor is defined with an initializer list. Recovery: Remove the initializer list. ═══ 6.326. EDC3331 ═══ EDC3331 Return value of type "&1" is expected. No return value is returned from the current function but the function is expecting a non-void return value. Recovery: Ensure a value is returned, or change the return type of the function to void. ═══ 6.327. EDC3332 ═══ EDC3332 "&1" bypasses initialization of "&2". It is invalid to jump past a declaration with an explicit or implicit initializer unless the declaration is in an inner block that is also jumped past. Recovery: Enclose the initialization in a block statement. ═══ 6.328. EDC3333 ═══ EDC3333 "&1" is being redeclared as a member function. It was originally declared as a data member. The template redeclares a data member of a class template as a member function. Recovery: Change the original declaration of the variable to a member function, or change the redeclaration of the variable to a data member. ═══ 6.329. EDC3334 ═══ EDC3334 "&1" is being redeclared as a non-function member or has syntax errors in its argument list. The template redeclares a member function of a class template as a data member. There may be syntax errors in the declaration. Recovery: Change one of the declarations if necessary. ═══ 6.330. EDC3335 ═══ EDC3335 A string literal cannot be longer than &1 characters. The compiler limit for the length of a string literal has been exceeded. The string literal is too long for the compiler to handle. Recovery: Specify a shorter string literal. ═══ 6.331. EDC3336 ═══ EDC3336 A wide string literal cannot be longer than &1 characters. The compiler limit for the length of a wide string literal has been exceeded. The wide string literal is too long for the compiler to handle. Recovery: Specify a shorter string literal. ═══ 6.332. EDC3337 ═══ EDC3337 The definition of "&1" is not contained in an include file. It may be needed for automatic generation of template functions. The definition of the class can only be used during automatic generation of template functions if it is contained in an include file. Recovery: Add the definition to an include file. ═══ 6.333. EDC3338 ═══ EDC3338 Invalid "multibyte character sequence character" (MBCS) character. The compiler has detected a multibyte character sequence that it does not recognize. Recovery: Replace the "multibyte character sequence character" (MBCS) character. ═══ 6.334. EDC3339 ═══ EDC3339 "&1" is an undefined pure virtual function. The user tried to call a member function that was declared to be a pure virtual function. Recovery: Remove or define the function as pure virtual. ═══ 6.335. EDC3340 ═══ EDC3340 The presence of the "#line" directive in source files compiled with "-a" or "-ae" may result in the "tcov" program behaving unpredictably. Recovery: Remove the "#line" directive or recompile without the "-a" or "-ae" option. ═══ 6.336. EDC3341 ═══ EDC3341 Missing value for option "&1". The option was messing a required parameter. See the "Users Guide" for details on the option. Recovery: Add a value for the option. ═══ 6.337. EDC3342 ═══ EDC3342 Template "&1" cannot be instantiated because the actual argument for formal argument "&2" has more than one variant. The argument is a function template or an overloaded function with two or more variants. The compiler cannot decide which variant to choose to bind to the argument type. Recovery: Change the formal template argument or remove the extra variants. ═══ 6.338. EDC3343 ═══ EDC3343 More than 32760 files in a compilation unit. The compiler limit has been exceeded for the number of include files allowed in a compilation unit. Recovery: Reduce the number of files. ═══ 6.339. EDC3345 ═══ EDC3345 Pointer to a built-in function not allowed. Because you cannot take the address of a built-in function, you cannot declare a pointer to a built-in function. Recovery: Remove the pointer. ═══ 6.340. EDC3346 ═══ EDC3346 Built-in function "&1" not recognized. The function declared as a built-in is not recognized by the compiler as being a built-in function. Recovery: Ensure the function is a built-in function or remove the built-in keyword from the declaration. ═══ 6.341. EDC3347 ═══ EDC3347 "&1" is not supported. Recovery: Remove the operator from the expression. ═══ 6.342. EDC3348 ═══ EDC3348 Function calls are not supported. You can only generate this message in the debugger, when you use an expression that includes a function call. Recovery: Remove function calls from the expression. ═══ 6.343. EDC3349 ═══ EDC3349 The expression is too complicated. Recovery: Simplify the expression. ═══ 6.344. EDC3350 ═══ EDC3350 Evaluation of the expression requires a temporary. Recovery: Change the expression so that a temporary object is not required. ═══ 6.345. EDC3351 ═══ EDC3351 "&1" is an overloaded function. The identifier refers to an overloaded function with two or more variants. The compiler requires a prototype argument list to decide which variant to process. Recovery: Specify a prototype argument list or remove variants of the overloaded function. ═══ 6.346. EDC3352 ═══ EDC3352 Identifier or function prototype expected. The symbol must be the name of a data object, the name of a function with no variants, or a function or operator name followed by a parenthesized argument list. Recovery: Ensure the symbol is either the name of a data object, the name of a function with no variants, or a function or operator name followed by a parenthesized argument list. ═══ 6.347. EDC3353 ═══ EDC3353 "&1" does not have external linkage. The pragma directives #map, #import, and #export can only be applied to objects or functions that are external. Recovery: Add or remove the #pragma directive. ═══ 6.348. EDC3354 ═══ EDC3354 "&1" has already been mapped. Only one map name may be given to any object or function. Recovery: Change one of the map names. ═══ 6.349. EDC3356 ═══ EDC3356 Invalid option with #pragma. The option specified for the #pragma directive is not valid. Recovery: Remove or change the option. ═══ 6.350. EDC3358 ═══ EDC3358 The "&1" option is not allowed with the "&2" option. The specified options cannot be used together. The first option specified in the message is ignored. Recovery: Remove one of the options. ═══ 6.351. EDC3359 ═══ EDC3359 The result of string concatenation is a non-Pascal string. A Pascal string was concatenated to a non-Pascal string. The result of the concatenation is a non-Pascal string. Recovery: Ensure both strings are either Pascal or non-Pascal. ═══ 6.352. EDC3360 ═══ EDC3360 The result of string concatenation is a Pascal string. A non-Pascal string was concatenated to a Pascal string. The result of the concatenation is a Pascal string. Recovery: Ensure both strings are either Pascal or non-Pascal. ═══ 6.353. EDC3361 ═══ EDC3361 A Pascal string is too long; the length has been set to 255. A Pascal string is longer than 255 bytes. The length byte has been set to 255, but the rest of the string is left intact. Recovery: Shorten the Pascal string. ═══ 6.354. EDC3362 ═══ EDC3362 Compiler-generated name "&1" overridden, may cause link problems. The specified object has a special compiler-generated external name, but appears in a #pragma map directive that would override that name. Using #pragma map to replace the name may cause link errors or prevent argument type checking across compilation units. Recovery: Remove the #pragma map directive that overrides the compiler-generated external name. ═══ 6.355. EDC3363 ═══ EDC3363 The bit-field length must not be negative. The bit-field length must be a non-negative integer value. Recovery: Change the bit-field length to a non-negative integer value. ═══ 6.356. EDC3364 ═══ EDC3364 A zero-length bit-field must not have a name. A named bit-field must have a positive length; a zero-length bit-field is used for alignment only, and must not be named. Recovery: Remove the name from the zero-length bit-field. ═══ 6.357. EDC3365 ═══ EDC3365 The bit-field is too small; &1 bits are needed for "&2". The bit-field length is smaller than the number of bits needed to hold all values of the enum. Recovery: Increase the bit-field length. ═══ 6.358. EDC3366 ═══ EDC3366 The bit-field is larger than necessary; only &1 bits are needed for "&2". The bit-field length is larger than the number of bits needed to hold all values of the enum. Recovery: Decrease the bit-field length. ═══ 6.359. EDC3367 ═══ EDC3367 An object declared as compatible with 16-bit applications is larger than 64K. The name of the object, or a typedef name used to declare it, appeared in a #pragma seg16 directive, indicating it can be used in 16-bit code and will not cross 64K boundaries. However, because the object is larger than 64K, it will cross the 64K boundary. Recovery: Remove the name of an object in the #pragma seg16 directive. ═══ 6.360. EDC3370 ═══ EDC3370 A template friend declaration may only declare, not define, a class or function. The class or function declared in the template friend declaration must be defined at file scope. Recovery: Remove the definition from the template friend declaration. ═══ 6.361. EDC3371 ═══ EDC3371 The function "&1" must not be declared "&2" at block scope. There can be no static or inline function declarations at block scope. Recovery: Move the function so that it is not defined at block scope. ═══ 6.362. EDC3372 ═══ EDC3372 The previous &1 messages apply to function argument &2. The previous message applies to the specified argument number. This message does not indicate another error or warning, it indicates which argument of the function call is the subject of the previous message. ═══ 6.363. EDC3373 ═══ EDC3373 The previous &1 messages apply to argument &2 of function "&3". The previous message applies to the specified argument number. This message does not indicate another error or warning, it indicates which argument of the function call is the subject of the previous message. ═══ 6.364. EDC3374 ═══ EDC3374 "&1" is not a static member of "&2". Non-static data members cannot be defined outside the class definition. Recovery: Make the member a static member or move it into the class definition. ═══ 6.365. EDC3375 ═══ EDC3375 The initializer must be enclosed in braces. Array element initializers must be enclosed in braces. Recovery: Put braces around the initializer. ═══ 6.366. EDC3376 ═══ EDC3376 union "&1" has multiple initializers associated with its constructor "&2". A union can only contain one member object at any time, and therefore can be initialized to only one value. Recovery: Remove all but one of the initializers. ═══ 6.367. EDC3377 ═══ EDC3377 "&1" is declared on line &2 of "&3". This is an informational message; no response is necessary. ═══ 6.368. EDC3378 ═══ EDC3378 "&1" is defined on line &2 of "&3". This is an informational message; no response is necessary. ═══ 6.369. EDC3379 ═══ EDC3379 Maximum number of error messages exceeded. Recovery: Correct the error and recompile. ═══ 6.370. EDC3380 ═══ EDC3380 You cannot override virtual function "&1" because "&3" is an ambiguous base class of "&2". The compiler must generate code to convert the actual return type into the type that the overridden function returns (so that calls to the original overridden function is supported). However, the conversion is ambiguous. Recovery: Clarify the base class. ═══ 6.371. EDC3381 ═══ EDC3381 The operands have type "&1" and "&2". ═══ 6.372. EDC3382 ═══ EDC3382 "&1" is defined in this compilation and cannot be imported. Only externally-defined functions can be imported. Recovery: Remove the directive that imports the function or define the function externally. ═══ 6.373. EDC3383 ═══ EDC3383 "&1" is not defined in this compilation and cannot be exported. Only functions defined in this compilation can be exported. Recovery: Remove the directive that exports the function or define the function in this compilation unit. ═══ 6.374. EDC3384 ═══ EDC3384 "&1" is already imported or exported. Duplicate directive ignored. You can only import or export a function once. Recovery: Remove one of the directives. ═══ 6.375. EDC3385 ═══ EDC3385 Macro "&1" has been invoked with an incomplete argument for parameter "&2". The terminating "," or ")" for the argument was not found. Recovery: Ensure the terminating "," or ")" is in the argument. ═══ 6.376. EDC3386 ═══ EDC3386 The enum cannot be packed to the requested size of &1. The enum type is too large to fit in the storage requested with the /Su option. Recovery: Redefine the storage to a larger size by specifying a larger number for /Su option. ═══ 6.377. EDC3387 ═══ EDC3387 "&1" is not initialized until after the base class is initialized. First, the base classes are initialized in declaration order, then the members are initialized in declaration order, then the body of the constructor is executed. Recovery: Do not reference the class member in the base class initializer. ═══ 6.378. EDC3388 ═══ EDC3388 The expression to the left of the "&1" operator is a relational expression ("&2"). The "&3" operator may have been intended. The compiler has detected the mixing of relational and bitwise operators in what was determined to be a conditional expression. Recovery: Ensure the correct operator is being used. ═══ 6.379. EDC3389 ═══ EDC3389 The expression to the left of the "&1" operator is a logical expression ("&2"). The "&3" operator may have been intended. The compiler has detected the mixing of relational and bitwise operators in what was determined to be a conditional expression. Recovery: Ensure the correct operator is being used. ═══ 6.380. EDC3390 ═══ EDC3390 The expression to the left of the "&1" operator is an equality expression ("&2"). The "&3" operator may have been intended. The compiler has detected the mixing of relational and bitwise operators in what was determined to be a conditional expression. Recovery: Ensure the correct operator is being used. ═══ 6.381. EDC3391 ═══ EDC3391 The expression to the right of the "&1" operator is a relational expression ("&2"). The "&3" operator may have been intended. This message is generated by the /Wcnd option. This option warns of possible redundancies or problems in conditional expressions involving relational expressions and bitwise operators. Recovery: Ensure the correct operator is being used. ═══ 6.382. EDC3392 ═══ EDC3392 The expression to the right of the "&1" operator is a logical expression ("&2"). The "&3" operator may have been intended. This message will be generated when /Wcnd option is specified, in order to warn possible redundancies or problems in conditional expressions involving logical expressions and bitwise operators. Recovery: Ensure the correct operator is being used. ═══ 6.383. EDC3393 ═══ EDC3393 The expression to the right of the "&1" operator is an equality expression ("&2"). The "&3" operator may have been intended. This message will be generated when /Wcnd option is specified, in order to warn possible redundancies or problems in conditional expressions involving equality expressions and bitwise operators. Recovery: Ensure the correct operator is being used. ═══ 6.384. EDC3394 ═══ EDC3394 Assignment to the "this" pointer is not allowed. The "this" pointer is a const pointer and cannot be modified. Recovery: Remove the assignment to the "this" pointer. ═══ 6.385. EDC3395 ═══ EDC3395 "&1" must not have any arguments. Recovery: Remove all arguments from the special member function. ═══ 6.386. EDC3396 ═══ EDC3396 The second operand to the "offsetof" operator is not valid. The second operand to the "offsetof" operator must consist only of "." operators and "[]" operators with constant bounds. Recovery: Remove or change the second operand. ═══ 6.387. EDC3397 ═══ EDC3397 "&1" is a member of "&2" and cannot be used without qualification. The specified name is a class member, but no class qualification has been used to reference it. Recovery: Use the scope operator (::) to qualify the name. ═══ 6.388. EDC3398 ═══ EDC3398 "&1" is undefined. Every variable of type "&2" will assume "&1" has no virtual bases and no multiple inheritance. The definition of the class is not given but the compiler must implement the pointer to member. It will do so by assuming the class has at most one nonvirtual base class. Recovery: If this assumption is incorrect, define the class before declaring the member pointer. ═══ 6.389. EDC3399 ═══ EDC3399 "&1" is undefined. The delete operator will not call a destructor. The definition of the class is not given so the compiler does not know whether the class has a destructor. No destructors will be called. Recovery: Define the class. ═══ 6.390. EDC3400 ═══ EDC3400 Label "&1" is undefined. The specified label is used but is not defined. Recovery: Define the label before using it. ═══ 6.391. EDC3401 ═══ EDC3401 The initializer for enumerator "&1" must be an integral constant expression. The value of an enumerator must be a constant expression that is promotable to a signed int value. A constant expression has a value that can be determined during compilation and does not change during program execution. Recovery: Change the initializer to an integral constant expression. ═══ 6.392. EDC3402 ═══ EDC3402 Static member template encountered - see Programming Guide for restrictions. Templates for static data members are only partially supported, and may cause linker errors if they are overridden by explicit definitions, or if they occur in library objects. For more details, see the chapter on "Using Templates in C++ Programs" in the Programming Guide. Recovery: Ensure that you observe the restrictions listed in the Programming Guide. ═══ 6.393. EDC3403 ═══ EDC3403 Overriding virtual function "&1" may not return "&2" because class &3 has multiple base classes or a virtual base class. Contravariant virtual functions are supported only for classes with single inheritance and no virtual bases. Recovery: Ensure the class has single inheritance and no virtual bases. ═══ 6.394. EDC3404 ═══ EDC3404 Virtual function "&1" is not a valid override virtual function because "&3" is an inaccessible base class of "&2". The compiler must generate code to convert the actual return type into the type that the overridden function returns (so that calls to the original overridden function is supported). However, the target type is inaccessible to the overriding function. Recovery: Make the base class accessible. ═══ 6.395. EDC3405 ═══ EDC3405 "&1" is a member of &2 classes. To reference one of these members, "&3" must be qualified. The class member specified is defined in more than one class nested within the base class and cannot be referenced from the base class if it is not qualified. This message is generated by the /Wund option. Recovery: Use the scope operator (::) to qualify the name. ═══ 6.396. EDC3406 ═══ EDC3406 "&1" is a member of "&2". This message will be invoked with /Wund option when UNQUALIFIED_MEMBER message (about unqualified members) is generated. This message tells you about the member data and the class it belongs to. ═══ 6.397. EDC3407 ═══ EDC3407 "&1" is not the name of a function. A function name is required in this context. The specified name has been declared but it is not the name of a function. Recovery: Ensure the name is the correctly-spelled name of a function. ═══ 6.398. EDC3408 ═══ EDC3408 The value given for the "#pragma priority" is in range reserved for the system. #pragma priority values less than -2147482624 are reserved for system purposes. Recovery: Change the #pragma priority value so that it is greater than -2147482624. ═══ 6.399. EDC3409 ═══ EDC3409 Priority values in successive "#pragma priority" statements must increase. The current priority cannot be higher than the priority specified in the previous #pragma priority statement. As the priority value increases with each #pragma priority directive, the priority level decreases. Recovery: Ensure priority values increase with each #pragma priority statements. ═══ 6.400. EDC3410 ═══ EDC3410 Initialization or termination done before first "#pragma priority" statement. Static objects should not be initialized or terminated before the first #pragma priority directive. before the first #pragma priority. Recovery: Ensure initialization or termination follows the first "#pragma priority" statement. ═══ 6.401. EDC3417 ═══ EDC3417 Enum type "&1" cannot contain both negative and unsigned values. The enumerator type values should fit into an integer. Specifying both unsigned and negative values will exceed this limit. Recovery: Remove the negative or unsigned values. ═══ 6.402. EDC3418 ═══ EDC3418 A conflicting #pragma alloc_text was previously supplied for function &1. A different code segment for the function has been previously specified in the #pragma alloc_text directive. Recovery: Change or remove the current code segment of the function in the #prgama alloc_text directive. ═══ 6.403. EDC3419 ═══ EDC3419 Syntax error in directive - expected "&1" and found "&2". A syntax error was found during preprocessing. The message identifies what the compiler expected and what it actually found. Recovery: Correct the syntax error. ═══ 6.404. EDC3420 ═══ EDC3420 Ordinal value on #pragma import or export must be in range 0 to 65535. The ordinal value specified in a #pragma import or #pragma export directive must be a positive number within the range of short integer values. Recovery: Change the ordinal value so that it is within the range. ═══ 6.405. EDC3422 ═══ EDC3422 Functions callable from 16-bit code may not have pass-by-value aggregate parameters. If the calling function has a 16-bit calling convention (_Far16 _Cdecl, _Far16, _Pascal, or _Far16 _Fastcall), the function being called should not have an aggregate parameter passed by value. Recovery: Remove the by-value aggregate parameters. ═══ 6.406. EDC3423 ═══ EDC3423 Functions callable from 16-bit code may not return an aggregate by value. If the calling function has a 16-bit calling convention (_Far16 _Cdecl, _Far16, _Pascal, or _Far16 _Fastcall), the function being called should not have an aggregate parameter passed by value. Recovery: Remove the return of an aggregate by value. ═══ 6.407. EDC3427 ═══ EDC3427 Cannot take the address of the machine-coded function "&1". Because the function is machine-coded, you cannot take its address. Recovery: Remove the reference to that function. ═══ 6.408. EDC3431 ═══ EDC3431 Invalid pragma name "&1" ignored. The pragma specified is not valid. The compiler ignores it. Recovery: Remove the invalid pragma name. ═══ 6.409. EDC3433 ═══ EDC3433 An initializer is not allowed for the nonvirtual function "&1". The declaration of a pure virtual function must include the keyword virtual. Recovery: Remove the initializer. ═══ 6.410. EDC3473 ═══ EDC3473 Invalid syntax for pragma "&1". Expected "&2". The compiler encountered a pragma with an invalid syntax. The message identifies what the compiler expected and what it actually found. Recovery: Correct the syntax. ═══ 6.411. EDC3474 ═══ EDC3474 Argument to va_start must be a parameter name. va_start initializes the argument to point to the beginning of the list. Recovery: Ensure the argument to va_start is a parameter name. ═══ 6.412. EDC3475 ═══ EDC3475 A local variable or compiler temporary is being used to initialize reference member "&1". The local variable is only active until the end of the function, but it is being used to initialize a member reference variable. Recovery: Ensure that no part of your program depends on the variable or temporary. ═══ 6.413. EDC3476 ═══ EDC3476 Compilation aborted by user or by the operating system. Either you pressed Ctrl-C or the operating system killed the process. Possible cause: swap space is exhausted ═══ 6.414. EDC3482 ═══ EDC3482 "&1" must appear inside the member list for its class. The specified pragma may only appear within the member list for the class to which it applies. Recovery: Move the pragma inside the definition of the class. ═══ 6.415. EDC3484 ═══ EDC3484 Ellipsis parameters not supported for 16 bit callable functions. Variable length parameter lists cannot be used when calling between 16 and 32 bit functions. This is a permanent restriction. ═══ 6.416. EDC3485 ═══ EDC3485 "&1" is not the SOM name of a SOM class. A SOM name that represents a SOM class is expected, and was not found. The SOM name of a class may differ from its C++ name. Recovery: Ensure that you use the correct SOM name for the class. ═══ 6.417. EDC3486 ═══ EDC3486 SOM class version must be an integer greater than or equal to zero. The major and minor version numbers supplied in the SOMClassVersion pragma must both be integers greater than or equal to zero. Recovery: Replace the number with a valid version number. ═══ 6.418. EDC3487 ═══ EDC3487 "&1" must specify the C++ name of a SOM class. The pragma requires the name of a SOM class. Some pragmas may also permit an asterisk, if the pragma appears inside the class definition. The name you have supplied does not represent a SOM class visible in the current scope. Recovery: Ensure that you use the correct C++ name of a SOM class. correctly. ═══ 6.419. EDC3488 ═══ EDC3488 "SOMObject" method "&1" is missing or misplaced in the release order. The definition of the special SOM class "SOMObject" is not compatible with the use of the Direct-to-SOM feature. A valid definition is found in the standard Direct-to-SOM include header "somobj.hh". Recovery: Use the valid definition or disable the Direct-to-SOM feature. ═══ 6.420. EDC3489 ═══ EDC3489 Definition of "&1" is only allowed at file scope. A template class is being defined in a scope other than file scope. Because all template class names have file scope this definition is not allowed. Recovery: Move the template class definition to file scope. ═══ 6.421. EDC3490 ═══ EDC3490 Class template "&1" cannot be used until its containing template has been instantiated. The class template referenced cannot be used until the template that contains it has been instantiated. template cannot be used. Recovery: Declare the class template at file scope or instantiate the template that contains it. ═══ 6.422. EDC3491 ═══ EDC3491 The data in precompiled header &1 does not have the correct format. The precompiled header file has been corrupted or is not actually a precompiled header file. Recovery: Delete the corrupted header file or use the correct option to regenerate it. ═══ 6.423. EDC3492 ═══ EDC3492 Unable to open precompiled header &1. The original header will be used. The specified error occurred when the compiler attempted to open the precompiled header file. Recovery: Correct the condition that prevented the open. ═══ 6.424. EDC3493 ═══ EDC3493 Precompiled header &1 was created by a later release of the compiler. The original header will be used. The precompiled header cannot be used because it was created by a later version of the compiler. Recovery: Delete the header or use the -genpcomp option to regenerate it. ═══ 6.425. EDC3494 ═══ EDC3494 Unable to write to precompiled header &1. The specified error occurred when the compiler attempted to write to the precompiled header file. Recovery: Correct the condition which prevented the write operation. ═══ 6.426. EDC3495 ═══ EDC3495 Invalid wchar_t value &1. A multibyte character or escape sequence in a literal has been converted to an invalid value for type wchar_t. Recovery: Change the character or escape sequence. ═══ 6.427. EDC3496 ═══ EDC3496 Macro &1 has been invoked with an empty argument for parameter &2. The argument corresponding to the specified parameter has no tokens. Recovery: If necessary, specify an argument. ═══ 6.428. EDC3498 ═══ EDC3498 Precompiled header &1 created. The precompiled header was successfully created. ═══ 6.429. EDC3499 ═══ EDC3499 Cannot open precompiled header &1 for output. The specified error occurred when the compiler attempted to open the precompiled header file. Recovery: Correct the condition which prevented the compiler from opening the file. ═══ 7. EDC3500 - EDC3999 ═══ ═══ 7.1. EDC3500 ═══ EDC3500 Precompiled header &1 not used because the header file was modified. The precompiled header cannot be used because the header file that created it was modified after the precompiled header file was generated. Recovery: Delete the header or use the -genpcomp option to regenerate it. ═══ 7.2. EDC3501 ═══ EDC3501 Precompiled header &1 used. The compiler is using the precompiled header file indicated. ═══ 7.3. EDC3502 ═══ EDC3502 "&1" was introduced in class "&2" and can only be specified in the SOMReleaseOrder list for that class. Only those virtual functions or operators introduced in a class may appear in its release order list. Virtual functions that override a base class virtual function should normally only appear in the release order of the base class. However, under special circumstances you can use the "!" notation to also put it in the derived class release order; see the description of the SOMReleaseOrder pragma for details. Recovery: Remove the member from this release order pragma. ═══ 7.4. EDC3503 ═══ EDC3503 SOM class "&1" has a non-SOM base class "&2". All base classes of a SOM class must themselves be SOM classes. Recovery: Change the list of base classes so they are either all SOM or all non-SOM. ═══ 7.5. EDC3504 ═══ EDC3504 Instances of SOM class "&1" will inherit more than one sub-object of base class "&2". All base classes of a SOM class that appear more than once in the class hierarchy must be virtual base classes. Recovery: Make the base class a virtual base class. ═══ 7.6. EDC3507 ═══ EDC3507 "&1" has already been defined as a SOM class name or metaclass name. All SOM names of classes and metaclasses must be unique, without regard to case sensitivity. Recovery: Change the SOM name of the class or the metaclass to make it unique. ═══ 7.7. EDC3508 ═══ EDC3508 "&1" has already been defined as a SOM member name in class "&2". All SOM member names must be unique within the class, without regard to case sensitivity. Recovery: Change the SOM name of the member to make it unique. ═══ 7.8. EDC3509 ═══ EDC3509 "&1" already has a SOM name "&2". A SOM class or member is being assigned a SOM name when it already has one. It may have already been assigned a SOM name by a preceding pragma, or it may have assumed a default SOM name because the pragma occurs too late in the source. We recommended that you put the pragma inside the class definition to avoid the latter problem. Recovery: Remove redundant pragmas or move unique ones into the class definition. ═══ 7.9. EDC3511 ═══ EDC3511 "&1" already has a SOM metaclass name "&2". A SOM class is being assigned a SOM metaclass name when it already has one. Recovery: Remove the redundant pragma. ═══ 7.10. EDC3512 ═══ EDC3512 "&1" is not a member of a SOM class. The name is not declared as a member of a SOM class. Recovery: Replace the name with the name of a member of a SOM class. ═══ 7.11. EDC3513 ═══ EDC3513 "#pragma SOMAttribute" cannot be applied to "&1". The SOMAttribute pragma can only be applied to nonstatic data members. In addition, the data member cannot be a reference to an abstract class type. Recovery: Remove the SOMAttribute pragma or change the data member type. ═══ 7.12. EDC3514 ═══ EDC3514 Direct-to-SOM class "SOMObject" must have a SOMReleaseOrder pragma. The definition of the special SOM class SOMObject is not compatible with the use of the Direct-to-SOM feature. A valid definition is found in the standard Direct-to-SOM include header "somobj.hh". Recovery: Use the valid definition or disable the Direct-to-SOM feature. ═══ 7.13. EDC3515 ═══ EDC3515 Argument "&1" of "#pragma SOMClassInit" is not of the necessary function type. Argument "&1" of #pragma SOMClassInit must be a non-member or static member function taking one argument of type "SOMClass*" and returning void. Recovery: Replace the argument with a function of the correct type. ═══ 7.14. EDC3516 ═══ EDC3516 Entry "&1" in the release order list has either been specified twice or is not a member of the class. You can only specify a member of a class in the release order list of that class, and each member may not appear more than once. Recovery: Remove the entry from the release order list and recompile or add a corresponding member to the class and recompile. ═══ 7.15. EDC3517 ═══ EDC3517 Some members did not appear in the release order list for SOM class "&1". There are public or protected members that were not mentioned in the release order list. They are added to the end of the list. Recovery: Add the missing members to the release order list. ═══ 7.16. EDC3518 ═══ EDC3518 The string must be terminated before the end of the line. The compiler detected a string that was not terminated before an end-of-line character was found. Recovery: End the string or use "\" to continue the string on the next line. The "\" must be the last character on the line. ═══ 7.17. EDC3519 ═══ EDC3519 A character constant must end before the end of the line. The compiler detected a character constant that was not terminated before an end-of-line character was found. Recovery: End the character constant or use "\" to continue it on the next line. The "\" must be the last character on the line. ═══ 7.18. EDC3520 ═══ EDC3520 A matching &1 function named "&2" could not be found. The call may have failed because no member function exists that accepts the 'const/volatile' qualifications of the object. Recovery: Ensure the type qualifier is correct and that the function name is spelled correctly. ═══ 7.19. EDC3521 ═══ EDC3521 "&1" was previously declared as a SOM class, but is not being defined as a SOM class. The class was expected to be a SOM class, probably because its name appeared in a SOMClassName or SOMMetaClass pragma, but it is being defined as a non-SOM class. It will be defined as a SOM class only if the SOMAsDefault pragma is "on", or if the class inherits from the SOMObject class. Recovery: Change the class declaration or definition to make them consistent. ═══ 7.20. EDC3522 ═══ EDC3522 The macro "&1" has been redefined. An active definition already exists for the macro name being defined. The second definition will be used. Recovery: Remove or rename one of the macro definitions if necessary. ═══ 7.21. EDC3523 ═══ EDC3523 "&1" is a type name being used where a variable name is expected. The identifier must be a variable name not a type name. Recovery: Check that the identifier is a variable name and ensure the variable is not hidden by a type name. ═══ 7.22. EDC3524 ═══ EDC3524 Template "&1" has a missing or incorrect template argument list. A template name was found where a variable name was expected. Recovery: Complete the template argument list or change the identifier to a variable name. ═══ 7.23. EDC3526 ═══ EDC3526 Template friend declaration does not declare a class or a function. A template friend declaration must declare a class or a function following the template arguments. Recovery: Change the template declaration to declare a class or a function. ═══ 7.24. EDC3528 ═══ EDC3528 The 'const' object has been cast to a non-'const' object. A cast has been used to possibly modify a 'const' object. This may cause undefined behaviour at run-time. Recovery: Remove the cast or make the object non-const. ═══ 7.25. EDC3531 ═══ EDC3531 #pragma HasHome must be specified for "&1" before #prama IsHome may be specified. You must specify #pragma HasHome for "&1" before you can specify #pragma IsHome for it. Recovery: Specify the #pragma HasHome before the #pragma IsHome or remove the #pragma IsHome. ═══ 7.26. EDC3532 ═══ EDC3532 &1 may only be used at file scope. The pragma is only valid at file scope. Recovery: Move the pragma so that it is in file scope. ═══ 7.27. EDC3533 ═══ EDC3533 Global friend functions may not be defined in a local class. A local class cannot have a friend function. Recovery: Make the function a member function in the local class. ═══ 7.28. EDC3534 ═══ EDC3534 No matching #pragma &1(on|off) for #pragma &1(pop) Either a #pragma &1(on|off) was not specified or a #pragma &1(pop) has already been encountered. Recovery: Remove the pop or add on|off to the pragma. ═══ 7.29. EDC3542 ═══ EDC3542 Function &1 cannot be inlined and will be treated as static. The inliner is not able to inline this function without changing the behavior of the program. An out-of-line copy of the function will be generated in each compilation unit in which it is used. Recovery: Remove the inline specification from the declaration so that a single out-of-line copy is generated. ═══ 7.30. EDC3543 ═══ EDC3543 SOM class &1 must not have operator= functions and somAssign functions. somAssign is an obsolete SOM member function, introduced by the SOMObject base class, that performs similar to operator= function. somAssign is still supported for backward compatibility, but classes may not have both somAssign member functions and operator= members. If you define only one, the compiler will supply a compatible version of the other. Recovery: Remove either the operator= methods or the somAssign methods. ═══ 7.31. EDC3544 ═══ EDC3544 #pragma argument directive has already been specified for function "&1". This #pragma will be ignored. #pragma argument for a function can only be defined once. Any subsequent specification will be ignored. ═══ 7.32. EDC3545 ═══ EDC3545 Function "&1" specified within #pragma argument should not have any linkage type (except "C") associated with it. Function with linkage type such as "OS" or "built-in" are not allowed in the #pragma directive. Recovery: Remove the linkage type or make it "C". ═══ 7.33. EDC3546 ═══ EDC3546 Function specified in #pragma argument must be defined or declared before the directive. The function specified within the #pragma argument is either not defined or defined after the directive. Recovery: Define the function before the #pragma argument directive. ═══ 7.34. EDC3547 ═══ EDC3547 The member function "&1" cannot be used in #pragma weak. Do not use a member function in #pragma weak. Use only standard functions. Recovery: Replace the member function in the #pragma weak with a standard function. ═══ 7.35. EDC3548 ═══ EDC3548 The initial #pragma SOMAsDefault(on) is not at file scope. The SOMAsDefault pragma may not appear nested inside a class or in a function. If you are declaring nested classes and wish them to be SOM classes, you must either use the pragma at file scope, or explicitly derive the classes from the SOMObject class. Recovery: Delete the pragma or move it to file scope. ═══ 7.36. EDC3549 ═══ EDC3549 "&1" cannot be converted to "&2" because one has SOMCallStyle(oidl) and the other has SOMCallStyle(idl). The callstyle of a class affects how its methods are called, and methods of a SOM class must be invoked using the call style they were constructed to expect. For this reason, pointers to members of a SOM class cannot be converted to pointers to members of a class with an incompatible call style. Recovery: Change the classes to have the same call style. ═══ 7.37. EDC3550 ═══ EDC3550 Unimplemented SOM feature: &1. You have attempted to use a feature of SOM that is not supported, or a C++ language construct that is not supported for SOM objects. This may occur if you try to use the unsupported construct directly, or if the compiler needs to use an unsupported construct in order to implement your code. Recovery: Rewrite your code using different constructs, to accomplish the same result. ═══ 7.38. EDC3551 ═══ EDC3551 The address of data member "&1" cannot be taken because the member is being referenced through a _get_ function. An attribute is access through a "_get_" method if its backing data is not accessible, or if the SOMNoDataDirect pragma is in effect for the class. Since the "__get" method returns the value of the member, and not its address, it isn't possible to use the address operator "&" on the member to create an ordinary pointer. This error may also be generated if you haven't used the "&" operator explicitly, but the compiler needs to use it to implement your code. You can create a a pointer-to-member that refers to an attribute. Recovery: Rewrite the expression that causes the address to be taken, or remove the SOMAttribute pragma. ═══ 7.39. EDC3552 ═══ EDC3552 Local class "&1" may not be a SOM class. A local class is a class defined inside a function body. Local classes that are SOM classes are not supported. Recovery: Make the class a non-SOM class or define it at file scope. ═══ 7.40. EDC3553 ═══ EDC3553 Class "&1" has multiple SOMClassVersion pragmas with differing values. A single pair of major and minor version numbers should be associated with the implementation of each class, and with each client, so that SOM can detect incompatibilities. Recovery: Remove all but one of the pragmas. ═══ 7.41. EDC3554 ═══ EDC3554 "&1" must occur at SOM class scope. Some SOM pragmas must appear within the class scope, because the compiler must have the information they supply to correctly process the class definition. Put these pragmas inside the braces of the class definition, but not inside any nested classes or function bodies. Recovery: Move the pragma inside the class definition. ═══ 7.42. EDC3555 ═══ EDC3555 Using '*' to represent the current class for "&1" is only valid at SOM class scope. Some SOM pragmas that take a SOM class name as a parameter can also use an asterisk '*' to identify the class, but only if the pragma appears in the definition of the class. The pragma also must not be inside a nested scope, such as a nested class or function body. Recovery: Move the pragma inside the class definition or replace '*' with the class name. ═══ 7.43. EDC3556 ═══ EDC3556 '*' is not valid for SOM "&1". The pragma does not accept '*' to designate the current class. You may achieve the same effect by turning the pragma 'on' before the class, and using the 'pop' parameter after the class. Recovery: Replace '*' with one of 'on', 'off', or 'pop'. ═══ 7.44. EDC3557 ═══ EDC3557 Expected one of 'on'/'off'/'pop' for "&1". This pragma toggles a SOM option on or off when the 'on' or 'off' parameters are supplied, and returns to the previous value when the 'pop' parameter is used. No other parameter values are valid. Recovery: Replace the invalid parameter with one of 'on', 'off', or 'pop'. ═══ 7.45. EDC3558 ═══ EDC3558 Expected one of 'on'/'off'/'pop'/'*' for "&1". This pragma toggles a SOM option default on or off when the 'on' or 'off' parameters are supplied, and returns to the previous value when the 'pop' parameter is used. In addition, if the parameter appears inside a SOM class scope, you can use the '*' parameter to turn the option on only for the current class. No other parameter values are valid. Recovery: Replace the invalid parameter with one of 'on', 'off', 'pop', 'or' *. ═══ 7.46. EDC3559 ═══ EDC3559 Expected one of 'idl'/'oidl' for "&1". The callstyle of a SOM class determines how its methods are called, and is specified using the SOMCallStyle pragma. This pragma takes a single parameter which must be either 'idl' or 'oidl'. Recovery: Replace the invalid or missing parameter with 'idl' or 'oidl'. ═══ 7.47. EDC3560 ═══ EDC3560 More than one "&1" in class &2. Only one instance of this pragma is permitted in any particular SOM class. Recovery: Remove the extra pragmas. ═══ 7.48. EDC3561 ═══ EDC3561 The address of a dereferenced pointer-to-member expression may not be taken because get/set methods are being used. An attribute is accessed through a "__get" method if its backing data is not accessible, or if the SOMNoDataDirect pragma is in effect for the class. It is possible to create a pointer-to-member that refers to an attribute, and the "__get" method will be called when the pointer-to-member is dereferenced. However, since the "__get" method returns the value of the member and not its address, it isn't possible to use the address operator "&" on the dereferenced pointer-to-member to create an ordinary pointer. Recovery: Don't take the address of the attribute, or make the attribute's backing store accessible, or remove the SOMAttribute pragma so the data member will not be an attribute. ═══ 7.49. EDC3562 ═══ EDC3562 Alignment is determined at the left brace of the definition. The alignment has been changed during a class definition. Recovery: Remove the #pragma align or place it before the class definition. ═══ 7.50. EDC3563 ═══ EDC3563 '!' was specified for "&1", which was introduced in the current class. '!' must only be used for names introduced in a base class. Recovery: Remove the '!' from the SOMReleaseOrder entry. ═══ 7.51. EDC3564 ═══ EDC3564 No assignment operator exists for "&1" in class "&2". Compiler-generated "_set_&1" will call SOMError. The compiler cannot generate the _set function for a class member because the member is an instance of a class that does not have a suitable operator=. Recovery: Use #pragma SOMAttribute(var, noset) and write your own _set function. ═══ 7.52. EDC3565 ═══ EDC3565 The #include of is not at file scope. A line containing #pragma SOM was found nested inside a class or function, but the pragma is only valid at file scope. Since the pragma is normally found only within the standard header file somobj.hh, it is likely that somobj.hh (or another header file that includes it, such as som.hh) was included inside a class or function scope. Recovery: Move the #include line to file scope. ═══ 7.53. EDC3566 ═══ EDC3566 SOMMethodName for "&1" is not valid because "&1" was introduced in class "&2". The SOMMethodName pragma cannot be applied to virtual functions that override a function in a base class, because the introducing function and all its overrides must have the same SOM name. The pragma can be applied to virtual functions only in the introducing class, and to any non-virtual member functions. Recovery: Remove the SOMMethodName pragma or make the function not virtual. ═══ 7.54. EDC3567 ═══ EDC3567 #pragma SOMCallStyle may not be changed more than once per class. The callstyle of a SOM class is associated with the class and affects all of its member functions. Callstyle cannot be changed once set, and cannot have different values for different member functions. Recovery: Remove the extra #pragma SOMCallStyle. ═══ 7.55. EDC3568 ═══ EDC3568 "&1" may only be used for SOM classes. This pragma is valid only for SOM classes. A class is a SOM class if it inherits from SOMObject, or if the SOMAsDefault pragma is 'on'. Recovery: Remove the pragma. ═══ 7.56. EDC3570 ═══ EDC3570 Syntax error while processing option "&1" - expected "&2" and found "&3". A syntax error was found while parsing the option. The message identifies what the compiler expected and what it actually found. Often the source of the error is an unmatched parenthesis or a missing semicolon. Recovery: Correct the syntax. ═══ 7.57. EDC3571 ═══ EDC3571 User cast between SOM and non-SOM pointer types "&1" and "&2". Either the source or destination type is a pointer to a SOM object, and the other type is a pointer to some non-SOM object. This cast could cause problems because the layout of SOM objects is known only to SOM, and may change in later versions of the class or of its base classes. Recovery: If this is the desired cast, cast to void* first to suppress the warning. ═══ 7.58. EDC3572 ═══ EDC3572 &1 is not valid for &2. This pragma is valid only for certain kinds of SOM class members, but has been applied to a different kind of member. For example, the SOMMethodName pragma is valid only for functions, and attempts to use it on data members will generate this error. Recovery: Remove the pragma. ═══ 7.59. EDC3573 ═══ EDC3573 "&1" is not a typename. Parameters to #pragma SOMIDLTypes must be type names, which are either typedef names or the names of classes, structs, unions, or enums. Variable names are not valid, nor are the predefined basic types such as 'int'. Recovery: Do not use variables or basic types as parameters to pragma SOMIDLTypes. ═══ 7.60. EDC3588 ═══ EDC3588 "&1" must have type "Environment *", not "&2". The __SOMEnv variable that you declared does not have the correct type. Recovery: Correct the declared type. ═══ 7.61. EDC3590 ═══ EDC3590 Address of "&1" may not be taken, because "&1" is an indirect attribute. An indirect attribute may not be converted to a pointer to data member, because the compiler cannot generate code to correctly dereference the pointer later. Indirect attributes are for compatibility with SOM 1.0. Recovery: Remove the indirect attribute from the #pragma SOMAttribute for the variable. ═══ 7.62. EDC3598 ═══ EDC3598 The compiler could not open the output file "&1". The open command failed for file "&1". Recovery: Ensure the output file name is correct. Also, ensure that the location of the output file has sufficient storage available. If using a LAN drive, ensure that the LAN is working properly and you have permission to write to the disk. ═══ 7.63. EDC3601 ═══ EDC3601 _get/_set routines must not be declared by users. The compiler will generate _get/_set declarations for SOM attributes. You must not declare them. You may define these routines if the noget/noset/nodata attributes are on. Recovery: Use #pragma SOMAttribute to declare the _get and _set routines. ═══ 7.64. EDC3602 ═══ EDC3602 Only one of 'nodata', 'publicdata', 'protecteddata', 'privatedata' may be specified in a "#pragma SOMAttribute". A SOM attribute must either have no backing data, or the backing data must be public, protected or private. It is an error to specify more than one backing data modifier for a variable. Recovery: Remove the extra modifiers. ═══ 7.65. EDC3603 ═══ EDC3603 Access mode "&1" for backing data is more accessible than mode "&2" for member "&3". It is an error for the backing data for a SOM attribute to be more accessible than the _get/_set routines. An example of the problem would be a private attribute with public backing data. Recovery: Change the access of the backing data or of the member. ═══ 7.66. EDC3604 ═══ EDC3604 #pragma SOMAttribute may only be given once for data member "&1". The SOMAttribute pragma may only be specified once for each data member. Recovery: Combine all the attributes into one #pragma SOMAttribute. ═══ 7.67. EDC3605 ═══ EDC3605 Assignment to read-only variable "&1" is not allowed. A SOM readonly variable is similar to a C++ const variable. It is an error to assign to the variable using the _set_var procedure call. You can assign to a read-only attribute only if its backing data is accessible. Recovery: Remove the assignment to the SOM read-only variable. ═══ 7.68. EDC3606 ═══ EDC3606 "&1" already has a class initializer function "&2". Only one class initializer function is allowed for each SOM class. Recovery: Remove the extra SOMClassInit pragmas. ═══ 7.69. EDC3607 ═══ EDC3607 The address of compiler-generated routine "&1" may not be taken unless it appears in a #pragma SOMReleaseOrder. A compiler-generated operator assignment function for a SOM class may not be converted to a pointer-to-function member unless the routine is mentioned in the release order. The purpose of this restriction is to ensure binary compatibility if the class is modified later. Recovery: Add the method to the release order. ═══ 7.70. EDC3608 ═══ EDC3608 "&1" is not a SOM attribute. Only data members that are SOM attributes may be specified in the SOMReleaseOrder pragma. Recovery: Remove the member from the release order. ═══ 7.71. EDC3616 ═══ EDC3616 Cannot adjust access of "&1" because it is not an attribute. The access to a SOM class data member can be adjusted only if the data member is designated an attribute by use of the SOMAttribute pragma. Recovery: Remove the access adjustment expression or use the SOMAttribute pragma. ═══ 7.72. EDC3617 ═══ EDC3617 Precompiled header file cannot be generated because a declaration was not complete when the last header file ended. A declaration may not begin in a header file and end in the main program file. No precompiled header file is generated. Recovery: Complete the declaration before the end of the header file. ═══ 7.73. EDC3618 ═══ EDC3618 Pointer to member does not refer to an attribute when the SOMNoDataDirect pragma is in effect for the class. A pointer to member is assigned the address of a data member &1 that is not an attribute when the SOMNoDataDirect pragma is in effect for the class. If the pointer is dereferenced, the compiler will attempt to use "__get" and "__set" methods to access the member, which will result in a run-time error, because these methods do not exist for the data member. Recovery: Rewrite the expression that causes the address to be taken, designate the data member as an attribute using the SOMAttribute pragma, or remove the SOMNoDataDirect pragma. ═══ 7.74. EDC3619 ═══ EDC3619 Undefined class &1 specified with -Fr option. The class name &1 was specified with the -Fr command line option, but this class is not defined. A release order will not be generated for the class. Recovery: Define the class, change the name specified with the Fr option, or remove the Fr option. ═══ 7.75. EDC3620 ═══ EDC3620 #pragma &1 directive can be specified only once per source file. You can specify the #pragma directive indicated only once in each source file. Recovery: Remove one of the #pragma &1 statements. ═══ 7.76. EDC3621 ═══ EDC3621 The function specified in #pragma weak &1 should not be defined and referenced in the same compilation unit. The function specified in #pragma weak should only be defined externally and should not be referenced in the same compilation unit. Recovery: Split the function definition and the function reference into separate compilation units. ═══ 7.77. EDC3636 ═══ EDC3636 Address of readonly attribute taken when the SOMNoDataDirect pragma is in effect for the class. The address is taken of a data member &1 that is a readonly attribute, when the SOMNoDataDirect pragma is in effect for the class. If the address is used to modify the member, the compiler will attempt to use the "__set" method to access the member, which will result in a run-time error, because this method does not exist for the data member. Recovery: Rewrite the expression that causes the address to be taken, remove the readonly designation for the attribute, or remove the SOMNoDataDirect pragma. ═══ 7.78. EDC3637 ═══ EDC3637 Compiler does not supply volatile operator= functions for SOM classes. An assignment was attempted to a volatile SOM object of type &1 for which no matching operator= could be found. The compiler supplies four operator= functions which are not qualified with volatile. In order to operate on volatile SOM objects, you must supply volatile versions of the member functions. It is recommended that you supply volatile versions of all four assignment operators. Recovery: Rewrite the expression that causes the assignment, remove the volatile qualifier for the SOM object, or supply volatile versions of the operator= functions for the SOM class. ═══ 7.79. EDC3638 ═══ EDC3638 The header file name in the #include directive cannot be empty. Recovery: Specify a non-empty header file name in the #include directive. ═══ 7.80. EDC3641 ═══ EDC3641 Direct access to &1 is valid only through the "this" pointer when NoDataDirect is in effect for the class. A pointer or reference is used to directly access the instance data for non-attribute member &1 when NoDataDirect is in effect for the class. If the object is remote, this will result in a run-time error because the data is not locally accessible. When NoDataDirect is in effect for the class, direct access to instance data, even within a member function, is valid only through the "this" pointer, because then the object is guaranteed to be local. Recovery: Rewrite the expression that references the data, designate the data member as an attribute using the SOMAttribute pragma, or remove NoDataDirect for the class. ═══ 7.81. EDC3642 ═══ EDC3642 #&1 condition evaluates to &2. This message traces preprocessor expression evaluation. Recovery: No response. ═══ 7.82. EDC3643 ═══ EDC3643 defined(&1) evaluates to &2. This message traces preprocessor #ifdef and #ifndef evaluation. Recovery: No response. ═══ 7.83. EDC3644 ═══ EDC3644 Stop skipping tokens. This messages traces conditional compilation activity. Recovery: No response. ═══ 7.84. EDC3645 ═══ EDC3645 File &1 has already been #included. This #include directive is redundant. Recovery: Remove the #include directive. ═══ 7.85. EDC3646 ═══ EDC3646 #include found file &1. This message traces the activity of the #include directive. Recovery: No response. ═══ 7.86. EDC3647 ═══ EDC3647 #line directive changing line to &1 and file to &2. Traces #line directive evaluation. Recovery: No response. ═══ 7.87. EDC3648 ═══ EDC3648 #line directive changing line to &1. Traces #line directive evaluation. Recovery: No response. ═══ 7.88. EDC3649 ═══ EDC3649 The macro definition will override the keyword "&1". Overriding a C keyword with a preprocessor macro may cause unexpected results. Recovery: Change the name of the macro if necessary. ═══ 7.89. EDC3650 ═══ EDC3650 Some program text not scanned due to &1 option or #pragma &2. MARGINS or SEQUENCE option, or #pragma margins or sequence was used to limit the valid text region in a source file. Recovery: Remove the MARGINS or SEQUENCE option, or remove the #pragma margins or sequence, or specify a more inclusive text region. ═══ 7.90. EDC3651 ═══ EDC3651 Macro &1 redefined with identical definition. Identical macro redefinitions are allowed but not necessary. The amount of whitespace separating tokens have no bearing on whether macros are considered identical. Recovery: Remove the identical definition if necessary. ═══ 7.91. EDC3652 ═══ EDC3652 #&1 nesting level is &2. Traces conditional compilation activity. Recovery: No response. ═══ 7.92. EDC3653 ═══ EDC3653 Compiler internal name "&1" has been defined as a macro. Internal compiler names should not be redefined. Recovery: Delete the macro definition or change the name of the macro being defined. ═══ 7.93. EDC3654 ═══ EDC3654 Compiler internal name "&1" has been undefined as a macro. Internal compiler names should not be undefined. Recovery: Delete the undefined macro. ═══ 7.94. EDC3655 ═══ EDC3655 Begin skipping tokens. This messages traces conditional compilation activity. Recovery: No response. ═══ 7.95. EDC3656 ═══ EDC3656 A trigraph sequence occurred in a character literal. The trigraph sequence will be converted, although a literal interpretation may have been desired. Recovery: Change the value of the character literal if necessary. ═══ 7.96. EDC3657 ═══ EDC3657 A trigraph sequence occurred in a string literal. The trigraph sequence will be converted, although a literal interpretation may have been desired. Recovery: Change the value of the string literal if necessary. ═══ 7.97. EDC3658 ═══ EDC3658 #undef undefining macro name "&1". Traces #undef preprocessor directive evaluation. Recovery: No response. ═══ 7.98. EDC3659 ═══ EDC3659 Unknown macro name "&1" on #undef directive. An attempt is being made to undefine a macro that has not been previously defined. Recovery: Remove the #undef directive. ═══ 7.99. EDC3660 ═══ EDC3660 Header &1 included again because it is never empty. The referenced header file has already been #included and will be physically #included again because there is no conditional compilation path in it which results in an empty file. Recovery: If desired, at the top of the header, test a macro name which is defined by the header to prevent subsequent inclusions. ═══ 7.100. EDC3661 ═══ EDC3661 Header &1 not included again because it is empty. The referenced header file has already been #included and will not be physically #included again because it is empty. Recovery: If desired, do not #include the header since it is empty. ═══ 7.101. EDC3662 ═══ EDC3662 Header &1 included again because conditional compilation analysis is incomplete. The referenced header file has already been #included and will be physically #included again because the inclusion is recursive and the conditional compilation analysis of the header is therefore incomplete. Recovery: If desired, test a macro name which is defined by the header at the point of inclusion to prevent subsequent inclusions. ═══ 7.102. EDC3663 ═══ EDC3663 Header &1 not included again because it would have no effect due to conditional compilation. The referenced header file has already been #included and will not be physically #included again because conditional compilation would expose no additional source to the compiler. Recovery: If desired, do not #include the header since it is redundant. ═══ 7.103. EDC3664 ═══ EDC3664 End of precompiled header processing. The compiler has finished processing a precompiled header. Recovery: No response. This message merely traces the activity of the precompiled header feature. ═══ 7.104. EDC3665 ═══ EDC3665 Macro "&1" is required by the precompiled header and is defined differently than when the precompiled header was created. The referenced macro was expanded during the creation of the precompiled header and is now defined differently. This prevents the precompiled header from being used for this compilation. Recovery: If necessary, redefine the macro, or regenerate the precompiled header ═══ 7.105. EDC3666 ═══ EDC3666 One or more assertions are defined which were not defined when the precompiled header was created. An assertion is defined which was not defined when the precompiled header was generated. Since the effect of the new assertion is unknown, the precompiled header cannot be used for this compilation. Recovery: Do not define the assertion or regenerate the precompiled header with the new assertion. ═══ 7.106. EDC3667 ═══ EDC3667 One or more macros are defined which were not defined when the precompiled header was created. A macro is defined which was not defined when the precompiled header was generated. Since the effect of the new macro is unknown, the precompiled header cannot be used for this compilation. Recovery: Do not define the macro or regenerate the precompiled header with the new macro. ═══ 7.107. EDC3668 ═══ EDC3668 Compiler options do not match those in effect when the precompiled header was created. The compiler options in use are not compatible with those used when the precompiled header was generated. The precompiled header cannot be used. Recovery: Use the same options as when the precompiled header was generated or regenerate the precompiled header with the new options. ═══ 7.108. EDC3669 ═══ EDC3669 Assertion "&1" is required by the precompiled header and is not defined. The referenced assertion was tested during the creation of the precompiled header and is not defined. This prevents the precompiled header from being used for this compilation. Recovery: If necessary, redefine the assertion, or regenerate the precompiled header without the assertion. ═══ 7.109. EDC3670 ═══ EDC3670 Macro "&1" is required by the precompiled header and is not defined. The referenced macro was expanded during the creation of the precompiled header and is not defined. This prevents the precompiled header from being used for this compilation. Recovery: If necessary, redefine the macro, or regenerate the precompiled header without the macro. ═══ 7.110. EDC3671 ═══ EDC3671 Unable to use precompiled header &1. The precompiled header can not be used for this compilation. A subsequent message will explain the reason. Recovery: Correct the problem indicated by the subsequent message. ═══ 7.111. EDC3672 ═══ EDC3672 Expecting &1 and found &2. The header file being included is not the next header in the sequence used to generate the precompiled header. The precompiled header cannot be used for this compilation. Recovery: #include the correct header or regenerate the precompiled header using the new sequence of #include directives. ═══ 7.112. EDC3673 ═══ EDC3673 Syntax error - the argument list in the new placement syntax is empty. At least one new placement argument must be specified. Recovery: Specify an argument in the new placement syntax or remove the new placement. ═══ 7.113. EDC3674 ═══ EDC3674 Pointer to member declared using non-SOM class, but accessed through SOM object. The pointer to member was declared for a non-SOM class, but is being applied to a SOM object. This is likely to occur if a forward declaration for the class as non-SOM occurred, followed by the pointer to member declaration, followed by the actual class definition as a SOM class. Recovery: Specify the pointer to member declaration after the SOM class is defined or use pragma SOMAsDefault with the forward declaration of the class. ═══ 8. EDC4000 - EDC4499 ═══ ═══ 8.1. EDC4004 ═══ EDC4004 Not enough memory is available. The compiler cannot obtain the necessary virtual storage or memory. Recovery: Any of the following may help:  Shut down large processes.  Ensure your swap path is large enough.  Redefine your virtual disk, if you are using one.  Reboot.  Obtain more RAM and/or disk space. ═══ 8.2. EDC4005 ═══ EDC4005 Error occurred in an intermediate file. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.3. EDC4006 ═══ EDC4006 An addressing mode combination is not valid. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.4. EDC4008 ═══ EDC4008 An unsupported data type was encountered. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.5. EDC4010 ═══ EDC4010 An unexpected dependent register was encountered. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.6. EDC4011 ═══ EDC4011 Error occurred while opening assembly file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.7. EDC4012 ═══ EDC4012 Error occurred while writing assembly file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.8. EDC4013 ═══ EDC4013 Error occurred while closing assembly file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.9. EDC4014 ═══ EDC4014 Error occurred while opening object file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.10. EDC4015 ═══ EDC4015 Error occurred while writing object file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.11. EDC4016 ═══ EDC4016 Error occurred while closing object file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.12. EDC4017 ═══ EDC4017 Expression contains division by zero. The optimizer identified an expression containing division by zero. Recovery: Eliminate the division by zero if it was not intended. ═══ 8.13. EDC4018 ═══ EDC4018 Too many debug options were specified. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.14. EDC4019 ═══ EDC4019 Error occurred while opening intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.15. EDC4020 ═══ EDC4020 Error occurred while writing to intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.16. EDC4021 ═══ EDC4021 Error occurred while reading from intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.17. EDC4022 ═══ EDC4022 Error occurred while closing intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.18. EDC4023 ═══ EDC4023 Error occurred while creating name. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.19. EDC4024 ═══ EDC4024 Expression contains modulo by zero. The optimizer identified an expression containing modulo by zero. Recovery: Eliminate the modulo by zero if it was not intended. ═══ 8.20. EDC4026 ═══ EDC4026 Data definitions require more 16-bit segments than are allowed. The data declared requires more 16-bit segments than the maximum 242 available. Recovery: Break the program down into several smaller programs, or use less data. ═══ 8.21. EDC4027 ═══ EDC4027 The text associated with a #pragma comment user is too long. The text of the #pragma comment user directive exceeds the limit of 255 characters. Recovery: Shorten the text of the comment, or use multiple #pragma comment user directives. ═══ 8.22. EDC4028 ═══ EDC4028 The path or file name for output file &2 is not valid. The path or file name given has not been specified correctly. Recovery: Check the spelling and syntax of the path or file name and change the name accordingly. ═══ 8.23. EDC4029 ═══ EDC4029 Open access denied for output file &2. The file system will not allow the specified file to be opened. You may be trying to write to a readonly disk. Recovery: Direct output to a writable disk. ═══ 8.24. EDC4030 ═══ EDC4030 Cannot open output file &2. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The target directory of the assembler or object file is writable  These directories exist and have enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.25. EDC4031 ═══ EDC4031 Cannot open output file &2. The file is already open. Another process has already opened the file. Recovery: Close the file and compile again. ═══ 8.26. EDC4032 ═══ EDC4032 Cannot write to the output file. The disk is full. Recovery: Delete some files to make some space on the disk. ═══ 8.27. EDC4033 ═══ EDC4033 Precondition violated. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.28. EDC4034 ═══ EDC4034 The command line passed to the Back End is not correct. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.29. EDC4035 ═══ EDC4035 Error occurred while opening source file. An operating system or compiler error has occurred. Recovery: Ensure that:  No other processes are modifying the directory or file  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.30. EDC4036 ═══ EDC4036 The path or file name for source file &2 is not valid. The path or file name given has not been specified correctly. Recovery: Check the spelling and syntax of the path or file name and change the name accordingly. ═══ 8.31. EDC4037 ═══ EDC4037 Open access denied for source file &2. The file system will not allow the specified file to be opened because of an OS/2 file system error. Recovery: Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.32. EDC4038 ═══ EDC4038 Cannot open source file &2. An operating system or compiler error has occurred. Recovery: Ensure that:  No other processes are modifying the directory or file  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.33. EDC4039 ═══ EDC4039 Cannot open source file &2. The file is already open. Another process has already opened the file. Recovery: Close the file and compile again. ═══ 8.34. EDC4040 ═══ EDC4040 Assembler listing line is too long for successful assembly. The line in the assembler listing is too long to be assembled. Recovery: Try using shorter variable and function names. ═══ 8.35. EDC4041 ═══ EDC4041 Error occurred while closing source file. An operating system or compiler error has occurred. Recovery: Ensure that:  No other processes are modifying the directory or file  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.36. EDC4042 ═══ EDC4042 Cannot use __parmdwords in a function that does not use the _System calling convention. You can only call the __parmdwords function from a function that uses the _System calling convention. Recovery: Change the function's calling convention to _System. or remove the call to __parmdwords. For information on setting the calling convention, see the section about it under Compiling in the User's Guide ═══ 8.37. EDC4043 ═══ EDC4043 Automatic function inliner will inline function &2. The compiler is placing the code for the indicated function inline in the source, instead of generating a call to the function, because of the /Oi compiler option. When you specify /Oi with a value (for example, /Oi45), the compiler inlines all functions qualified with the inline and _Inline. keywords, and all other functions less than or equal to the value in abstract code units, as measured by the compiler. This is called auto-inlining. Because you have no way of knowing beforehand what functions will be inlined for a particular value, this message is generated for each function that is auto-inlined. Recovery: If for some reason you do not want the function to be inlined, reduce the value for the /Oi option, or use /Oi- to turn inlining off altogether, and recompile. Otherwise, no action is necessary. ═══ 8.38. EDC4044 ═══ EDC4044 The Back End has run out of stack space. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 8.39. EDC4045 ═══ EDC4045 &2 has grown beyond auto inliner value of &3; the function will no longer be inlined. The number of abstract code units (ACUs) for the function is greater than the value specified for the /Oi compiler option. Only functions that are less than or equal to the /Oi value (in ACUs) are automatically inlined. Recovery: If you want the function to be inlined, increase the value specified for /Oi, or qualify the function name with the inline (for C++) or _Inline. keyword. Otherwise, no action is required. ═══ 8.40. EDC4046 ═══ EDC4046 The call to function &2 from function &3 will not be inlined. Because of the call complexity of the program, the compiler will not inline the function specified. Requesting that a function be inlined, either through the use of a keyword or a value for the /Oi option, does not necessarily mean a function will be inlined. In all cases, whether a function is actually inlined is up to the compiler. Recovery: There is no recovery. Because the compiler uses very complicated algorithms to determine what functions will be inlined, there are no specific steps you can take to ensure a function will always be inlined. ═══ 9. EDC6000 - EDC6499 ═══ ═══ 9.1. EDC6004 ═══ EDC6004 Not enough memory is available. The intermediate code linker cannot obtain the necessary virtual storage or memory. Recovery: Any of the following may help:  Shut down large processes.  Ensure your swap path is large enough.  Redefine your virtual disk, if you are using one.  Reboot.  Obtain more RAM and/or disk space. ═══ 9.2. EDC6005 ═══ EDC6005 Error occurred in intermediate file. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.3. EDC6006 ═══ EDC6006 A type mismatch was found between declarations of symbol &2 in files &3 and &4. The symbol was declared with different types in the two files. You can declare a symbol more than once, but all declarations must be identical. Recovery: Ensure that all declarations of the symbol are identical, and recompile. ═══ 9.4. EDC6007 ═══ EDC6007 The definitions of symbol &2 in file &3 and file &4 are not consistent. The symbol was defined differently in the two files. You can define a symbol more than once, but all definitions must be identical. Recovery: Ensure that all definitions of the symbol are identical, and recompile. ═══ 9.5. EDC6008 ═══ EDC6008 The value of the /R option must be consistent across source files. The /R options control the use of the runtime environment. All source files in a compilation must use the same runtime environment option, either /Re (runtime environment) or /Rn (subsystem - no runtime environment). Recovery: Recompile your source files so they all use the same /R option. ═══ 9.6. EDC6009 ═══ EDC6009 The value of the /G3, /G4, or /G5 options must be consistent across source files. The /G3, /G4, and /G5 options control the target processor of the executable file. All source files in a compilation must use the same option for the target processor: /G3 for 80386, /G4 for 80486, or /G5 for the Pentium processor. Recovery: Recompile your source files so they all target the same processor. ═══ 9.7. EDC6010 ═══ EDC6010 The value of the &2 option must be consistent across source files. The source files were compiled with different settings for the compiler option specified. All source files in a compilation must use the same setting for the option. Recovery: Recompile your source files so they all use the same setting of the option. ═══ 9.8. EDC6011 ═══ EDC6011 The value of the /O option must be consistent across source files. The /O option controls optimization. All source files in a compilation must use the same setting for the /O option. (Note that if you compile the files separately, you can specify different /O settings, then link the resulting objects in a separate step.) Recovery: Recompile your source files so they all use the same setting for the /O option. ═══ 9.9. EDC6012 ═══ EDC6012 A second #pragma entry was detected in file &2. #pragma entry sets the entry point for your program. Because each program can have only one entry point, #pragma entry can appear only once in your source files. application. Recovery: Remove one of the #pragma entry statements and recompile. ═══ 9.10. EDC6013 ═══ EDC6013 The declarations of function &2 in file &3 and file &4 have inconsistent calling conventions. The function declarations are not consistent from file to file. They use different calling conventions. Recovery: Ensure that all declarations for the function are identical, and recompile. ═══ 9.11. EDC6014 ═══ EDC6014 The declarations of function &2 in file &3 and file &4 have inconsistent numbers of parameters. The function declarations are not consistent from file to file. They differ in the number of parameters specified. Recovery: Ensure that all declarations for the function are identical, and recompile. ═══ 9.12. EDC6015 ═══ EDC6015 The declarations of function &2 in file &3 and file &4 have inconsistent variable argument properties. The function declarations are not consistent from file to file. They may have a different number of parameters specified before the variable-argument ellipsis, or one definition may have variable arguments when the other does not. Recovery: Ensure that all declarations for the function are identical, and recompile. ═══ 9.13. EDC6016 ═══ EDC6016 The command line passed to the intermediate code linker is not correct. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.14. EDC6017 ═══ EDC6017 Unknown error. An error has occurred that the compiler does not recognize. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.15. EDC6018 ═══ EDC6018 Error in .DEF file &1. The intermediate code linker found an error while parsing the module definition (.DEF) file. Recovery: Check the .DEF file and correct the error. For more information about module definition files, see the section about them under Linking Your Program in the User's Guide. ═══ 9.16. EDC6019 ═══ EDC6019 Error occurred while opening intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.17. EDC6020 ═══ EDC6020 Error occurred while writing to the intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.18. EDC6021 ═══ EDC6021 Error occurred while reading from the intermediate file. An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.19. EDC6022 ═══ EDC6022 An operating system or compiler error has occurred. Recovery: Ensure that:  The TMP directory is set to a writable disk  The directory exists and has enough available space  No other processes are modifying the directory or file  The file system is functioning properly  The virtual disk for the directory, if you are using one, is large enough. Try rebooting. If the problem persists, contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.20. EDC6023 ═══ EDC6023 Error occurred while creating name. An internal compiler error has occurred. Recovery: Contact VisualAge C++ Service and Support or your IBM Service Representative. ═══ 9.21. EDC6024 ═══ EDC6024 Source files containing conflicting language indicators were linked; debugging may be restricted. The intermediate code linker was passed files that indicated different programming languages (for example, C and C++). The intermediate code linker sets the language environment for the debugger to handle the language of the last file processed. If that language was not C++, debugging of the program will be restricted. Recovery: Ensure that all files passed to the intermediate code linker are the same language. If you are intentionally mixing C and C++ code, ensure the last source file passed to the intermediate code linker is a C++ file.