Export (0) Print
Expand All

Compiler Errors

The following error messages are generated during MIDL compilation:

Return codeDescription
MIDL2000

must specify /c_ext for abstract declarators

Abstract declarators represent a Microsoft extension to RPC and are not defined in DCE RPC. Therefore, if your file includes abstract declarators, you cannot compile with the /osf switch, which enforces strict DCE compatibility. MIDL versions 3.0 and later use the /c_ext switch as the default; the /osf switch turns off the /c_ext switch. For information on abstract declarators, see The ACF Body.

MIDL2001

instantiation of data is illegal; you must use "extern" or "static"

Declaration and initialization in the IDL file are not compatible with DCE RPC. This feature is a Microsoft extension that is not available when you compile in DCE-compatibility (/osf) mode.

MIDL2002

compiler stack overflow

The compiler ran out of stack space while processing the IDL file. This problem can occur when the compiler is processing a complex declaration or expression. To solve the problem, simplify the complex declaration or expression.

MIDL2003

redefinition

This error message can appear under the following circumstances: a type has been redefined; a procedure prototype has been redefined; a member of a structure or union of the same name already exists; a parameter of the same name already exists in the prototype.

MIDL2004

[auto_handle] binding will be used

No handle type has been defined as the default handle type. The compiler assumes that an auto handle will be used as the binding handle for the specified procedure.

MIDL2005

out of memory

The compiler ran out of memory during compilation. Reduce the size or complexity of the IDL file or allocate more memory to the process.

MIDL2006

recursive definition

A structure or union has been recursively defined. This error can occur when a pointer specification in a nested structure definition is missed.

MIDL2007

import ignored; file already imported

Importing an IDL file is an idempotent operation. Including it more than once has no effect. All but the first import operation are ignored.

MIDL2008

sparse enums require /c_ext or /ms_ext

Assigning values to enumeration constants is not compatible with DCE RPC. If you want to use the Microsoft extensions to MIDL that permit assigning values to enumeration constants,you cannot compile with the /osf switch, which enforces strict DCE compatibility. MIDL versions 3.0 and later use the /c_ext and /ms_ext switches as the default; the /osf switch turns off these extension switches.

MIDL2009

undefined symbol

An undefined symbol has been used in an expression. This error can occur when you use an undefined enumerated value.

MIDL2010

type used in ACF file not defined in IDL file

An undefined type is being used.

MIDL2011

unresolved type declaration

The type reported in the additional error-information field has not been defined elsewhere in the IDL file.

MIDL2012

use of wide-character constants requires /ms_ext or /c_ext

Wide-character constants are a Microsoft extension to DCE IDL. To use the data type wchar_t, you cannot compile with the /osf switch, which overrides the MIDL compiler default switches–/ms_ext and /c_ext.

MIDL2013

use of wide character strings requires /ms_ext or /c_ext

Wide-character string constants are a Microsoft extension to DCE IDL. To use the data type wchar_t, you cannot compile with the /osf switch, which overrides the MIDL compiler default switches–/ms_ext and /c_ext.

MIDL2014

inconsistent redefinition of type wchar_t

The type wchar_t has been redefined as a type that is not equivalent to unsigned short DOS *.

MIDL2015

importlib not found

The compiler could not find the type library specified by the [ importlib] directive. Check to make sure the path and name of the library are correct.

MIDL2016

two library blocks

Two library blocks (even with different names) in the same source file are illegal. Combine all the elements into a single library block.

MIDL2017

the dispinterface statement requires a definition for IDispatch

This error generally occurs when the files Stdole2.tlb or Oaidl.idl are not imported.

MIDL2018

error accessing type library

The compiler could not find the specified type library. Check to make sure that you have specified the path correctly.

MIDL2019

error accessing type info

The imported type library is corrupt, invalid, or only partially constructed.

MIDL2020

error generating type library

The type library could not be generated. One possible cause of this error is specifying a path to the IDL file that is longer than 126 characters. Oleaut32.dll does not support path names longer than 126 characters.

MIDL2021

duplicate id

Applications use the id statement in IDL files to specify a DISPID for member functions. The member functions can be either properties or methods of interfaces or dispinterfaces. This error indicates the IDL file specifies the same identifier number for two methods or properties.

MIDL2022

illegal or missing value for entry attribute

The argument for the entry attribute may be either a string that specifies a named entry point, or an ordinal number that defines the entry point. This argument is either missing or it contains an invalid value.

MIDL2023

error recovery assumes

The MIDL compiler found illegal characters in the IDL file.

MIDL2024

error recovery discards

The MIDL compiler found illegal characters in the IDL file. It will ignore the illegal characters.

MIDL2025

syntax error

The compiler detected a syntax error at the specified line.

MIDL2026

cannot recover from earlier syntax errors; aborting compilation

The MIDL compiler automatically tries to recover from syntax errors by adding or removing syntactic elements. This message indicates that despite these attempts to recover, the compiler detected too many errors. Correct the specified error(s) and recompile.

MIDL2027

unknown pragma option

The specified C pragma is not supported in MIDL. Remove the pragma from the IDL file.

MIDL2028

feature not implemented

The MIDL feature, although part of the language definition, is not implemented in Microsoft RPC and is not supported by the MIDL compiler. For example, the following language features are not implemented: bitset, pipe, and the international character type. The unimplemented language feature appears in the additional error-information field of the error message.

MIDL2029

type not implemented

The specified data type, although a legal MIDL keyword, is not implemented in Microsoft RPC.

MIDL2030

non-pointer used in a dereference operation

A data type that is not a pointer has been associated with pointer operations. You cannot access the object through the specified non-pointer.

MIDL2031

expression has a divide by zero

The constant expression contains division by zero.

MIDL2032

expression uses incompatible types

The left and right sides of the operator in an expression are of incompatible types.

MIDL2033

nonarray expression uses index operator

The expression uses the array-indexing operation on a data item that is not of the array type.

MIDL2034

left-hand side of expression does not evaluate to struct/union/enum

The direct or indirect reference operator "." or "->" has been applied to a data object that is not a structure, union, or an enumeration. You cannot obtain a direct or indirect reference using the specified object.

MIDL2035

constant expression expected

A constant expression was expected in the syntax. For example, array bounds require a constant expression. The compiler issues this error message when the array bound is defined with a variable or undefined symbol.

MIDL2036

expression cannot be evaluated at compile time

The compiler cannot evaluate an expression at compile time.

MIDL2037

expression not implemented

A feature that was supported in previous releases of the MIDL compiler is not supported in the version of the compiler supplied with Microsoft RPC. Remove the specified expression.

MIDL2038

no [pointer_default] attribute specified, assuming [unique] for all unattributed pointers

The MIDL compiler offers three different default cases for pointers that do not have pointer attributes. Function parameters that are top-level pointers default to [ref] pointers. Pointers embedded in structures and pointers to other pointers (not top-level pointers) default to the type specified by the [pointer_default] attribute. When no [pointer_default] attribute is supplied, these nontop-level pointers default to unique pointers. This error message indicates the last case: no [pointer_default] attribute is supplied, and there is at least one non-top-level pointer that will be treated as a unique pointer. For more information, see Default Pointer Types.

MIDL2039

interface is not automation marshaling conformant

The interface does not meet the requirements for an OLE Automation interface. Check to make sure the interface is derived from IUnknown or IDispatch.

MIDL2040

[out] only parameter cannot be a pointer to an open structure

An [out]-only parameter has been used as a pointer to a structure, known as an open structure, whose transmitted range and size are determined at run time. The server stub does not know how much space to allocate for an open structure. Use a pointer to a pointer to the open structure and ensure that the server application allocates sufficient space for it.

MIDL2041

[out] only parameter cannot be an unsized string

An array with the string attribute has been declared as an [out]-only parameter without any size specification. The server stub needs size information to allocate memory for the string. You can remove the string attribute and add the [size_is] attribute, or you can change the parameter to an [in, out] parameter.

MIDL2042

[out] parameter is not a pointer

All [out] parameters must be pointers, in keeping with the call-by-value convention of the C programming language. The [out] directional parameter indicates that the server transmits a value to the client. With the call-by-value convention, the server can transmit data to the client only if the function argument is a pointer.

MIDL2043

open structure cannot be a parameter

An open structure contains a conformant array as the last element. A structure or union is truncated when the last element of that structure or union is a conformant array.

MIDL2044

[out] context handle/generic handle must be specified as a pointer to that handle type

A context-handle or user-defined handle parameter with the [out] directional attribute must be a pointer to a pointer.

MIDL2045

context handle must not derive from a type that has the [transmit_as] attribute

Context handles must be transmitted as context-handle types. They cannot be transmitted as other types and cannot derive from [transmit_is], [represent_as], [wire_marshal], or [user_marshal].

MIDL2046

cannot specify a variable number of arguments to a remote procedure

Remote procedure calls that specify a variable number of arguments at compile time are not compatible with the DCE RPC definition. You cannot use a variable number of arguments in Microsoft RPC.

MIDL2047

named parameter cannot be "void"

A parameter with the base type void is specified with a name.

MIDL2048

parameter derives from "coclass" or "module"

The coclass specifies a top-level object that contains interfaces and dispinterfaces. It cannot be passed as a parameter.

MIDL2049

only the first parameter can be a binding handle; you must specify the /ms_ext switch

DCE RPC allows only the first parameter to be a binding handle. Compiling with the /osf switch turns off the default /ms_ext switch that supports multiple handle parameters and handle parameters in other than the left-most position.

MIDL2050

cannot use [comm_status] on both a parameter and a return type

Both the procedure and one of its parameters have the [comm_status] attribute. The [comm_status] attribute specifies that only one data object at a time can be of type error_status_t.

MIDL2051

[local] attribute on a procedure requires /ms_ext

The [local] attribute is a Microsoft extension to DCE IDL. To use this attribute on a function, you cannot compile with the /osf switch. The /osf switch overrides the MIDL compiler default switches–/ms_ext and /c_ext.

MIDL2052

property attributes may only be used with procedures

Improper usage of a [propget], [propput], or [propputref] attribute. Check to be sure that you have spelled the property's function name correctly and that the property and function have the same name.

MIDL2053

