Compiler Errors

The following error messages are generated during MIDL compilation:

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.
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 and 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 for procedure
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. All but the first import operation are ignored.
MIDL2008 : sparse enums require /c_ext or /ms_ext switch
Assigning 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 enum label that is not defined.
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-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.
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
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
?
MIDL2020 : error generating type library
?
MIDL2021 : duplicate id
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. The argument is either missing, or contains an invalid value.
MIDL2023 : error recovery assumes
MIDL2024 : error recovery discards
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-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 a divide by zero.
MIDL2032 : expression uses incompatible types
The left and right sides of the operator in an expression are of incompatible types.
MIDL2033 : non-array 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 enum. 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 feature.
MIDL2038 : no [pointer_default] 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 non-top-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.
MIDL2039 : interface does not conform to [oleautomation] attribute
The interface does not meet the requirements for and 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
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.
MIDL2046 : cannot specify a variable number of arguments to a remote procedure
Remote procedure calls that specify the number of variable 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"
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 requires that only the first parameter can 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 can be of type error_status_t at a time.
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, which 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 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, one of propget, propput and 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(s).
MIDL2059 : attribute expression must be of integral, non hyper type
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]
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
The comm_status attribute may only appear once, and the fault_status attribute may only appear once per procedure.
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 foo {
    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 for interface
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] cannot 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 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 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 hex 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 at the end of the parameter list
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(str)] 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 setting functions.
MIDL2093 : procedures with [propput], [propget] or [propref] 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] paramter 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 file does not match that specified in the IDL file
In this 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
Duplicated 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.
MIDL 2097 : 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 : [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 array-bounds constructs of 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. See the RPC Programmer's Guide for rules governing conformant arrays.
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 SAFEARRAYs 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
The identifier exceeded the maximum allowable length of 255 characters and has been 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
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 on data that is 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 non-integer 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 non-integer 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 and, as such, is 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 non-rpcable 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 struct/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 non-rpcable 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 singleline 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 specified 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 non-void 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 non-encapsulated 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 are permitted because each structure consists of the union and its discriminant.
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 : a parameter or a return value must not derive from a type that has [ignore] applied to it
The ignore attribute is a field attribute that can only be applied 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 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 non-terminating. Use a unique pointer attribute to allow the data structure to specify a null element or redefine the data structure as a non-recursive 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 only allowed in the IDL file 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
The version of OLEAUT32.DLL provided with Windows NT 4.0 is needed in order for you to use this attribute.
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 accept ththis feature 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 varying/conformant 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 the 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
The use of initializing expressions is limited to constant expressions 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, byte, 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 value 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. Reference pointers cannot be used.
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 non-encapsulated 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]
The unique and full pointer attributes allow the value NULL. 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 valid 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 : [transmit_as] must not be specified on void type
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 Foo(void)
MIDL2190 : [switch_is] must be specified only on a type deriving from a non-encapsulated union
The switch_is keyword is incorrectly applied. It can only be used with non-encapsulated union types. For more information, see the syntax section in the reference entry for non-encapsulated unions.
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; it can be applied to each individual array.
MIDL2192 : switch type can only be integral, char, byte, 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.
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 non-encapsulated union
The non-encapsulated 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
Const 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.
MIDL2204 : this name already used as an 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
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 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 : struct 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 non-encapsulated union cannot be another non-encapsulated 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 a type that has [transmit_as] applied to it
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 primitive 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 only appear as a parameter or a 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] must be specified with "/server none" in this mode
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, 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 may only have one default: arm.
MIDL2233 : too many default interface specified for coclass
A coclass may 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 VTBL.
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 may not be returned.
MIDL2239 : [handle] must not be applied to a type deriving from a context handle
A type may not 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 use of "int" is not remotableon 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 * are not remotable types.
MIDL2242 : field must not derive from a struct containing bit-fields
bit fields in structs are not remotable.
MIDL2243 : field must not derive from a non-rpcable union
A union must be specified as a non-encapsulated union or encapsulated union in order to be remoted. Ordinary C unions lack the discriminant needed to remote the union.
MIDL2244 : field must not derive from a pointer to a function
Pointers to functions may not be remoted.
MIDL2245 : cannot use [fault_status] on both a parameter and a return type
[fault_status] may only be used once per procedure, although [comm_status] may be used independently.
MIDL2246 : return type too complicated for /Oi, using /Os
Large by-value return types may only be handled by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.
MIDL2247 : generic handle type too large for /Oi, using /Os
Large by-value generic handle types may only be handled 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 re-allocate 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
Ref pointers must always point to valid memory, but an [in,out] union with a ref pointer may return a ref pointer when the [in] direction used another type.
MIDL2250 : return of context handles not supported for /Oi modes, using /Os
MIDL doesn't support context handles in the fully interpreted optimization modes. Switching to mixed-mode optimization.
MIDL2251 : use of [comm_status] or [fault_status] not supported for /Oi, using /Os
[comm_status] and [fault_status] may only be handled by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization.
MIDL2252 : use of an unknown type for [represent_as] not supported for /Oi, using /Os
Use of a represent_as with a local type that is not defined in the idl file or an imported idl file may only be handled 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, using /Os
Returning an array with [transmit_as] or [represent_as] applied may 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 [represents_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
[callback] 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
[iid_is] can only be applied to interface pointers, although they may be specified as IUnknown *.
MIDL2259 : interfaces may only be used in pointer-to-interface constructs
Interface names may not 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 may only have one of the above.
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 or /env powermac"
[object] interfaces may not be used with 16-bit environments.
MIDL2266 : [callback] with -env dos/win16 not supported for /Oi, using /Os
Callbacks in 16-bit environments may only be handled 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, using /Os
Float and double as parameters may only be handled by /Os optimization stubs. The stubs for this routine will be generated using /Os optimization. Float and double within structs/arrays/etc. May still be handled with /Oi.
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 non-[local] procedures in an object interface must return an HRESULT/SCODE.
MIDL2270 : duplicate UUID
UUIDs must be unique.
MIDL2271 : [object] interfaces must derive from other [object] interfaces
Interface inheritance is only allowed using object interfaces.
MIDL2272 : interfaces must derive from another interface
Object interfaces 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
Tthe target of a call_as, 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]
[encode] and [decode] may only be used with explicit handles or implicit handles.
MIDL2277 : normal procs are not allowed in an interface with [encode] or [decode]
Interfaces containing [encode] or [decode] procedures may not also have remoted procedures.
MIDL2278 : top-level conformance or variance not allowed with [encode] or [decode]
Types that have top-level conformance or variance may not use type serialization, since there is no way to provide sizing/lengthing. Structs containing them are, however, allowed.
MIDL2279 : [out] parameters may not have \"const\"
Since an [out] parameter is altered, it may not have const.
MIDL2280 : return values may not have \"const\"
Since a function value is set, it must not have const.
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 may 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 [object].
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 it to allow it to be returned.
MIDL2285 : procedure used twice as the caller in [call_as]
A given [local] procedure may only be used 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 may not be used together.
MIDL2288 : [maybe] procedures may not have a return value or [out] params
Since [maybe] procedures may never return, there is no way to get returned values.
MIDL2289 : pointer to function must be used
Although function type definitions are allowed in /c_ext mode, they may only be used as pointers to functions (and may never be remoted).
MIDL2290 : functions may not be passed in an RPC operation
Functions and function pointers may not be remoted.
MIDL2291 : hyper/double not supported as return value for /Oi, using /Os
Hyper and double return values may only be handled 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
[string] may only be applied to a struct whose fields are all of type byte, or a type definition equivalent of byte.
MIDL2294 : [notify] not supported for /Oi, using /Os
The [notify] attribute may only be processed by /Os optimization stubs.
MIDL2295 : handle parameter or return type is not supported on a procedure in an [object] interface
Handles may not be used with [object] interfaces.
MIDL2296 : ANSI C only allows the leftmost array bound to be unspecified
In a conformant array, ANSI C only allows 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 typedef, this may not be possible. Try putting all the array dimensions on the use of the array 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.
MIDL 2297 : 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
An object interface must have a
MIDL2299 : [size_is] or [max_is] attribute is invalid on a fixed array
MIDL2300 : [encode] or [decode] are invalid in an [object] interface
MIDL2301 : [encode] or [decode] on a type requires /ms_ext
MIDL2302 : int not supported on /env win16 or /env dos
MIDL2303 : [bstring] may only be applied to a pointer to char or whchar_t
MIDL2304 : attribute invalid on a proc in an [object] interface
MIDL2305 : attribute invalid on an [object] interface
MIDL2306 : too many parameters or stack too big for /Oi modes, using /Os
MIDL2307 : no attributes on ACF file typedef so no effect
MIDL2308 : calling conventions other than __stdcall or __cdecl not supported for Oi modes, using /Os
MIDL2309 : more than 64 delegated methods not supported
MIDL2310 : auto handles not supported with /env mac or /env powermac
MIDL2311 : statements outside library block are illegal in mktyplib compatibility mode
MIDL2312 : illegal syntax unless using mktyplib compatibility mode
MIDL2313 : illegal definition, must use typedef in mktyplib compatibility mode
MIDL2314 : explicit pointer attribute [ptr] [ref] ignored for interface pointers
MIDL2315 : /Oi modes not implemented for PowerMac, switching to /Os
MIDL2316 : illegal expression type used in attribute
MIDL2317 : illegal type used in pipe
MIDL2318 : procedure uses pipes, using /Oicf
MIDL2319 : procedure uses pipes, using /Oicf
MIDL2320 : procedure's parameters are too complex to include pipes - simplify other parameters or don't use pipes
MIDL2321 : pipe cannot be a member of a struct or a union, nor an array element
MIDL2322 : invalid pipe usage
MIDL2323 : feature requires the advanced interpreted optimization option; use /Oicf
MIDL2324 : feature requires the advanced interpreted optimization option; use /Oicf
MIDL2329 : the optimization option is being phased out, use /Oic:
MIDL2330 : the optimization option is being phased out, use /Oicf
MIDL2331 : the optimization option is being phased out, use /ic
MIDL2332 : the optimization option is being phased out, use /icf
MIDL2333 : the /old and /new switches are obsolete, use /oldtlb and /newtlb
MIDL2334 : illegal argument value
MIDL2335 : illegal expression type in constant
MIDL2336 : illegal expression type in enum
MIDL2337 : unsatisfied forward declaration
MIDL2338 :switches are contradictory
MIDL2339 : MIDL cannot generate HOOKOLE information for the non-rpc-able union
MIDL2340 : no case expression found for union
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]
MIDL2343 : all pipe interface pointers must use single indirection
MIDL2344 : [iid_is()] cannot be used with a pipe interface pointer
MIDL2345 : invalid or inapplicable /lcid switch:
MIDL2346 : the specified lcid is different from previous specification
MIDL2347 : importlib is not allowed outside of a library block
MIDL2348 : invalid floating point value
MIDL2349 : invalid member
MIDL2350 : possible invalid member
MIDL2351 : mismatch in pipe and interface types
MIDL9008: internal compiler problem <system error code> - the compiler cannot continue for an unknown reason. See documentation for suggestions on how to find a workaround.
The compiler could not continue and the cause of the error is unknown. The hexadecimal error number is a Windows NT or Windows 95 system-error identifier. The compile may have failed because of an external problem, such as an out-of-memory condition. In that case, you may find more information regarding your particular error in the winerror.h or ntstatus.h files.

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