### Compiler Error Messages EDC0601 - EDC0693

EDC0601
  Definition of "&1" is not allowed.
EDC0602
  Identifier "&1" is not a class name.
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.

EDC0604
  Storage class "&1" is not allowed for member functions.
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.

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.

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.

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.

EDC0609
  The type of "reference" cannot be "&1".
EDC0610
  "&1" is not allowed as an array element type.
EDC0611
  The type of "pointer" cannot be "&1".
EDC0612
  The reference variable "&1" is uninitialized.
EDC0613
  Duplicate function specifier "&1" ignored.
EDC0614
  "&1" conflicts with "&2".
EDC0615
  Keyword "&1" is not allowed.
EDC0616
  "&1" must already be declared.
EDC0617
  "&1" was previously declared as "&2".
EDC0618
  "&1" is not allowed.
EDC0619
  The arguments passed using the ellipsis may not be accessible.
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.

EDC0621
  Ellipsis (...) cannot be used for "&1".

  Recovery: Remove the ellipsis.

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.

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.

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.

EDC0625
  "&1" was declared in base class "&2".
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.

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".

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

EDC0642
  The return type for the "operator->" cannot be the containing class.

  Recovery: Change the return type for the "operator->".

EDC0643
  Class qualification for "&1" is not allowed.

  Recovery: Remove the qualification.

EDC0644
  "&1" is neither an immediate base class nor a non-static data member of class "&2".
EDC0645
  "&1" cannot be initialized multiple times.
EDC0646
  There are too many initializers in the initializer list.
EDC0647
  The const member "&1" must be initialized in the constructor's initializer list.
EDC0648
  The reference member "&1" must be initialized in the constructor's initializer list.
EDC0649
  A namespace alias may not be used to extend a namespace.
EDC0650
  "&1" is not a namespace or namespace alias.
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.

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.

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.

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.

EDC0655
  Namespace "&1" was not defined within the scope of namespace "&2".
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.

EDC0657
  Using declaration cannot declare class member "&1" in a non class scope.
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.

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.

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.

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.

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.

EDC0663
  Ambiguous reference to "&1"

  Recovery: Change one of the names, or always fully qualify the name.

EDC0664
  A virtual function initializer must be 0.

  Recovery: Set the virtual function initializer to 0.

EDC0665
  "&1" is not declared at namespace scope.
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.

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.

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.

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.

EDC0670
  The type of "pointer to member" cannot be "&1".
EDC0671
  The header file name in the #include directive cannot be empty.

  Recovery: Specify a non-empty header file name in the #include directive.

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.

EDC0673
  Template has too many arguments.
EDC0674
  Template parameter &1 expects a type argument.
EDC0675
  The return type is not valid for a function of this linkage type

  The linkage type of the function puts certain restrictions on the return type, on which the function definition violated.

  Recovery: Check the linkage type restrictions and change the return type.

EDC0676
  Function "&1" which returns a return code cannot be defined.

  The function has FORTRAN linkage type with the RETURNCODE option. Therefore it should be a FORTRAN function defined somewhere else and referenced here (should not be defined in the compile unit).

  Recovery: Make sure the function is a FORTRAN function.

EDC0681
  #pragma export(&1) is ignored because option LONGNAME or RENT is not specified.

  The variable/function is not exported because option(s) LONGNAME or RENT is specified.

  Recovery: Make sure the LONGNAME and RENT options are specified.

EDC0682
  "&1" will not be exported because #pragma variable(&2,NORENT) is specified.

  Variables with NORENT option cannot be exported.

EDC0683
  "&1" will not be exported because it does not have external storage class.

  Only objects with external storage class can be exported.

EDC0684
  Exporting function main is not allowed.

  Main cannot be exported.

  Recovery: Remove the pragma export for main.

EDC0685
  "&1" will not be exported because it is not external defined.

  The variable cannot be exported because it is not defined here.

  Recovery: Remove the pragma export for the variable.

EDC0686
  Unexpected keyword(s). One or more keywords were found in an invalid location.

  One or more keywords were found in an invalied location.

  Recovery: Remove the keyword(s) or place them immediately to the left of the identifier to which they apply.

EDC0687
  The &1 keyword cannot be applied to the return type of a function.

  The keyword is being applied to the return type of a function.

  Recovery: Remove the keyword.

EDC0688
  Declaration cannot specify conflicting keywords &1 and &2.

  The keywords conflict and cannot both be used in the same declaration.

  Recovery: Remove one of the keywords.

EDC0689
  The &1 keyword was specified more than once in the declaration.

  The keyword was used more than once in the same declaration.

  Recovery: Remove one of the keywords.

EDC0690
  Builtin function &1 is unrecognized. The default linkage convention

  The function specified in the pragma linkage builtin is not a

  Recovery: Check the function name and correct; or remove the pragma if it is

EDC0691
  The &1 keyword can only be applied to functions.

  The keyword has been applied to an identifier which does not correspond to a function type.

  Recovery: Check that the correct identifier is specified or remove the keyword.

EDC0692
  Both "main" and "WinMain" are defined in this compilation unit. Only one of them is allowed.

  In each compilation unit, only one of "main" and "WinMain" is allowed.

  Recovery: Remove either "main" or "WinMain".

EDC0693
  The &1 keyword conflicts with a previously specified keyword.

  The keyword conflicts with another keyword specified in the same declaration.

  Recovery: Remove one of the keywords.

Summary of Compiler Error Messages