a procedure may not have more than one property attribute

At most, only one of the [propget], [propput], or [propputref] attributes can be specified for a function.

MIDL2054

the procedure has an illegal combination of operation attributes

Certain attributes cannot be used in connection with other attributes. Check the MIDL Language Reference for the exact requirements and syntax of the attributes used in this procedure.

MIDL2055

field deriving from a conformant array must be the last member of the structure

The structure contains a conformant array that is not the last element in the structure. The conformant array must appear as the last structure element.

MIDL2056

duplicate [case] label

A duplicate case label has been specified. The duplicate label is displayed.

MIDL2057

no [default] case specified for discriminated union

A discriminated union has been specified without a default case.

MIDL2058

attribute expression cannot be resolved

The expression associated with the attribute cannot be resolved. This error usually occurs when a variable that appears in the expression is not defined. For example, the error can occur when the variable s is not defined and is used by the attribute [size_is].

MIDL2059

attribute expression must be of integral type, no support for 64-bit expressions

The specified attribute variable or expression must be an integral type. This error occurs when the attribute-expression type does not resolve to an integer.

MIDL2060

[byte_count] requires /ms_ext

The [byte_count] attribute is a Microsoft extension to DCE IDL. To use this attribute you cannot compile with the /osf switch, which overrides the MIDL compiler–default switches–/ms_ext and /c_ext.

MIDL2061

[byte_count] can be applied only to out parameters of pointer type

The [byte_count] attribute can only be applied to [out] parameters, and all [out] parameters must be pointer types.

MIDL2062

[byte_count] cannot be specified on a pointer to a conformant array or structure

The [byte_count] attribute cannot be applied to a conformant array or structure.

MIDL2063

parameter specifying the byte count is not [in] only or byte count parameter is not [out] only

The value associated with the [byte_count] must be transmitted from the client to the server; it must be an [in] parameter. The [byte_count] parameter does not need to be an [in, out] parameter.

MIDL2064

parameter specifying the byte count is not an integral type

The value associated with the byte count must be the integer type int, small, short, or long.

MIDL2065

[byte_count] cannot be specified on a parameter with size attributes

The [byte_count] attribute cannot be used with other size attributes such as [size_is] or [length_is].

MIDL2066

[case] expression is not constant

The expression specified for the case label is not a constant.

MIDL2067

[case] expression is not of integral type

The expression specified for the case label is not an integer type.

MIDL2068

specifying [context_handle] on a type other than void * requires /ms_ext

For DCE-RPC compatibility, the context handle must be a pointer of type void *. If you want the context handles to be associated with types other than void *, do not use the MIDL compiler switch /osf, which overrides the MIDL compiler default switch /ms_ext.

MIDL2069

cannot specify more than one parameter with each of comm_status/fault_status

A procedure can have only one parameter with the [comm_status] attribute. It can have at most one parameter with the [fault_status] attribute.

MIDL2070

comm_status/fault_status parameter must be an [out] only pointer parameter

The error-code types [comm_status] and [fault_status] are transmitted from server to client and therefore must be specified as an [out] parameter. Due to the constraints in the C-programming language, all [out] parameters must be pointers.

MIDL2071

endpoint syntax error

The endpoint syntax is incorrect.

MIDL2072

inapplicable attribute

The specified attribute cannot be applied in this construct. For example, the string attribute applies to char arrays or char pointers and cannot be applied to a structure that consists of two short integers:

typedef [string] struct moo 
{
    short x;
    short y;
};
MIDL2073

[allocate] requires /ms_ext

The allocate attribute represents a Microsoft extension that is not defined as part of DCE RPC. To use this attribute, you cannot compile with the /osf switch, which overrides the MIDL compiler default switch /ms_ext

MIDL2074

invalid [allocate] mode

An invalid mode for the [allocate] attribute construct has been specified. The four valid modes are single_node, all_nodes, on_null, and always.

MIDL2075

length attributes cannot be applied with string attribute

When the string attribute is used, the generated stub files call the strlen function to determine the string length. Don't use the length attribute and the string attribute for the same variable.

MIDL2076

[last_is] and [length_is] cannot be specified at the same time

Both [last_is] and [length_is] have been specified for the same array. These attributes are related as follows: length = last – first + 1. Because each value can be derived from the other, don't specify both.

MIDL2077

[max_is] and [size_is] cannot be specified at the same time

Both [ max_is] and [ size_is] have been specified for the same array. These attributes are related as follows: max = size + 1. Because each value can be derived from the other, don't specify both.

MIDL2078

no [switch_is] attribute specified at use of union

No discriminant has been specified for the union. The [switch_is] attribute indicates the discriminant used to select among the union fields.

MIDL2079

no [uuid] specified

No UUID has been specified for the interface.

MIDL2080

[uuid] ignored on [local] interface

Using the [local] attribute on an object interface causes the MIDL compiler to ignore the [uuid] attribute. You cannot use both attributes on an RPC interface.

MIDL2081

type mismatch between length and size attribute expressions

The length and size attribute expressions must be of the same types. For example, this warning is issued when the attribute variable for the [size_is] expression is of type unsigned long and the attribute variable for the [length_is] expression is of type long.

MIDL2082

[string] attribute must be specified "byte," "char," or "wchar_t" array or pointer

A string attribute cannot be applied to a pointer or array whose base type is not a byte, char, or struct in which the members are all of the byte or char type.

MIDL2083

mismatch between the type of the [switch_is] expression and the switch type of the union

If the union [switch_type] is not specified, the switch type is the same type as the [switch_is] field.

MIDL2084

[transmit_as] must not be applied to a type that derives from a context handle

Context handles cannot be transmitted as other types.

MIDL2085

[transmit_as] must specify a transmissible type

The specified [transmit_as] type derives from a type that cannot be transmitted by Microsoft RPC, such as void, void *, or int. Use a defined RPC base type; in the case of int, add size specifiers like small, short, or long to qualify the int.

MIDL2086

transmitted type for [transmit_as] and [represent_as] must not be a pointer or derive from a pointer

The transmitted type cannot be a pointer or derive from a pointer.

MIDL2087

presented type for [transmit_as] and [represent_as] must not derive from a conformant/varying array, its pointer equivalent, or a conformant/varying structure

The type to which [transmit_as] has been applied cannot derive from a conformant array or structure (an array or structure whose size is determined at run time).

MIDL2088

[uuid] format is incorrect

The UUID format does not conform to specification. The UUID must be a string that consists of five sequences of hexadecimal digits of length 8, 4, 4, 4, and 12 digits. "12345678-1234-ABCD-EF01-28A49C28F17D" is a valid UUID. Use the function UuidCreate or a utility to generate a valid UUID.

MIDL2089

uuid is not a hexadecimal number

The UUID specified for the interface contains characters that are invalid in a hexadecimal number representation. The characters 0 through 9 and A through F are valid in a hexadecimal representation.

MIDL2090

optional parameters must come after required parameters

For a description of the ordering of parameter lists, see [optional] in the MIDL Language Reference.

MIDL2091

[dllname] required when [entry] is used

If you are specifying an entry point into a DLL you must also specify the name of that DLL by using the [dllname] attribute.

MIDL2092

[bindable] is invalid without [propget], [propput], or [propputref]

The [bindable] attribute is valid only on a property, therefore you must also specify one of the property-accessing or property-setting functions.

MIDL2093

procedures with [propput] or [propputref] must have at least one parameter

A [propput] or [ propputref] procedure must have at least an [in] parameter with the property to set; a [propget] procedure must have at least an [out, retval] parameter to receive the property or reference.

MIDL2094

[id] attribute is required

This member function, because of the dispinterface syntax used, requires a DISPID, which you specify by using the [ id] attribute. When you specify a dispinterface by using properties and methods you must specify a DISPID for every property and method.

MIDL2095

interface name specified in the ACF does not match that specified in the IDL file

In the current compiler mode, the name that follows the interface keyword in the ACF must be the same as the name that follows the interface keyword in the IDL file. The interface names in the IDL and ACF files can be different when you compile with the MIDL compiler switch /acf.

MIDL2096

duplicated attribute

Duplicate or conflicting attributes have been specified. This error often occurs when two attributes are mutually exclusive. For example, the attributes [code] and [nocode] cannot be used at the same time.

MIDL2097

parameter with [comm_status] or [fault_status] attribute must be a pointer to type error_status_t

When [fault_status] or [comm_status] is used as a parameter attribute, the parameter must be an [out] parameter of type error_status_t. If a server error occurs, the parameter is set to the error code. When the remote call is successfully completed, the procedure sets the value.

MIDL2098

a [local] procedure cannot be specified in ACF file

A local procedure has been specified in the ACF. The local procedure can only be specified in the IDL file.

MIDL2099

specified type is not defined as a handle

The type specified in the [implicit_handle] attribute is not defined as a handle type. Change the type definition or the type name specified by the attribute.

MIDL2100

procedure undefined

An attribute has been applied to a procedure in the ACF, and that procedure is not defined in the IDL file.

MIDL2101

this parameter does not exist in the IDL file

A parameter specified in the ACF does not exist in the definition in the IDL file. All parameters, functions, and type definitions that appear in the ACF must correspond to parameters, functions, and types previously defined in the IDL file.

MIDL2102

this array-bounds construct is not supported

MIDL currently supports expressing the upper and lower bounds of an array in the form Array[Lower .. Upper] only when the constant that specifies the lower bound of the array resolves to the value zero.

MIDL2103

array bound specification is illegal

The user specification of array bounds for the fixed-size array is illegal. For example:

typedef short Array[-1]
MIDL2104

pointer to a conformant array or an array that contains a conformant array is not supported

Illegal conformant array usage. For rules governing conformant arrays, see Arrays and RPC.

MIDL2105

pointee/array does not derive any size

A conformant array has been specified without any size specification. You can specify the size with the [max_is] or [size_is] attribute.

MIDL2106

only fixed arrays and SAFEARRAYs are legal in a type library

You have used an array type inside a library statement that cannot be used in a type library.

MIDL2107

SAFEARRAYs are only legal inside a library block

The MIDL compiler does not recognize a SAFEARRAY as a valid data type except when generating a type library.

MIDL2108

