cobWrapper Boilerplates

Boilerplate	Content
cobWrapper_commArea_erxcomm-usage	For usage, refer to the following sections: Copybook `ERXCOMM` under The RPC Communication Area (Reference) Step 1: Declare and Initialize the RPC Communication Area in document Writing Standard Call Interface Clients
cobWrapper_commArea_erxvstr-generated	The RPC communication area extension copybook `ERXVSTR` is generated for Target Operating System z/OS and RPC clients using a call interface to its client interface object, meaning one of the following Client Interface Types is selected: CICS with Standard Linkage Calling Convention Batch with Standard Linkage Calling Convention IMS BMP with Standard Linkage Calling Convention IMS MPP with Standard Linkage Calling Convention
cobWrapper_commArea_erxvstr-usage	For usage, refer to the following sections: Using Broker Logon and Logoff Using RPC Authentication (Natural Security, Impersonation, Integration Server) Copybook `ERXVSTR` under The RPC Communication Area (Reference) Step 1: Declare and Initialize the RPC Communication Area in document Writing Standard Call Interface Clients
cobWrapper_using-client_batch_desc	In this scenario, every generated client interface object, the generic RPC services module and the broker stub are linked together or called dynamically by the COBOL client program. For platform z/OS this scenario supports the following: Long broker passwords. See Using Broker Logon and Logoff. Long RPC user IDs/passwords. See Using RPC Authentication (Natural Security, Impersonation, Integration Server). IDL unbounded groups or arrays without maximum mapped to COBOL's `OCCURS 1 TO UNBOUNDED DEPENDING ON`.
cobWrapper_using-client_batch_to_1	Generate the client interface object(s) for the target operating system, for example "z/OS", and use interface type "Batch with standard linkage calling convention". See Generating COBOL Source Files from Software AG IDL Files. Check the option Generate the generic RPC service module COBSRVI. More info
cobWrapper_using-client_batch_to_6	Using a COBOL compiler supported by COBOL Wrapper, compile: the generated client interface object(s) if required, the generic RPC service module COBSRVI your COBOL client program Take care the generated copybooks (see Using the Generated Copybooks) are accessed correctly by the compiler and not confused with the client interface objects, because the copybooks and client interface objects have identical file names. See your compiler documentation.
cobWrapper_using-client_batch_to_6_bs2	The IDL types U or UV require a compiler that supports COBOL data type NATIONAL. See BS2000 Prerequisites for more information on supported compilers. More info
cobWrapper_using-client_batch_to_6_i	Use the command CRTCBLMOD (create COBOL module) and compile all modules above to ILE modules using the following options: CRTCBLMOD MODULE(COBSRVI) OPTION(NOMONOPRC) LINKLIT(PRC) CRTCBLMOD MODULE(<client-interface-object-1>) LINKLIT(PRC) CRTCBLMOD MODULE(<client-interface-object-2>) LINKLIT(PRC) CRTCBLMOD MODULE(<client-interface-object..>) LINKLIT(PRC) CRTCBLMOD MODULE(<COBOL-client-program>) LINKLIT(PRC)
cobWrapper_using-client_batch_to_7	Using the standard linker (binder) of the target platform, link (bind) the following programs: the generated client interface object(s) if required, the generic RPC service module COBSRVI if required, the broker stub your COBOL client program
cobWrapper_using-client_batch_to_7_i	Use the IBM i command `CRTPGM` to bind all compiled modules to an executable ILE program of type *PGM. CRTPGM PGM(<COBOL-client-program>) MODULE(<COBOL-client-program> <client-interface-object-1> <client-interface-object-2> <client-interface-object...>) BNDSRVPGM(EXX/EXA) where `EXX` is the EntireX product library and `EXA` the broker stub.
cobWrapper_using-client_batch_to_8	Make sure that the correct broker stub module is used and, if linked (bound) dynamically, that it can be called dynamically.
cobWrapper_using-client_batch_to_8_bs2	The broker stub module BROKER is located in the broker LMS load library.
cobWrapper_using-client_batch_to_8_i	The broker stub EXA is located by default in the EntireX product library EXX. Make sure this library is added to your library list.
cobWrapper_using-client_batch_to_8_vse	See the broker installation documentation and use a broker stub for batch (for example BKIMB), see sublibrary EXX960.
cobWrapper_using-client_batch_to_8_zos	See the broker installation documentation and use a broker stub for batch (for example BROKER) from the common load library EXX107.LOAD. See also Administering Broker Stubs.
cobWrapper_using-client_call_desc	The COBOL Wrapper can be used with a call interface, even in CICS. This means you can build a client application where every generated client interface object, the generic RPC services module and the broker stub are linked together or called dynamically by the COBOL client program, similar to the batch scenario. See Using the COBOL Wrapper for Batch (z/OS, BS2000, z/VSE and IBM i). Using a call interface within CICS may be useful if the maximum COMMAREA length for IDL data (about 31 KB) and other restrictions prevent you from using the Using the COBOL Wrapper for CICS with `DFHCOMMAREA` Calling Convention (z/OS and z/VSE) scenario you do not require a distributed program link (CICS DPL) to your client interface object(s) you prefer a call interface instead of `EXEC CICS LINK` to your client interface objects. For platform z/OS this scenario supports the following: Long broker passwords. See Using Broker Logon and Logoff. Long RPC user IDs/passwords. See Using RPC Authentication (Natural Security, Impersonation, Integration Server). IDL unbounded groups or arrays without maximum mapped to COBOL's `OCCURS 1 TO UNBOUNDED DEPENDING ON`.
cobWrapper_using-client_call_to_1	Generate the client interface object(s) for the target operating system, for example "z/OS", and use the interface type "CICS with standard calling convention". See Generating COBOL Source Files from Software AG IDL Files. Check the option Generate the generic RPC service module COBSRVI. More info
cobWrapper_using-client_call_to_6	Using the CICS translator for COBOL provided with your CICS installation and a COBOL compiler supported by the COBOL Wrapper, translate and compile: the generated client interface object(s) if required, the generic RPC service module COBSRVI your COBOL client program Take care the generated copybooks (see Using the Generated Copybooks) are accessed correctly by the compiler and not confused with the client interface objects, because the copybooks and client interface objects have identical file names. See your compiler documentation.
cobWrapper_using-client_call_to_7	Using the standard linker (binder) of the target platform, link (bind) all translated and compiled modules, and, if required, the broker stub, together to the client application (that is, a CICS program), using the standard linker (binder) of the target platform.
cobWrapper_using-client_call_to_8	Install the client application within CICS.
cobWrapper_using-client_call_to_9	Make sure the correct broker stub is used and can be called dynamically by the generic RPC service module COBSRVI.
cobWrapper_using-client_call_to_9_vse	See the broker installation documentation and use a broker stub for CICS (for example BKIMC), see sublibrary EXX960.
cobWrapper_using-client_call_to_9_zos	See the broker installation documentation and use a broker stub for CICS (for example CICSETB) from the common load library EXX107.LOAD. See also Administering Broker Stubs.
cobWrapper_using-client_common_to_2	If necessary, use FTP to transfer the client interface object(s), and also the generic RPC service module COBSRVI, to the target platform where you write your client application.
cobWrapper_using-client_common_to_4	Write your COBOL client program. See Writing Applications with the COBOL Wrapper, in particular the section The RPC Communication Area (Reference), and take into consideration the information given in Software AG IDL to COBOL Mapping.
cobWrapper_using-client_dfh_desc	In this scenario, the generic RPC services module is installed only once within CICS as a CICS program and shared by all COBOL RPC client programs. Also, the COBOL client program and every generated client interface object are installed each as separate individual CICS programs. Use the COBOL Wrapper for CICS with DFHCOMMAREA calling convention in the following situations: You want to have an `EXEC CICS LINK` DFHCOMMAREA interface to your client interface object(s). You wish to separate the generic RPC service module and the broker stub from the client interface object(s). You require a program link to the client interface object(s). You can accept the following restrictions: The maximum COMMAREA length suits your purposes. Because the RPC communication area is also transferred in the COMMAREA, the effective length that can be used for IDL data is shorter than the CICS COMMAREA length. Nearly 31 KB can be used for IDL data. No support for long broker passwords and long RPC user IDs/passwords. No support for IDL unbounded arrays without maximum. See Mapping Fixed and Unbounded Arrays. Check if Using the COBOL Wrapper for CICS with Call Interfaces (z/OS and z/VSE) is an alternative for you.
cobWrapper_using-client_dfh_to_1	Generate the client interface object for the target operating system, for example "z/OS", and use interface type "CICS with DFHCOMMAREA calling convention". See Generating COBOL Source Files from Software AG IDL Files. Check the option Generate the generic RPC service module COBSRVI. More info
cobWrapper_using-client_dfh_to_6	Using the CICS translator for COBOL provided with your CICS installation and a COBOL compiler supported by the COBOL Wrapper, translate and compile: the generated client interface object(s) if required, the generic RPC service module COBSRVI your COBOL client program. Take care the generated copybooks (see Using the Generated Copybooks) are accessed correctly by the compiler and not confused with the client interface objects, because the copybooks and client interface objects have identical file names. See your compiler documentation.
cobWrapper_using-client_dfh_to_7	Using the standard linker (binder) of the target platform, link (bind) the following programs to separate CICS programs: every generated client interface object if required, the generic RPC service module COBSRVI together with a broker stub your COBOL client program.
cobWrapper_using-client_dfh_to_8	Install every client interface object, if required the CICS RPC service module COBSRVI and your COBOL client program as separate CICS programs.
cobWrapper_using-client_dfh_to_9	Make sure the correct broker stub is used and can be called dynamically by the CICS generic RPC service module COBSRVI.
cobWrapper_using-client_dfh_to_9_vse	See the broker installation documentation and use a broker stub for CICS (for example BKIMC), see sublibrary EXX960.
cobWrapper_using-client_dfh_to_9_zos	See the broker installation documentation and use a broker stub for CICS (for example CICSETB) from the common load library EXX107.LOAD. See also Administering Broker Stubs.
cobWrapper_using-client_idms_desc	The COBOL Wrapper can be used with a call interface in IDMS/DC. This means you can build an application where the COBOL client program, every generated client interface object, the generic RPC services module and the broker stub are linked together, similar to the batch scenario. See Using the COBOL Wrapper for Batch (z/OS, BS2000, z/VSE and IBM i).
cobWrapper_using-client_idms_to_1	Generate the client interface object(s) for the target operating system "z/OS", and use the interface type "IDMS/DC with standard calling convention". See Generating COBOL Source Files from Software AG IDL Files. Check the option Generate the generic RPC service module COBSRVI. More info
cobWrapper_using-client_idms_to_7	Using the standard linker (binder) of the target platform, link (bind) all translated and compiled modules, and, if required, the broker stub, together to an IDMS/DC program, using the standard linker (binder) of the target platform.
cobWrapper_using-client_idms_to_8	Install the IDMS/DC program within IDMS/DC.
cobWrapper_using-client_idms_to_9	Make sure the correct broker stub is used and can be called dynamically by the generic RPC service module COBSRVI. See the broker installation documentation and use a broker stub for IDMS/DC (for example IDMSETB) from the common load library EXX107.LOAD. See also Administering Broker Stubs.
cobWrapper_using-client_ims_desc	In this scenario, every generated client interface object, the generic RPC services module and the broker stub are linked together or called dynamically by the COBOL client program. For platform z/OS this scenario supports the following: Long broker passwords. See Using Broker Logon and Logoff. Long RPC user IDs/passwords. See Using RPC Authentication (Natural Security, Impersonation, Integration Server). IDL unbounded groups or arrays without maximum mapped to COBOL's `OCCURS 1 TO UNBOUNDED DEPENDING ON`.
cobWrapper_using-client_ims_to_1	Generate the client interface object(s) for the target operating system "z/OS" and use the interface type "IMS BMP with standard linkage calling convention" or "IMS MMP with standard linkage calling convention". See Generating COBOL Source Files from Software AG IDL Files. Check the option Generate the generic RPC service module COBSRVI. More info.
cobWrapper_using-client_ims_to_6	Using a COBOL compiler supported by the COBOL Wrapper, compile: the generated client interface object(s) if required, the generic RPC service module COBSRVI your COBOL client program. Take care the generated copybooks (see Using the Generated Copybooks) are accessed correctly by the compiler and not confused with the client interface objects, because the copybooks and client interface objects have identical file names. Do not assign the data set with the client interface objects prior in sequence to the copybooks to SYSLIB. See your compiler documentation.
cobWrapper_using-client_ims_to_7	Link (bind) all compiled modules and, if required, the broker stub, together to an executable program, using the standard linker (binder) of the target platform.
cobWrapper_using-client_ims_to_8	Make sure the correct broker stub is used and can be called dynamically. In the common load library EXX107.LOAD you can find broker stubs that can be used for IMS BMP (for example BROKER) IMS MPP (for example MPPETB) See Administering Broker Stubs.
cobWrapper_using-client_write-call	Write your COBOL client program. If this is your first COBOL client program, refer to Writing Standard Call Interface Clients.
cobWrapper_using-client_write-exec	Write your COBOL client program. If this is your first COBOL client program, refer to Writing `EXEC CICS LINK` Clients.
cobWrapper_using-client_zos-support	For platform z/OS this scenario supports the following: Long broker passwords. See Using Broker Logon and Logoff. Long RPC user IDs/passwords. See Using RPC Authentication (Natural Security, Impersonation, Integration Server). IDL unbounded groups or arrays without maximum mapped to COBOL's `OCCURS 1 TO UNBOUNDED DEPENDING ON`.
cobWrapper_using-server_common_map-cics-no-vse	If you are using the RPC Server for CICS, before using your server(s), check if you need to alter CICS settings - for example `TWASIZE` - before using your server(s); see CICS Settings under Administering the RPC Server for CICS IBM LE Runtime Options - for example AMODE24, how to trap ABENDS etc.
cobWrapper_using-server_common_map-cics	If you are using the RPC Server for CICS, before using your server(s), check if you need to alter CICS settings - for example `TWASIZE`; see CICS Settings for z/OS additionally IBM LE Runtime Options - for example AMODE24, how to trap ABENDS etc.
cobWrapper_using-server_common_map-no	If no server mapping file is required (see When is a Server Mapping File Required?) or the server is generated with a previous version of EntireX without support for server mapping - the library name (see `library-definition`) given in the IDL is ignored (see Note). Example: If a client performs an RPC request that is based on the IDL program name CALC, the RPC server will dynamically try to execute a program CALC. If no corresponding program can be found, the access will fail.
cobWrapper_using-server_common_map-yes	If you are using a server mapping file (.cvm), the server mapping is taken from the RPC request and the program with the COBOL name (see Note) defined in the server mapping is executed. See Customize Automatically Generated Server Names. If no corresponding program can be found, the access will fail.
cobWrapper_using-server_rebuildAllClients	You need to rebuild all RPC clients communicating with this RPC server program. Select the appropriate wrapper (see EntireX Wrappers in the Designer documentation) and re-generate the client interface objects. For the EntireX Adapter you need to update your generated IS adapter as described under To update an existing connection in Step 3: Create or Update an Adapter Connection in the Integration Server Wrapper documentation.
cobWrapper_write-common_optional	Here you specify optional settings to the RPC communication area used by the COBOL Wrapper, for example: MOVE "EXAMPLE" to COMM-LIBRARY. MOVE "00000300" to COMM-ETB-WAIT. MOVE "PASSWORD" to COMM-PASSWORD. (Note 1) Notes: For Implicit Logon, if required in your environment, the client password can be given here. It is provided then through the client interface object. If you have to issue an Explicit Logon, see Using Broker Logon and Logoff.
cobWrapper_write-common_required	The following settings to the RPC communication area are required as a minimum to use the COBOL Wrapper. These settings have to be applied in your RPC client program. It is not possible to generate any defaults into the client interface objects. * assign the broker to talk with ... MOVE "localhost:1971" to COMM-ETB-BROKER-ID. * assign the server to talk with ... MOVE "RPC" to COMM-ETB-SERVER-CLASS. MOVE "SRV1" to COMM-ETB-SERVER-NAME. MOVE "CALLNAT" to COMM-ETB-SERVICE-NAME. * assign the user id to the broker ... MOVE "ERXUSER" to COMM-USERID.
cobWrapper_write-erxcomm-def	The `ERXCOMM` copybook enables an RPC client to specify and retrieve data for RPC communication. For usage refer to `ERXCOMM` Copybook under Using the Generated Copybooks.
cobWrapper_write-erxvstr-def	The optional `ERXVSTR` copybook is an extension to the `ERXCOMM` copybook. It enables an RPC client to specify long data strings (e.g. passwords). For usage see `ERXVSTR` Copybook under Using the Generated Copybooks.
cobWrapper_write-note-bothAddr	If both copybooks are used, you need to pass both addresses, first the address of `ERXCOMM`, then the address of `ERXVSTR` to the generic RPC service module.
cobWrapper_write-note-bothParms	If both copybooks `ERXCOMM` and `ERXVSTR` are used, you need to pass both parameters: CALL "COBSRVI" USING ERX-COMMUNICATION-AREA ERX-COMMUNICATION-VSTR.
cobWrapper_write-note-ccsid	If a `CCSID` is provided: It is used for conversion of the long RPC password and RPC user ID. If no `CCSID` is provided, the codepage active during compilation applies. Refer to your compiler documentation. It is used as the codepage name to tell the broker the encoding of your application data. See Using Internationalization with the COBOL Wrapper.
cobWrapper_write-note-error	The field `COMM-RETURN-CODE` in the RPC communication area contains the error provided by the COBOL Wrapper. For the error messages returned, see Error Messages and Codes.
cobWrapper_write-note-erxcomm-only	If you are only using copybook `ERXCOMM` only, pass only the address of `ERXCOMM` to the generic RPC service module.
cobWrapper_write-note-no-comm-area	Because the RPC communication area is not used for data exchange between the client application and the client interface objects, the `COMM-RETURN-CODE` field in the RPC communication area cannot be checked directly upon return from RPC calls. Therefore, the COBOL mechanism `RETURN-CODE` special register is used to provide errors from client interface objects to the client application. For IBM compilers, errors can be adapted in the `COBEXIT` copybook (see folder include).
cobWrapper_write-note-rpcCommit	After successful call, both reliable RPC messages are committed. This will deliver all reliable RPC messages to the server if it is available.
cobWrapper_write-note-uowid	After successful call the `UOWID` is available in the RPC communication area field `COMM-ETB-UOW-ID`. See The RPC Communication Area (Reference).
cobWrapper_write-note-uowstatus	After successful call the UOW status is available in the RPC communication area field `COMM-ETB-UOW-STATUS`. See The RPC Communication Area (Reference).
cobWrapper_write_exec_declare	Declare the RPC communication area as described under Step 1: Declare IDL Structures and RPC Communication Area in document Writing `EXEC CICS LINK` Clients.
cobWrapper_write_exec_init	Initialize the RPC communication area as described under Step 2: Initialize the RPC Communication Area under Writing `EXEC CICS LINK` Clients.
cobWrapper_write_scenarios-call	This interface type applies to the scenarios CICS \| Batch \| IMS.
cobWrapper_write_scenarios-exec	This interface type applies to the scenario Using the COBOL Wrapper for CICS with `DFHCOMMAREA` Calling Convention (z/OS and z/VSE).