1$ ++ 2$ ! 3$ ! Copyright (c) 2010 Apple Inc. All rights reserved. 4$ ! 5$ ! @APPLE_LICENSE_HEADER_START@ 6$ ! 7$ ! Redistribution and use in source and binary forms, with or without 8$ ! modification, are permitted provided that the following conditions 9$ ! are met: 10$ ! 11$ ! 1. Redistributions of source code must retain the above copyright 12$ ! notice, this list of conditions and the following disclaimer. 13$ ! 2. Redistributions in binary form must reproduce the above copyright 14$ ! notice, this list of conditions and the following disclaimer in the 15$ ! documentation and/or other materials provided with the distribution. 16$ ! 3. Neither the name of Apple Inc. ("Apple") nor the names of its 17$ ! contributors may be used to endorse or promote products derived from 18$ ! this software without specific prior written permission. 19$ ! 20$ ! THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 21$ ! EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 22$ ! WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23$ ! DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 24$ ! DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 25$ ! (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 26$ ! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 27$ ! ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28$ ! (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29$ ! THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30$ ! 31$ ! Portions of this software have been released under the following terms: 32$ ! 33$ ! (c) Copyright 1989-1993 OPEN SOFTWARE FOUNDATION, INC. 34$ ! (c) Copyright 1989-1993 HEWLETT-PACKARD COMPANY 35$ ! (c) Copyright 1989-1993 DIGITAL EQUIPMENT CORPORATION 36$ ! 37$ ! To anyone who acknowledges that this file is provided "AS IS" 38$ ! without any express or implied warranty: 39$ ! permission to use, copy, modify, and distribute this file for any 40$ ! purpose is hereby granted without fee, provided that the above 41$ ! copyright notices and this notice appears in all source code copies, 42$ ! and that none of the names of Open Software Foundation, Inc., Hewlett- 43$ ! Packard Company or Digital Equipment Corporation be used 44$ ! in advertising or publicity pertaining to distribution of the software 45$ ! without specific, written prior permission. Neither Open Software 46$ ! Foundation, Inc., Hewlett-Packard Company nor Digital 47$ ! Equipment Corporation makes any representations about the suitability 48$ ! of this software for any purpose. 49$ ! 50$ ! Copyright (c) 2007, Novell, Inc. All rights reserved. 51$ ! Redistribution and use in source and binary forms, with or without 52$ ! modification, are permitted provided that the following conditions 53$ ! are met: 54$ ! 55$ ! 1. Redistributions of source code must retain the above copyright 56$ ! notice, this list of conditions and the following disclaimer. 57$ ! 2. Redistributions in binary form must reproduce the above copyright 58$ ! notice, this list of conditions and the following disclaimer in the 59$ ! documentation and/or other materials provided with the distribution. 60$ ! 3. Neither the name of Novell Inc. nor the names of its contributors 61$ ! may be used to endorse or promote products derived from this 62$ ! software without specific prior written permission. 63$ ! 64$ ! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 65$ ! EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 66$ ! WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 67$ ! DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY 68$ ! DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 69$ ! (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 70$ ! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 71$ ! ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 72$ ! (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 73$ ! THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 74$ ! 75$ ! @APPLE_LICENSE_HEADER_END@ 76$ ! 77$ ! 78$ ! NAME: 79$ ! 80$ ! nidlmsg.msg 81$ ! 82$ ! FACILITY: 83$ ! 84$ ! Interface Definition Language (IDL) Compiler 85$ ! 86$ ! ABSTRACT: 87$ ! 88$ ! RPC IDL Compiler messages. 89$ ! 90$ ! %a%private_begin 91$ ! 92$ ! 93$ ! %a%private_end 94$ ! 95$ -- 96$ + 97$ These two symbols must have the same integer value. 98$ - 99$set 1 100 1011 2074 102 1032 Use %1$s for list of command options 104$ Explanation: 105$ Errors on the command line prevent the IDL compiler from 106$ executing. 107$ User Action: 108$ Invoke the IDL compiler with the indicated command option to 109$ get a list of valid command options, then correct the error. 110 1113 Operation %1$s has no binding handle parameter; [auto_handle] assumed 112$ Explanation: 113$ When an operation uses parametric binding, its first parameter 114$ is a handle parameter that determines the location of a 115$ server of the interface. Operations whose first parameter 116$ is not of type <kw>(handle_t) and does not have the <kw>([handle]) 117$ attribute are assumed to use nonparametric binding 118$ known as <kw>(auto_handle), whereby a binding is automatically 119$ established by the RPC runtime library. 120$ User Action: 121$ See the documentation on the various binding techniques 122$ to determine the best method for your application. 123 1244 File %1$s, line %2$lu: %3$s 125$ Explanation: 126$ Identifies the filename, source line number, and source 127$ text associated with an error. 128$ User Action: 129$ None. This is an informational message. 130 1315 Must compile stubs with ANSI C compiler to avoid promotion of float to double in operation %1$s 132$ Explanation: 133$ The operation contains a <kw>(float) parameter passed by value. 134$ Non-ANSI C compilers that do not support function prototypes, 135$ automatically promote <kw>(float) to <kw>(double). Function 136$ prototypes within generated C stubs are conditional on the 137$ IDL_PROTOTYPES preprocessor symbol. When you compile a 138$ stub with a non-ANSI C compiler, IDL_PROTOTYPES must not be 139$ defined (causing the non-prototyped definitions to compile) 140$ and thus causing <kw>(float) to <kw>(double) promotion. This breaks 141$ the marshalling logic in the stub, that expects a <kw>(float), not 142$ a <kw>(double). 143$ User Action: 144$ Problems do not occur 145$ as long as you compile stubs with an ANSI C compiler. However, 146$ to maximize portability, it is highly recommended that you 147$ modify any <kw>(float) parameter passed 148$ passed by value or a <kw>(float) passed by reference. This 149$ message is informational. 150 1516 Importing IDL file %1$s 152 1537 Creating include file %1$s 154 1558 Legal values are: 156$ Explanation: 157$ Identifies a list of legal values for a command option. 158$ User Action: 159$ Re-enter the option using one of the legal values. 160 1619 File %1$s, line %2$lu 162$ Explanation: 163$ Identifies the filename and source line number 164$ associated with an error. 165$ User Action: 166$ None. This is an informational message. 167 16810 Name %1$s is declared in file %2$s, line %3$lu 169$ Explanation: 170$ Gives the source file and line 171$ number of source text to help you diagnose the 172$ previous error. 173$ User Action: 174$ None. This is an informational message. 175 17611 Name is referenced in file %1$s, line %2$lu 177$ Explanation: 178$ Gives the source file and line 179$ number of source text to help you diagnose the 180$ previous error. 181$ User Action: 182$ None. This is an informational message. 183 18412 %1$s 185 18613 Options table: 187$ Explanation: 188$ Caption for options table printed in usage message 189$ User Action: 190$ None. This is an informational message. 191 19214 Processing attribute configuration file %1$s 193 19415 Running C preprocessor %1$s 195 19616 Compiling stub module %1$s 197 19817 Creating stub module %1$s 199 20018 Deleting stub module %1$s 201 20219 Type %1$s has a represent_as data type %2$s 203$ Explanation: 204$ IDL does not allow a data type that has a <kw>([represent_as]) type 205$ to itself be used as a <kw>([represent_as]) type in another type 206$ definition. 207$ User Action: 208$ The message gives 209$ information to help you locate the problem. 210 21120 Usage: idl filename [options] 212$ Explanation: 213$ Lists the format of the <kw>(idl) command 214$ that invokes the IDL compiler. 215$ User Action: 216$ Use the <kw>(-confirm) option to see a list of all 217$ to determine those you need. 218 21921 DCE IDL compiler version %1$s 220$ Explanation: 221$ Identifies the current version of the IDL compiler. 222$ User Action: 223$ Use this version number when submitting bug reports. 224 22522 Warning: Duplicate Protocol specification in endpoint list; \"%1$s\" ignored 226$ Explanation: 227$ Each protocol can be listed at most once in the endpoint list. The specified 228$ endpoint specification duplicates another 229$ endpoint specification and is ignored. 230$ User Action: 231$ Use each protocol at most once in the endpoint list. 232 23323 Warning: Syntax error in endpoint specification \"%1$s\" 234$ Explanation: 235$ The syntax of the string describing the endpoint must be of the 236$ form <v>(protocol:[endpoint]). 237$ Although not in the expected format, the string <v>(endpoint) 238$ is assumed to be the desired endpoint specification 239$ and is put into the generated stubs. 240$ User Action: 241$ Correct the syntax of the <kw>(endpoint) specification. 242 24324 Warning: Extraneous punctuation character \"%1$s\" ignored 244$ Explanation: 245$ A punctuation character was found in a location 246$ where it is not allowed in the IDL language syntax. 247$ User Action: 248$ If it is only an extra puncutation character, 249$ remove it. If the character appears correct, then the 250$ error may be caused by another nearby syntax error. 251$ Correct the other syntax errors and recompile the interface. 252 25325 Warning: The [handle] attribute of a parameter in a function pointer declaration is ignored 254 25526 Warning: Identifier: %1$s too long; maximum is %2$lu chars 256$ Explanation: 257$ The length identifier exceeds the maximum number of characters 258$ allowed by IDL for portability. 259$ User Action: 260$ Shorten the identifier name to within the allowed limit. 261$ Make sure the shortened identifier name is unique. 262 26327 Warning: include filename must not contain a file extension 264$ Explanation: 265$ The filename specified in an <kw>(include) statement in the 266$ Attribute Configuration File (ACF) must not contain a file 267$ extension. In a future IDL version, you will be able to 268$ specify a programming language, and the IDL compiler will 269$ automatically append the appropriate extension. 270$ User Action: 271$ Remove the file extension. The current IDL compiler 272$ always assumes an <kw>(.h) extension. 273 27428 Warning: ACF include statement advised for definition of type %1$s 275$ Explanation: 276$ An Attribute Configuration File (ACF) declares a type that is 277$ not defined in an IDL file. The type is referenced in the 278$ generated stub code, thus its definition needs to be included 279$ into the stub code as well. 280$ User Action: 281$ Place an <kw>(include) statement in the ACF to cause your module 282$ that defines the type to be included into the generated 283$ header file. 284 28529 Warning: A size specifier is required; long assumed 286$ Explanation: 287$ A size specifier is required when specifying the <kw>(int) data type. 288$ User Action: 289$ Place a size specifier -- <kw>(short, small, long,) 290$ or <kw>(hyper) -- before the <kw>(int) keyword. 291 29230 Warning: The attributes [in_line] and [out_of_line] apply only to non-scalar types 293$ Explanation: 294$ Scalar data types are always marshalled in-line, since there 295$ is performance degradation if they are 296$ marshalled out-of-line. 297$ User Action: 298$ Do not use the <kw>([in_line]) and <kw>([out_of_line]) attributes 299$ on scalar types. 300 30131 Warning: Missing pointer class for %1$s; [ptr], [ref], or [unique] required 302$ Explanation: 303$ A pointer declaration does not have pointer class attribute 304$ and no <kw>([pointer_default]) attribute was specified on the 305$ interface. 306$ User Action: 307$ All pointers must have one of the pointer class attributes: 308$ <kw>([ptr]), <kw>([ref]), or <kw>([unique]). 309$ Either add one of these attributes 310$ at the location of the pointer declaration, or add the 311$ <kw>([pointer_default]) attribute to the interface to specify the 312$ class to be used as the default for the module. 313 31432 Warning: The attributes [max_is,length_is] or [size_is,last_is] used together 315$ Explanation: 316$ The <kw>([max_is]) attribute specifies the array's upper bound while 317$ the <kw>([size_is]) attribute specifies the total number of array 318$ elements. Similarly, <kw>([last_is]) specifies the upper data 319$ limit while <kw>([length_is]) specifies the 320$ number of valid data elements. 321$ User Action: 322$ Mixing the attributes can be incorrect. 323$ Make sure the declaration is correct and change if necessary. 324 32533 Warning: An attribute is defined multiple times 326$ Explanation: 327$ An attribute is repeated multiple times in an attribute list. 328$ User Action: 329$ Remove all but one occurrence of the offending attribute. 330 33134 Warning: Generated name too long at line %1$lu. 332$ Explanation: 333$ The compiler generated an identifier that is too long 334$ for some standard C compiler implementations. 335$ User Action: 336$ Shorten the name at the specified line. 337 33835 Warning: At least one operation must have the [code] attribute 339$ Explanation: 340$ All of the operations in the interface are marked so 341$ no code is generated for them in the stub modules. 342$ User Action: 343$ If you used the ACF <kw>([nocode]) attribute on the interface, 344$ be sure to specify <kw>([code]) on at least one operation. 345$ To disable stub generation entirely use a command line option. 346 34736 Warning: No endpoint can be found in the endpoint specification \"%1$s\" 348$ Explanation: 349$ The syntax specified in the <kw>(endpoint) specification 350$ string does not contain 351$ an <kw>(endpoint) specification. 352$ The entire string is assumed to be the protocol name 353$ and the <kw>(endpoint) remains unspecified in the generated stubs. 354$ User Action: 355$ Correct the syntax of the <kw>(endpoint) specification. 356 35737 Warning: Character constant cannot be portable across character sets 358$ Explanation: 359$ You used an integer value to specify a character. This 360$ cannot be portable across different character sets 361$ (ASCII and EBCDIC). 362$ User Action: 363$ Consider your portability requirements. 364 36538 Warning: Semantic checking prevented by other reported errors 366$ Explanation: 367$ One or more of the reported errors prevented the compiler from 368$ completing the semantic checking of the interface. This 369$ can cause some semantic errors in the interface to go unreported. 370$ User Action: 371$ Correct the reported errors and compile the interface again. 372 37339 Warning: Old UUID format must be replaced with new format: 374$ Explanation: 375$ The UUID specified in the interface attribute list is in an 376$ old format. 377$ User Action: 378$ Although the old format is compatible with the new 379$ format, we recommend that you switch to the new format. 380$ If the input is an NCS Version 1 NIDL source file, process it with 381$ the translator utility (the <kw>(nidl_to_idl) command) that 382$ converts an NCS Version 1 NIDL source file into the 383$ format expected by the IDL compiler. 384$ You can also use the <kw>(uuidgen) command to convert the 385$ old format UUID to the new format. 386$ When you have the new format for the UUID, 387$ compile the translated source file. 388 38940 Warning: Object file for %1$s placed in current working directory 390$ Explanation: 391$ A command option specifies a directory other than the current 392$ working directory in which to place a generated C source and 393$ object file. 394$ The IDL compiler does not place the file in the requested 395$ directory if you use the <kw>(-cc_cmd) argument on the command line. 396$ Also, the IDL compiler does not place the file in the requested 397$ directory on systems on which the mechanism it usually uses 398$ for the placement does not work. 399$ User Action: 400$ IDL provides a command option that allows you to pass 401$ command options to the C compiler. Use the appropriate 402$ C compiler option to assure that the object files are placed 403$ in the correct directory. 404 40541 Warning: The attribute [%1$s] applied on type with [%2$s] set, [%3$s] assumed 406 40742 Warning: The attribute [nocode] does not apply to server stub 408$ Explanation: 409$ A server for an interface must support all of the routines in 410$ that interface, therefore, the <kw>([nocode]) ACF attribute is not 411$ valid when you use IDL to generate only server stub code. 412$ User Action: 413$ This is a warning, so no action is required. If you want to 414$ remove the warning message, create a new ACF for the 415$ interface that does not use the <kw>([nocode]) attribute. Or 416$ change the command line used so stub generation is not 417$ limited to the server stub. 418 41943 Warning: File %1$s is a system-defined IDL filename 420$ Explanation: 421$ The file <v>(filename) has the same name as an RPC-supplied 422$ system IDL file. This can cause unexpected compilation errors, 423$ such as missing declarations of IDL predefined types. 424$ User Action: 425$ Rename <v>(filename) so it does not conflict with any 426$ of the system-defined IDL filenames. 427 42844 Pipes must be defined with a typedef 429$ Explanation: 430$ The IDL compiler constructs routine names 431$ that are referenced by generated stub code 432$ from the name of any <kw>(pipe) data type. 433$ Therefore the type cannot be anonymous. 434$ User Action: 435$ Declare the <kw>(pipe) data type with a <kw>(typedef) 436$ so the <kw>(pipe) has a name associated with it. 437 43845 Declaration of %1$s cannot contain an anonymous type 439$ Explanation: 440$ The type specification for the parameter, field or <kw>(union) arm 441$ <v>(name) contains a data type that is an anonymous <kw>(struct) or 442$ <kw>(union). Since such a type is unique 443$ and not compatible with any other type, 444$ the generated stubs cannot generate code to access the type. 445$ User Action: 446$ Move the <kw>(struct) or <kw>(union) declaration into 447$ a <kw>(typedef) and modify the 448$ declaration of <v>(name) to use the newly created type name. 449 45046 An arm of a union cannot be or contain a [ref] pointer 451$ Explanation: 452$ IDL-generated server stub code must allocate storage for 453$ objects pointed to by <kw>([ref]) pointers. IDL does not allow 454$ a <kw>([ref]) pointer within a <kw>(union) because the valid 455$ arm of the <kw>(union), and therefore the 456$ object for which storage is allocated, is not 457$ known at compile time. 458$ User Action: 459$ Change the pointer within the <kw>(union) declaration to a full pointer. 460 46147 Array elements cannot be conformant arrays or conformant structures 462$ Explanation: 463$ Array elements must be of fixed size. 464$ User Action: 465$ If the element type is an array, make sure that the array has 466$ fixed bounds. If the element type is a structure, make sure 467$ that any arrays in the structure have fixed bounds. 468 46948 Array elements cannot be context handles 470$ Explanation: 471$ Arrays of context handles are not allowed. 472$ User Action: 473$ Change the definition of the array so its elements are 474$ not context handles. If you want to declare 475$ an array of context handles, you must use alternative means. 476 47749 Array elements cannot be pipes 478$ Explanation: 479$ Array elements cannot be pipes. 480$ User Action: 481$ Change the definition of the array so its elements are 482$ not of a <kw>(pipe) data type. If you want to declare 483$ an array of pipes, you must use alternative means. 484 48550 Array size information required for %1$s 486$ Explanation: 487$ The IDL code uses an array with bounds that are not fixed 488$ and does not specify the appropriate size attributes. 489$ User Action: 490$ Modify the array declaration to include the appropriate 491$ <kw>([max_is]) or <kw>([size_is]) attribute. 492$ If the array is a parameter, use an additional parameter to 493$ specify size information. If the array is a field 494$ in a structure, use an additional field to 495$ specify size information. 496$ The IDL code uses an array with bounds that are not fixed 497$ and does not specify the appropriate size attributes. 498$ Modify the array declaration to include the appropriate 499$ <kw>([min_is]), <kw>([max_is]), or <kw>([size_is]) attribute. 500$ If the array is a parameter, use an additional parameter to 501$ specify the missing size information. If the array is a field 502$ in a structure, use an additional field to 503$ specify the missing size information. 504 50551 Arrays can be conformant in the first dimension only 506$ Explanation: 507$ IDL only allows an array to be conformant in its first dimension. 508$ User Action: 509$ Modify the array declaration so dimensions other than 510$ the first have fixed bounds. 511 51252 An array with a pointer attribute is valid only as a parameter 513$ Explanation: 514$ An array that is a parameter in an operation can have a pointer 515$ attribute because arrays are implicitly passed by reference 516$ pointer. Otherwise, an array cannot have a pointer attribute. 517$ User Action: 518$ Remove the pointer attribute from the parameter or type 519$ definition, or define a new type without a pointer attribute. 520 52153 Use array syntax to declare multidimensional arrays 522$ Explanation: 523$ An IDL declaration attempts to use mixed pointer (<kw>(*)) and 524$ array (<kw>([])) syntax to define a multidimensional array. 525$ The interpretation that an asterisk (<kw>(*)) is used 526$ to represent an array 527$ is due to the presence of one or more of the 528$ <kw>([max_is]), or <kw>([size_is]) attributes. It is 529$ ambiguous whether size attributes apply to the pointer or the 530$ array, thus IDL does not allow mixing pointer and array syntax 531$ when size attributes are present. 532$ User Action: 533$ The IDL compiler requires that you make such declarations 534$ using only array <kw>([]) syntax. If you do not want to 535$ declare a multidimensional array, you used the 536$ <kw>([max_is]), or <kw>([size_is]) attribute incorrectly. They apply 537$ only to arrays with bounds that are not fixed, and the declared 538$ array has fixed bounds. 539 54054 Arrays can be varying in the first dimension only 541$ Explanation: 542$ IDL only allows an array to be varying in its first dimension. 543$ User Action: 544$ Remove the <kw>([first_is]), <kw>([last_is]), 545$ or <kw>([length_is]) 546$ attributes that refer to dimensions other than the first. 547 54855 Arrays with [transmit_as] cannot be conformant or varying 549$ Explanation: 550$ IDL does not allow a conformant or varying array with the 551$ <kw>([transmit_as]) attribute. 552$ User Action: 553$ Change the declaration so the array is of fixed size and 554$ has no data limit attributes, or remove the <kw>([transmit_as]) attribute. 555 55656 The attribute is no longer allowed in this context; use translator 557$ Explanation: 558$ An attribute list is encountered in an invalid context. 559$ In NCS Version 1 NIDL, attributes are allowed in this position. 560$ You may be compiling an NCS Version 1 NIDL source file. 561$ User Action: 562$ If the input is an NCS Version 1 NIDL source file, process it with the 563$ <kw>(nidl_to_idl) translator utility that 564$ converts an NCS Version 1 NIDL source file into the format expected by 565$ the IDL compiler. Then compile the translated source file. 566$ Otherwise, move the attributes to a valid location. 567 56857 An attribute variable cannot be an indirect field reference 569$ Explanation: 570$ An indirect field reference is used in a field attribute; 571$ indirection is not allowed in this context. 572$ User Action: 573$ Remove the indirection. For example, if the referenced field was 574$ <kw>(long *sp;) and the attribute expression was 575$ <kw>([size_is(*sp)]), then change the field to 576$ <kw>(long s;) and the attribute expression to 577$ <kw>([size_is(s)]). 578 57958 Invalid use of tag %1$s 580$ Explanation: 581$ You used a previously defined tag name in a declaration of a different type. 582$ Tag names can be used for 583$ a <kw>(struct) or <kw>(union) declaration, but not both. 584$ User Action: 585$ Either make sure that each use of the tag name specifies the same type, or 586$ use different tag names with each type. 587 58859 The attribute [broadcast] is not valid on an operation with pipes 589$ Explanation: 590$ IDL does not allow pipes to be used in <kw>([broadcast]) 591$ operations. 592$ User Action: 593$ Remove the <kw>([broadcast]) attribute from the operation, 594$ or remove the <kw>(pipe) parameter from the operation. 595 59660 Case label type does not agree with discriminator type 597$ Explanation: 598$ The value of a <kw>(case) expression in a discriminated <kw>(union) 599$ is not the same data type as the discriminator variable 600$ in the <kw>(switch) clause. 601$ User Action: 602$ Change the discriminator declaration or the <kw>(case) expression 603$ so the data types match. 604 60561 Case label must be a constant from the enumeration of the discriminant 606$ Explanation: 607$ The value of a <kw>(case) expression in a discriminated <kw>(union) 608$ is from a different enumeration data type than the enumeration 609$ data type of the discriminator variable in the <kw>(switch) clause. 610$ User Action: 611$ Change the discriminator declaration or the <kw>(case) expression 612$ so the enumeration data types match. 613 61462 Structures containing conformant arrays must be passed by reference 615$ Explanation: 616$ The size of a structure that contains a conformant array is 617$ not a compile-time constant. It is not possible to pass such 618$ a structure by value. 619$ User Action: 620$ Change the parameter declaration to pass the structure by 621$ reference by adding an asterisk (<kw>(*)) to the 622$ left of the parameter name. 623 62463 The base type of a pipe cannot be a conformant type 625$ Explanation: 626$ IDL does not allow pipes of any data type of size that is not fixed. 627$ User Action: 628$ Change your <kw>(pipe) type definition to use a fixed array or 629$ some other construct of fixed size. 630 63164 A conformant field must be the last field in the structure 632$ Explanation: 633$ The IDL compiler restricts arrays with bounds that are not fixed 634$ and that occur in structures to only the last field 635$ in the structure. 636$ User Action: 637$ If the structure contains more than one 638$ conformant array, remove all but one of them. 639$ Move the conformant array so it is the last field in the 640$ structure definition. 641 64265 Conformant array or structure is invalid within a union 643$ Explanation: 644$ The IDL compiler does not allow an array with bounds that are not fixed 645$ in a discriminated <kw>(union). Each member of a <kw>(union) must 646$ be of fixed size. 647$ User Action: 648$ It is possible to have a <kw>(union) case that is a full <kw>([ptr]) 649$ pointer to a conformant array or conformant structure. 650$ Change the declaration and 651$ associated code accordingly. 652 65366 Interface attributes [auto_handle] and [implicit_handle] cannot occur together 654$ Explanation: 655$ The <kw>([auto_handle]) and <kw>([implicit_handle]) attributes 656$ are two distinct 657$ mechanisms for managing the binding between client and server 658$ at runtime. You cannot specify both of these attributes. 659$ User Action: 660$ See the documentation to determine which binding mechanism 661$ to use. Then remove one of the conflicting attributes 662$ from the interface attribute list in the Attribute 663$ Configuration File (ACF). 664 66567 The attributes [in_line] and [out_of_line] cannot occur together 666 66768 The attributes [%1$s] and [%2$s] cannot occur together 668$ Explanation: 669$ The specified attributes are conflicting and only one or the other 670$ can be specified. 671$ User Action: 672$ Remove one of the attributes. 673 67469 The [represent_as] type %1$s conflicts with previously defined %2$s 675$ Explanation: 676$ The attribute configuration file (ACF) contains conflicting 677$ <kw>([represent_as]) clauses for the same data type. 678$ User Action: 679$ Remove one of the <kw>([represent_as]) clauses for that data type. 680 68170 Constant name: %1$s not found 682$ Explanation: 683$ The named <kw>(constant) is not defined. 684$ User Action: 685$ Modify the interface and specify a known constant. 686 68771 Constant type does not agree with constant expression 688$ Explanation: 689$ You used a constant expression that is inappropriate 690$ for the constant type. 691$ User Action: 692$ Modify the constant definition so the expression 693$ matches the type. 694 69572 A hyper constant type is not allowed 696$ Explanation: 697$ <kw>(hyper) constant is not allowed. 698$ User Action: 699$ Modify the <kw>(constant) type to one of the supported types: 700$ <kw>(long, char, boolean, void *,) or <kw>(char *). 701 70273 Missing \"}\" on interface declaration 703$ Explanation: 704$ The closing brace on the interface declaration was not found. 705$ It may have been omitted, the nesting of other braces may be incorrect, or 706$ some other syntax error may cause IDL to overlook a brace. 707$ User Action: 708$ Add the closing brace if missing, otherwise make sure all other braces 709$ are specified in pairs, and there are no other syntax errors. 710 71174 Missing \"]\" on attribute list 712$ Explanation: 713$ The closing bracket on an attribute list was not found. 714$ It may have been omitted, or 715$ some other syntax error may cause IDL to overlook the bracket. 716$ User Action: 717$ Add the closing bracket if it is missing, otherwise make sure 718$ there are no other syntax errors. 719 72075 Missing \"]\" on array bound 721$ Explanation: 722$ The closing bracket on an array bound specification was not found. 723$ It may have been omitted, or 724$ some other syntax error may cause IDL to overlook the bracket. 725$ User Action: 726$ Add the closing bracket if it is missing, otherwise make sure 727$ there are no other syntax errors. 728 72976 Missing result type on operation declaration 730$ Explanation: 731$ No data type was found for the result of an operation 732$ while processing what appeared to be an 733$ operation declaration. All operations must have an explicit result type. 734$ User Action: 735$ If the result type of an operation is omitted, explicitly 736$ specify it. If no result is returned from the operation, 737$ specify <kw>(void) as the result type. 738$ This error can also occur due to a previous syntax error. 739 74077 Missing type on parameter declaration 741$ Explanation: 742$ No data type is found for the parameter. 743$ User Action: 744$ If the parameter type is omitted, explicitly specify it. 745$ This error can also occur due to a previous syntax error. 746 74778 The base type of a pipe cannot be a [context_handle] type 748$ Explanation: 749$ A <kw>([context_handle]) type cannot be used as the base type 750$ of a <kw>(pipe). 751$ User Action: 752$ Remove the invalid declaration, or change it so the 753$ base type of the <kw>(pipe) is not a <kw>([context_handle]) type. 754 75579 Attribute [context_handle] only applies to void * types 756$ Explanation: 757$ The attribute <kw>([context_handle]) indicates that the data is a 758$ pointer-sized object that serves as the handle, or method 759$ of accessing, some object. To the called operation, the data is often 760$ an address of a structure in memory, although it need not be. 761$ A context handle is opaque to, and must never be written by, 762$ the caller code. To emphasize this, IDL previously required that 763$ context handles be defined as type <kw>(void *). 764$ IDL has since been relaxed to also allow a context handle type 765$ to be defined as a pointer to a structure type by tag name, e.g. 766$ <v>(typedef [context_handle] struct opaque_struct * opaque_ch_t). 767$ User Action: 768$ Change the declaration with the <kw>([context_handle]) attribute 769$ to data type <kw>(void *) or to a <kw>(struct *) data type 770$ similar to the example above. 771 77280 Context handles are not valid as structure fields 773$ Explanation: 774$ A context handle is not allowed as a field of a structure. 775$ User Action: 776$ Pass a context handle as a separate parameter to an operation, 777$ rather than embedding it as a field of a structure. 778 77981 Context handle is not valid as a member of a union 780$ Explanation: 781$ A context handle cannot be a member of a <kw>(union). 782$ User Action: 783$ Pass a context handle as a separate parameter to an operation, 784$ rather than embedding it as a member of a <kw>(union). 785 78682 Definition of tag %1$s is not yet complete 787$ Explanation: 788$ The tag <v>(name) is forward referenced in a context that requires it to be 789$ completely defined. References 790$ to <kw>(struct) or <kw>(union) types by means of tag 791$ name before the <kw>(struct) or <kw>(union) is 792$ completely defined is only allowed in 793$ contexts in which the size is not needed (a pointer to the type or 794$ in a <kw>(typedef)). Although IDL can process 795$ such references, the resulting 796$ stub cannot be compiled by most C compilers. 797$ User Action: 798$ Move the declaration of the <kw>(struct) or <kw>(union) prior to this 799$ reference. 800 80183 Duplicate case label value 802$ Explanation: 803$ A discriminated <kw>(union) contains more than one <kw>(case) label 804$ with the same value. Each <kw>(case) label value in a discriminated 805$ <kw>(union) can be used at most once. 806$ User Action: 807$ Remove one of the conflicting <kw>(case) labels. 808 80984 Unexpected end-of-file 810$ Explanation: 811$ The end of the source file was encountered before 812$ the end of the interface definition. 813$ The source file may be incomplete. 814$ User Action: 815$ Complete the interface definition. 816$ 817 81885 Unexpected end-of-file near '%2$.*1$s' 819$ Explanation: 820$ The end of the source file was encountered before 821$ the end of the interface definition. 822$ The source file may be incomplete. 823$ User Action: 824$ Complete the interface definition. 825 82686 Syntax error in attribute list 827$ Explanation: 828$ The syntax of the attribute list is not correct. It must contain a list of 829$ attributes separated by commas. 830$ User Action: 831$ Make sure the attribute list contains only 832$ valid attribute names and values, that 833$ their spellings are correct, and that they form a valid list. 834 83587 Data type %1$s must be defined in %2$s 836$ Explanation: 837$ You used a feature that requires a predefined data type that is 838$ normally present by default, but the data type was not found. 839$ An examples is a <kw>([comm_status]) or <kw>([fault_status]) 840$ parameter, which requires the data type <kw>(error_status_t). 841$ User Action: 842$ The compiler expected to find the type in the indicated file 843$ (usually <kw>(nbase.idl), which is automatically imported by 844$ IDL). Check that you are using the proper header files that were 845$ installed with DCE. 846 84788 File is not a directory: %1$s 848$ Explanation: 849$ A file that is not a directory is specified in a context 850$ where a directory is required; for example, as the command 851$ line option that specifies an output directory. 852$ User Action: 853$ Specify a filename that is a directory. 854 85589 File %1$s not found 856$ Explanation: 857$ A file, specified by the user either in the IDL source or 858$ ACF file, does not exist. 859$ User Action: 860$ Check the filenames you specified. Determine 861$ the location of any imported or included files that are needed to 862$ compile the IDL source file specified. If any are not in the 863$ directories that the IDL compiler searches by default, you 864$ must use a command line option to specify additional 865$ directories to search. 866 86790 The [first_is] parameter must have the [in] attribute 868$ Explanation: 869$ The <kw>([first_is]) attribute specifies a parameter that contains 870$ the lower data limit of a varying array. Since the array has the 871$ <kw>([in]) attribute, the lower data limit 872$ parameter must also be <kw>([in]) 873$ so the number of array elements to send from client to 874$ server is known. 875$ User Action: 876$ Change the lower data limit parameter referenced by the 877$ <kw>([first_is]) clause to have the <kw>([in]) attribute. 878 87991 A [first_is] variable must be a small, short, or long integer 880$ Explanation: 881$ The <kw>([first_is]) attribute specifies a field 882$ or parameter that contains 883$ the lower data limit of a varying array. Array data limits 884$ must be integers which are not <kw>(hyper). 885$ User Action: 886$ Change the data limit field or parameter referenced by the 887$ <kw>([first_is]) clause to integer data type. 888 88992 Floating point constants not supported 890$ Explanation: 891$ Floating point constants cannot be specified in IDL. 892$ User Action: 893$ Remove the <kw>(float) constant specification. 894 89593 Function pointers are not valid as elements of conformant arrays 896 89794 Function pointers are allowed only in local interfaces 898 89995 Function pointer parameters cannot be of type handle_t 900 90196 Function pointers in an operation must be [in] parameters 902 90397 The base type of a pipe cannot be a function pointer 904 90598 Function pointers are not valid as structure fields 906 90799 Function pointers are not valid as members of unions 908 909100 Function types are allowed only in local interfaces 910 911101 Array elements cannot be of type handle_t 912$ Explanation: 913$ Data type <kw>(handle_t) is only meaningful when used as the data 914$ type of the first parameter in an operation. It is used to 915$ establish a binding to a server of the interface. 916$ User Action: 917$ Do not declare arrays of type <kw>(handle_t). 918 919102 A [handle] binding parameter must be [in] or [in,out] 920$ Explanation: 921$ A parameter of a data type with the <kw>([handle]) attribute 922$ as the first parameter 923$ in an operation is used to 924$ establish a binding to a server of the interface. 925$ It must be an <kw>([in]) or <kw>([in,out]) parameter. 926$ User Action: 927$ Place the <kw>([in]) attribute on the <kw>([handle]) parameter. 928 929103 Pointers to type handle_t are valid only in parameter declarations 930$ Explanation: 931$ Data type <kw>(handle_t) is only meaningful when used as the data 932$ type of the first parameter in an operation. It is used to 933$ establish a binding to a server of the interface. 934$ User Action: 935$ Do not declare a pointer to data type <kw>(handle_t), except 936$ as a parameter. 937 938104 A handle_t as other than the first parameter requires a [transmit_as] 939$ Explanation: 940$ Data type <kw>(handle_t) is only meaningful when used as the data 941$ type of the first parameter in an operation. A bound handle 942$ is used to deliver the call to the correct server of the 943$ interface. A bound <kw>(handle_t) parameter itself 944$ is not transmittable. When the <kw>(handle_t) type is used 945$ in other than the first parameter, it must have a 946$ <kw>([transmit_as]) clause to convert it to a transmittable type. 947$ User Action: 948$ Use data type <kw>(handle_t) only as the data 949$ type of the first parameter in an operation, 950$ unless the defined data type has a <kw>([transmit_as]) clause. 951 952105 The base type of a pipe cannot be handle_t 953$ Explanation: 954$ Data type <kw>(handle_t) is only meaningful when used as the data 955$ type of the first parameter in an operation. It is used to 956$ establish a binding to a server of the interface. 957$ User Action: 958$ Do not declare pipes whose base type is <kw>(handle_t). 959 960106 A handle_t binding parameter must be an [in] parameter 961$ Explanation: 962$ A parameter of type <kw>(handle_t) as the first parameter 963$ in an operation 964$ establishes a binding to a server of the interface. 965$ It must be an <kw>([in]) parameter only. 966$ User Action: 967$ Remove the <kw>([out]) attribute from the <kw>(handle_t) parameter. 968 969107 Structure fields cannot be of type handle_t 970$ Explanation: 971$ Data type <kw>(handle_t) is only meaningful when used as the data 972$ type of the first parameter in an operation. It is used to 973$ establish a binding to a server of the interface. 974$ User Action: 975$ Do not declare structure fields of data type <kw>(handle_t). 976 977108 Members of unions cannot be of type handle_t 978$ Explanation: 979$ Data type <kw>(handle_t) is only meaningful when used as the data 980$ type of the first parameter in an operation. It is used to 981$ establish a binding to a server of the interface. 982$ User Action: 983$ Do not declare <kw>(union) members of data type <kw>(handle_t). 984 985109 A handle_t first parameter must not have [transmit_as] type 986$ Explanation: 987$ A parameter of type <kw>(handle_t), when used as the data 988$ type of the first parameter in an operation, is used to 989$ establish a binding to a server of the interface. 990$ It is not sent over the wire, therefore it is incorrect 991$ for it to have a <kw>([transmit_as]) data type. 992$ User Action: 993$ Remove the <kw>([transmit_as]) clause from the type's declaration. 994 995110 The attribute [idempotent] is not valid on an operation with pipes 996$ Explanation: 997$ An operation that uses pipes cannot be idempotent, because the 998$ <kw>(pipe) data stream can break at unpredictable times. 999$ User Action: 1000$ Remove the <kw>([idempotent]) attribute from the operation, 1001$ or remove the <kw>(pipe) parameter from the operation. 1002 1003111 The attribute [ignore] on array elements is not allowed 1004$ Explanation: 1005$ The <kw>([ignore]) attribute is not allowed on array elements 1006$ User Action: 1007$ Remove the <kw>([ignore]) attribute from the relevant declaration. 1008 1009112 The attribute [ignore] is valid only for pointers 1010$ Explanation: 1011$ The <kw>([ignore]) attribute is valid only for pointers. 1012$ User Action: 1013$ Remove the <kw>([ignore]) attribute from the declaration. 1014 1015113 The attribute [%1$s] on a field is not allowed 1016$ Explanation: 1017$ The specified attribute is not valid on a field. 1018$ User Action: 1019$ Remove the attribute. 1020 1021114 The attribute [%1$s] on a parameter is not allowed 1022$ Explanation: 1023$ The specified attribute is not valid on a parameter declaration. 1024$ User Action: 1025$ Remove the attribute. 1026 1027115 The attribute [%1$s] on a type is not allowed 1028$ Explanation: 1029$ The specified attribute is not valid on a type declaration. 1030$ User Action: 1031$ Remove the attribute. 1032 1033116 The attribute [%1$s] on an operation is not allowed 1034$ Explanation: 1035$ The specified attribute is not valid on an operation. 1036$ User Action: 1037$ Remove the attribute. 1038 1039117 The attribute [%1$s] on an interface is not allowed 1040$ Explanation: 1041$ The specified attribute is not valid on a interface declaration. 1042$ User Action: 1043$ Remove the attribute. 1044 1045118 The attribute [%1$s] on a union member is not allowed 1046$ Explanation: 1047$ The specified attribute is not valid on a <kw>(union) member declaration. 1048$ User Action: 1049$ Remove the attribute. 1050 1051119 An [implicit_handle] variable must either be of type handle_t or have the handle attribute 1052$ Explanation: 1053$ The <kw>([implicit_handle]) variable declared in the ACF must be a 1054$ handle, either a primitive handle of data type <kw>(handle_t); 1055$ or a customized handle, a data type with the <kw>([handle]) attribute. 1056$ User Action: 1057$ Specify a valid handle data type for the <kw>([implicit_handle]). 1058 1059120 A nonlocal interface cannot import a local interface 1060$ Explanation: 1061$ The <kw>([local]) interface attribute implies that the interface 1062$ is not part of an RPC application, but used only to generate 1063$ header files. This causes IDL to suppress any 1064$ errors specific to RPC that the interface uses as 1065$ part of an RPC application. 1066$ User Action: 1067$ Remove the <kw>([local]) attribute from the imported interface 1068$ definition. The imported interface does not need a UUID 1069$ unless the interface defines an operation and you compile it 1070$ independently. 1071 1072121 V1 attributes are incompatible with this type 1073$ Explanation: 1074$ The version 1 migration attributes are provided for compatibility for 1075$ applications that were originally written with NCS Version 1 NIDL. 1076$ These attributes 1077$ are <kw>([v1_string]), <kw>([v1_array]), <kw>([v1_enum]), 1078$ and <kw>([v1_struct]). In later versions of IDL, strings, 1079$ conformant and varying arrays, enumerations, 1080$ and structures are enhanced at 1081$ the network representation level. A data type with any of 1082$ the V1 migration attributes cannot contain one of these data types 1083$ that does not have the corresponding V1 attribute. 1084$ User Action: 1085$ Change the data type declaration so all relevant 1086$ contained types have the corresponding V1 attribute, or remove 1087$ V1 attributes if compatibility with NCS Version 1 NIDL is unnecessary. 1088 1089122 Interface attributes [code] and [nocode] cannot occur together 1090$ Explanation: 1091$ The <kw>([code]) or <kw>([nocode]) attribute on an interface 1092$ establishes the default for operations in the interface. 1093$ You can specify only one of these attributes. 1094$ User Action: 1095$ Remove one of the conflicting attributes. 1096 1097123 Integer division by zero 1098$ Explanation: 1099$ The evaluation of an integer constant expression resulted 1100$ in an integer divided by zero. 1101$ User Action: 1102$ Correct the expression so a division by zero does 1103$ not occur. 1104 1105124 Interface attributes [in_line] and [out_of_line] cannot occur together 1106$ Explanation: 1107$ The <kw>([in_line]) or <kw>([out_of_line]) attribute on an interface 1108$ establishes the default for types in the interface. 1109$ You can specify only one of these attributes. 1110$ User Action: 1111$ Remove one of the conflicting attributes. 1112 1113125 ACF interface name %1$s differs from IDL interface name %2$s 1114$ Explanation: 1115$ The interface name in an interface's Attribute Configuration 1116$ File must be identical to the interface name in the IDL source. 1117$ User Action: 1118$ Change the ACF to use the correct interface name. 1119 1120126 Integer value overflows %1$s 1121$ Explanation: 1122$ The integer value specified is too large to be contained in 1123$ the destination of size <v>(size). 1124$ User Action: 1125$ Either reduce the size of the integer value, or increase the 1126$ size of the destination declaration. 1127 1128127 Integer constant %1$s is invalid 1129$ Explanation: 1130$ The integer contains incorrect characters. 1131$ User Action: 1132$ Correct the specification of the integer. 1133 1134128 Interface UUID must be specified 1135$ Explanation: 1136$ The interface does not have the <kw>([uuid]) attribute required for 1137$ the complete definition of the interface. 1138$ User Action: 1139$ Either add the <kw>([local]) attribute to the interface, or generate 1140$ a UUID with the <kw>(uuidgen) utility supplied with IDL and specify 1141$ the UUID value in the interface <kw>([uuid]) attribute. 1142 1143129 Invalid array bound type 1144$ Explanation: 1145$ Array indices must be integers. 1146$ User Action: 1147$ Change the array declaration so the fixed bounds are integer 1148$ constants. 1149 1150130 Invalid case label type 1151$ Explanation: 1152$ The values in <kw>(case) clauses in 1153$ discriminated <kw>(union)s must be 1154$ integer, enumeration, boolean, or character values that match 1155$ the data type of the <kw>(union) discriminator. 1156$ User Action: 1157$ Modify the invalid clause to use a value of the correct 1158$ data type. 1159 1160131 Invalid character literal 1161$ Explanation: 1162$ The specification of the character literal is invalid. 1163$ User Action: 1164$ Character literals can be specified as a single printing 1165$ character or one of the following escape sequeces: 1166$ <literal>(\)n, <literal>(\)t, <literal>(\)v, <literal>(\)b, 1167$ <literal>(\)r, <literal>(\)f, <literal>(\)a, 1168$ <literal>(\)<literal>(\), <literal>(\)?, <literal>(\)', 1169$ <literal>(\)", <literal>(\)<v>(ooo), <literal>(\)x<v>(hh) 1170$ (where <v>(ooo) are octal digits, and 1171$ <v>(hh) are hexadecimal digits). 1172 1173132 Invalid octal digit in %1$s 1174$ Explanation: 1175$ An octal integer contains a digit that is not valid. 1176$ Integer constants with a leading zero are interpreted as 1177$ octal values. Only the digits 0 through 7 are valid in octal value. 1178$ User Action: 1179$ If the integer is not intended to be specified in octal, remove 1180$ the leading zeros. Otherwise correct the value to contain only 1181$ octal digits. 1182 1183133 Could not invoke the C preprocessor 1184$ Explanation: 1185$ The IDL compiler is unable to invoke the C preprocessor 1186$ to preprocess the IDL file before compiling it. 1187$ User Action: 1188$ If you do not need the C preprocessor, you can use a command 1189$ line option to prevent the 1190$ IDL compiler from calling it. If you specified 1191$ the C preprocessor to invoke with a command line option, 1192$ check to make sure you gave the correct file specification. 1193$ If you do not specify a C preprocessor, the IDL compiler 1194$ looks in a default directory for it. The C 1195$ preprocessor may not be installed in the expected directory. 1196 1197134 The attribute [out_of_line] is not allowed on parameters 1198$ Explanation: 1199$ IDL does not allow the <kw>([out_of_line]) 1200$ attribute on parameters. 1201$ User Action: 1202$ Apply the <kw>([out_of_line]) attribute to the type definition 1203$ rather than the parameter. If you do not want all 1204$ instances of the type <kw>([out_of_line]), define two separate 1205$ types, one of which has the <kw>([out_of_line]) attribute. 1206 1207135 Command option -%1$s %2$s is not valid 1208$ Explanation: 1209$ The <v>(option-value) specified is not valid for the option 1210$ with which it is used. 1211$ User Action: 1212$ See the documentation for the correct command line syntax. 1213 1214136 Invalid parameters on command line: 1215$ Explanation: 1216$ There are extra parameters on the command line. 1217$ User Action: 1218$ You may have attempted to use a value on a option that does 1219$ not take a value, or attempted to compile more than one 1220$ interface at once. 1221$ See the documentation for the proper command line syntax. 1222 1223137 Pointers to context handles are valid only in parameter declarations 1224$ Explanation: 1225$ IDL does not allow pointers to context handles, 1226$ except in parameter declarations. 1227$ User Action: 1228$ Do not declare a pointer to a <kw>(context_handle), except as a parameter. 1229 1230138 Pointers to pipes are valid only in parameter declarations 1231$ Explanation: 1232$ IDL does not allow a pointer to a <kw>(pipe), 1233$ except in a parameter declaration. 1234$ User Action: 1235$ Do not declare a pointer to a <kw>(pipe), except as a parameter. 1236 1237139 The [last_is] parameter must have the [in] attribute 1238$ Explanation: 1239$ The <kw>([last_is]) attribute specifies a parameter that contains 1240$ the upper data limit of a varying array. Since the array has the 1241$ <kw>([in]) attribute, the upper data 1242$ limit parameter must also be <kw>([in]) 1243$ so the number of array elements to send from client to 1244$ server is known. 1245$ User Action: 1246$ Change the data limit parameter referenced by the 1247$ <kw>([last_is]) clause to have the <kw>([in]) attribute. 1248 1249140 The attributes [last_is] and [length_is] cannot occur together 1250$ Explanation: 1251$ The <kw>([last_is]) and <kw>([length_is]) attributes both specify a 1252$ field or parameter used to determine the 1253$ data limit of a varying array. 1254$ You cannot use both. 1255$ User Action: 1256$ The <kw>([last_is]) attribute specifies the 1257$ index of the last valid element. 1258$ The <kw>([length_is]) attribute specifies the 1259$ total number of elements in the 1260$ array. Remove one of these attributes. 1261 1262141 A [last_is] variable must be a small, short, or long integer 1263$ Explanation: 1264$ The <kw>([last_is]) attribute specifies a field or parameter that contains 1265$ the upper data limit of a varying array. Array data limits 1266$ must be integers which are not <kw>(hyper). 1267$ User Action: 1268$ Change the upper data limit field or parameter referenced by the 1269$ <kw>([last_is]) clause to be of integer data type. 1270 1271142 The lower bound must not be greater than the upper bound 1272$ Explanation: 1273$ The syntax of an array requires the lower bound to 1274$ precede the upper bound. 1275$ User Action: 1276$ Modify the array declaration so the lower bound is first. 1277 1278143 The [length_is] parameter must have the [in] attribute 1279$ Explanation: 1280$ The <kw>([length_is]) attribute specifies a parameter used 1281$ to determine the data length of a varying array. 1282$ Since the array has the 1283$ <kw>([in]) attribute, the <kw>(length_is) parameter 1284$ must also be <kw>([in]) 1285$ so the number of array elements to send from client to 1286$ server is known. 1287$ User Action: 1288$ Change the parameter referenced by the 1289$ <kw>([length_is]) clause to have the <kw>([in]) attribute. 1290 1291144 A [length_is] variable must be a small, short, or long integer 1292$ Explanation: 1293$ The <kw>([length_is]) attribute specifies a field 1294$ or parameter that contains 1295$ the data length of a varying array. The field or parameter 1296$ must be integers which are not <kw>(hyper). 1297$ User Action: 1298$ Change the field or parameter referenced by the 1299$ <kw>([length_is]) clause to be of integer data type. 1300 1301145 The major version number is too large; the maximum is %1$lu 1302$ Explanation: 1303$ The major version number is too large. 1304$ User Action: 1305$ Replace the major version number (the portion 1306$ to the left of the period) with a value 1307$ less than <v>(number). 1308 1309146 The attribute [max_is] cannot be applied to dimension %1$lu; upper bound is not dynamic 1310$ Explanation: 1311$ A <kw>([max_is]) variable is only valid for array dimensions that 1312$ have an upper bound that is not fixed. 1313$ User Action: 1314$ If the array is multidimensional, you may have specified the 1315$ <kw>([max_is]) variable for the wrong dimension. See the 1316$ documentation for the proper syntax. If the array has only 1317$ one dimension, the <kw>([max_is]) clause is invalid, since the 1318$ array's upper bound is fixed. You may have meant to use a 1319$ <kw>([last_is]) clause. See the documentation for the 1320$ distinctions between conformant and varying arrays 1321$ and their attributes. 1322 1323147 Maximum identifier length for interface name is %1$lu characters 1324$ Explanation: 1325$ The IDL compiler constructs new identifier names 1326$ that are referenced by generated stub code 1327$ from the interface name. 1328$ Therefore, the number of characters allowed 1329$ in an interface name is 1330$ less than for other identifiers. 1331$ User Action: 1332$ Shorten the interface name. 1333 1334148 Maximum identifier length for type with [transmit_as] is %1$lu characters 1335$ Explanation: 1336$ The IDL compiler constructs new identifier names 1337$ that are referenced by generated stub code 1338$ from the names of any <kw>([transmit_as]) data types. 1339$ Therefore, the number of characters allowed 1340$ in such a data type is 1341$ less than for other identifiers. 1342$ User Action: 1343$ Shorten the data type name. 1344 1345149 Maximum identifier length for [handle] type is %1$lu characters 1346$ Explanation: 1347$ The IDL compiler constructs new identifier names 1348$ that are referenced by generated stub code 1349$ from the names of any <kw>([handle]) data types. 1350$ Therefore, the number of characters allowed 1351$ in such a data type is 1352$ less than for other identifiers. 1353$ User Action: 1354$ Shorten the data type name. 1355 1356150 Maximum identifier length for [context_handle] type is %1$lu characters 1357$ Explanation: 1358$ The IDL compiler constructs new identifier names 1359$ that are referenced by generated stub code 1360$ from the names of any <kw>([context_handle]) data types. 1361$ Therefore, the number of characters allowed 1362$ in such a data type is 1363$ less than for other identifiers. 1364$ User Action: 1365$ Shorten the data type name. 1366 1367151 Maximum identifier length for pointed-to type is %1$lu characters 1368$ Explanation: 1369$ The IDL compiler constructs new identifier names 1370$ that are referenced by generated stub code 1371$ from the names of any pointed-to data types. 1372$ Therefore, the number of characters allowed 1373$ in such a data type is 1374$ less than for other identifiers. 1375$ User Action: 1376$ Shorten the data type name. 1377 1378152 Maximum identifier length for pipe type is %1$lu characters 1379$ Explanation: 1380$ The IDL compiler constructs new identifier names 1381$ that are referenced by generated stub code 1382$ from the names of any <kw>(pipe) data types. 1383$ Therefore, the number of characters allowed 1384$ in such a data type is 1385$ less than for other identifiers. 1386$ User Action: 1387$ Shorten the data type name. 1388 1389153 Maximum identifier length for [represent_as] type is %1$lu characters 1390$ Explanation: 1391$ The IDL compiler constructs new identifier names 1392$ that are referenced by generated stub code 1393$ from the names of any <kw>([represent_as]) data types. 1394$ Therefore, the number of characters allowed 1395$ in such a data type is 1396$ less than for other identifiers. 1397$ User Action: 1398$ Shorten the data type name. 1399 1400154 Maximum identifier length for [out_of_line] type is %1$lu characters 1401$ Explanation: 1402$ The IDL compiler constructs new identifier names 1403$ that are referenced by generated stub code 1404$ from the names of any <kw>([out_of_line]) data types. 1405$ Therefore, the number of characters allowed 1406$ in such a data type is 1407$ less than for other identifiers. 1408$ User Action: 1409$ Shorten the data type name. 1410 1411155 A [max_is] parameter must have the [in] attribute 1412$ Explanation: 1413$ The <kw>([max_is]) attribute specifies a parameter that contains 1414$ the upper bound of a conformant array. This must be an <kw>([in]) 1415$ attribute so the server stub code knows how much 1416$ space to allocate for the array. 1417$ User Action: 1418$ Change the upper bound parameter referenced by the 1419$ <kw>([max_is]) clause to have the <kw>([in]) attribute. 1420 1421156 The attribute [max_is] or [size_is] is required 1422$ Explanation: 1423$ An array with an upper bound that is not fixed is used as a field of 1424$ a structure or as a parameter of an operation. You must 1425$ specify a field or parameter that determines 1426$ the allocation of the array at runtime. 1427$ User Action: 1428$ Use a <kw>([max_is]) or <kw>([size_is]) attribute to specify 1429$ the field or parameter that contains the size information. 1430 1431157 The attributes [max_is] and [size_is] cannot occur together 1432$ Explanation: 1433$ The <kw>([max_is]) and <kw>([size_is]) attributes both specify a 1434$ field or parameter used to determine the 1435$ upper bound of a conformant array. 1436$ You cannot use both. 1437$ User Action: 1438$ The <kw>([max_is]) attribute specifies 1439$ the index of the last possible array element. 1440$ The <kw>([size_is]) attribute specifies 1441$ the total number of possible elements in the 1442$ array. Remove one of the attributes. 1443 1444158 A [max_is] variable must be a small, short, or long integer 1445$ Explanation: 1446$ The <kw>([max_is]) attribute specifies a field or parameter that contains 1447$ the upper bound of a conformant array. Array bounds 1448$ must be integers which are not <kw>(hyper). 1449$ User Action: 1450$ Change the upper bound field or parameter referenced by the 1451$ <kw>([max_is]) clause to be of integer data type. 1452 1453159 A [maybe] operation cannot have [out] parameters or a function result 1454$ Explanation: 1455$ The <kw>([maybe]) attribute specifies that the operation's caller 1456$ does not require and does not receive a response or fault 1457$ indication. Do not use an <kw>([out]) 1458$ parameter or a function result in a <kw>([maybe]) operation. 1459$ User Action: 1460$ Remove the <kw>([maybe]) attribute from the operation, 1461$ or remove all <kw>([out]) parameters from the function and 1462$ declare its result type as <kw>(void). 1463 1464160 The attribute [min_is] is required 1465$ Explanation: 1466$ An array with a lower bound that is not fixed is used as a field of 1467$ a structure or as a parameter of an operation. You must 1468$ specify a field or parameter that determines 1469$ the lower bound of the array at runtime. 1470$ User Action: 1471$ Use a <kw>([min_is]) attribute to specify 1472$ the field or parameter that contains the lower bound. 1473 1474161 The attribute [min_is] cannot be applied to dimension %1$lu; lower bound is not dynamic 1475$ Explanation: 1476$ A <kw>([min_is]) variable is valid only for array dimensions that 1477$ have a lower bound that is not fixed. 1478$ User Action: 1479$ If the array is multidimensional, you may have specified the 1480$ <kw>([min_is]) variable for the wrong dimension. See the 1481$ documentation for the proper syntax. If the array has only 1482$ one dimension, the <kw>([min_is]) clause is invalid, since the 1483$ array's lower bound is fixed. The 1484$ <kw>([first_is]) clause is valid for single dimension 1485$ arrays. See the documentation for the 1486$ distinctions between conformant and varying arrays 1487$ and their attributes. 1488 1489162 A [min_is] parameter must have the [in] attribute 1490$ Explanation: 1491$ The <kw>([min_is]) attribute specifies a parameter that contains 1492$ the lower bound of a conformant array. This parameter 1493$ must have an <kw>([in]) 1494$ attribute so the server stub code will allocate adequate 1495$ space for the array. 1496$ User Action: 1497$ Change the lower bound parameter referenced by the 1498$ <kw>([min_is]) clause to have the <kw>([in]) attribute. 1499 1500163 The minor version number is too large; the maximum is %1$lu 1501$ Explanation: 1502$ The minor version number is too large. 1503$ User Action: 1504$ Replace the minor version number (the portion 1505$ to the right of the period) with a value 1506$ less than <v>(number). 1507 1508164 A [min_is] variable must be a small, short, or long integer 1509$ Explanation: 1510$ The <kw>([min_is]) attribute specifies a field or parameter that contains 1511$ the lower bound of a conformant array. Array bounds 1512$ must be integers that are not <kw>(hyper). 1513$ User Action: 1514$ Change the lower bound field or parameter referenced by the 1515$ <kw>([min_is]) clause so that it is a small, short, or long 1516$ integer. 1517 1518165 Name already declared: %1$s 1519$ Explanation: 1520$ The name referenced is already declared. 1521$ User Action: 1522$ Modify the interface and select a unique name 1523$ for the given item. 1524 1525166 Name is not a constant: %1$s 1526$ Explanation: 1527$ The name used to define a new constant is not the name of 1528$ a <kw>(constant). 1529$ User Action: 1530$ Modify the <kw>(constant) definition to use 1531$ a predefined <kw>(constant) name. 1532 1533167 Name is not a field: %1$s 1534$ Explanation: 1535$ The name referenced in an array attribute is not 1536$ declared as a field in the structure being defined. 1537$ User Action: 1538$ Declare a field in the structure that can be used 1539$ in the array attribute. 1540 1541168 Name not found: %1$s 1542$ Explanation: 1543$ The referenced name is not defined. 1544$ User Action: 1545$ Modify the interface to define an appropriate type for the 1546$ specified name. 1547 1548169 Name is not a parameter: %1$s 1549$ Explanation: 1550$ The name referenced in an array attribute is not 1551$ declared as a parameter in the operation being defined. 1552$ User Action: 1553$ Declare a parameter in the operation that can be used 1554$ in the array attribute. 1555 1556170 Name is not a type: %1$s 1557$ Explanation: 1558$ The name referenced is not a type definition. 1559$ User Action: 1560$ Modify the interface to specify a unique type specification 1561$ instead of the name referenced. 1562 1563171 Name %1$s previously declared in file %2$s, line %3$lu 1564$ Explanation: 1565$ The name referenced was previously declared at the specified location. 1566$ User Action: 1567$ Remove this declaration, if it is redundant, or change the spelling 1568$ so it does not conflict with the existing name. 1569 1570172 %1$sNLS message catalog version mismatch in \"%2$s\", Expected: \"%3$lu\", Actual: \"%4$s\" 1571 1572173 %1$sError messages may be incorrect 1573$ Explanation: 1574$ The error messages reported by the IDL compiler are stored in an NLS 1575$ message catalog. The catalog <v>(filename) is not the same version 1576$ as the IDL compiler being invoked. The error messages reported may 1577$ therefore be incorrect or cause the compiler to terminate abnormally. 1578$ User Action: 1579$ Check the definition of the NLS environment variable NLSPATH and verify that 1580$ it searches the appropriate directories. The default location for the IDL 1581$ compiler message catalog is 1582$ <v>(<literal>(<)dceshared>)<kw>(/nls/msg/)<v>(LANG)<kw>(/%N) 1583 1584174 Non-integer values are not allowed in expressions 1585$ Explanation: 1586$ One of the values in the expression is not 1587$ an integer (or one that can be promoted to integer). 1588$ User Action: 1589$ Correct the expression to contain only integer values. 1590 1591175 The [align] attribute is not yet supported 1592 1593176 The attribute [in(shape)] is not yet supported 1594 1595177 Arrays with a nonzero lower bound are not yet supported 1596 1597178 The attribute [out(shape)] is not yet supported 1598 1599179 Attribute [unique] is not yet supported 1600 1601180 Operation attributes [code] and [nocode] cannot occur together 1602$ Explanation: 1603$ The <kw>([code]) and <kw>([nocode]) attributes have directly opposite 1604$ meanings. Do not use both. 1605$ User Action: 1606$ Remove one of the conflicting attributes. 1607 1608181 Unable to open %1$s for read access 1609$ Explanation: 1610$ The IDL compiler is unable to open a file for processing. 1611$ User Action: 1612$ Make sure the file exists, and that it has the proper access 1613$ protection for the IDL compiler. 1614 1615182 Unable to open %1$s for write access 1616$ Explanation: 1617$ The IDL compiler is unable to create a file. 1618$ User Action: 1619$ Make sure the directory to contain the file exists, 1620$ and that it has the proper access 1621$ protection for the IDL compiler. 1622 1623183 Operation name %1$s referenced in ACF is not defined 1624$ Explanation: 1625$ Any operation referenced in an Attribute Configuration File 1626$ (ACF) must be defined in the corresponding IDL file. 1627$ User Action: 1628$ Check for typographical errors in either file. 1629 1630184 An [out] conformant array must be a top-level parameter or under a non-[ref] pointer 1631$ Explanation: 1632$ An array with unspecified lower and/or upper bounds requires 1633$ size information. If the array is a top-level parameter, 1634$ the size information must be in additional <kw>([in]) parameters. 1635$ If the array is contained within a structure, the size 1636$ information must be in additional fields of the structure, 1637$ and the parameter containing the structure must be <kw>([in]) or 1638$ <kw>([in,out]). In both cases, the size 1639$ information must be <kw>([in]) 1640$ so the server stub knows how much storage to allocate 1641$ for the array. The exception to this latter case is any <kw>([out]) 1642$ conformant array that is pointed to by a full <kw>([ptr]) pointer 1643$ or a <kw>([unique]) pointer 1644$ or that indirectly lies under a <kw>([ptr]) 1645$ or <kw>([unique]) pointer. In this 1646$ case the semantics are that the user-written manager code 1647$ either allocates and/or manages the 1648$ storage for the array and any other data below the <kw>([ptr]) 1649$ or <kw>([unique]) 1650$ pointer or returns a <kw>(NULL) value for 1651$ the <kw>([ptr]) or <kw>([unique]) pointer. 1652$ User Action: 1653$ Change the parameter to be <kw>([in,out]), or pass the array as a 1654$ separate <kw>([out]) parameter with <kw>([in]) size information 1655$ parameters, or change the data structure and the code that 1656$ manipulates it so the conformant array is under a 1657$ <kw>([ptr]) or <kw>([unique]) pointer. 1658 1659185 Output parameters must be passed by reference 1660$ Explanation: 1661$ Parameters with the <kw>([out]) or <kw>([in,out]) attributes must be 1662$ passed by reference, so the changed value of the 1663$ parameter can be reflected back to the caller. 1664$ User Action: 1665$ Add a <kw>(*) to the parameter declaration to indicate 1666$ pass-by-reference calling mechanism. 1667 1668186 An [out,ptr] parameter is not valid 1669$ Explanation: 1670$ The <kw>([ptr]) parameter attribute implies that the value of the 1671$ pointer may be <kw>(NULL). It is invalid on an <kw>([out]) only 1672$ parameter, since the possible NULL-ness is not shipped 1673$ to the server (for example, in the <kw>([in]) direction). 1674$ User Action: 1675$ If the pointer cannot be <kw>(NULL) 1676$ remove the <kw>([ptr]) attribute. 1677$ Otherwise, make the parameter an <kw>([in,out,ptr]) parameter. 1678 1679187 An [out] parameter or operation result cannot contain [unique] pointers 1680$ Explanation: 1681$ Operation results and parameters that are <kw>([out]) only cannot 1682$ have <kw>([unique]) pointers. Unique pointers may be <kw>(NULL), 1683$ but there is no way to express the <kw>(NULL) value to the server 1684$ unless the pointer is part of an <kw>([in]) parameter. 1685$ User Action: 1686$ Change your type declarations so no types contained in 1687$ the parameter have the <kw>([unique]) attribute, or, if the pointer 1688$ is part of a parameter, add the <kw>([in]) attribute to the parameter. 1689 1690188 An operation result cannot be a pipe 1691$ Explanation: 1692$ Pipes are not allowed as operation results. 1693$ User Action: 1694$ Change the operation so the <kw>(pipe) is an extra <kw>([out]) 1695$ parameter instead of the operation result. 1696 1697189 Output parameters require an explicit top-level * 1698$ Explanation: 1699$ Parameters with the <kw>([out]) or <kw>([in,out]) attributes must be 1700$ passed by reference, so the changed value of the 1701$ parameter can be reflected back to the caller. 1702$ IDL does not allow a <kw>(*) in a type definition to serve as 1703$ a passing mechanism <kw>(*). 1704$ User Action: 1705$ Change the declaration of the parameter so it 1706$ contains an explicit <kw>(*). 1707 1708190 An [out,unique] parameter is not valid 1709$ Explanation: 1710$ The <kw>([unique]) parameter attribute implies that the value of the 1711$ pointer may be <kw>(NULL). The <kw>(NULL) value is 1712$ invalid on an <kw>([out]) only 1713$ parameter, since the <kw>(NULL) value was not sent 1714$ to the server as an <kw>([in]) parameter. 1715$ User Action: 1716$ If the pointer cannot be <kw>(NULL), remove the 1717$ <kw>([unique]) attribute. 1718$ Otherwise, make the parameter an <kw>([in,out,unique]) parameter. 1719 1720191 The base type of a pipe cannot be a pipe type 1721$ Explanation: 1722$ A <kw>(pipe) type cannot be used in the definition of 1723$ another <kw>(pipe) type. 1724$ User Action: 1725$ Remove the invalid declaration, or change it so the 1726$ base type of the <kw>(pipe) is not another <kw>(pipe) type. 1727 1728192 Pipes are not valid as structure fields 1729$ Explanation: 1730$ Pipes are not allowed as fields of structures. 1731$ User Action: 1732$ Pass a <kw>(pipe) as a separate parameter to an operation, 1733$ rather than embedding it as a field of a structure. 1734 1735193 Pipes are not valid as members of unions 1736$ Explanation: 1737$ Pipes are not allowed as members of <kw>(union)s. 1738$ User Action: 1739$ Pass a <kw>(pipe) as a separate parameter to an operation, 1740$ rather than embedding it as a member of a <kw>(union). 1741 1742194 A pipe cannot have a [transmit_as] type 1743$ Explanation: 1744$ A pipe is a specialized object handled by RPC that, 1745$ by itself, is not a transmittable object. 1746$ Thus, a <kw>([transmit_as]) clause is invalid on 1747$ a <kw>(pipe) definition. 1748$ User Action: 1749$ Remove the <kw>([transmit_as]) attribute. 1750 1751195 A parameter with [%1$s] cannot be passed by value 1752$ Explanation: 1753$ The <v>([attribute-name]) attribute can only be applied 1754$ to a parameter if that parameter has an explicit <kw>(*). 1755$ User Action: 1756$ Modify the parameter signature to have a top-level <kw>(*). 1757 1758196 A parameter must have either or both the [in] and [out] attributes 1759$ Explanation: 1760$ The direction of a parameter must be declared. The 1761$ <kw>([in]) attribute tells IDL that the parameter is passed from 1762$ client to server. The 1763$ <kw>([out]) attribute tells IDL that the parameter is passed from 1764$ server to client. 1765$ User Action: 1766$ Add the <kw>([in]), <kw>([out]), or <kw>([in,out]) attribute 1767$ to the parameter. 1768 1769197 Parameter attributes [in_line] and [out_of_line] cannot occur together 1770 1771198 Parameter name %1$s referenced in ACF operation %2$s is not defined 1772$ Explanation: 1773$ Any parameter referenced within an operation declaration in an 1774$ Attribute Configuration File (ACF) must be defined in the 1775$ corresponding operation definition in the IDL file. 1776$ User Action: 1777$ Check for typographical errors in either file. 1778 1779199 The attribute [ptr] is invalid on a binding handle parameter 1780$ Explanation: 1781$ The first parameter in an operation is a <kw>(handle) parameter, 1782$ either of type <kw>(handle_t) or a type with 1783$ the <kw>([handle]) attribute. 1784$ It cannot have the <kw>([ptr]) attribute, since it 1785$ cannot be <kw>(NULL). 1786$ User Action: 1787$ Remove the <kw>([ptr]) attribute from the parameter. 1788 1789200 The attribute [ptr] is valid only for pointer types or array parameter types 1790$ Explanation: 1791$ The <kw>([ptr]) attribute modifies the default behavior of any 1792$ pointer type or an array parameter data type. 1793$ It is not valid on other data types. 1794$ Note that a <kw>(void *) object is not considered a pointer. 1795$ User Action: 1796$ There may be a missing <kw>(*) in your declaration. 1797$ If not, remove the <kw>([ptr]) attribute. 1798 1799201 The base type of a pipe cannot be or contain a pointer 1800$ Explanation: 1801$ IDL does not allow the base type of a <kw>(pipe) to be a pointer 1802$ or any data type that contains pointers. 1803$ User Action: 1804$ Change your <kw>(pipe) type definition so the base type of 1805$ the <kw>(pipe) is not a pointer and does not contain any pointers. 1806 1807202 Incorrect syntax for pointer to conformant array 1808$ Explanation: 1809$ An IDL declaration attempts to use mixed pointer <kw>(*) and 1810$ array <kw>([]) syntax to declare a pointer to an array that has 1811$ bounds that are not fixed. It is 1812$ ambiguous whether size attributes apply to the pointer or the 1813$ array, thus IDL does not allow mixing pointer and array syntax 1814$ when size attributes are present. 1815$ User Action: 1816$ If the declaration is a parameter declaration and the 1817$ top-level <kw>(*) is a pointer to an array, that <kw>(*) is 1818$ unnecessary. This is because arrays are implicitly passed 1819$ by reference, as in C. Remove the top-level <kw>(*). 1820$ If the declaration is a field of a structure, change the 1821$ declaration to use arrayified pointer syntax. A field that is 1822$ a pointer to a type and also has a conformant array attribute 1823$ represents a pointer to an array of that type. 1824$ If the declaration is an [out] parameter, see the description 1825$ of the message "An [out] conformant array must be a top-level 1826$ parameter or under a full pointer." 1827 1828203 Full pointers to context handles are not allowed 1829$ Explanation: 1830$ IDL does not allow full pointers 1831$ to context handles. 1832$ User Action: 1833$ If the declaration has the <kw>([ptr]) attribute, either explicitly 1834$ or by default, change it to a <kw>([ref]) pointer. 1835$ However, if the 1836$ declaration is an operation result, it cannot be a <kw>([ref]) 1837$ pointer and an operation resulting in a pointer to a 1838$ context handle is not possible. 1839 1840204 The attribute [ptr] is not valid on pipe parameters 1841$ Explanation: 1842$ IDL does not allow the <kw>([ptr]) attribute 1843$ on <kw>(pipe) parameters. 1844$ User Action: 1845$ Remove the <kw>([ptr]) attribute from the parameter. 1846 1847205 Pointers to [v1_enum] types are not allowed 1848$ Explanation: 1849$ An enumeration type with the <kw>([v1_enum]) attribute follows 1850$ NCS Version 1 NIDL semantics, and does not allow pointers to 1851$ enumerations except as a reference passing mechanism on a 1852$ parameter. 1853$ User Action: 1854$ If compatibility with NCS Version 1 NIDL is not necessary, 1855$ remove the <kw>([v1_enum]) attribute. 1856 1857206 Pointers to varying arrays are not allowed 1858$ Explanation: 1859$ An IDL declaration attempts to use mixed pointer <kw>(*) and 1860$ array <kw>([]) syntax to declare a pointer to an array that has 1861$ varying bounds. Usually, it is 1862$ ambiguous whether size attributes apply to the pointer or the 1863$ array, thus IDL does not allow mixing pointer and array syntax 1864$ when size attributes are present. 1865$ User Action: 1866$ If the declaration is a parameter declaration and the 1867$ top-level <kw>(*) is a pointer to an array, that <kw>(*) is 1868$ unnecessary. This is because arrays are implicitly passed 1869$ by reference, as in C. Remove the top-level <kw>(*). 1870$ If the declaration is more complex, 1871$ investigate alternative ways to achieve 1872$ results, such as using a pointer to a 1873$ structure that has the required information. 1874 1875207 void * must be used in conjunction with the [context_handle] attribute 1876$ Explanation: 1877$ The only valid use of a <kw>(void *) data type in an interface 1878$ definition is on an item with the <kw>([context_handle]) attribute. 1879$ User Action: 1880$ Change the data type in the declaration, or add the 1881$ <kw>([context_handle]) attribute. 1882 1883208 The attribute [ref] is valid only for pointer types or array parameter types 1884$ Explanation: 1885$ The <kw>([ref]) attribute modifies the default behavior of any 1886$ pointer type or an array parameter data type. 1887$ It is not valid on other data types. 1888$ Note that a <kw>(void *) object is not considered a pointer. 1889$ User Action: 1890$ There may be a missing <kw>(*) in your declaration. 1891$ If not, remove the <kw>([ref]) attribute. 1892 1893209 A [ref] function result is not valid 1894$ Explanation: 1895$ Unlike <kw>([out]) parameters, there is never any pre-existing 1896$ storage in the caller for pointer valued function results. 1897$ The pointer always indicates new storage. This is the 1898$ capability provided by full pointers only, not 1899$ <kw>([ref]) pointers. 1900$ User Action: 1901$ Remove the <kw>([ref]) attribute from the type definition 1902$ of the data type of the function result. 1903 1904210 Rename of %1$s to %2$s failed 1905$ Explanation: 1906$ The call to rename <v>(filename1) to <v>(filename2) returned 1907$ a failing status. 1908$ User Action: 1909$ Make sure the filenames and paths are valid, you have privilege 1910$ to perform the rename operation, and there is enough free space on the 1911$ destination device. 1912 1913211 Types with [represent_as] cannot be nested 1914$ Explanation: 1915$ IDL does not allow a data type that has a <kw>([represent_as]) type 1916$ to itself be used as a <kw>([represent_as]) type in another type 1917$ definition. 1918$ User Action: 1919$ Do not nest <kw>([represent_as]) types. 1920 1921212 Too many scoping levels 1922$ Explanation: 1923$ The input source is too complicated to be parsed. This 1924$ occurs because of deeply 1925$ nested <kw>(struct) or <kw>(union) declarations. 1926$ User Action: 1927$ Simplify the input source by using <kw>(typedef)s to represent the 1928$ nested <kw>(struct) or <kw>(union) declarations, and 1929$ building the more 1930$ complicated <kw>(struct) or <kw>(union) declarations 1931$ by referencing the 1932$ named types instead of in-line specification of the <kw>(struct) 1933$ or <kw>(union) declaration. 1934 1935213 Size attributes can only be applied to array types 1936$ Explanation: 1937$ Array bound attributes are only valid when used on array types or pointers 1938$ used as an array. 1939$ User Action: 1940$ Remove the array bound attribute or correct the type to be 1941$ an array. 1942 1943214 The attribute [size_is] cannot be applied to dimension %1$lu; upper bound is not dynamic 1944$ Explanation: 1945$ A <kw>(size_is) variable is only valid for array dimensions that 1946$ have an upper bound that is not fixed. 1947$ User Action: 1948$ If the array is multidimensional, you may have specified the 1949$ <kw>(size_is) variable for the wrong dimension. See the 1950$ documentation for the proper syntax. If the array has only 1951$ one dimension, the <kw>(size_is) clause is invalid, since the 1952$ array's upper data limit is fixed. You may have meant to use a 1953$ <kw>([length_is]) clause. See the documentation for the 1954$ distinctions between conformant and varying arrays 1955$ and their attributes. 1956 1957215 A [size_is] parameter must have the [in] attribute 1958$ Explanation: 1959$ The <kw>([size_is]) attribute specifies a parameter that contains 1960$ size information of a conformant array. This must be an <kw>([in]) 1961$ attribute so the server stub code knows how much 1962$ space to allocate for the array. 1963$ User Action: 1964$ Change the size parameter referenced by the 1965$ <kw>([size_is]) clause to have the <kw>([in]) attribute. 1966 1967216 The size attributes do not match the array dimension 1968$ Explanation: 1969$ There are too many attribute references for the number of 1970$ dimensions defined for the array. 1971$ User Action: 1972$ Modify the array bound attribute, specifying one reference 1973$ for each dimension of the array. 1974 1975217 The array size attribute variable %1$s cannot have the [ptr] or [unique] attributes 1976$ Explanation: 1977$ An array size attribute clause in the source IDL specifies 1978$ its value by dereferencing a pointer parameter. 1979$ This is invalid if the pointer variable has either of the 1980$ <kw>([ptr]) or <kw>([unique]) attributes, since both 1981$ allow the pointer 1982$ to be <kw>(NULL). If the pointer is <kw>(NULL), there is no 1983$ way to determine the size of the array. 1984$ User Action: 1985$ Either redeclare the size variable as a scalar rather 1986$ than a pointer, or change the size variable to a <kw>([ref]) 1987$ pointer. 1988 1989218 A [size_is] variable must be a small, short, or long integer 1990$ Explanation: 1991$ The <kw>([size_is]) attribute specifies a field or parameter that contains 1992$ size information of a conformant array. Array bounds, and 1993$ thus array size, 1994$ must be integers which are not <kw>(hyper). 1995$ User Action: 1996$ Change the size information field or parameter referenced by the 1997$ <kw>([size_is]) clause to be of integer data type. 1998 1999219 A size attribute variable must not have a represent_as type 2000$ Explanation: 2001$ The parameter or field referenced 2002$ in a <kw>([max_is]), 2003$ <kw>([size_is]), <kw>([first_is]), <kw>([last_is]), 2004$ or <kw>([length_is]) clause must 2005$ not be of a data type that is declared to have a 2006$ <kw>([represent_as]) type. 2007$ User Action: 2008$ Change either the referenced parameter or field data type, 2009$ or the data type definition itself. 2010$ The parameter or field referenced 2011$ in a <kw>([min_is]), <kw>([max_is]), 2012$ <kw>([size_is]), <kw>([first_is]), <kw>([last_is]), 2013$ or <kw>([length_is]) clause must 2014$ not be of a data type that is declared to have a 2015$ <kw>([represent_as]) type. 2016$ Change either the referenced parameter or field data type, 2017$ or the data type definition itself. 2018 2019220 A size attribute variable must not have a transmit_as type 2020$ Explanation: 2021$ The parameter or field referenced 2022$ in a <kw>([max_is]), 2023$ <kw>([size_is]), <kw>([first_is]), <kw>([last_is]), 2024$ or <kw>([length_is]) clause must 2025$ not be of a data type that is declared to have a 2026$ <kw>([transmit_as]) type. 2027$ User Action: 2028$ Change either the referenced parameter or field data type, 2029$ or the data type definition itself. 2030$ The parameter or field referenced 2031$ in a <kw>([min_is]), <kw>([max_is]), 2032$ <kw>([size_is]), <kw>([first_is]), <kw>([last_is]), 2033$ or <kw>([length_is]) clause must 2034$ not be of a data type that is declared to have a 2035$ <kw>([transmit_as]) type. 2036$ Change either the referenced parameter or field data type, 2037$ or the data type definition itself. 2038 2039221 The attribute [v1_array] must be in array, not pointer, syntax 2040$ Explanation: 2041$ The <kw>([v1_array]) attribute is for compatibility with 2042$ NCS Version 1 arrays. NCS Version 1 NIDL did 2043$ not allow pointers to represent arrays. 2044$ User Action: 2045$ Define the array using array syntax. 2046 2047222 A conformant [v1_array] must also be varying 2048$ Explanation: 2049$ An array with the <kw>([v1_array]) attribute that has a 2050$ conformant upper bound that is not fixed must also be varying (it must 2051$ have a <kw>([last_is]) or <kw>([length_is]) attribute in 2052$ addition to the <kw>([max_is]) or <kw>([size_is]) 2053$ attribute). 2054$ User Action: 2055$ If compatibility with NCS Version 1 NIDL is not necessary, remove the 2056$ <kw>([v1_array]) attribute. 2057$ Otherwise, add a <kw>([last_is]) or <kw>([length_is]) 2058$ attribute to the declaration. 2059 2060223 The attribute [v1_array] is invalid for an array with more than 65535 elements 2061$ Explanation: 2062$ An array with the <kw>([v1_array]) attribute is limited to a total 2063$ of 65535 or fewer elements. The declared array has too many 2064$ elements to be <kw>([v1_array]). 2065$ User Action: 2066$ Remove the <kw>([v1_array]) attribute from the array declaration. 2067 2068224 The attribute [v1_array] cannot occur with the [min_is] or [first_is] attributes 2069$ Explanation: 2070$ The only valid array attributes for the 2071$ <kw>([v1_array]) attribute are 2072$ <kw>([max_is]), <kw>([last_is]), and 2073$ <kw>([length_is]). 2074$ User Action: 2075$ If you require compatibility with NCS 2076$ Version 1 NIDL, the lower bound 2077$ of the array must be fixed; therefore, 2078$ remove the 2079$ <kw>([first_is]) attribute and change the array declaration. 2080$ Otherwise, remove the <kw>([v1_array]) attribute. 2081$ The only valid array attributes for the 2082$ <kw>([v1_array]) attribute are 2083$ <kw>([max_is]), <kw>([size_is]), <kw>([last_is]), and 2084$ <kw>([length_is]). 2085$ If you require compatibility with NCS 2086$ Version 1 NIDL, the lower bound 2087$ of the array must be fixed; therefore, 2088$ remove the <kw>([min_is]) or 2089$ <kw>([first_is]) attribute and change the array declaration. 2090$ Otherwise, remove the <kw>([v1_array]) attribute. 2091 2092225 A [v1_array] can be conformant or varying in first dimension only 2093$ Explanation: 2094$ An array with the <kw>([v1_array]) attribute is limited to 2095$ a conformant or varying upper data limit 2096$ in the first dimension only. 2097$ User Action: 2098$ Remove the <kw>([v1_array]) attribute from the array declaration. 2099 2100226 A [v1_array] cannot have a conformant lower bound 2101$ Explanation: 2102$ A <kw>([v1_array]) specifies that the array be handled in a 2103$ manner compatible with NCS Version 1 NIDL, which did not 2104$ support non-fixed lower bounds for arrays. 2105$ User Action: 2106$ If compatibility with NCS Version 1 is required, the array 2107$ must not have a conformant lower bound. Otherwise, remove 2108$ the <kw>([v1_array]) attribute. 2109 2110227 Arrays of strings are not allowed 2111 2112228 The attribute [string] cannot be applied to a [v1_array] 2113$ Explanation: 2114$ A string that is compatible with the NCS Version 1 NIDL <kw>(string0) data 2115$ type must have the <kw>([v1_array]) and <kw>([v1_string]) attributes. 2116$ The <kw>([string]) attribute only applies 2117$ without the <kw>([v1_array]) 2118$ attribute. A <kw>([v1_array]) is for 2119$ compatibility with NCS Version 1 NIDL. 2120$ User Action: 2121$ If compatibility with NCS Version 1 NIDL is required, 2122$ place the <kw>([v1_string]) attribute on the declaration. 2123$ Otherwise, remove the <kw>([v1_array]) attribute from the 2124$ array declaration. 2125 2126229 The attribute [string] is valid only for one-dimensional array of valid base type 2127$ Explanation: 2128$ The <kw>([string]) attribute flags that an array is a 2129$ string. Strings must be arrays whose base type is one of the 2130$ following: char, byte, unsigned short, unsigned long, 2131$ or a structure whose fields are all scalar byte fields. 2132$ User Action: 2133$ Remove the <kw>([string]) attribute, or change the data type 2134$ so it is a valid string. 2135 2136230 Structures with [transmit_as] or [represent_as] cannot be conformant 2137$ Explanation: 2138$ IDL does not support a conformant structure with the 2139$ <kw>([transmit_as]) or <kw>([represent_as]) attribute. 2140$ User Action: 2141$ Either change the declaration so the structure fields are of 2142$ a fixed size and have none of the conformant array attributes 2143$ <kw>([max_is]) or <kw>([size_is]), 2144$ or remove the <kw>([transmit_as]) or <kw>([represent_as]) attribute. 2145$ IDL does not support a conformant structure with the 2146$ <kw>([transmit_as]) or <kw>([represent_as]) attribute. 2147$ Either change the declaration so the structure fields are of 2148$ a fixed size and have none of the conformant array attributes 2149$ <kw>([min_is]), <kw>([max_is]), or <kw>([size_is]), 2150$ or remove the <kw>([transmit_as]) or <kw>([represent_as]) attribute. 2151 2152231 Unterminated string literal 2153$ Explanation: 2154$ There is a missing closing double quote (<kw>(")) on the string literal. 2155$ User Action: 2156$ Make sure the the closing quote for the string literal is on 2157$ the same source line as the starting quote. Also verify that 2158$ any double quote characters internal to the string are 2159$ preceded by the escape character (<literal>(\)). 2160 2161232 The [v1_string] attribute can only be applied to a [v1_array] 2162$ Explanation: 2163$ A <kw>([v1_string]) is compatible with 2164$ the NCS Version 1 NIDL <kw>(string0) data 2165$ type. It can be applied only to an array 2166$ compatible with NCS Version 1. For example, 2167$ an array with the <kw>([v1_array]) attribute. 2168$ User Action: 2169$ If compatibility with NCS Version 1 NIDL is required, 2170$ place the <kw>([v1_array]) attribute on the array. 2171$ Otherwise, change the <kw>([v1_string]) attribute to <kw>([string]), 2172$ that is a generalization of <kw>([v1_string]). 2173 2174233 A [v1_string] must be an array of char with fixed bounds 2175$ Explanation: 2176$ A <kw>([v1_string]) is compatible with 2177$ the NCS Version 1 NIDL <kw>(string0) data 2178$ type. It must be a single dimensioned array of <kw>(char) with 2179$ a zero lower bound and a fixed upper bound. 2180$ User Action: 2181$ If compatibility with NCS Version 1 NIDL is required, 2182$ change the declaration accordingly. 2183$ Otherwise, see the documentation regarding the <kw>([string]) 2184$ attribute. 2185 2186234 A [string] array cannot have varying array attributes 2187$ Explanation: 2188$ The <kw>([string]) attribute says that the length of a string is 2189$ an intrinsic property of the string itself; for example, C 2190$ strings are zero-terminated. 2191$ User Action: 2192$ Remove any <kw>([first_is]), <kw>([last_is]), 2193$ or <kw>([length_is]) clauses 2194$ from the string declaration. 2195 2196235 The attribute [%1$s] can occur at most once per operation 2197$ Explanation: 2198$ A <kw>([comm_status]) or <kw>([fault_status]) parameter or operation 2199$ result is used to return an error code if a certain type of 2200$ error occurs during execution of an operation. Do not use 2201$ either attribute more than once per operation. 2202$ User Action: 2203$ Remove the redundant usages of the attribute 2204$ from the interface's Attribute Configuration File (ACF). 2205 2206236 A parameter with [%1$s] must be an [out] parameter 2207$ Explanation: 2208$ A <kw>([comm_status]) or <kw>([fault_status]) parameter 2209$ is used to return 2210$ an error code if a certain type of error occurs during 2211$ execution of an operation. Thus, it must be an <kw>([out]) 2212$ parameter. 2213$ User Action: 2214$ Place the <kw>([out]) attribute on the parameter. 2215 2216237 An operation with [%1$s] must return a value of type error_status_t 2217$ Explanation: 2218$ The <kw>([comm_status]) or <kw>([fault_status]) attribute 2219$ on an operation 2220$ signifies that the return value of the operation is used to 2221$ return an error code if a certain type of error occurs during 2222$ execution of an operation. Thus, the operation must be 2223$ declared to deliver a result of data type <kw>(error_status_t). 2224$ User Action: 2225$ Declare the operation result to be of data type <kw>(error_status_t). 2226 2227238 A parameter with [%1$s] must be of type error_status_t 2228$ Explanation: 2229$ A <kw>([comm_status]) or <kw>([fault_status]) parameter 2230$ or function result 2231$ is used to return an error code if a certain type of error 2232$ occurs during execution of an operation. The data type of the 2233$ variable must be <kw>(error_status_t). 2234$ User Action: 2235$ Declare the variable to be of data type <kw>(error_status_t). 2236 2237239 Syntax error 2238$ Explanation: 2239$ The source input is incorrect and no interpretation 2240$ can be made. 2241$ User Action: 2242$ Examine the source input on and near the source listed 2243$ and correct any errors. 2244 2245240 Syntax error near \"%2$.*1$s\" 2246$ Explanation: 2247$ The source input is incorrect and no interpretation 2248$ can be made for <v>(source-text). 2249$ User Action: 2250$ Examine the source input on and near the source listed 2251$ and correct any errors. 2252 2253241 Syntax error in UUID format 2254$ Explanation: 2255$ The UUID specified in the <kw>([uuid]) attribute of an interface 2256$ is not in a valid format. 2257$ User Action: 2258$ Make sure the UUID is transcribed correctly and 2259$ contains the required punctuation. 2260 2261242 System error message: %1$s 2262$ Explanation: 2263$ Identifies the cause of the 2264$ previous error. 2265$ User Action: 2266$ See the system documentation for an explanation 2267$ of the error message. 2268 2269243 Too many elements in %1$s 2270$ Explanation: 2271$ The <kw>(enum) <v>(item) contains more than 32767 elements. 2272$ User Action: 2273$ Reduce the number of elements included in the 2274$ <kw>(enum). 2275 2276244 Too many endpoint specifications; Maximum is %1$lu 2277$ Explanation: 2278$ There are more endpoint specifications than IDL can process. 2279$ User Action: 2280$ Remove some of the endpoint specifications listed 2281$ in the <kw>([endpoint]) attribute. 2282$ Specify at most <v>(number) endpoint specifications for an interface. 2283 2284245 Type name: %1$s not found 2285$ Explanation: 2286$ The type <v>(name) is not declared at this point in the 2287$ interface declaration. 2288$ User Action: 2289$ Correct the spelling of <v>(name) if incorrect, and make sure 2290$ that a definition of <v>(name) precedes the reference. 2291 2292246 Type attributes [in_line] and [out_of_line] cannot occur together 2293$ Explanation: 2294$ The <kw>([in_line]) and <kw>([out_of_line]) attributes are 2295$ opposite in meaning. 2296$ You can specify at most one of these attributes on a type. 2297$ User Action: 2298$ Remove one of the conflicting attributes. 2299 2300247 Type name %1$s referenced in ACF is not defined 2301$ Explanation: 2302$ The context in which a type name is used in the Attribute 2303$ Configuration File (ACF) requires that the type be defined 2304$ in the corresponding IDL file. 2305$ User Action: 2306$ See if the referenced type is defined in some other interface. 2307$ If so, the ACF reference belongs in the ACF for that interface. 2308$ Check for typographical errors in both the IDL and ACF files. Check that 2309$ you have not omitted a type definition in the IDL file. 2310 2311248 Unbalanced parentheses 2312$ Explanation: 2313$ The number of left parentheses and right parentheses are not equal. 2314$ User Action: 2315$ Make sure the number of left parentheses equals the number of right 2316$ parentheses and that each parenthesis is in the correct place. 2317 2318249 Unbalanced brackets 2319$ Explanation: 2320$ The number of left brackets and right brackets are not equal. 2321$ User Action: 2322$ Make sure the number of left brackets equals the number of right 2323$ brackets and that each bracket is in the correct place. 2324 2325250 Unbalanced braces 2326$ Explanation: 2327$ The number of left braces and right braces are not equal. 2328$ User Action: 2329$ Make sure the number of left braces equals the number of right 2330$ braces and that each brace is in the correct place. 2331 2332251 A union discriminator type must be small, short, long, char, boolean, or enum 2333$ Explanation: 2334$ The discriminator of a <kw>(union), that determines which case of 2335$ the <kw>(union) is used, is restricted to integer, character, 2336$ enumeration, and boolean data types. Also, <kw>(hyper int) 2337$ discriminators are not allowed. 2338$ User Action: 2339$ Change the discriminator to one of the valid data types. 2340$ Make sure the data type of the <kw>(constant) values 2341$ in the <kw>(case) 2342$ clauses within the <kw>(union) agree with the discriminator data type. 2343 2344252 The attribute [unique] is invalid on a binding handle parameter 2345$ Explanation: 2346$ The first parameter in an operation is a <kw>(handle) parameter, 2347$ which is either of type <kw>(handle_t) or a type 2348$ with the <kw>([handle]) attribute. 2349$ A binding handle parameter cannot have the <kw>([unique]) 2350$ attribute because it cannot be <kw>(NULL). 2351$ User Action: 2352$ Remove the <kw>([unique]) attribute from the parameter. 2353 2354253 The attribute [unique] is valid only for pointer types or array parameter types 2355$ Explanation: 2356$ The <kw>([unique]) attribute modifies the default behavior 2357$ of any pointer type or an array parameter data type. 2358$ It is not valid on other data types. 2359$ Note that a <kw>(void *) object is not considered a pointer. 2360$ User Action: 2361$ There may be a missing asterisk (<kw>(*)) in your declaration. 2362$ If not, remove the <kw>([unique]) attribute. 2363 2364254 [unique] pointers to context handles are not allowed 2365$ Explanation: 2366$ IDL does not allow <kw>([unique]) pointers to context handles. 2367$ User Action: 2368$ If the declaration has the <kw>([unique]) attribute, either 2369$ explicitly or by default, change it to a <kw>([ref]) pointer. 2370$ However, if the 2371$ declaration is an operation result, it cannot be a <kw>([ref]) 2372$ pointer and an operation resulting in a pointer to a 2373$ context handle is not valid. 2374 2375255 A [unique] function result is not valid 2376$ Explanation: 2377$ Unlike <kw>([out]) parameters, there is never any 2378$ preexisting storage in the caller for 2379$ pointer-valued function results. 2380$ The pointer always points to new storage. 2381$ This is the 2382$ capability provided only by full pointers, not by 2383$ <kw>([unique]) pointers. 2384$ User Action: 2385$ Remove the <kw>([unique]) attribute from the type definition 2386$ of the data type for the function result. 2387 2388256 Unknown attribute [%1$s] 2389$ Explanation: 2390$ The attribute specified is not a valid IDL attribute. 2391$ User Action: 2392$ Check for spelling errors or misplaced syntax. 2393 2394257 Obsolete feature encountered; Use translator 2395$ Explanation: 2396$ A feature of NCS Version 1 NIDL was encountered that is not supported in 2397$ the IDL compiler. You may be compiling an NCS Version 1 NIDL source file. 2398$ User Action: 2399$ If the input is a NCS Version 1 NIDL source file, process it with 2400$ the translator utility (the <kw>(nidl_to_idl) command) that 2401$ converts an NCS Version 1 NIDL source file into the format expected by 2402$ the IDL compiler. Then compile the translated source file. Otherwise, remove 2403$ the reference to the obsolete feature. 2404 2405258 The attribute [uuid] is invalid when the [local] attribute is specified 2406$ Explanation: 2407$ The <kw>([local]) interface attribute flags that an interface is not 2408$ for RPC use, but is only a local header generation 2409$ mechanism. The <kw>([uuid]) attribute is only used for 2410$ RPC interfaces. 2411$ User Action: 2412$ Remove one of the conflicting attributes. 2413 2414259 Variable declarations are not supported; declaration of %1$s ignored 2415$ Explanation: 2416$ IDL does not support the declaration of variables. The types 2417$ of data that can be declared in IDL are; constants, types, and 2418$ functions. The declaration of <v>(variable) is not a function 2419$ and is incorrect. 2420$ User Action: 2421$ If intended as a function declaration, 2422$ correct the declaration so the top-level declaration 2423$ is a function. Otherwise, remove the declaration. 2424 2425260 void is valid only in an operation or a context handle pointer declaration 2426$ Explanation: 2427$ The <kw>(void) keyword is only valid as the return value of an 2428$ operation, or as part of a <kw>(void *) declaration. Note also 2429$ that in RPC interfaces, <kw>(void *) is only valid if the 2430$ <kw>([context_handle]) attribute is also specified on the data item. 2431$ User Action: 2432$ There may be a missing <kw>(*) in your declaration. 2433$ If not, change the <kw>(void) reference to some valid data type. 2434 2435261 A type used in a [transmit_as] clause cannot have a [represent_as] type 2436$ Explanation: 2437$ The type used in a <kw>([transmit_as]) clause specifies an alternative 2438$ type that a base IDL type is translated to or from and before or after 2439$ transmission over the network. 2440$ The type used in a <kw>([represent_as]) clause is an 2441$ alternative type that a base IDL type is translated from or to at 2442$ the application code-to-stub code interface. 2443$ Going from base IDL type to transmittable type and then to 2444$ a <kw>([represent_as]) type (that may not be transmittable) is 2445$ invalid. 2446$ User Action: 2447$ You may have meant to put a <kw>([represent_as]) clause on the base IDL 2448$ type, not its transmittable type. 2449 2450262 A [transmit_as] or [represent_as] type cannot be a conformant array 2451$ Explanation: 2452$ A type specified in a <kw>([transmit_as]) clause or a type with 2453$ the <kw>([transmit_as]) or <kw>([represent_as]) attribute cannot be a 2454$ conformant array, since there is nowhere to attach the size 2455$ information attribute that is needed to transmit the data. 2456$ User Action: 2457$ Define a structure that contains a conformant array and 2458$ a size information field instead of using a conformant array 2459$ directly. 2460 2461263 The base type of a pipe cannot be a [transmit_as] type 2462$ Explanation: 2463$ IDL does not allow the base type of 2464$ a <kw>(pipe) to have the <kw>([transmit_as]) attribute. 2465$ User Action: 2466$ Declare the base type of the <kw>(pipe) to be the data type 2467$ in the <kw>([transmit_as]) clause. 2468 2469264 A translated transmittable type cannot contain [%1$s] pointers 2470$ Explanation: 2471$ A transmittable type that is derived by calling a translation 2472$ routine, for example, a <kw>(from_local) translation 2473$ of a <kw>([represent_as]) 2474$ type or a <kw>(to_xmit) translation of a <kw>([transmit_as]) type, 2475$ cannot contain pointers of the indicated type. 2476$ User Action: 2477$ Define a transmittable type that does not contain invalid pointers. 2478$ If using <kw>([represent_as]), reconsider using it. 2479 2480265 A type with [transmit_as] cannot have other type attributes 2481$ Explanation: 2482$ A data type with the <kw>([transmit_as]) attribute 2483$ (the presented type) has an 2484$ associated transmittable type, and you must write routines 2485$ to convert the presented type to or from the transmittable type. 2486$ Only the transmittable type is relevant to the RPC mechanism, 2487$ thus it is incorrect for the presented type 2488$ to have additional RPC-specific attributes. 2489$ User Action: 2490$ Remove any type attributes other than <kw>([transmit_as]). 2491 2492266 Command option -bug %1$lu conflicts with -no_bug %2$lu 2493$ Explanation: 2494$ The command line options conflict with each other. 2495$ User Action: 2496$ Remove one of the conflicting options. 2497 2498267 Unterminated comment, end-of-file encountered 2499$ Explanation: 2500$ During the processing of a multiline comment, 2501$ the end of the source 2502$ file was reached before the termination characters for 2503$ the comment. 2504$ User Action: 2505$ Make sure that all multiline comments are correctly terminated. 2506 2507268 Compilation aborted 2508$ Explanation: 2509$ Previous errors caused the compilation to abort. 2510$ User Action: 2511$ Correct the errors and recompile. 2512 2513269 Internal IDL compiler error: Module %1$s, Line %2$lu 2514$ Explanation: 2515$ An internal IDL compiler error was found. 2516$ User Action: 2517$ Submit a Software Performance Report and notify 2518$ your software support representative so the appropriate 2519$ action can be taken. 2520 2521270 Command option -bug %1$lu is not known 2522$ Explanation: 2523$ The documentation defines all the valid integers that can 2524$ accompany the <kw>(-bug) and <kw>(-no_bug) options. You have chosen 2525$ an invalid value. 2526$ User Action: 2527$ See the documentation for the correct number. 2528 2529271 Command option -no_bug %1$lu is not known 2530$ Explanation: 2531$ The documentation defines all the valid integers that can 2532$ accompany the <kw>(-bug) and <kw>(-no_bug) options. You have chosen 2533$ an invalid value. 2534$ User Action: 2535$ See the documentation for the correct number. 2536 2537272 Reached maximum of %1$lu warnings; exiting 2538$ Explanation: 2539$ The IDL compiler has a predefined maximum number of warnings 2540$ it produces before aborting the compilation. This feature 2541$ suppresses what may be the same warning 2542$ over and over. 2543$ User Action: 2544$ Fix the warnings you get, or recompile the IDL file or 2545$ specify the <kw>(-no_warn) option. 2546 2547273 Command option %1$s does not take a value 2548$ Explanation: 2549$ You specified a value with a command line option that 2550$ does not take a value. 2551$ User Action: 2552$ If the value is meant to be the source file, it must 2553$ be separated from the command option with a space. 2554 2555274 Out of memory 2556$ Explanation: 2557$ The system-defined limit of memory available to the compiler was exceeded. 2558$ User Action: 2559$ Either have the system-defined limit of memory raised, or 2560$ simplify the source file being compiled by breaking it into multiple modules or 2561$ eliminating unnecessary imports. 2562 2563275 Length of source filename and stub suffix exceed 8 chars 2564 2565276 A source IDL filename is required 2566$ Explanation: 2567$ The command line does not contain a source IDL file to compile. 2568$ User Action: 2569$ You must specify a source IDL file. You may have erroneously 2570$ specified the source IDL file when 2571$ actually you gave a value to a command option. 2572 2573277 Unknown command line option: %1$s 2574$ Explanation: 2575$ You entered an invalid command line option. 2576$ User Action: 2577$ Check the command line for typographical errors. 2578$ See the documentation for proper command line syntax. 2579 2580278 Warning: Use of a nonencapsulated union requires %1$s 2581$ Explanation: 2582$ A nonencapsulated union is not portable to all implementations of DCE V1.0. 2583$ User Action: 2584$ Use an encapsulated union instead or specify the extended standard 2585$ option on the compiler command. 2586 2587279 Warning: Use of [unique] pointers requires %1$s 2588$ Explanation: 2589$ A <kw>([unique]) pointer is not portable to all implementations of DCE V1.0. 2590$ User Action: 2591$ Use a <kw>([ref]) or <kw>([ptr]) pointer instead or specify the extended standard 2592$ option on the compiler command. 2593 2594280 An [in] or [in,out] union must have an [in] discriminator 2595$ Explanation: 2596$ A nonencapsulated union parameter that has the <kw>([in]) 2597$ attribute must have a discriminator, specified in a 2598$ <kw>([switch_is]) clause, that also has the <kw>([in]) 2599$ attribute, since the client stub code must know which member 2600$ of the union to send to the server. 2601$ User Action: 2602$ Modify the parameter referenced in the <kw>([switch_is]) clause 2603$ to have the <kw>([in]) attribute. 2604 2605281 An [in,out] or [out] union must have an [out] discriminator 2606$ Explanation: 2607$ A nonencapsulated union parameter that has the <kw>([out]) 2608$ attribute must have a discriminator, specified in a 2609$ <kw>([switch_is]) clause, that also has the <kw>([out]) 2610$ attribute, since the server stub code must know which member 2611$ of the union to send to the client. 2612$ User Action: 2613$ Modify the parameter referenced in the <kw>([switch_is]) clause 2614$ to have the <kw>([out]) attribute. 2615 2616282 A [switch_is] variable must not have a [represent_as] type 2617$ Explanation: 2618$ The parameter or field referenced in a <kw>([switch_is]) clause 2619$ must not be of a data type that has been declared to have a 2620$ <kw>([represent_as]) type. 2621$ User Action: 2622$ Change the referenced parameter or field data type, 2623$ or the data type definition itself. 2624 2625283 A [switch_is] variable must not have a [transmit_as] type 2626$ Explanation: 2627$ The parameter or field referenced in a <kw>([switch_is]) clause 2628$ must not be of a data type that has been declared to have a 2629$ <kw>([transmit_as]) type. 2630$ User Action: 2631$ Change the referenced parameter or field data type, 2632$ or the data type definition itself. 2633 2634284 An encapsulated union member cannot have the [%1$s] attribute 2635$ Explanation: 2636$ The attribute used is valid only on nonencapsulated unions, 2637$ but was used on an encapsulated union. 2638$ User Action: 2639$ Remove the attribute. Consult the documentation for the 2640$ differences between encapsulated and nonencapsulated unions. 2641 2642285 Arrays of nonencapsulated unions are not allowed 2643$ Explanation: 2644$ IDL does not allow arrays of nonencapsulated unions since there 2645$ is no way to apply a different discriminator to each element. 2646$ User Action: 2647$ Use an array of encapsulated unions. 2648 2649286 A [represent_as] type cannot be a nonencapsulated union 2650$ Explanation: 2651$ A type referenced in a <kw>([represent_as]) clause cannot be a 2652$ nonencapsulated union, since there is no defined way to 2653$ communicate the union discriminator to/from <kw>([represent_as]) 2654$ data translation routines. 2655$ User Action: 2656$ Use an encapsulated union for the local representation type. 2657 2658287 A nonencapsulated union cannot have a [represent_as] type 2659$ Explanation: 2660$ A nonencapsulated union type cannot be defined to have a 2661$ local representation type, since there is no defined way to 2662$ communicate the union discriminator to/from <kw>([represent_as]) 2663$ data translation routines. 2664$ User Action: 2665$ Use an encapsulated union, or reconsider the need for a 2666$ different local representation type for the union. 2667 2668288 A nonencapsulated union declaration must have a [switch_is] attribute 2669$ Explanation: 2670$ A <kw>([switch_is]) attribute is required on an instance of a 2671$ nonencapsulated union type to identify the union discriminator 2672$ variable. 2673$ User Action: 2674$ Provide a <kw>([switch_is]) clause that specifies a field or 2675$ parameter that is the union discriminator, or use an 2676$ encapsulated union, where the union discriminator variable is 2677$ encapsulated as a field within the union type. 2678 2679289 The union switch variable %1$s cannot be a [ptr] or [unique] pointer 2680$ Explanation: 2681$ A <kw>([switch_is]) attribute clause in the source IDL specifies 2682$ its value by dereferencing a pointer field or parameter. 2683$ This is invalid if the pointer variable has either of the 2684$ <kw>([ptr]) or <kw>([unique]) attributes, since both allow the 2685$ pointer to be <kw>(NULL). If the pointer were <kw>(NULL), there 2686$ would be no way to determine the union discriminator. 2687$ User Action: 2688$ Either redeclare the <kw>([switch_is]) variable to be a scalar 2689$ rather than a pointer, or change the <kw>([switch_is]) variable 2690$ to be a <kw>([ref]) pointer. 2691 2692290 A nonencapsulated union type must have a [switch_type] attribute 2693$ Explanation: 2694$ A <kw>([switch_type]) attribute is required on a definition of a 2695$ nonencapsulated union type to identify the data type of the 2696$ union discriminator. 2697$ User Action: 2698$ Provide a <kw>([switch_type]) clause that specifies a valid 2699$ union discriminator data type. 2700 2701291 A [transmit_as] type cannot be a nonencapsulated union 2702$ Explanation: 2703$ A type referenced in a <kw>([transmit_as]) clause cannot be a 2704$ nonencapsulated union, since there is no defined way to 2705$ communicate the union discriminator to/from <kw>([transmit_as]) 2706$ data translation routines. 2707$ User Action: 2708$ Use an encapsulated union for the transmissible type. 2709 2710292 A nonencapsulated union cannot have a [transmit_as] type 2711$ Explanation: 2712$ A nonencapsulated union type cannot be defined to have a 2713$ transmissible type, since there is no defined way to 2714$ communicate the union discriminator to/from <kw>([transmit_as]) 2715$ data translation routines. 2716$ User Action: 2717$ Use an encapsulated union, or reconsider the need for a 2718$ different transmissible type for the union. 2719 2720293 Cannot have more than one level of indirection to a nonencapsulated union 2721$ Explanation: 2722$ IDL allows only a single level of pointer to a nonencapsulated 2723$ union type. 2724$ User Action: 2725$ Remove the extra levels of indirection, or use an encapsulated 2726$ union type instead. 2727 2728294 A [switch_is] attribute is only valid on a nonencapsulated union 2729$ Explanation: 2730$ A <kw>([switch_is]) attribute is used on a union type to 2731$ identify the union discriminator variable. It is not valid 2732$ on a non-union type. It is also not valid on an encapsulated 2733$ union type, where the union discriminator variable is 2734$ encapsulated as a field within the union type. 2735$ User Action: 2736$ Use the <kw>([switch_is]) attribute only on instances of 2737$ nonencapsulated union types. 2738 2739295 Data type of [switch_is] variable %1$s does not agree with [switch_type] %2$s 2740$ Explanation: 2741$ The data type of the variable referenced in the <kw>([switch_is]) 2742$ clause must be the same as the data type referenced in the 2743$ <kw>([switch_type]) clause of the item's type definition. 2744$ User Action: 2745$ Make sure that all instances of a type that has the 2746$ <kw>([switch_type]) attribute have a <kw>([switch_is]) clause 2747$ whose data type agrees with the <kw>([switch_type]). 2748 2749296 A [switch_type] attribute is only valid on a nonencapsulated union type 2750$ Explanation: 2751$ A <kw>([switch_type]) attribute is used on a union type to 2752$ identify the union discriminator type. It is not valid 2753$ on a non-union type. It is also not valid on an encapsulated 2754$ union type, where the union discriminator type and variable 2755$ must be specified in a <kw>(switch) clause. 2756$ User Action: 2757$ Use the <kw>([switch_type]) attribute only on definitions of 2758$ nonencapsulated union types. 2759 2760297 Data type of %1$s must be a named TPS_STDL_ type 2761 2762298 A structure field cannot be of a presented type for which the transmitted type is conformant 2763$ Explanation: 2764$ IDL does not allow a structure field whose type has a 2765$ <kw>([transmit_as]) attribute where the transmissible type 2766$ is conformant. 2767$ User Action: 2768$ Use a valid IDL construct. 2769 2770299 A type with the [represent_as] attribute cannot be conformant 2771$ Explanation: 2772$ IDL does not allow a conformant network type to have a local 2773$ represented type. 2774$ User Action: 2775$ Use a valid IDL construct. 2776 2777300 An arm of a union cannot be or contain a [unique] pointer 2778$ Explanation: 2779$ IDL-generated server stub code must allocate storage for 2780$ objects pointed to by <kw>([unique]) pointers. IDL does not allow 2781$ a <kw>([unique]) pointer within a <kw>(union) because the valid 2782$ arm of the <kw>(union), and therefore the 2783$ object for which storage is allocated, is not 2784$ known at compile time. 2785$ User Action: 2786$ Change the pointer within the <kw>(union) declaration to a full pointer. 2787 2788301 Warning: FORTRAN INTEGER*%1$lu used for IDL pointer type 2789$ Explanation: 2790$ FORTRAN does not have a generic explicit pointer type. IDL maps pointer 2791$ references to INTEGER*<v>(n) in the generated FORTRAN header file. 2792$ User Action: 2793$ It is up to the FORTRAN application code to correctly manage 2794$ the generated INTEGER*<v>(n) object as a pointer. 2795 2796302 Warning: FORTRAN INTEGER*4 used for IDL unsigned long 2797$ Explanation: 2798$ FORTRAN does not support unsigned integers. IDL maps unsigned 2799$ long to INTEGER*4 in the generated FORTRAN header file. 2800$ User Action: 2801$ If the application needs to store large unsigned integer values 2802$ special care might be necessary in the FORTRAN application code. 2803 2804303 Warning: Conformant structures not supported in target language 2805$ Explanation: 2806$ An IDL conformant structure does not have a source 2807$ representation in the target language selected. 2808$ User Action: 2809$ The IDL conformant array will be declared as a one-element array 2810$ in the generated language header file. Your application code 2811$ might be able to use the address of this array to access other 2812$ array elements, depending on the target language. 2813$ Alternatives are to write application code that uses the 2814$ construct in another programming language, or to change the IDL 2815$ source to use a construct that is supported by the target 2816$ language. 2817 2818304 Warning: Conformant strings not supported in target language 2819$ Explanation: 2820$ An IDL conformant string does not have a source 2821$ representation in the target language selected. 2822$ User Action: 2823$ The IDL conformant array will be declared as a one-element array 2824$ in the generated language header file. Your application code 2825$ might be able to use the address of this array to access other 2826$ array elements, depending on the target language. 2827$ Alternatives are to write application code that uses the 2828$ construct in another programming language, or to change the IDL 2829$ source to use a construct that is supported by the target 2830$ language. 2831 2832305 Warning: Character doesn't map to target language 2833$ Explanation: 2834$ A character in an IDL character or string constant does not 2835$ have a source representation in the target language selected. 2836$ User Action: 2837$ The character will be translated to a '?' in the generated 2838$ language header file. Edit the file manually as necessary. 2839 2840306 Warning: Pipes not supported for target language 2841$ Explanation: 2842$ The data structures necessary to manage IDL pipes do not 2843$ have a source representation in the target language selected. 2844$ User Action: 2845$ Pipe objects will have no corresponding definition in the 2846$ generated language header file. Application code for operations 2847$ with pipes should be written in another programming language. 2848 2849307 Warning: Non-scalar function result converted to trailing [out] parameter 2850$ Explanation: 2851$ The target language selected does not allow the function result 2852$ argument of a routine to be a non-scalar type. The IDL compiler 2853$ converts such a construct to a trailing <kw>([out]) parameter. 2854$ User Action: 2855$ No action is required. You might want to edit your IDL source 2856$ and change the declaration from a function result to an <kw>([out]) 2857$ parameter in order to map naturally to the target language. 2858 2859308 Target language supports maximum of %1$lu array dimensions 2860$ Explanation: 2861$ The target language selected does not support arrays with more 2862$ than the indicated number of dimensions. 2863$ User Action: 2864$ Such arrays will have no corresponding declaration in the 2865$ generated language header file. Application code using such 2866$ arrays should be written in another programming language. 2867 2868309 Warning: Name %1$s differs from a previous name only in case 2869$ Explanation: 2870$ The target language selected is not case-sensitive with respect 2871$ to identifiers; that is, any two identifiers that differ only in 2872$ case are considered to be identical. The IDL source contains 2873$ two distinct identifiers that differ only in case, but they 2874$ conflict with eachother in the generated language header file. 2875$ User Action: 2876$ Edit the IDL source code to remove the conflict. 2877 2878310 Warning: Attribute [%1$s] not supported for target language 2879$ Explanation: 2880$ IDL does not support the indicated attribute for the 2881$ target language selected. 2882$ User Action: 2883$ In some cases the attribute can be removed. For example, 2884$ the <kw>(v1_) attributes are only necessary if interoperation 2885$ with NCS Version 1 is required. 2886 2887311 Array function results are not allowed 2888$ Explanation: 2889$ Because array function results are not supported in the C 2890$ languages, they are not allowed in IDL. 2891$ User Action: 2892$ Return the required array as an <v>([out]) parameter. 2893 2894312 Attribute [%1$s] cannot be applied to a void * type 2895$ Explanation: 2896$ The indicated attribute is not valid on a <kw>(void *) type. 2897$ The only attribute that is meaningful on a <kw>(void *) type 2898$ is <v>([context_handle]). 2899$ User Action: 2900$ Edit the IDL source code to remove the conflict. 2901 2902313 The [handle] attribute is valid only on transmittable types 2903$ Explanation: 2904$ The <v>([handle]) attribute was used on a type that is not 2905$ transmittable, such as <v>(handle_t). Types with <v>([handle]) 2906$ are sent from client to server and must have a concrete 2907$ definition so that they are transmittable. 2908$ User Action: 2909$ Remove the <v>([handle]) attribute or change the base type to 2910$ which it is applied. 2911 2912314 Warning: Forward tag reference %1$s in this declaration is not ANSI C compliant 2913$ Explanation: 2914$ A tag reference, such as <kw>(struct tagname), was used before 2915$ the actual definition of the tag. Such references are not 2916$ ANSI C compliant when used in certain scopes, such as in a 2917$ parameter declaration. Thus the C source modules generated by 2918$ the IDL compiler might not compile successfuly. 2919$ User Action: 2920$ Define the type that is referenced by tag name before 2921$ referencing it in a parameter declaration. 2922 2923315 Attribute cannot be used more than once 2924$ Explanation: 2925$ An attribute is repeated multiple times in an attribute list. 2926$ User Action: 2927$ Remove all but one occurrence of the offending attribute. 2928 2929316 Type with [%1$s] cannot be used in definition of type with [%2$s] 2930$ Explanation: 2931$ IDL restricts the use of the two attributes such that the base 2932$ type of a type that has the first attribute must not contain 2933$ the second attribute in its definition. 2934$ User Action: 2935$ Refer to the IDL documentation on the two attributes for more 2936$ information. 2937 2938317 Warning: Use of nonzero array lower bound requires %1$s 2939$ Explanation: 2940$ A nonzero array lower bound is not portable to all 2941$ implementations of DCE V1.0. 2942$ User Action: 2943$ Use an array with lower bound zero instead or specify the 2944$ extended standard option on the compiler command. 2945 2946318 Creating template file %1$s 2947 2948319 Warning: Use of conformant minor array dimension requires %1$s 2949$ Explanation: 2950$ An array that is conformant in a minor dimension, i.e. other than 2951$ the first dimension, is not portable to all 2952$ implementations of DCE V1.0. 2953$ User Action: 2954$ Use an array that is conformant in only the first dimension, 2955$ or specify the extended standard option on the compiler command. 2956 2957320 Warning: Use of varying minor array dimension requires %1$s 2958$ Explanation: 2959$ An array that is varying in a minor dimension, i.e. other than 2960$ the first dimension, is not portable to all 2961$ implementations of DCE V1.0. 2962$ User Action: 2963$ Use an array that is varying in only the first dimension, 2964$ or specify the extended standard option on the compiler command. 2965 2966321 Translation routines for [represent_as] type %1$s 2967 2968322 Translation routines for [transmit_as] type %1$s 2969 2970323 Customized binding routines for [handle] type %1$s 2971 2972324 Rundown routine for [context_handle] type %1$s 2973 2974325 Support routines for interface %1$s 2975 2976326 Support routines and Remote Procedure Implementations for interface %1$s 2977 2978327 Implementation of Remote Procedures for %1$s 2979 2980328 Operation with [encode] must have at least one [in] or [in,out] parameter 2981$ Explanation: 2982$ The client stub for an operation with the <kw>([encode]) ACF 2983$ attribute encodes the operation's <kw>([in]) and <kw>([in,out]) 2984$ parameters into a data stream. The <kw>([encode]) attribute 2985$ is not meaningful on an operation with only <kw>([out]) 2986$ parameters (excluding the binding handle parameter). 2987$ User Action: 2988$ Perhaps you meant to use the <kw>([decode]) attribute on the 2989$ operation. If not, either remove the <kw>([encode]) attribute 2990$ or add the <kw>([in]) attribute to one or more parameters. 2991 2992329 Operation with [decode] must have at least one [out] or [in,out] parameter 2993$ Explanation: 2994$ The client stub for an operation with the <kw>([decode]) ACF 2995$ attribute decodes a data stream into the operation's <kw>([out]) 2996$ and <kw>([in,out]) parameters. The <kw>([decode]) attribute 2997$ is not meaningful on an operation with only <kw>([in]) 2998$ parameters. 2999$ User Action: 3000$ Perhaps you meant to use the <kw>([encode]) attribute on the 3001$ operation. If not, either remove the <kw>([decode]) attribute 3002$ or add the <kw>([out]) attribute to one or more parameters. 3003 3004330 Warning: Operation with [reflect_deletions] has no [in] or [in,out] full pointers 3005$ Explanation: 3006$ Reflection of node deletions from server to client is only 3007$ applicable to operations that have <kw>([in]) or <kw>([in,out]) 3008$ full (<kw>([ptr])) pointers. The <kw>([reflect_deletions]) 3009$ attribute thus has no effect on the indicated operation. 3010$ User Action: 3011$ Remove the <kw>([reflect_deletions]) attribute from the 3012$ operation to avoid this warning message. 3013 3014331 Warning: Operation with [encode] has [out]-only parameter %1$s 3015$ Explanation: 3016$ The client stub for an operation with the <kw>([encode]) 3017$ attribute encodes all of the operation parameters with the 3018$ <kw>([in]) attribute. Parameters with only the <kw>([out]) 3019$ attribute are ignored. 3020$ User Action: 3021$ If any client will decode the encoded information by 3022$ applying the <kw>([decode]) attribute to the operation, the 3023$ operation must contain all <kw>([in,out]) parameters except for 3024$ the binding handle parameter. 3025 3026332 Warning: Operation with [decode] has [in]-only parameter %1$s 3027$ Explanation: 3028$ The client stub for an operation with the <kw>([decode]) 3029$ attribute decodes encoded data into operation parameters with the 3030$ <kw>([out]) attribute. Parameters with only the <kw>([in]) 3031$ attribute are ignored. 3032$ User Action: 3033$ If any client will encode the data by 3034$ applying the <kw>([encode]) attribute to the operation, the 3035$ operation must contain all <kw>([in,out]) parameters except for 3036$ the binding handle parameter. 3037 3038333 Operation with [encode,decode] must have all [in,out] parameters 3039$ Explanation: 3040$ The client stub for an operation with the <kw>([encode,decode]) 3041$ attributes can encode the operation's parameters into a data 3042$ stream and subsequently decode the data back into parameters. 3043$ This only makes sense if the decoded data, i.e. the <kw>([out] 3044$ parameters, agrees with the originally encoded <kw>([in]) 3045$ parameters. 3046$ User Action: 3047$ The operation must contain all <kw>([in,out]) parameters except 3048$ for the binding handle parameter. 3049 3050334 Operation with [encode] or [decode] may not contain pipe parameters 3051$ Explanation: 3052$ The IDL encoding services do not support pipes. 3053$ User Action: 3054$ Use arrays to represent the data, or utilize multiple 3055$ procedure calls to encode or decode the data. 3056 3057335 Operation with [encode] or [decode] must use explicit binding 3058$ Explanation: 3059$ An operation with either of the <kw>([encode]) or <kw>([decode]) 3060$ attributes may not use automatic, customized, or implicit 3061$ binding. 3062$ User Action: 3063$ Edit the IDL operation definition to have an item of type 3064$ <v>(handle_t) as its first argument, or edit the ACF operation 3065$ declaration to include the <kw>([explicit_handle]) attribute. 3066 3067336 Exception name %1$s referenced in ACF is not defined 3068$ Explanation: 3069$ An exception name is referenced in an Attribute Configuration 3070$ File (ACF) but is not defined in the corresponding IDL file. 3071$ Exceptions are not imported, so in order to reference an 3072$ exception name in the ACF for a particular interface it must 3073$ be defined in the IDL file for that same interface. 3074$ User Action: 3075$ Check for typographical errors in both the IDL and ACF files. 3076$ If necessary, add the exception name to the source IDL file 3077$ using the [exceptions] interface attribute, or move the ACF 3078$ reference to the ACF file corresponding to the interface in which 3079$ the exception name is defined. 3080 3081337 Invalid file specification: %1$s 3082$ Explanation: 3083$ An invalid file specification was given. 3084$ User Action: 3085$ Check the files names specified on the command line for 3086$ proper syntax. 3087 3088338 File specification required for %1$s 3089$ Explanation: 3090$ The indicated IDL command option requires a file specification. 3091$ User Action: 3092$ Supply a file specification following the option. 3093 3094339 Warning: Operation with [cs_tag_rtn] contains no codeset tag parameters 3095$ Explanation: 3096$ The <kw>([cs_tag_rtn]) attribute normally appears on an 3097$ operation only if it has least one parameter with a 3098$ <kw>([cs_stag]), <kw>([cs_drtag]), or <kw>([cs_rtag]) attribute. 3099$ User Action: 3100$ Make sure the ACF declaration for the operation has one or more 3101$ of the above tags applied to parameter(s) in the operation. 3102 3103340 Types with the [%1$s] attribute cannot be nested 3104$ Explanation: 3105$ A type with the indicated attribute cannot include 3106$ another type with the same attribute. 3107$ User Action: 3108$ Do not nest types with the attribute. 3109 3110341 The [%1$s] attribute cannot be duplicated in the same parameter list 3111$ Explanation: 3112$ The named attribute cannot be applied twice in the same 3113$ parameter list. 3114$ User Action: 3115$ Make sure that only one parameter in the operation's parameter 3116$ list has the attribute applied to it. The attribute is 3117$ specified either in the source IDL or source ACF file. 3118 3119342 Operation with [in] [cs_char] data requires [cs_stag] parameter 3120$ Explanation: 3121$ If any <kw>([in]) parameter, or part of an <kw>([in]) parameter, 3122$ has a <kw>([cs_char]) type, there must be a parameter in the 3123$ same operation to which <kw>([cs_stag]) is applied. 3124$ User Action: 3125$ Make sure the ACF declaration for the operation has the 3126$ <kw>([cs_stag]) attribute applied to one of the parameters in 3127$ the operation. 3128 3129343 Operation with [out] [cs_char] data requires [cs_rtag] parameter 3130$ Explanation: 3131$ If any <kw>([out]) parameter, or part of an <kw>([out]) parameter, 3132$ has a <kw>([cs_char]) type, there must be a parameter in the 3133$ same operation to which <kw>([cs_rtag]) is applied. 3134$ User Action: 3135$ Make sure the ACF declaration for the operation has the 3136$ <kw>([cs_rtag]) attribute applied to one of the parameters in 3137$ the operation. 3138 3139344 Array attribute variable cannot be used for both [cs_char] and non-[cs_char] arrays 3140$ Explanation: 3141$ In a structure or parameter list, any variable which specifies 3142$ the <kw>([size_is]) or <kw>([length_is]) for a <kw>([cs_char]) 3143$ array must not be referenced in any attribute of a 3144$ non-<kw>([cs_char]) array. 3145$ User Action: 3146$ Use separate structure fields or operation parameters to 3147$ specify array attributes for the non-<kw>([cs_char]) array. 3148 3149345 An [in,size_is] parameter for an [out,cs_char] array cannot be used for other array attributes 3150 3151346 A [size_is] or [max_is] attribute cannot be applied to a pointer to a [cs_char] type 3152$ Explanation: 3153$ The <kw>([cs_char]) ACF attribute cannot be applied to a type 3154$ which is the target of a pointer with the <kw>([size_is]) or 3155$ <kw>([max_is]) attribute. 3156$ User Action: 3157$ Use an array of <kw>([cs_char]) instead of pointer to array 3158$ of <kw>([cs_char]), or use a pointer to a structure which 3159$ contains a conformant array of <kw>([cs_char]). 3160 3161347 An array with [%1$s] base type cannot have the [ptr] or [unique] attributes 3162$ Explanation: 3163$ If an array parameter has a base type with the indicated 3164$ attribute, it cannot have <kw>([ptr]) or <kw>([unique]) as 3165$ parameter attributes. 3166$ User Action: 3167$ Remove the <kw>([ptr]) or <kw>([unique]) attribute. This 3168$ implies that the parameter cannot have the value NULL, i.e. 3169$ it must always point to valid array storage. 3170 3171348 A [transmit_as] transmitted type cannot contain a [%1$s] type 3172$ Explanation: 3173$ The indicated attribute cannot be applied to any type 3174$ which is used as the transmitted type used in a 3175$ <kw>([transmit_as]) attribute or any type which is 3176$ used in the definition of the transmitted type used in a 3177$ <kw>([transmit_as]) attribute. 3178$ User Action: 3179$ Do not use the attribute on the transmitted type specified in the 3180$ <v>([transmit_as(transmitted_type)]) attribute or any other type 3181$ that is contained within that transmitted type. 3182 3183349 A [cs_stag] parameter must precede any [in] [cs_char] data in a parameter list 3184$ Explanation: 3185$ A <kw>([cs_stag]) parameter must occur in an operation's 3186$ parameter list before any [in] parameters containing types 3187$ with the [cs_char] ACF attribute. 3188$ User Action: 3189$ Re-order the parameters to meet this requirement. 3190 3191350 A [cs_rtag] parameter must precede any [out] [cs_char] data in a parameter list 3192$ Explanation: 3193$ A <kw>([cs_rtag]) parameter must occur in an operation's 3194$ parameter list before any [out] parameters containing types 3195$ with the [cs_char] ACF attribute. 3196$ User Action: 3197$ Re-order the parameters to meet this requirement. 3198 3199351 A [handle] binding parameter cannot contain a [%1$s] type 3200$ Explanation: 3201$ A customized binding handle (a type with the <kw>([handle]) 3202$ attribute used as the first parameter in an operation) cannot 3203$ include types with the indicated attribute. 3204$ User Action: 3205$ Do not use the indicated attribute with customized binding. 3206 3207352 The base type of a pipe cannot be or contain a [%1$s] type 3208$ Explanation: 3209$ The indicated attribute cannot be applied to the base type of a 3210$ pipe, or a type used in constructing the base type of a pipe. 3211$ User Action: 3212$ Do not use the indicated attribute with pipes. 3213 3214353 Arrays of [%1$s] type cannot be multidimensional 3215$ Explanation: 3216$ The indicated attribute cannot be applied to a type if there 3217$ is an array which has this type as base type and the array has 3218$ more than one dimension. 3219$ User Action: 3220$ Specify a different base type for the array which has more than 3221$ one dimension. 3222 3223354 Arrays of [%1$s] type can only use the [size_is] and [length_is] array attributes 3224$ Explanation: 3225$ The indicated attribute cannot be applied to a type if there 3226$ is an array which has this type as base type and any of the 3227$ attributes <kw>([min_is]), <kw>([max_is]), <kw>([first_is]), 3228$ <kw>([last_is]), or <kw>([string]) has been applied to the array. 3229$ User Action: 3230$ Use only the <kw>([size_is]) and/or <kw>([length_is]) 3231$ attributes in relevant array declarations, or 3232$ specify a different base type for the array that has 3233$ the indicated attribute. 3234 3235355 Type with [%1$s] cannot be or contain type with [%2$s] 3236$ Explanation: 3237$ A type with the first attribute cannot also have the second 3238$ attribute, nor can it contain any type which has the second 3239$ attribute. 3240$ User Action: 3241$ The two features cannot interact on a single type. 3242$ Consider alternate ways to achieve the desired result. 3243 3244356 Type with [%1$s] must resolve to byte or structure containing only byte fields 3245$ Explanation: 3246$ A type with the indicated attribute must be defined as an IDL 3247$ type that resolves to byte or to a structure type in which all 3248$ of the fields have types which resolve to byte. 3249$ User Action: 3250$ Change the type definition, or remove the attribute if it is 3251$ not needed. 3252 3253357 Tag parameters must have type unsigned long int passed by value or reference 3254$ Explanation: 3255$ Parameters to which tag attributes (<kw>([cs_stag]), 3256$ <kw>([cs_drtag]), or <kw>([cs_rtag])) are attached must be 3257$ either <v>(unsigned long) integer values or <v>(unsigned long) 3258$ integers passed by reference. 3259$ User Action: 3260$ Change the parameter types as required. 3261 3262358 Maximum identifier length for [%1$s] type is %2$lu characters 3263$ Explanation: 3264$ A type name with the indicated attribute is used to construct 3265$ other names with a prefix and/or suffix concatenated to it. 3266$ This further restricts the length of the name to the indicated 3267$ value, to make sure that the maximum identifier length is not 3268$ exceeded in the generated names. 3269$ User Action: 3270$ Shorten the type name. 3271 3272359 Warning: Use of user-defined exceptions requires %1$s 3273$ Explanation: 3274$ Use of user-defined exceptions is not interoperable with 3275$ implementations of DCE V1.0. 3276$ User Action: 3277$ Do not use the feature if interoperability with DCE V1.0 3278$ is required. Otherwise, specify the extended standard option 3279$ on the compiler command to suppress the warning. 3280 3281360 Warning: Use of [%1$s] attribute requires %2$s 3282$ Explanation: 3283$ The indicated attribute is not supported by DCE V1.0, and 3284$ thus should not be used if interoperability with 3285$ implementations of DCE V1.0 is required. 3286$ User Action: 3287$ Do not use the feature if interoperability with DCE V1.0 3288$ is required. Otherwise, specify the extended standard option 3289$ on the compiler command to suppress the warning. 3290 3291361 A [%1$s] parameter must have the [%2$s] attribute 3292$ Explanation: 3293$ A parameter with the first attribute must also have the 3294$ second attribute. 3295$ User Action: 3296$ Add the second attribute to the parameter declaration. 3297 3298362 Warning: Use of C preprocessor directive requires %1$s 3299$ Explanation: 3300$ The IDL compiler detected a C preprocessor directive in a 3301$ source IDL or ACF file. C preprocessor directives begin in 3302$ the first column of a source line and start with the '#' 3303$ character. Either you have specified an IDL command option to 3304$ disable C preprocessing, or IDL does not invoke the C 3305$ preprocessor by default on the platform on which you are running. 3306$ User Action: 3307$ Add the indicated command option to your <kw>(idl) command 3308$ so that the IDL compiler will invoke the C preprocesor 3309$ to preprocess source IDL and ACF files before they are parsed. 3310 3311363 Warning: Use of anonymous %1$s may not be portable across C compilers 3312$ Explanation: 3313$ The source IDL contains an IDL language construct, such as an 3314$ <kw>(enum), declared as an unnamed type within another 3315$ definition. The generated stub code will compile cleanly under 3316$ some C compilers, but generate errors from others. The potential 3317$ errors are due to differences in the scoping of identifiers 3318$ across C compilers. 3319$ User Action: 3320$ Use a <kw>(typedef) statement to define the base <kw>(type) 3321$ as a named type, then use the type name in any subsequent 3322$ declarations in place of an anonymous definition. 3323 3324364 Warning: A [fault_status] parameter has no utility in this operation 3325$ Explanation: 3326$ A <kw>([fault_status]) parameter is used in an operation where no 3327$ fault can ever occur. An example is an encoding services 3328$ operation, i.e. one using <kw>([encode]) or <kw>([decode]) - 3329$ there is no remote entity from which a fault might be received. 3330$ User Action: 3331$ Perhaps you meant to use a <kw>([comm_status]) attribute. 3332$ If not, the parameter can be removed from the operation or 3333$ the <kw>([fault_status]) attribute can be removed from the 3334$ parameter. 3335 3336365 Only objects can inherit interfaces 3337 3338366 Interface ref not allowed 3339 3340367 Warning: Pointer attributes are ignored for interface references 3341 3342368 Inherited interface '%1$s' not defined/imported 3343 3344369 Expression must be constant 3345 3346370 exp is null?? 3347 3348371 Only simple expressions allowed for now 3349 3350372 The upper bound of a [range] attribute must be greater than the lower bound 3351 3352373 A [range] attribute is only valid on integral types other than hyper, a type identifier to an integral type, an enumerated type, or a pipe type name 3353 3354374 A constant [size_is] or [length_is] requires a constant [min_is] or [first_is] 3355 3356375 Correlation checking will not be performed for attributes that occur after the field or parameter they modify 3357