badly formed character constant

The end-of-line character is not allowed in character constants.

MIDL2109

end of file found in comment

The end-of-file character has been encountered in a comment.

MIDL2110

end of file found in string

The end-of-file character has been encountered in a string.

MIDL2111

identifier length exceeds 31 characters

Identifiers are limited to 31 alphanumeric characters. Identifier names longer than 31 characters are truncated.

MIDL2112

end of line found in string

The end-of-line character has been encountered in the string. Verify that you have included the double-quote character that terminates the string.

MIDL2113

string constant exceeds limit of 255 characters

The string exceeded the maximum allowable length of 255 characters.

MIDL2114

identifier exceeds limit of 255 characters and has been truncated

The identifier exceeded the maximum allowable length of 255 characters. Excess characters in the identifier are truncated.

MIDL2115

constant too big

The constant is too large to be represented internally.

MIDL2116

numerical parsing error

The compiler could not parse the numerical identifier.

MIDL2117

error in opening file

The operating system reported an error while trying to open an output file. This error can be caused by a name that is too long for the file system or by a duplicate filename.

MIDL2118

error binding to function

MIDL2119

error initializing OLE

MIDL2120

error loading library

MIDL2121

[out] only parameter must not derive from a top-level [unique] or [ptr] pointer/array

A unique pointer cannot be an [out]-only parameter. By definition, a unique pointer can change from NULL to non-NULL. No information about the [out]-only parameter is passed from client to server.

MIDL2122

attribute is not applicable to this non-rpcable union

Only the [switch_is] and [switch_type] attributes apply to a union that is transmitted as part of a remote procedure call.

MIDL2123

expression used for a size attribute must not derive from an [out]-only parameter

The value of an [out]-only parameter is not transmitted to the server and cannot be used to determine the length or size of the [in] parameter.

MIDL2124

expression used for a length attribute for an [in] parameter cannot derive from an [out]-only parameter

The value of an [out]-only parameter is not transmitted to the server and cannot be used to determine the length or size of the [in] parameter.

MIDL2125

use of "int" needs /c_ext

MIDL is a strongly typed language. All parameters transmitted over the network must be derived from one of the MIDL base types. The type int is not defined as part of MIDL. Transmitted data must include a size specifier: small, short, or long. Data that is not transmitted over the network can be included in an interface; use the /c_ext switch.

MIDL2126

struct/union field must not be "void"

Fields in a structure or union must be declared to be of a specific base type supported by MIDL or a type that is derived from the base types. Void types are not allowed in remote operations.

MIDL2127

array element must not be void

An array element cannot be void.

MIDL2128

use of type qualifiers and/or modifiers needs /c_ext

Type modifiers such as _cdecl and _far can be compiled only if you specify the /c_ext switch.

MIDL2129

struct/union field must not derive from a function

The fields of a structure or union must be MIDL base types or types that are derived from these base types. Functions are not legal in structure or union fields.

MIDL2130

array element must not be a function

An array element cannot be a function.

MIDL2131

parameter must not be a function

The parameter to a remote procedure must be a variable of a specified type. A function cannot be a parameter to the remote procedure.

MIDL2132

struct/union with bit fields needs /c_ext

You must specify the MIDL compiler switch /c_ext to allow bit fields in structures that are not transmitted in a remote procedure call.

MIDL2133

bit field specification on a type other that "int" is a non-ANSI-compatible extension

The ANSI C programming language specification does not allow bit fields to be applied to noninteger types.

MIDL2134

bit field specification can be applied only to simple, integral types

The ANSI C programming language specification does not allow bit fields to be applied to noninteger types.

MIDL2135

struct/union field must not derive from handle_t or a context-handle

Context handles cannot be transmitted as part of another structure. They must be transmitted as context handles.

MIDL2136

array element must not derive from handle_t or a context handle

Context handles cannot be transmitted as part of an array.

MIDL2137

this specification of union needs /c_ext

A union that appears in the interface definition must be associated with the discriminant or declared as local. Data that is not transmitted over the network can be implicitly declared as local when you use the /c_ext switch, which is the MIDL default. You cannot compile this IDL with the /osf switch.

MIDL2138

parameter deriving from an "int" must have size specifier "small," "short," or "long" with the "int"

The type int is only a valid MIDL type on 32-bit platforms, on 16-bit systems int must be accompanied by a size specification. Use one of the size specifiers small, short, or long.

MIDL2139

type of the parameter cannot derive from void or void*

MIDL is a strongly typed language. All parameters transmitted over the network must be derived from one of the MIDL base types. MIDL does not support void as a base type. You must change the declaration to a valid MIDL type.

MIDL2140

parameter deriving from a struct/union containing bit fields is not supported

Bit fields are not defined as a valid data type by DCE RPC.

MIDL2141

use of a parameter deriving from a type containing type-modifiers/type-qualifiers needs /c_ext

The use of keywords such as far, near, const, and volatile in the IDL file is a Microsoft extension to DCE RPC. These keywords are not available when you compile with the /osf switch, which turns off the default /c_ext extension switch.

MIDL2142

parameter must not derive from a pointer to a function

The RPC run-time libraries transmit a pointer and its associated data between client and server. Pointers to functions cannot be transmitted as parameters because the function cannot be transmitted over the network.

MIDL2143

parameter must not derive from a nonrpc–capable union

The union must be associated with a discriminant. Use the [switch_is] and [switch_type] attributes.

MIDL2144

return type derives from an "int." You must use size specifiers with the "int"

On 16-bit systems, the type int is not a valid MIDL type unless it is accompanied by a size specification. Use one of the size specifiers small, short, or long.

MIDL2145

return type must not derive from a void pointer

MIDL is a strongly typed language. All parameters transmitted over the network must be derived from one of the MIDL base types. Void types are not defined as part of MIDL. You must change the declaration to a valid MIDL type.

MIDL2146

return type must not derive from a structure/union containing bit-fields

Bit fields are not defined as a valid data type by DCE RPC.

MIDL2147

return type must not derive from a nonrpc–capable union

The union must be associated with a discriminant. Use the [switch_is] and [switch_type] attributes.

MIDL2148

return type must not derive from a pointer to a function

The RPC run-time libraries transmit a pointer and its associated data between client and server. Pointers to functions cannot be transmitted as parameters because RPC does not define a method to transmit the associated function over the network.

MIDL2149

compound initializers are not supported

DCE RPC supports simple initialization only. The structure or array cannot be initialized in the IDL file.

MIDL2150

ACF attributes in the IDL file need the /app_config switch

A Microsoft extension allows you to specify ACF attributes in the IDL file. Use the /app_config switch to activate this extension.

MIDL2151

single-line comment needs /ms_ext or /c_ext

Single-line comments that use two slash characters (//) represent a Microsoft extension to DCE RPC. You cannot use single-line comments if you are compiling with the /osf switch.

MIDL2152

[version] format is incorrect

The interface version number in the interface header must be specified in the format major.minor, where each number can range from 0 to 65535.

MIDL2153

"signed" needs /ms_ext or /c_ext

The use of the signed keyword is a Microsoft extension to DCE RPC. You cannot use the /osf switch if you want to use this feature.

MIDL2154

mismatch in assignment type

The type of the variable does not match the type of the value that is assigned to the variable.

MIDL2155

declaration must be of the form: const <type><declarator> = <initializing expression>

The declaration is not compatible with DCE RPC syntax. Use the /ms_ext or /c_ext MIDL compiler mode switch.

MIDL2156

declaration must have "const"

Declarations in the IDL file must be constant expressions that use the keyword const, for example:

const short x = 2;
MIDL2157

struct/union/enum must not be defined in a parameter-type specification

The structure, union, or enumerated type must be explicitly stated outside of the function prototype.

MIDL2158

[allocate] attribute must be applied only on non-void pointer types

The [allocate] attribute is designed for complex pointer-based data structures. When the [allocate] attribute is specified, the stub file traverses the data structure to compute the total size of all objects accessible from the pointer and all other pointers in the data structure. Change the type to a nonvoid pointer type or remove the [allocate] attribute and use another method to determine its allocation size, such as the sizeof operator.

MIDL2159

array or equivalent pointer construct cannot derive from a nonencapsulated union

Each union must be associated with a discriminant. Arrays of unions are not permitted because they do not provide the associated discriminant. Arrays of structures in which the structure packages the union and its discriminant are permitted because the stubs can use the discriminant to determine the size of each union.

MIDL2160

field must not derive from an error_status_t type

The error_status_t type can only be used as a parameter or a return type. It cannot be embedded in the field of a structure or union.

MIDL2161

union has at least one arm without a case label

The union declaration does not match the required MIDL syntax for the union. Each union arm requires a case label or default label that selects that union arm.

MIDL2162

parameter or return value must not derive from a type that has [ignore] applied to it

The [ignore] attribute is a field attribute that can be applied only to fields, such as fields of structures and arrays. The [ignore] attribute indicates that the stub should not dereference the pointer during transmission and is not allowed when it conflicts with other attributes that must be dereferenced, such as [out] parameters and function return values.

MIDL2163

pointer already has a pointer attribute applied to it

Only one of the pointer attributes, [ref], [unique], or [ptr], can be applied to a single pointer.

MIDL2164

field/parameter must not derive from a structure that is recursive through a ref pointer

By definition, a reference pointer cannot be set to NULL. A recursive data structure defined with a reference pointer has no NULL elements and by convention is nonterminating. Use a [unique] pointer attribute to allow the data structure to specify a NULL element, or redefine the data structure as a nonrecursive data structure.

MIDL2165

use of field deriving from a void pointer needs /c_ext

The type void * and other types and type qualifiers that are not supported by DCE IDL are allowed in the IDL file only when you use the MIDL default compiler settings. Using the /osf switch overrides this default. If you must compile in osf-compatibility mode, you will need to redefine the pointer type.

MIDL2166

use of this attribute needs /ms_ext

This language feature is a Microsoft extension to DCE IDL. You cannot use this feature if you are compiling in osf-compatibility mode ( /osf ).

MIDL2167

this attribute only allowed with new format type libraries

To use this attribute, you need the version of Oleaut32.dll provided with Windows 2000 or later.

MIDL2168

use of wchar_t needs /ms_ext or /c_ext

The wide-character type represents an extension to DCE IDL. The MIDL compiler does not accept the wide-character type when you specify the /osf switch.

MIDL2169

unnamed fields need /ms_ext or /c_ext

DCE IDL does not support the use of unnamed structures or unions embedded in other structures or unions. In DCE IDL, all such embedded fields must be named. The MIDL compiler does not allow their use when you specify the /osf switch.

MIDL2170

unnamed fields can derive only from struct/union types

The Microsoft extension to the DCE IDL that supports unnamed fields applies only to structures and unions. You must assign a name to the field or redefine the field to comply with this restriction.

MIDL2171

field of a union cannot derive from a conformant/varying array or its pointer equivalent

The conformant array cannot appear alone in the union but must be accompanied by the value that specifies the size of the array. Instead of using the array as the union arm, use a structure that consists of the conformant array and the identifier that specifies its size.

MIDL2172

no [pointer_default] attribute specified, assuming [ptr] for all unattributed pointers in interface

The DCE IDL implementation specifies that all pointers in each IDL file must be associated with pointer attributes. When an explicit pointer attribute is not assigned to the parameter or pointer type and no [pointer_default] attribute is specified in the IDL file, the full pointer attribute ptr is associated with the pointer. You can change the pointer attributes by using explicit pointer attributes, by specifying a [pointer_default] attribute, or by specifying the /ms_ext switch to change the default for unattributed pointers to [unique].

MIDL2173

initializing expression must resolve to a constant expression

If an expression is used as an initializer, the expression must be a constant expression. This is true in all MIDL compiler modes. The expression must be resolvable at compile time. Specify a literal constant or an expression that resolves to a constant, rather than a variable.

MIDL2174

attribute expression must be of type integer, char, Boolean or enum

The specified type does not resolve to a valid switch type. Use an integer, character, byte, Boolean, or enum type, or a type that is derived from one of these types.

MIDL2175

illegal constant

The specified constant is out of the valid range for the specified type.

MIDL2176

attribute not implemented; ignored

The attribute specified is not implemented in this release of Microsoft RPC. The MIDL compiler continues processing the IDL file as if the attribute were not present.

MIDL2177

return type must not derive from a [ref] pointer

Function return values that are defined to be pointer types must be specified as [unique] or full pointers. You cannot use reference pointers.

MIDL2178

attribute expression must be a variable name or a pointer dereference expression in this mode. You must specify the /ms_ext switch

The DCE IDL compiler requires the size associated with the [size_is] attribute to be specified by a variable or pointer variable. If you want to take advantage of the Microsoft extension that allows the [size_is] attribute to be defined by a constant expression, you cannot use the /osf compiler switch.

MIDL2179

parameter must not derive from a recursive nonencapsulated union

A union must include a discriminant, so a union cannot have another union as an element. A union can be embedded in another union only when it is part of a structure that includes the discriminant.

MIDL2180

binding-handle parameter cannot be [out] only

The handle parameter identified by the MIDL compiler as the binding handle for this operation must be an [in] parameter. [out]-only parameters are undefined on the client stub, and the binding handle must be defined on the client.

MIDL2181

pointer to a handle cannot be [unique] or [ptr]

You cannot use the unique and full pointer attributes for a pointer to a handle. These attributes allow the value NULL, and the binding handle cannot be NULL. Use the [ref] attribute to derive the binding-handle parameter from reference pointers.

MIDL2182

parameter that is not a binding handle must not derive from handle_t

The primitive handle type handle_t is not a valid data type that is transmitted over the network. Change the parameter type to a type other than handle_t, or remove the parameter.

MIDL2183

unexpected end of file found

The MIDL compiler found the end of the file before it was able to successfully resolve all syntactical elements of the file. Verify that the terminating right-brace character (}) is present at the end of the file, or check the syntax.

MIDL2184

type deriving from handle_t must not have [transmit_as] applied to it

The primitive handle type handle_t is not transmitted over the network.

MIDL2185

[context_handle] must not be applied to a type that has [handle] applied to it

The [context_handle] and [handle] attributes cannot be applied to the same type.

MIDL2186

[handle] must not be specified on a type deriving from void or void *

A type specified with the [handle] attribute can be transmitted over the network, but the type void* is not a transmissible type. The handle type must resolve to a type that derives from the transmissible base types.

MIDL2187

parameter must have either [in], [out] or [in,out] in this mode. You must specify /ms_ext or /c_ext

The DCE IDL compiler requires all parameters to have explicit directional parameters. To use the Microsoft extensions to DCE IDL, you cannot use the /osf switch, which overrides /ms_ext and /c_ext.

MIDL2188

transmitted type may not derive from "void" for [transmit_as], [represent_as], [wire_marshal], [user_marshal]

The [transmit_as] attribute applies only to pointer types. Use the type void* in place of void.

MIDL2189

"void" must be specified on the first and only parameter specification

The keyword void incorrectly appears with other function parameters. To specify a function without parameters, the keyword void must be the only element of the parameter list, as in the following example:

void Moo(void)
MIDL2190

[switch_is] must be specified only on a type deriving from a nonencapsulated union

The [switch_is] keyword is incorrectly applied. It can only be used with nonencapsulated union types.

MIDL2191

stringable structures are not implemented in this version

DCE IDL allows the attribute [string] to apply to a structure whose elements consist only of characters, bytes, or types that resolve to characters or bytes. This functionality is not supported in Microsoft RPC. The [string] attribute cannot be applied to the structure as a whole. However, it can be applied to each individual array.

MIDL2192

switch type can only be integral, char, Boolean or enum

The specified type does not resolve to a valid switch type. Use an integer, character, byte, Boolean, enum type, or a type that is derived from one of these types.

MIDL2193

[handle] must not be specified on a type deriving from handle_t

A handle type must be defined using one and only one of the handle types or attributes. Use the primitive type handle_t or the attribute [handle], but not both. The user-defined handle type must be transmissible, but the handle_t type is not transmitted on the network.

MIDL2194

parameter deriving from handle_t must not be an [out] parameter

A handle of the primitive type handle_t is meaningful only to the side of the application in which it is defined. The type handle_t is not transmitted on the network.

MIDL2195

attribute expression derives from [unique] or [ptr] pointer dereference

Although the [unique] and full pointer attributes allow pointers to have NULL values, the expression that defines the size or length attribute must never have a NULL value. When pointers are used, MIDL constrains expressions to [ref] pointers.

MIDL2196

"cpp_quote" requires /ms_ext

The cpp_quote attribute is a Microsoft extension to DCE IDL. Do not use the MIDL compiler switch /osf, which overrides /ms_ext.

MIDL2197

quoted uuid requires /ms_ext

The ability to specify a UUID value within quotation marks is a Microsoft extension to DCE IDL. Do not use the MIDL compiler switch /osf, which overrides /ms_ext.

MIDL2198

return type cannot derive from a nonencapsulated union

The nonencapsulated union cannot be used as a function return type. To return the union type, specify the union type as an [out] or [in, out] parameter.

MIDL2199

return type cannot derive from a conformant structure

The size of the return type must be a constant. You cannot specify as a return type a structure that contains a conformant array even when the structure also includes its size specifier. To return the conformant structure, specify the structure as an [out] or [in, out] parameter.

MIDL2200

[transmit_as] must not be applied to a type deriving from a generic handle

In this release, the [handle] and [transmit_as] attributes cannot be combined on the same type.

MIDL2201

[handle] must not be applied to a type that has [transmit_as] applied to it

In this release, the [handle] and [transmit_as] attributes cannot be combined on the same type.

MIDL2202

type specified for the const declaration is invalid

Constant declarations are limited to integer, character, wide-character, string, and Boolean types.

MIDL2203

operand to the sizeof operator is not supported

The MIDL compiler supports the sizeof operation for simple types only. The specified operand does not evaluate to an integer type.

MIDL2204

this name already used as a const identifier name

The identifier has previously been used to identify a constant in a const declaration. Change the name of one of the identifiers so that the identifiers are unique.

MIDL2205

inconsistent redefinition of type error_status_t

The type error_status_t must resolve to the type unsigned long. Other type definitions cannot be used.

MIDL2206

[case] value out of range of switch type

The value associated with the switch statement case is out of range for the specified switch type. For example, this error occurs when a long integer value is used in the case statement for a short integer type.

MIDL2207

parameter deriving from wchar_t needs /ms_ext

The wide-character type wchar_t is a Microsoft extension to DCE IDL. Do not use the MIDL compiler switch /osf, which overrides /ms_ext

MIDL2208

this interface has only callbacks

Callbacks are valid only in the context of a remote procedure call. The interface must include at least one function prototype for a remote procedure call that does not include the [callback] attribute.

MIDL2209

redundantly specified attribute; ignored

The specified attribute has been applied more than once. Multiple instances of the same attribute are ignored.

MIDL2210

context handle type used for an implicit handle

A type that was defined using the [context_handle] attribute has been specified as the handle type in an [ implicit_handle] attribute. The attributes cannot be combined in this way.

MIDL2211

conflicting options specified for [allocate]

The options specified for the ACF attribute [allocate] represent conflicting directives. For example, specify either the option all_nodes or the option single_node, but not both.

MIDL2212

error while writing to file

An error occurred while writing to the file. This condition can be caused by errors relating to disk space, file handles, file-access restrictions, and hardware failures.

MIDL2213

no switch type found at definition of union, using the [switch_is] type

The union definition does not include an explicit [switch_type] attribute. The type of the variable specified by the [switch_is] attribute is used as the switch type.

MIDL2214

semantic check incomplete due to previous errors

The MIDL compiler makes two passes over the input file(s) to resolve any forward declarations. Due to errors encountered during the first pass, checking for the second pass has not been performed. Unreported errors relating to forward declarations may still be present in the file.

MIDL2215

handle parameter or return type is not supported on a [callback] procedure

A [callback] procedure occurs in the context of a call from a client to the server and uses the same binding handle as the original call. Explicit binding-handle parameters or return types are not permitted in callback functions.

MIDL2216

[ptr] does not support aliasing in this version

An alias occurs when data is accessible through more than one pointer or variable name. Remove the alias. For more information, see Unique Pointers.

MIDL2217

parameter already defined as a context handle

The parameter was previously defined as a context handle.

MIDL2218

[context_handle] must not derive from handle_t

The three handle characteristics: the type handle_t, the attribute [handle], and the attribute [context_handle], are mutually exclusive. Only one characteristic can be applied to a type or parameter at a time.

MIDL2219

array size exceeds 65536 bytes

On some Microsoft platforms, the maximum transmissible data size is 64K. Redesign your application so that all transmitted data fits within the maximum transmissible size.

MIDL2220

structure size exceeds 65536 bytes

On some Microsoft platforms, the maximum transmissible data size is 64K. Redesign your application so that all transmitted data fits within the maximum transmissible size.

MIDL2221

field of a nonencapsulated union cannot be another nonencapsulated union

Unions that are transmitted as part of a remote procedure call require an associated data item, the discriminant, that selects the union arm. Unions nested in other unions do not offer a discriminant; as a result, they cannot be transmitted in this form. Create a structure that consists of the union and its discriminant.

MIDL2222

pointer attribute(s) applied on an embedded array; ignored

A pointer attribute can be applied to an array only when the array is a top-level parameter. Other pointer attributes applied to arrays embedded in other data structures are ignored.

MIDL2223

[allocate] is illegal on either the transmitted or presented type for [transmit_as], [represent_as], [wire_marshal], or [user_marshal]

The [transmit_as] and [allocate] attributes cannot both be applied to the same type. The [transmit_as] attribute distinguishes between presented and transmitted types, while the [allocate] attribute assumes that the presented type is the same as the transmitted type.

MIDL2224

[switch_type] must be specified in this import mode

MIDL2225

[implicit_handle] type undefined; assuming generic handle

The handle type specified in the ACF is not defined in the IDL file. The MIDL compiler assumes that the handle type resolves to the primitive handle type handle_t. Add the [handle] attribute to the type definition if you want the handle to behave like a user-defined or generic handle.

MIDL2226

array element must not derive from error_status_t

In this release of Microsoft RPC, the type error_status_t can appear only as a parameter or return type. It cannot appear in arrays.

MIDL2227

[allocate] illegal on a type deriving from a primitive/generic/context handle

By design, the ACF attribute [allocate] cannot be applied to handle types.

MIDL2228

transmitted or presented type must not derive from error_status_t

In this release of Microsoft RPC, the type error_status_t cannot be used with the [transmit_as] attribute.

MIDL2229

discriminant of a union must not derive from a field with [ignore] applied to it

A union used in a remote procedure call must be associated with another data item, called the discriminant, that selects the union arm. The discriminant must be transmitted. The [ignore] attribute cannot be applied to the union discriminant.

MIDL2230

[nocode] ignored for server side since "/server none" not specified

Some DCE IDL compilers generate an error when the [nocode] attribute is applied to a procedure in an interface for which server stub files are being generated. Because the server must support all operations, [nocode] must not be applied to a procedure in this mode, or you must use the MIDL compiler switch /server none to explicitly specify that no server routines are to be generated.

MIDL2231

no remote procedures specified in non-[local] interface; no client/server stubs will be generated

The provided interface does not have any remote procedures, so only header files will be generated.

MIDL2232

too many default cases specified for encapsulated union

An encapsulated union can have only one default: arm.

MIDL2233

too many default interfaces specified for coclass

A coclass can have at most two [default] members, one to represent the outgoing (source) interface or dispinterface, and one to represent the incoming (sink) interface or dispinterface.

MIDL2234

items with [defaultvtable] must also have [source]

The defaultvtable interface creates a second source interface for an object, one that lets sinks receive events through the V-table.

MIDL2235

union specification with no fields is illegal

Unions must have at least one field.

MIDL2236

value out of range

The provided case value is out of the range of the switch type.

MIDL2237

[context_handle] must be applied on a pointer type

Context handles must always be pointer types. DCE specifies that all context handles must be typed as void *.

MIDL2238

return type must not derive from handle_t

handle_t cannot be returned.

MIDL2239

[handle] must not be applied to a type deriving from a context handle

A type cannot be both a context handle and a generic handle.

MIDL2240

field deriving from an "int" must have size specifier "small", "short", or "long" with the "int"

The type int is not transmissible on 16-bit systems, since the size of int may be different across machines.

MIDL2241

field must not derive from a void or void *

void and void * cannot be used as parameter types for remote procedures.

MIDL2242

field must not derive from a structure containing bit-fields

Structures containing bit fields cannot be used as parameters or return types for remote procedures.

MIDL2243

field must not derive from a non-rpcable union

A union must be specified as a nonencapsulated union or encapsulated union in order to be transmitted. Ordinary C unions lack the discriminant needed to transmit the union across the network.

MIDL2244

field must not derive from a pointer to a function

Pointers to functions cannot be transmitted to remote procedures. Pointers to functions point to function code, and no function code can be transmitted across the network using RPC.

MIDL2245

cannot use [fault_status] on both a parameter and a return type

The attribute [fault_status] can be used only once per procedure. The [comm_status] attribute can be used independently.

MIDL2246

return type too complicated for /Oi modes, using /Os

Large return types that are passed by value can be handled only by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2247

generic handle type too large for /Oi modes, using /Os

Large generic handle types that are passed by value can be handled only by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2248

[allocate(all_nodes)] on an [in,out] parameter may orphan the original memory

Use of [allocate(all_nodes)] on an [in, out] parameter must reallocate contiguous memory for the [out] direction, thus orphaning the [in] parameter. This usage is not recommended.

MIDL2249

cannot have a [ref] pointer as a union arm

Reference pointers must always point to valid memory, but an [in, out] union with a reference pointer may return a reference pointer when the [in] direction used another type.

MIDL2250

return of context handles not supported for /Oi modes, using /Os

MIDL does not support context handles in the fully interpreted optimization modes. Switching to mixed-mode optimization.

MIDL2251

use of the extra [comm_status] or [fault_status] parameter not supported for /Oi modes, using /Os

The [comm_status] and [fault_status] attributes can be handled only by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2252

use of an unknown type for [represent_as] or [user_marshal] not supported for /Oi modes, using /Os

Use of the [represent_as] attribute with a local type that is not defined in the IDL file or an imported IDL file can be handled only by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2253

array types with [transmit_as] or [represent_as] not supported on return type for /Oi modes , using /Os

Returning an array with [transmit_as] or [represent_as] applied can only be handled by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2254

array types with [transmit_as] or [represent_as] not supported pass-by-value for /Oi modes, using /Os

This action is not supported for fully-interpreted optimization. Switching to mixed-mode optimization.

MIDL2255

[callback] requires /ms_ext

The [callback] attribute is a Microsoft extension and requires that the /ms_ext switch be enabled. Do not compile with /osf, which overrides /ms_ext.

MIDL2256

circular interface dependency

This interface uses itself (directly or indirectly) as a base interface.

MIDL2257

only IUnknown may be used as the root interface

Currently, all interfaces must have IUnknown as the root interface.

MIDL2258

[IID_IS] may only be applied to pointers to interfaces

The [iid_is] attribute can only be applied to interface pointers, although they can be specified as pointers to IUnknown *.

MIDL2259

interfaces may only be used in pointer-to-interface constructs

Interface names cannot be used except as base interfaces or interface pointers.

MIDL2260

interface pointers must have a UUID/IID

The base type of the [iid_is] expression must be a UUID/GUID/IID type.

MIDL2261

definitions and declarations outside of interface body requires /ms_ext

Putting declarations and definitions outside of any interface body is a Microsoft extension and requires the use of the /ms_ext switch.

MIDL2262

multiple interfaces in one file requires /ms_ext

Using multiple interfaces in a single idl file is a Microsoft extension and is not available when you compile in /osf mode.

MIDL2263

only one of [implicit_handle], [auto_handle], or [explicit_handle] allowed

Each interface can have only one of these three attributes.

MIDL2264

[implicit_handle] references a type which is not a handle

Implicit handles must be of one of the handle types.

MIDL2265

[object] procs may only be used with "/env win32"

Interfaces with the [object] attribute cannot be used with 16-bit environments.

MIDL2266

[callback] with -env dos/win16 not supported for /Oi, using /Os

Callbacks in 16-bit environments can be handled only by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2267

float/double not supported as top-level parameter for /Oi mode, using /Os

The float and double types can only be handled as parameters by the /Os optimization stubs. The stubs for this routine will be generated using /Os optimization. The float and double types within structures, arrays, or unions can still be handled with/Os.

MIDL2268

pointers to context handles may not be used as return values

Context handles must be used as direct return values, not indirect return values.

MIDL2269

procedures in an object interface must return an HRESULT

All procedures in an object interface that do not have the-[local] attribute must return an HRESULT/SCODE.

MIDL2270

duplicate UUID

Same as UUIDs must be unique.

MIDL2271

[object] interfaces must derive from another [object] interface such as IUnknown

Interface inheritance is allowed only when you are using object interfaces.

MIDL2272

(async) interface must derive from another (async) interface

Object interfaces, both synchronous and asynchronous, must derive from IUnknown or some other base OLE interface.

MIDL2273

[IID_IS] expression must be a pointer to IID structure

The base type of the [iid_is] expression must be a UUID/GUID/IID type.

MIDL2274

[call_as] type must be a [local] procedure

The target of a [call_as] type, if defined, must have [ local] applied.

MIDL2275

undefined [call_as] must not be used in an object interface

You must define the target of a [call_as] type. Make sure you have supplied call_as routines for both the calling and called applications.

MIDL2276

[auto_handle] may not be used with [encode] or [decode]

The [ encode] and [ decode] attributes can be used only with explicit handles or implicit handles.

MIDL2277

normal procedures are not allowed in an interface with [encode] or [decode]

Interfaces containing [encode] or [decode] procedures cannot also have remote procedures.

MIDL2278

top-level conformance or variance not allowed with [encode] or [decode]

Types that have top-level conformance or variance cannot use type serialization, since there is no way to provide sizing/lengthening. Structures containing them are, however, allowed to use type serialization.

MIDL2279

[out] parameters may not have "const"

Since an [out] parameter is altered, it must not be declared as sa constant.

MIDL2280

return values may not have "const"

Since a function value is set when the function returns, this value must not be declared as a constant.

MIDL2281

invalid use of "retval" attribute

Check to make sure you have not used the [optional] attribute and that the [retval] parameter is the last parameter in the list.

MIDL2282

multiple calling conventions illegal

Only one calling convention can be applied to a single procedure.

MIDL2283

attribute illegal on [object] procedure

The above attribute only applies to procedures in interfaces that do not have the [object] attribute.

MIDL2284

[out] interface pointers must use double indirection

Since the altered value is the pointer to the interface, there must be another level of indirection above the pointer to allow it to be returned.

MIDL2285

procedure used twice as the caller in [call_as]

A given [local] procedure can be used only once as the target of a [call_as], in order to avoid name clashes.

MIDL2286

[call_as] target must have [local] in an object interface

The target of a [call_as] must be a defined [local] procedure in the current interface.

MIDL2287

[code] and [nocode] may not be used together

These two attributes are contradictory and cannot be used together.

MIDL2288

procedures with [maybe] or [message] attributes may not have [out] params, or return values must be of type HRESULT or error_status_t

Since [maybe] procedures never return, there is no way to get return values.

MIDL2289

pointer to function must be used

Although function-type definitions are allowed in /c_ext mode, they can only be used as pointers to functions. They can never be transmitted as a parameter or a return value of a remote procedure.

MIDL2290

functions may not be passed in an RPC operation

Functions and function pointers cannot be passed as parameters or return values of remote procedures.

MIDL2291

hyper/double not supported as return value for /Oi modes, using /Os

Hyper and double return values can be handled only by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.

MIDL2292

#pragma pack(pop) without matching #pragma pack(push)

#pragma pack(push) and #pragma pack(pop) must appear in matching pairs. At least one too many #pragma pack(push)s were specified.

MIDL2293

stringable structure fields must be byte/char/wchar_t

The type [string] can only be applied to a structure whose fields are all of type byte, or a type definition equivalent to byte.

MIDL2294

[notify] not supported for /Oi modes, using /Os

The [notify] attribute can be processed only by /Os optimization stubs.

MIDL2295

handle parameter or return type is not supported on a procedure in an [object] interface

Handles cannot be used with [ object] interfaces.

MIDL2296

ANSI C only allows the leftmost array bound to be unspecified

In a conformant array, ANSI C allows only the leftmost (most significant) array bound to be unspecified. If multiple dimensions are conformant, MIDL will attempt to put a "1" in the other conformant dimensions. If the other dimensions are defined in a different type definition, this cannot be possible. Try putting all the array dimensions on the array declaration to avoid this. In any case, beware of the array-indexing calculations done by the compiler; you may need to do your own calculations using the actual sizes.

MIDL2297

by-value union parameters not supported for /Oi modes, using /Os

This action is not supported for fully-interpreted optimization. Switching to mixed-mode optimization.

MIDL2298

[version] attribute is ignored on an [object] interface

The [object] attribute identifies a COM interface. An interface attribute list for a COM interface cannot include the [ version] attribute.

MIDL2299

[size_is] or [max_is] attribute is invalid on a fixed array

Arrays of fixed size can't use the size_is or max_is attributes.

MIDL2300

[encode] or [decode] are invalid in an [object] interface

The [object] attribute identifies a COM interface. The [encode] and [ decode] attributes enable serialization. That is, you can provide and control buffers for data marshal and unmarshal, however, you cannot perform serialization on COM interfaces.

MIDL2301

[encode] or [decode] on a type requires /ms_ext

Serialization is not part of the DCE-IDL specification. It is a Microsoft extension that requires the use of the /ms_ext command-line switch.

MIDL2302

int not supported on /env win16 or /env dos

The 16-bit Microsoft platforms do not support the use of the int type in an IDL file. Qualify the int type with small, short, or long.

MIDL2303

[bstring] may only be applied to a pointer to "char" or "whchar_t"

This error is obsolete. It is provided only for backward compatibility.

MIDL2304

attribute invalid on a procedure in an [object] interface

The specified attribute is not allowed on procedure in a COM interface.

MIDL2305

attribute invalid on an [object] interface

The specified attribute is not allowed in a COM interface.

MIDL2306

too many parameters or stack too big for /Oi modes, using /Os

This warning is obsolete. It is provided only for backward compatibility. It indicates that the call to the remote procedure causes the stack to grow larger than 64 K.

MIDL2307

no attributes on ACF file typedef, so no effect

IDL file should contain all of the typedef statements that do not have attributes. They should not occur in ACF files. If they do, the MIDL compiler interprets them as redundant and ignores them.

MIDL2308

calling conventions other than __stdcall or __cdecl not supported for /Oi modes, using /Os

Calling conventions such as __pascal or __fastcall change the format of the stack. The /Oi modes only support the __stdcall and __cdecl calling conventions. If you must use other calling conventions, use the /Os mode.

MIDL2309

Too many delegation methods in the interface, require Windows 2000 or greater

One interface can inherit from another. When it does, the methods of the base interface are considered delegated. No derived interface can contain more than 256 delegated methods.

MIDL2310

auto handles not supported with /env mac or /env powermac

When compiling your IDL file for a PowerMac, you cannot use automatic binding handles. You must specify explicit or implicit handles.

MIDL2311

statements outside library block are illegal in mktyplib compatibility mode

You may need to specify the /mktyplib203 command-line switch when you compile your IDL file.

Note  The Mktyplib.exe tool is obsolete. Use the MIDL compiler instead.

MIDL2312

illegal syntax unless using mktyplib compatibility mode

You may need to specify the /mktyplib203 command-line switch when you compile your IDL file.

Note  The Mktyplib.exe tool is obsolete. Use the MIDL compiler instead.

MIDL2313

illegal definition, must use typedef in mktyplib compatibility mode

You may need to specify the /mktyplib203 command-line switch when you compile your IDL file.

Note  The Mktyplib.exe tool is obsolete. Use the MIDL compiler instead.

MIDL2314

explicit pointer attribute [ptr] [ref] ignored for interface pointers

Pointers to interfaces cannot have IDL attributes.

MIDL2315

/Oi modes not implemented for PowerMac, switching to /Os

MIDL2316

illegal expression type used in attribute

The default value for the pointer should be a constant.

MIDL2317

illegal type used in pipe

Pipes are limited to basic IDL data types. For example, you cannot specify a pipe of arrays.

MIDL2318

procedure uses pipes, using /Oicf

The mode you selected does not support pipes. The MIDL compiler detected the use of one or more pipes in your interface. Therefore, it is compiling your IDL file in /Oicf mode.

MIDL2319

procedure has an attribute that requires use of /Oif, switching modes

You must compile [async] procedures in /Oif mode.

MIDL2320

conflicting optimization requirements, cannot optimize

This error often indicates that you specified both /Os and /Oi (or a variant of /Oi) MIDL compiler modes. It can also mean that the features you specified in your IDL and ACL files require the use of both modes. You must select one mode or the other to optimize.

MIDL2321

pipes cannot be array elements, or members of structures or unions

Pipe data types can only be top-level parameters.

MIDL2322

invalid pipe usage

You cannot use pipes with the [transmit_as], [represent_as], or [user_marshal] attributes. In addition, pipes cannot be used as return types.

MIDL2323

feature requires the advanced interpreted optimization option; use -Oicf

This error indicates that MIDL compiler command-line switches such as /robust require the use of /Oicf mode.

MIDL2324

feature requires the advanced interpreted optimization option; use -Oicf

This warning indicates that MIDL compiler command-line switches such as /robust require the use of /Oicf mode.

MIDL2329

the optimization option is being phased out, use -Oic

The /Oi1 optimization mode was specified on the MIDL command line. This mode is no longer supported and /Oicf should be used instead.

MIDL2330

the optimization option is being phased out, use -Oicf

The /Oi2 optimization mode was specified on the MIDL command line. This mode is no longer supported and /Oicf should be used instead.

MIDL2331

the optimization option is being phased out, use -ic

The i1 optimization mode was specified in an [optimize] ACF attribute. This mode is no longer supported and icf should be used instead.

Example ACF file:

[optimize("i1")] roo();    //MIDL 2331
MIDL2332

the optimization option is being phased out, use -icf

The i2 optimization mode was specified in an [optimize] ACF attribute. This mode is no longer supported and icf should be used instead.

Example ACF file:

[optimize("i2")] roo();    //MIDL 2332
MIDL2333

the -old and -new switches are obsolete, use -oldtlb and -newtlb

This message is obsolete and is no longer omitted by MIDL.

MIDL2334

illegal argument value

The allowed variants of the /O command-line switch include /Os, /Oi, /Oic, /Oicf, and /Oif.

MIDL2335

illegal expression type in constant

The expression does not evaluate to a constant.

MIDL2336

illegal expression type in enum

An enumerated value in an enum definition does not evaluate to an integral type.

MIDL2337

unsatisfied forward declaration

The MIDL compiler could not resolve the definition of a forward declaration.

MIDL2338

switches are contradictory

You cannot use both the /osf and /ms_ext command-line switches when you compile an IDL file. You must choose one or the other.

MIDL2339

MIDL cannot generate HOOKOLE information for the non-rpc-able union

This error is obsolete. It is provided strictly for backward compatibility.

MIDL2340

no case expression found for union

Each field of a union must have a case statement with a constant expression.

MIDL2341

[user_marshal] and [wire_marshal] not supported with -Oi and -Oic flags, use -Os or -Oicf

The [user_marshal] and [wire_marshal] attributes require the specific optimization features available only in /Oicf (codeless proxy with fast format strings) or /Os (mixed mode marshaling).

MIDL2342

pipes can't be used with data serialization, i.e. [encode] and/or [decode]

You cannot pass pipes as parameters to procedures that have the [encode] or [decode] attributes.

MIDL2343

all pipe interface pointers must use single indirection

You cannot use a pointer to a pointer to a pipe interface in this manner.

MIDL2344

[iid_is()] cannot be used with a pipe interface pointer

This message is obsolete. This message is no longer used by the compiler.

MIDL2345

invalid or inapplicable -lcid switch

The local identifier (LCID) that you specified is not valid.

MIDL2346

the specified lcid is different from previous specification

The values specified in /lcid and [lcid] are different. The MIDL compiler will use the last one defined.

MIDL2347

importlib is not allowed outside of a library block

All [importlib] statements should occur in a [library] block.

MIDL2348

invalid floating point value

This error should not be emitted by MIDL. If you see this error please report a bug to Microsoft providing all files needed to reproduce the error, including your IDL files, ACF files, headers, etc.

MIDL2349

invalid member

Procedures cannot be members of a library.

MIDL2350

possible invalid member

To be a valid member of a library, the library element must be a module, a dispinterface, a coclass, an if statement, a structure, a union, an enumeration, or a forward declaration.

MIDL2351

mismatch in pipe and interface types

This message is obsolete.

MIDL2352

string, varying array, conformant array and full pointer parameters may be incompatible with pipe parameters during run time

A method combining one or more [in] strings, varying arrays, conformant arrays and full pointer parameters and any [in] pipe parameter result in generation of a stub that runs only on ncacn_* and ncalrpc protocol sequences on Windows computers. Using the stub to make calls on ncadg_* protocol sequences or accepting calls from other OSF DCE RPC vendors may generate faults on the server during run time. This error occurs starting with Windows Server 2003.

MIDL2353

parameter must be in

Asynchronous handles must be [in] parameters.

MIDL2354

parameter type of an [async] object must be a double pointer to an interface

The parameter must be of type IAsyncManager **.

MIDL2355

incorrect async handle type

The handle type should be IAsyncManager or a type derived from IAsyncManager.

MIDL2356

the "internal" switch enables unsupported features, use with caution

Avoid using this switch.

MIDL2357

async procedures cannot use auto handle

Procedures with the [async] attribute require explicit handles.

MIDL2358

error_status_t should have both [comm_status] and [fault_status]

A procedure was specified with the IDL attributes [maybe] or [message] but the return type only has the ACF attributes [comm_status] or [fault_status]. Both ACF attributes are required.

Example ACF file:

[comm_status] roo();    //MIDL 2358
[fault_status] bar();    //MIDL 2358
[comm_status, fault_status] baz();    //OK
MIDL2359

this construct is only allowed within a library block

A module can occur only within a library block.

MIDL2360

invalid type redefinition

A new type was recursively defined on a nonexisting type.

Example:

typedef roo roo[10];    //MIDL 2360
MIDL2361

procedures with a [vararg] attribute must have a SAFEARRAY(VARIANT) parameter; param order is [vararg], [lcid], [retval]

Most of the parameters for procedures with the [vararg] attribute must occur before the SAFEARRAY(VARIANT) parameter. The SAFEARRAY(VARIANT) parameter must be present. If the parameter list contains a parameter with the [ lcid] attribute, it must follow the SAFEARRAY(VARIANT) parameter. If the parameter list contains a parameter with the [retval] attribute, it must occur after the parameter with the [lcid] attribute.

MIDL2363

too many methods in the interface, requires Windows 2000 or greater

The MIDL compiler does not allow more than 1024 methods in an interface when you are compiling in /Oicf mode.

MIDL2364

switch is being phased out

The following switches are obsolete: /hookole, /env win16, and /env.

MIDL2365

cannot derive from IAdviseSink, IAdviseSink2, or IAdviseSinkEx

These interfaces cannot be extended.

MIDL2366

cannot assign a default value

Assigning a default value to a parameter is allowed in Visual Basic, but not in C++. If you are using C++, the default value is ignored.

MIDL2367

type library generation for DOS/Win16/MAC is not supported

MIDL does not support 16-bit type libraries.

MIDL2368

error generating type library, ignored

A nonfatal error occurred while generating the type library.

MIDL2369

exceeded stack size for /Oi, using /Os

The -Oi optimization mode is limited to 128 bytes of stack space for parameters. The compiler has automatically switched to the Os optimization mode to work around this limitation.

To avoid this warning, use the -Oicf or -Os optimization modes. The optimization mode may be changed on the command line by specifying -Oicf or -Os instead of -Oi or by adding an [optimize9"icf")] or optimize[("s")] attribute to the function in the ACF file.

This warning typically happens when passing large structures as parameters by value. The required stack size can be lowered by passing a pointer to the structure instead.

Example:

typedef struct
{
char a[127];
}
large;
//This function has a stack size of 132 (x86) or 136 (alpha) on 32-bit systems
void roo(large s, int a);    //MIDL 2360
// workaround: pass by reference
void bar (large *s, int a);
MIDL2370

use of /robust requires /Oicf, switching modes

You must compile in /Oicf mode when you specify the /robust switch on the command line.

MIDL2371

incorrect range specified

The highest value specified in a [range] attribute is less than the lowest value.

Example:

void roo([range(3,2)] int a);    //MIDL 2371
MIDL2372

invalid combination of [in] only and [out] parameters for [async_uuid] interface

Only simple combinations of attributes with [in] or [out] parameters are allowed for this type of interface.

MIDL2373

DOS, Win16 and MAC platforms are not supported with /robust

MIDL supports the /robust switch on Microsoft Windows 2000 or later.

MIDL2374

support for NT 3.51 style stubless proxies for object interfaces will be phased out; use /Oif.

This mode is obsolete. Use /Oif or /Oicf.

MIDL2375

[encode] or [decode] with /robust requires /Oicf

Serialization cannot be performed when the /robust switch is specified.

MIDL2377

conflicting attributes specified

Both [context_handle_serialize] and [context_handle_noserialize] were specified.

MIDL2378

[serialize], [noserialize] can be applied to context_handles

The ACF attributes [context_handle_serialize] or [context_handle_noserialize] can only be applied to types that are context handles.

Example IDL file:

typedef /*[context_handle] */ void *PV;    //Note: PV is *not* a context handle.

Example ACF file:

typedef [context_handle_serialize] PV;    //MIDL 2378
MIDL2379

The compiler reached a limit for a format string representation. See documentation for advice.

The MIDL compiler has a 64 KB limit for format strings. This error generally occurs when IDL files include other IDL files. The composite IDL file generated by all of the include statements exceeds the limits of the type representation tables of the marshaling engine interpreter. Try using the import directive rather than the include directive in your IDL files. For more information, see Importing System Header Files, include, and import.

MIDL2380

wire format may be incorrect, you may need to use -ms_conf_struct, see documentation for advice

The MIDL compiler could not generate a transmissible format for the data. One common way to get this error is to define an ms_conf_struct inside a complex structure.

MIDL2381

a stack size or an offset bigger than 64 K limit. See documentation for advice.

The call results in a stack that is larger than 64 KB. Try passing the data in smaller blocks.

MIDL2382

an interpreter mode forced for 64-bit platform

64-bit platforms require the /Oicf compilation mode.

MIDL2383

The array element size is bigger than 64 KB limit.

All array elements must be less than 64 KB in size.

MIDL2384

there can be only one [Icid] parameter in a method, and it should be last or second to last if last parameter has [retval]

A parameter with the [lcid] attribute must occur last. The only exception is when there is also a parameter with the [retval] attribute. When both occur, the second to the last parameter in the parameter list must have the [ lcid] attribute. The last parameter must have the [retval] attribute.

MIDL2385

incorrect syntax for midl_pragma

The MIDL compiler detected an unknown syntax error in a midl_pragma statement.

MIDL2386

__int3264 is not supported in /osf mode

If you need to use __int3264, compile in /ms-ext mode.

MIDL2387

unresolved symbol in type library

The compiler could not resolve a formal declaration or referenced type in the type library.

MIDL2388

async pipes cannot be passed by value

Asynchronous pipes should be passed by reference or by address.

MIDL2389

parameter offset exceed 64-KB limit for interpreted procedures

This error typically means that a procedure has too many parameters.

MIDL2390

invalid array element

Pipes cannot be used as array elements.

MIDL2391

dispinterface members must be methods, properties or interfaces

A dispinterface cannot contain type definitions, structures, enumerations, or unions.

MIDL2392

[local] procedure without [call_as]

Object procedures that have the [local] attribute also require the [call_as] attribute.

MIDL2393

multi dimensional vector, switching to /Oicf

The /Os optimization mode does not support multidimensional nonfixed size arrays. The compiler has automatically switched the optimization mode to /Oicf for this function.

This warning can be suppressed globally by changing the compiler mode by specifying /Oicf on the MIDL command line or by using midl_pragma warning (disable: 2393) in the IDL file. The optimization mode can be changed for an individual function by adding the [optimize("icf")] attribute to the function in the ACF file.

The following example demonstrates this warning:

void roo(long s1, [size_is(s1)] long a[][30];    //MIDL2393
void bar(long s1, long s2, [size_is(s1,s2) long **a);//MIDL2393
MIDL2395

type or construct not supported in a library block because Oleaut32.dll support for 64-KB polymorphic types is missing

OLE automation does not support polymorphic types (such as _int3264, INT_PTR, etc). These types have incompatible data representations between 32-bit and 64-bit platforms. The remote call will fail at run time on 64-bit platforms.

Note  Note that as of Windows 2000 release, 64-bit TLB files are supported by OLE Automation by converting 32-bit TLB information at run time. Therefore, only 32-bit TLB generation is supported by MIDL.

If MIDL is being used just to generate a header file, the /notlb switch will suppress generation of the TLB file.

MIDL2396

old interpreter code being generated for 64b

This error is obsolete. If you see this error, please report a bug to Microsoft giving your IDL files, ACF files, and full MIDL-command line.

MIDL2397

the compiler switch is not supported anymore

The specified switch or switches are no longer supported.

MIDL2398

cannot execute MIDL engine

As of the Windows 2000 release (MIDL version 5.03.279), the MIDL compiler is implemented using two executable files: Midl.exe (the driver), and Midlc.exe (the compiler engine). This error indicates the Midl.exe is unable to launch Midlc.exe. Make sure that Midlc.exe is in the same directory as Midl.exe, and that they are the same version.

The error may have been caused by copying Midl.exe but not Midlx.exe from the latest distribution. Run midl and/or midlc at the command line without any parameters to see the version number of the executable.

MIDL2399

bad commands from driver

As of the Windows 2000 release (MIDL version 5.03.279), the MIDL compiler is implemented using two executable files: Midl.exe (the driver), and Midlc.exe (the compiler engine). This error indicates that the temporary file used to pass commands from Midl.exe to Midlc.exe is missing or corrupt. Make sure that Midlc.exe is in the same directory as Midl.exe, and that they are the same version.

The error may have been caused by attempting to run Midlc.exe directly or by copying Midl.exe but not Midlc.exe from the latest distribution. Run midl and/or midlc at the command line without any parameters to see the version number of the executable.

MIDL2400

for ole automation, optional parameters should be VARIANT or VARIANT *

OLE Automation requires that all [optional] parameters be of type VARIANT or VARIANT*.

In OLE automation, using non-VARIANT parameters may cause the call to fail at run time or to pass undefined data for the [optional] parameters.

MIDL2401

[defaultvalue] is applied to a non-VARIANT and [optional]. Please remove [optional]

The [defaultvalue] attribute implies [optional]. The [ optional] attribute is not necessary.

MIDL2402

[optional] attribute is inapplicable outside of a library block

The functionality implied by the [ optional] attribute is not applicable to proxies generated for an interface outside of a library block.

MIDL2403

The data type of the [Icid] parameter must be long

OLE Automation requires that parameters with the [Icid] attribute must be of type long.

MIDL2404

procedures with [propput], [propget] or [propref] can't have more than one required parameter after [optional] one

There cannot be more than one parameter without [optional] after the last parameter with [optional] when using [propput], [propget], or [ propputref].

MIDL2405

[comm_status] or [fault_status] with pickling requires -Oicf

The old -Oi optimization mode does not support procedures or parameters with [ comm_status] or [ fault_status] with pickling (that is, using [ encode] and/or [ decode]).

This warning can be suppressed globally by specifying -Oicf on the MIDL command line or for an individual function by adding the [optimize("icf:)] attribute to the function in the ACF file.

In general, the -Oicf optimization mode is recommended over -Oi mode.

MIDL2406

midl driver and compiler version mismatch

As of the Windows 2000 release (MIDL version 5.03.279) the MIDL compiler is implemented using two executable files: Midl.exe (the driver), and Midlc.exe (the compiler engine). This error indicates that the version of Midl.exe does not match the version of Midlc.exe.

The error may have been caused by copying Midl.exe but not Midlc.exe from the latest distribution. Run midl and/or midlc at the command line without any parameters to see the version number of the executable.

MIDL2407

no intermediate file specified: use Midl.exe

As of the Windows 2000 release (MIDL version 5.03.279), the MIDL compiler is implemented using two executable files: Midl.exe (the driver), and Midlc.exe (the compiler engine). This error indicates that Midlc.exe was run directly instead of using Midl.exe.

MIDL2408

processing problem with a parameter in a procedure

This error may be seen when importing data from a TLB and when a procedure has an invalid parameter.

If you see this error, report a bug to Microsoft. Specify your IDL files, ACF files, TLB file, and full MIDL-command line.

MIDL2409

processing problem with a field in a structure

This error may be seen when importing data from a TLB and when a structure has an invalid structure or union field.

If you see this error, report a bug to Microsoft. Specify your IDL files, ACF files, TLB file, and full MIDL-command line.

MIDL2410

internal compiler inconsistency detected: the format string offset is invalid. See the documentation for more information.

The MIDL compiler detected an invalid value in its internal data structures. This may be caused by structures that are recursive or by compiler breaching its own limits of representation for internal data. To identify and/or work around the problem, try to simplify the IDL file. You can do this by simplifying complex parameters and recursive data structures or making the IDL file smaller by splitting it. This message may be accompanied by a diagnostic printout with additional information about the problem.

If you see this error, report a bug to Microsoft. Specify your IDL files, ACF files, full MIDL command line, and diagnostic output, if any.

MIDL2411

internal compiler inconsistency detected: the type offset is invalid. See the documentation for more information.

The MIDL compiler detected an invalid value in its internal data structures. This may be caused by structures that are recursive or by the compiler breaching its own limits of representation for internal data. To identify and/or work around the problem try to simplify the IDL file. You can do this by simplifying complex parameters and recursive data structures or by making the IDL file smaller by splitting it. This message may be accompanied by a diagnostic printout with additional information about the problem.

If yoiu see this error, report a bug to Microsoft. Specify your IDL files, ACF files, full MIDL command line, and diagnostic output, if any.

MIDL2412

SAFEARRAY(roo) syntax is not supported outside of the library block, use LPSAFEARRAY for proxy

Explicitly-typed SAFEARRAYs are not allowed outside of a library block. Use LPSAFEARRAY instead.

The following example demonstrates this error:

void roo(SAFEARRAY(long) *a); //MIDL2412 when outside a library block
void roo(LPSAFEAEEAY a);         //OK
MIDL2413

bit fields are not supported

C-style bit fields are not supported by MIDL. This applies to proxy generation as well as TLB generation.

MIDL2414

floating point or complex return types with [decode] are not supported in -Oicf, using -OI

Procedures with floating point or structure/union return types are not supported in the -Oicf style pickling. A work around for 32-bit is to use the -Oi optimization mode when serializing data (using [encode] and/or [decode]). However, as the old -Oi style interpreter and pickling support are slated to be phased out after the Windows 2000 release, using pointers is strongly suggested as the work around for this problem. Also note that typically, changing an interface method to use an [out, ref] pointer instead of the return value causing the problem is fully backward-compatible on wire and can be easily hidden from the app layer.

This warning can be suppressed globally by specifying -Oi on the MIDL command line or for an individual function by adding the [optimize("i")] attribute to the function in the ACF file.

The following example demonstrates the issue:

roo.idl:

double GetDouble();

roo.acf:

[decode] GetDouble();

One option to work around this limitation would be to pass an [out] parameter to hold the result instead of using a return value:

roo.idl:

void GetDouble([out] double *result); //top level pointer is a [ref] pointer

roo.acf:

[decode] GetDouble();

As mentioned earlier, the solution described above is good not only for the new interfaces but also as a work-around for the old ones. The wire representation for the new "out" argument is the same as for the return value (notice void as the new return value).

MIDL2415

the return type is not supported for 64-bit when using [decode]

Procedures with floating point or structure/union return types are not supported in 64-bit mode when performing data serialization (using [ encode] and/or [ decode]). This is related to the old style -Oi interpreter and data serializer not being supported on 64-bit platform. Please see the description of MIDL2414 for more information.

The following example demonstrates this error:

roo.idl:

double GetDouble();

roo.acf:

[decode] GetDouble();

The following is advised as a work-around for both new and old interfaces. Use an [out] parameter to hold the result instead of using a return value:

roo.idl:

void GetDouble([out] double *result); //top level pointer is a [ref] pointer.

roo.acf:

[decode] GetDouble();

Note that this solution is fully backward-compatible on wire, as the wire representation of a [ref, out] pointer or a double is the same as that of a double.

MIDL2416

transmitted type may not contain a full pointer for either [wire_marshal] or [user_marshal]

Types with [ wire_marshal] or [ user_marshal] attributes may not contain full ([ ptr]) pointers. Use [ unique] or [ ref] instead.

The following example demonstrates this error:

typedef struct
{
    [ptr] long *a;    //Should use [ref] or [unique] instead
}
st1;
typedef [wire_marshal(st1)] struct
{
    long a;
}
st2:
void roo(st2 *s);    //MIDL2416
MIDL2417

transmitted type must either be a pointer or have a constant size for [wire_marshal] and [user_marshal]

Top-level types with [ wire_marshal] or [ user_marshal] attributes must have a well-defined size at compile time. They cannot be or contain conformant or varying-sized arrays.

The following example demonstrates this error:

typedef struct        //Type contains variable-sized array
{
    long s;
    [size_is(s)] char a[];
}
st1;
typedef [wire_marshal(st1)] struct
{
    long a;
}
st2;
void roo(st2 *s);        //MIDL2417
MIDL2418

procedures with [propget] must have at least one parameter or a return value

Procedures with the [propget] attribute must have some means of returning the property value. They must have at least one [out] parameter or a return value.

MIDL2461

The [readonly] attribute was applied at the method level.

The [readonly] attribute can only be applied at the parameter level.

MIDL2465

Structures containing conformant arrays must be passed by reference

Top level parameters in RPC must have a well-defined size at compile time. They cannot be, nor contain conformant or varying-sized array. In addition, users cannot encode/decode a type without well-defined size. Applications need to pass conformant struct/conformant varying struct by reference.

The following example demonstrates this error:

typedef struct        //Type contains variable-sized array
{
    long s;
    [size_is(s)] char a[];
}
st1;
void roo(st1 s);        //MIDL2465
 
on .acf file
typedef [encode,decode] st1; //MIDL2465

MIDL9008

internal compiler problem <system error code> - the compiler cannot continue for an unknown reason. See documentation for a workaround.

The compiler could not continue and the cause of the error is unknown. The hexadecimal error number is a system-error identifier. The compile may have failed because of an external problem, such as an out-of-memory condition. In that case, you can find more information in Winerror.h or Ntstatus.h.

There are two situations that usually generate this error:

  • The MIDL compiler failed to recover after detecting an error in the IDL file. If MIDL returned any error messages about your IDL file, try fixing them and recompiling. If there are no error messages, the compiler may have failed before it could report an error. Look for a syntax error on the line for which the internal compiler error is reported.
  • The MIDL compiler could not generate correct code under a specified optimization option. Try changing compiler modes, compiling in mixed-mode optimization (/Os), or removing all optimizations. Or, recompile using the /NO_FORMAT_OPT flag to suppress MIDL's default optimization of procedure and type descriptors.

Occasionally this error occurs even when the IDL file is correct and no optimization options are being used. If this is the case, try rewriting the section of code in the vicinity of where the error was reported by removing any recent modifications, simplifying or rearranging data types, changing prototypes, or else begin to comment out portions of the IDL file to locate the problem code.

If none of these options works, or if you think the problem may be related to a bug in Midl.exe, please notify Microsoft, giving all the relevant details.

 

 

 

Community Additions

ADD
Show:
© 2014 Microsoft