IBM Developer for z/OS

IBM Developer for z/OS Enterprise Edition

16.0

Setting up an Eclipse Development

Environment
Last updated 2024-10-16

IBM
About this PDF
© International Business Machines Corporation 1992, 2024.

This PDF was generated from the content of the IBM® Developer for z/OS® online documentation. It is
provided for reference only. Many of the links in this PDF do not lead to a target location on the IBM
Developer for z/OS IBM Documentation site. For the most recent content, go to [Link]
docs/en/developer-for-zos/latest.
Some of the content in the IBM Developer for z/OS IBM Documentation site is embedded from other
IBM product documentation sites. Because of this content reuse, the embedded content might not be
included in the generated PDFs.
Setting up an Eclipse development environment
Preparing your Eclipse workspace for developing z/OS applications consists of three areas of setup. Each
of these areas is described in this section:
• Setting up a workspace for developing with a specific language. If you know that you plan to work
mainly in Assembler, COBOL, or PL/I, you can start with “Setting up a workspace for editing source
code” on page 1.
• Setting up property groups for passing information about your source files to compilers, runtime
environments, debug tools, and testing tools.
• Setting Eclipse preferences for the product tooling.
Additionally, you create customized menus for your Eclipse workspace and add these to the pop-up
menus in various Eclipse editors and views.
All of these set-up options are explained in the topics in this section.

Setting up a workspace for editing source code

Learn what tasks you need to complete to setup your workspace for editing source code in COBOL,
High-level Assembler, JCL, PL/I, or REXX. Link to the guide builder to generate a documentation set that is
tailored to these tasks and to the languages and editors you need to use.
When you are ready to generate the documentation set, click this link:

Roadmap
Use this roadmap to understand the tasks you must complete to set up a development environment for
editing source code.
1. Verify installed components: If your source files are located in a Git repository, a Jazz® repository, or
on z/OS under control of the CA Endevor source control manager, verify that the features necessary for
accessing these repositories are installed with the product.
2. Set up access to your source files. The product provides access to source files in several locations:
• On a z/OS system
• In a Git repository
• In a Jazz repository
• On a z/OS system under CA Endevor source control
3. Set up a property group. Property groups provide a central location for settings that the product uses
for several functions. Some common tasks in the development of COBOL applications use property
group settings:
• Editing source files
• Generating JCL
• Compiling source code
• Running applications
Property groups support other functions as well, such as unit testing, debug, and code coverage, but
this section describes property group settings for editing, compilation, and runtime.
4. Create a z/OS project. Although you can work with your source files directly in an MVS™ file system or
source control repository, adding them to a z/OS project has several benefits:
• You can include in the project only the exact resources you need.

© Copyright IBM Corp. 1992, 2024 1

 • z/OS projects are enabled for a number of product features, such as integration with EGit, IBM
Dependency Based Build, Engineering Workflow Management, and Z Systems Development and Test
Environment.
• z/OS projects are shareable either through export and import or through the push-to-client feature.
The product provides several methods for creating z/OS projects depending on where your source files
are located.
5. Set up the editors. The product provides editors that are optimized specifically for development in
each of these source languages: COBOL, High-Level Assembler, JCL, PL/I, and REXX. The workbench
Preferences window contains several pages for setting options for editor functions.

Defining resource options with property groups

You can create property groups with property values that can be shared by MVS subprojects, local z/OS
projects, and their resources.

Overview
System properties, subproject properties, local project properties, and resource properties make the
development environment more convenient. You can build code at a keystroke, for example, because
compilers and linkage editors are referenced as property values. Properties define the characteristics of
a local or remote resource. They are created for each resource when the resource is first accessed and
maintained until the resource is deleted. Disconnecting from a remote system makes the properties and
resources unviewable, but the properties persist and can be viewed again when you reconnect to the
system.
When you modify a resource by an operation that you initiate from within the Developer for z/OS client,
the properties of the resource are kept up-to-date. When you modify a resource from outside the client,
such as by using ISPF, the properties of the resource become out of sync until they are refreshed from the
workstation.
You define resource properties in property groups, or named sets of property values that can be easily
shared and reused among projects, systems, and users. A property group is a set of property values that
you define for local z/OS projects or specific local and remote resources. After the property group is
defined, the values in it can be applied to the z/OS projects, subprojects, and resources that you create on
that system. Property groups provide a way to manage resource properties; share them across systems,
projects, resources, and users; and maintain consistency in your development and build environment. The
systems, projects, and resources you define have default properties. If no property groups are defined for
a system, then the default properties are in effect for the system and its resources.
You can, for example, define a property group with values required for debugging and apply that property
group to your resources when you must debug a project or subproject. If you must change a specific
property value, such as the JCL job card and data set, you can change this property in the property group,
and the change is propagated to all resources associated with that property group.
You can add, copy, delete, edit, import, and export property groups. Physical resources, such as systems,
files, and data sets, and logical resources, such as projects and subprojects, can be associated with a
property group that can be overridden for specific situations. Property groups are independent of each
other. That is, changing property values in one property group has no effect on the property values in
other property groups.
Your site can create system property groups and default property values and make them available to
users. When a connection is made to a system, if these files are found, then those property groups or
default values are loaded and can be used. For instructions for creating default property values, see
“Configuring default property values” on page 9.

How property groups are used

Many product components use property groups to set options for the functions they support. The
topics in this section explain how to create, edit, and assign property groups to resources. For more

2 Developer for z/OS: Setting up an Eclipse Development Environment

 information about the options in property groups and how they are used by various product components
and functions, see these topics:
• Property group options for editors, compilers, preprocessors, and build functions
• Property group options for configuring preprocessors
• Property group options for the Remote C/C++ Editor
• Property groups for the Dependency Based Build Integration
• Property groups for Engineering Workflow Management local projects

The Property Group Manager

The Property Group Manager view provides tools for creating, deleting, editing, importing, exporting, and
copying property groups. Because it is one of the default views in the z/OS Projects perspective, it is
usually open when you start the workspace. If it is not already open, do these steps to open it:
1. From the menu bar, click Window (on Windows) or IBM Developer for z/OS (on macOS) > Show View
> Other.
2. In the Show View window, expand z/OS Project Views.
3. Select Property Group Manager and click OK.
The Property Group Manager opens. It lists all system connections, the property groups that are defined
for each system, and the last edit date for each property group. You can sort the list by clicking the
table headings. Property groups are sorted first by system name and then by property group name or
description. To reverse the sort order, click the column heading again.
For more information about creating and managing property groups, select one of the following topics:

Creating and editing property groups

When you create property groups and associate them with resources, you can easily change property
values for various uses.

Creating a property group

1. From the Property Group Manager view, select a system, open the menu and click New Property
Group. The Property Group Editor opens. This editor contains a series of tabs that open each page of
the editor.
2. Type a name and description for the new property group. For example, to create a property group that
contains property values for debugging COBOL programs, you might type DebugCOBOL for the name
and Properties for debugging COBOL programs for the description.
3. For remote property groups, you can define several property group values on the Property Group
Information page. These settings include the properties that are required to resolve dependencies
when you edit a file. All of these settings are also available on other property group pages, but are
placed on the Property Group Information page for quick access.
• Application language: Choose COBOL, PL/I, or Any. The default value is COBOL. This field controls
the other fields that are displayed on this page: some fields apply to COBOL files and some to PL/I
files. If you choose Any, no additional fields are displayed on this page. If you clear the COBOL
Settings or PL/I Settings checkbox on the Categories page, then the corresponding language is
removed from this list.
• SYSLIB: Specify libraries for resolving copybooks or include files. To add a library to this list, click
Add. To reorder the list, click the Up and Down buttons. To delete a library from the list, select it and
click Remove.
• Additional JCL: Specify your own JCL, such as additional data definitions (DD cards). The contents
of this field are echoed at the end of the compilation step. You must specify syntactically correct JCL.

Setting up an Eclipse development environment 3

 • Set local preprocessor options: Opens the Local Preprocessor page of COBOL Settings or PL/I
Settings. For more information about using local preprocessors, see the related topics.
• Set remote preprocessor options: Opens the Editor Configurations page of COBOL Settings or
PL/I Settings. For more information about using remote preprocessors, see the related topics.
4. Click the Categories tab and select the checkboxes beside the categories for which you want to enter
values for the property group.
5. Select each property category tab to open the property page for that category.
6. On each property category page, specify property values to be included in the property group.
• For fields that take partitioned data sets as their values, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop
it in the field. To change the order of partitioned data set names in a field, place the cursor in the field
and click Change Order from the menu. The property group editor checks that the value in a data set
field is valid:
– The system for the data set is compared to the system for the property group. If the system for the
data set is different, an error message is displayed.
– The property group editor verifies that the value is an MVS data set rather than a partitioned data
set member, z/OS UNIX System Services file, or local file.
– If multiple data sets are dropped in a field that accepts only one data set, an error message is
displayed.
• Click Check Data Sets or Check Remote Location to check that data sets or folders that are
specified in the step options fields exist on the remote system.
Note: If a data set name contains the <HLQ> variable substitution, Check Data Sets and Check
Remote Location cannot validate the data set name.
7. When you close the Property Group Editor, a window prompts you to save your changes. The name
and description are displayed in the Property Group Manager view. If you do not save your changes,
the property group is not created.

Editing a property group

When you edit a property group, you can select new or different property categories for the group or
change property values in the group. This action is a good way to propagate property changes across
multiple projects, subprojects, or data sets because it allows for making a property change in one place
and having it take effect for all resources that are associated with the property group.
• From the Property Group Manager view, double-click a property group name or select a property group
to edit and then select Edit from the menu.
• From the Remote Systems view or the z/OS Projects view, select one of the following resources and
then select Property Group > Edit Associated Property Group from the menu:
– The MVS Files node
– An MVS subproject
– A data set or data set member
– A local COBOL, PL/I, or Assembler project, directory, or file
This menu item is available only if a property group is associated with the selected resource.

Copying a property group

1. From the Property Group Manager view, select a property group to copy and then select Copy from
the menu.

4 Developer for z/OS: Setting up an Eclipse Development Environment

 The Copy Property Group window opens. The System field on this window shows the system for
which the property group is being created. You can copy property groups only within the same system.
2. Type a name for the new property group and click OK.
The default name for a copy is Copy of PropertyGroup. If another property group is already using the
name that you enter, a message is displayed and OK is disabled.
3. If you want to change the property categories or values for the new property group, select it in the
Property Group Manager and click Edit.
The Property Group Editor opens.

Associating and overriding property groups

Associating a property group with a resource allows for consistent property settings across projects,
subprojects, or data sets. If you decide a different set of properties is more suitable for your purposes,
you can change the property group associated with a resource or override one or more properties in an
associated property group.

Associating a property group with a resource

1. In the z/OS Projects view or the Remote Systems view, select the MVS Files node, an MVS
subproject, a data set or data set member, or a local COBOL, PL/I, or Assembler project, directory,
or file.
Note: When you associate a property group with an MVS subproject, this association does not apply
to the files or data sets in other views, even if the files or data sets are part of the subproject.
For example, a COBOL program might inherit one property group from a subproject, but a different
property group from the partitioned data set that it is a member of in the Remote Systems view.
2. Right-click and select Property Group > Associate Property Group. The Associate Property Group
window opens. The table view displays property groups that are defined for the system. You can sort
the list by clicking the table headings. To reverse the sort order, click the table headings again.
3. Select the checkbox beside a property group to associate with the resource and click OK.

Finding the current properties of a resource

You can use the Properties view or Properties window to see the current property group for a resource.
• Use the Properties view to determine the property group that is associated with a resource.
1. In the z/OS Projects view or Remote Systems view, select the resource for which you want to see
properties. The Properties view shows the current property group for the resource. The Overrides
field in this view indicates whether any property overrides are in effect for the resource.

Setting up an Eclipse development environment 5

 2. Open the Property Group Manager expand the system name for the resource of interest, and
double-click the current property group of the resource. The Property Group Editor opens.
3. To see property values for each category, select the corresponding tab.
• Use the Property Group page of the Properties window.
1. In the z/OS Projects view or Remote Systems view, select the resource for which you want to see
properties and then click Properties.
2. In the Properties window, click Property Group.
The current property group is marked by a selected checkbox in the table.

Overriding properties in a property group

When you associate a property group with a resource, it is referred to as the current property group.
Actions such as build and syntax check use the information in the current property group to provide
values for that resource. The current property group in parent resources is also the current property group
for child resources, unless you explicitly set the current property group for child resources. For example,
the current property group for an MVS subsystem is also the current property group for all data sets and
members in the subsystem. You can explicitly set the current property group for a data set or member.
For a specific resource, you can override values for the properties in the resource's current property
group. The overridden values do not affect any other resource, nor do they affect the property group itself;
rather, they are local to the resource. In this way, you can work with variations in property groups. Using
property overrides is a good way to change a property value for a specific purpose, such as testing the
effect of a change before you propagate it to other resources. If the current property group for a resource
is changed, the overridden values are deleted. You can specify property group overrides for partitioned
data set members and for files in local z/OS projects. Property group overrides are not available for MVS
subprojects, partitioned data sets, the MVS Files node in the Remote Systems view, local projects, and
directories in local projects.
A resource with property overrides displays Overrides Yes in the Property group section of the
Properties view.
Overriding property group values
1. In the z/OS Projects or Remote Systems view, select a partitioned data set member or file in local
z/OS project.
2. Right-click and select Property Group > Override Properties. The Property Group Editor opens.
3. Specify property values to be overridden in the property group.
4. Save your changes.
Note: Changing the property group association for a resource deletes any property overrides for that
resource.
Deleting overrides
If you delete the overrides all property values revert to the current property group.
1. In the z/OS Projects or Remote Systems view, select a partitioned data set member or a file in a
local z/OS project with property group overrides.
2. Right-click and select Property Group > Delete Overrides. The property values for the resource
revert to the current property group.

Exporting and importing property groups

You can export and import property groups for sharing with other users.

Exporting a property group

1. From the Property Group Manager view, do one of the following steps:

6 Developer for z/OS: Setting up an Eclipse Development Environment

 • To export all property groups for a system, select the system and then select Export from the menu.
• To export a single property group, select the property group and then select Export from the menu.
The Export Property Groups window opens.
2. In the Location field, type the directory path where you want to the file to be stored or click Browse to
navigate to the directory path.
3. In the File name field, type a file name for the property group. Do not include the file extension. The
file extension .xml is automatically appended to the file name as needed.
4. From the table view, select one or more property groups to export.
You can click Select All or Deselect All to select all property groups or clear all groups. You can sort
the list by clicking the table headings. To reverse the sort order, click the table headings again.
5. Click OK to save the file.

Importing a property group

1. From the Property Group Manager view, select the system into which you want to import property
groups and then select Import from the menu. The Import Property Groups window opens.
2. In the File field, type the path of the XML file or click Browse to navigate to the file. The property
groups that are defined in the file are loaded into the table view.
3. From the table view, select one or more property groups to import. You can sort the list by clicking the
table headings. To reverse the sort order, click the table headings again.
4. Click OK to import the property group from the file.
Note: If you attempt to import a property group that contains unsupported categories, then the
unsupported categories are ignored, but the supported categories are imported. This situation might
occur, for example, if you attempt to import a property group into a previous version of Developer for
z/OS, and the previous version does not recognize a category that was introduced in a more recent
version.

Exporting and importing from a ZAPP file

What is a ZAPP file?

A ZAPP file is a .yaml or .json file that specifies options for a Z APPlication ("ZAPP") development
environment. ZAPP files have several uses and functions, one of which is to define property group options
in an IBM Developer for z/OS or IBM Developer for z/OS on VS Code development environment. For
a full description of ZAPP files and how to define property group options in them, see Configure your
applications with ZAPP files in the IBM Developer for z/OS on VS Code documentation.
Before Developer for z/OS can make use of the options in a ZAPP file, it must import them into a property
group. The import operation occurs automatically when you load a z/OS project that contains a ZAPP
file into the workspace. You can also export property groups into ZAPP files. This topic explains how the
product imports ZAPP files, and how to export property groups to ZAPP files.
Note:
If you attempt to edit the ZAPP file and encounter any issues with the Eclipse YAML editor, you can open a
bug report at [Link]

How ZAPP files are imported into the workspace

A ZAPP file that is in a local or remote z/OS project generates a property group automatically. A common
use case illustrates this process:
1. Add a Git repository that contains a ZAPP file to the Git Repositories view. For instructions, see Adding
a Repository.

Setting up an Eclipse development environment 7

 2. Use the Create a z/OS Project menu action to add the repository to the z/OS Projects view. For
instructions, see Creating a z/OS project from a Git repository.
Important: The project must have only one ZAPP file in the root folder of the project.
3. A read-only local property group is generated and added to the Property Group Manager.

Exporting to a ZAPP file

1. In the Property Group Manager, right-click a local or remote property group and select Generate
ZAPP.

2. In the Generate ZAPP file from Property Groups window, click Browse to navigate to a project to
save the ZAPP file in. Select the project that you want to apply the property group options to.
3. From the file extension list, choose .yaml or .json. The file name must be zapp and cannot be
altered.
4. Click OK. The ZAPP file is generated and added to the project. The product also generates a copy of the
property group and adds it to the Property Group Manager.

Tip: In the generated property group, all fields that were populated from the ZAPP file are read-only.
If you need to update any of the read-only fields, you must update them in the ZAPP file. The product
keeps the ZAPP file and the generated property group in [Link] other property group options can be
changed in the property group editor.

8 Developer for z/OS: Setting up an Eclipse Development Environment

Configuring default property values
You configure default property values for a remote system by creating a set of configuration files on that
system.
You can configure default property values to define site-specific defaults for particular properties. When a
user connects to a system for the first time, Developer for z/OS determines whether a default values file
exists on the system. If so, the default values are stored in the workspace so that whenever users create
a property group for that system, the defaults from the default values file are used. For properties that
do not have default values in the default values file, the default Developer for z/OS property values are
used. If the default values file on the system is updated after the default values are transferred to the
workspace, users are prompted to replace the defaults in the workspace with the ones from the system.
If no default property values are configured for a remote system, the system uses default values that are
included with Developer for z/OS.
To configure default property values on a remote system, you must define a default values file that defines
property values that are available to users when they connect to the system for the first time.
When a user connects to a system for the first time, the Developer for z/OS product determines whether
a default values file exists on the system. If so, the default values are stored in the workspace so that
whenever users create a property group for that system, the defaults from the default values file are used.
For properties that do not have default values in the default values file, the default Developer for z/OS
property values are used. If the default values file on the system is updated after the default values are
transferred to the workspace, users are prompted to replace the defaults in the workspace with the ones
from the system. The default values file is [Link] and contains the following tags. It must
be encoded in UTF-8. For the default values schema, see the related topics.

<?xml version="1.0" encoding="UTF-8"?>

<DEFAULT-VALUES>
<CATEGORY-INSTANCE>
<CATEGORY>category name</CATEGORY>
<PROPERTY>
<NAME>property name</NAME>
<VALUE>property value</VALUE>
</PROPERTY>
</CATEGORY-INSTANCE>
</DEFAULT-VALUES>

<CATEGORY-INSTANCE>
Specify one <CATEGORY-INSTANCE> tag for each property category for which you want to define
default values. This tag can contain one <CATEGORY> tag and one or more <PROPERTY> tags.
<CATEGORY>
Specify the name of a property category for which you want to define default values. For a list of valid
category names, see the related links.
<PROPERTY>
Specify one or more property <NAME> and <VALUE> pairs to include for the category. For a list of valid
property names, see the related links.

Default values schema

The default values schema defines tags that are used to define a default values file.

<xsd:schema xmlns:xsd="[Link]
<xsd:element name="DEFAULT-VALUES">
<xsd:annotation>
<xsd:documentation>
These property values are available to users when they
connect to the system for the first time.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:element maxOccurs="unbounded" ref="CATEGORY-INSTANCE"></xsd:element>
</xsd:sequence>
</xsd:complexType>

Setting up an Eclipse development environment 9

 </xsd:element>
<xsd:element name="CATEGORY-INSTANCE">
<xsd:annotation>
<xsd:documentation>
A category instance has property values for properties defined in
a particular category.
</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:element name="CATEGORY" type="xsd:string">
<xsd:annotation>
<xsd:documentation>
The name of the category for the category instance.
</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element maxOccurs="unbounded" ref="PROPERTY"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="PROPERTY">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="NAME" type="xsd:string"></xsd:element>
<xsd:element name="VALUE" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

Sample default values file

This example illustrates a default values file.

<?xml version="1.0" encoding="UTF-8"?>

<DEFAULT-VALUES>
<CATEGORY-INSTANCE>
<CATEGORY>COBOL_SETTINGS</CATEGORY>
<PROPERTY>
<NAME>HOST_COMPILE_OPTIONS</NAME>
<VALUE>TEST</VALUE>
</PROPERTY>
<PROPERTY>
<NAME>COMPILE_JCL_PROCEDURE_NAME</NAME>
<VALUE>ELAXFCOC</VALUE>
</PROPERTY>
</CATEGORY-INSTANCE>
</DEFAULT-VALUES>

Category and property names

You can use these categories and properties in the [Link] and [Link]
files. These names are case-sensitive.

Categories
• COBOL_SETTINGS
• PLI_SETTINGS
• ASSEMBLER_SETTINGS
• C_CPP_SETTINGS
• BMS_SETTINGS
• MFS_SETTINGS
• JCL_OPTIONS
• LINK_OPTIONS
• RUNTIME_OPTIONS
• FILEMANAGER_SETTINGS

10 Developer for z/OS: Setting up an Eclipse Development Environment

• ZUNIT_SETTINGS

Properties
Table 1.
Category Properties
COBOL_SETTINGS HOST_COMPILE_OPTIONS
COMPILE_JCL_PROCEDURE_NAME
COMPILE_JOB_STEPS
LISTING_DATASET
OBJECT_DATASET
HOST_SYSLIB
COMPILE_ERROR_FEEDBACK_ENABLED
ERROR_FEEDBACK_FILE_PREFIX
COMPILE_ADDITIONAL_JCL
COMPILE_SYSDEBUG_DATASET
HOST_USE_CICS
HOST_CICS_LEVEL
HOST_CICS_SEPTRANSLATOR
CICS_TRANSLATOR_JCL_PROCEDURE_NAME
CICS_TRANSLATOR_JOB_STEPS
HOST_CICS_OPTIONS
HOST_CICS_SYSLIB
HOST_USE_DB2
HOST_DB2_PREPROCESSOR
HOST_DB2_JCL_PROCEDURE_NAME
HOST_DB2_JOB_STEPS
HOST_DB2_OPTIONS
HOST_DB2_SYSLIB
HOST_DB2_DBRMLOCATION
HOST_DB2_SYSTSIN
HOST_USE_IMS
HOST_IMS_LIBRARY
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
ADDED_STEP_ADDITIONAL_JCL
ADDED_STEP_OPTIONS
ADDED_STEP_ERROR_FEEDBACK
ADDED_STEP_ERROR_FEEDBACK_FILE_PREFIX
LOCAL_CICS_PREPROCESSOR
LOCAL_CICS_PREPROCESSOR_OPTIONS
LOCAL_COMPILE_OPTIONS
LOCAL_DB2_COPROCESSOR
LOCAL_DB2_CONNECTION
LOCAL_DB2_COPROCESSOR_OPTIONS
LOCAL_SYSLIB
LOCAL_ENVIRONMENT_VARIABLES
LOCAL_PREPROCESSOR_DESCRIPTION
LOCAL_PREPROCESSOR_NAME
LOCAL_PREPROCESSOR_OPTIONS
LOCAL_PREPROCESSOR_OUTPUT_FILE_NAME
LOCAL_PREPROCESSOR_SUPPORT_ERRFDBK
LOCAL_PREPROCESSOR_XML_LOCATION
LOCAL_PREPROCESSOR_ENVIRONMENT_VARIABLES
LOCAL_PREPROCESSOR_IS_ACTIVE

Setting up an Eclipse development environment 11

 Table 1. (continued)
Category Properties
PLI_SETTINGS COMPILE_JCL_PROCEDURE_NAME
COMPILE_JOB_STEPS
HOST_COMPILE_OPTIONS
LISTING_DATASET
OBJECT_DATASET
HOST_SYSLIB
COMPILE_ERROR_FEEDBACK_ENABLED
ERROR_FEEDBACK_FILE_PREFIX
COMPILE_ADDITIONAL_JCL
COMPILE_SYSDEBUG_DATASET
HOST_USE_CICS
HOST_CICS_LEVEL
HOST_CICS_SEPTRANSLATOR
CICS_TRANSLATOR_JCL_PROCEDURE_NAME
CICS_TRANSLATOR_JOB_STEPS
HOST_CICS_OPTIONS
HOST_CICS_SYSLIB
HOST_USE_DB2
HOST_DB2_PREPROCESSOR
HOST_DB2_JCL_PROCEDURE_NAME
HOST_DB2_JOB_STEPS
HOST_DB2_OPTIONS
HOST_DB2_SYSLIB
HOST_DB2_DBRMLOCATION
HOST_DB2_SYSTSIN
HOST_USE_IMS
HOST_IMS_LIBRARY
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
ADDED_STEP_ADDITIONAL_JCL
ADDED_STEP_OPTIONS
ADDED_STEP_ERROR_FEEDBACK
ADDED_STEP_ERROR_FEEDBACK_FILE_PREFIX
LOCAL_CICS_PREPROCESSOR
LOCAL_CICS_PREPROCESSOR_OPTIONS
LOCAL_COMPILE_OPTIONS
LOCAL_SYSLIB
LOCAL_DB2_COPROCESSOR
LOCAL_DB2_CONNECTION
LOCAL_DB2_COPROCESSOR_OPTIONS
LOCAL_ENVIRONMENT_VARIABLES
LOCAL_PREPROCESSOR_DESCRIPTION
LOCAL_PREPROCESSOR_NAME
LOCAL_PREPROCESSOR_OPTIONS
LOCAL_PREPROCESSOR_OUTPUT_FILE_NAME
LOCAL_PREPROCESSOR_SUPPORT_ERRFDBK
LOCAL_PREPROCESSOR_XML_LOCATION
LOCAL_PREPROCESSOR_ENVIRONMENT_VARIABLES
LOCAL_PREPROCESSOR_IS_ACTIVE

12 Developer for z/OS: Setting up an Eclipse Development Environment

Table 1. (continued)
Category Properties
LINK_OPTIONS JCL_PROCEDURE_NAME
JOB_STEPS
HOST_LINK_OPTIONS
LIBRARIES
USER_SPECIFIED_INSTRUCTIONS_ENABLED
USER_SPECIFIED_INSTRUCTIONS
ENTRY_NAME
LOAD_MODULE
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
APPEND_LOCATION_VALUE
APPEND_CHECKBOX
ADDITIONAL_JCL
ADDED_STEP_ADDITIONAL_JCL
ADDED_STEP_OPTIONS
LOCAL_LINK_OPTIONS
LOCAL_CREATE_DLL
LOCAL_CREATE_EXE
LOCAL_LIBRARY_OPTIONS

JCL_OPTIONS JOBCARD
GENERATED_JCL_DATASET

BMS_SETTINGS ASSEMBLE_MAINMODULE
MAP_ASSEMBLE_STEP
MAP_OBJECT
DSECT_ASSEMBLE_STEP
DSECT_COPYLIB
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
ADDED_STEP_ADDITIONAL_JCL
ADDED_STEP_OPTIONS
MAIN_PROGRAM_SELECTED
MAIN_PROGRAM_NAME

ASSEMBLER_SETTINGS ASSEMBLER_JCL_PROCEDURE_NAME
ASSEMBLER_JOB_STEPS
HOST_ASSEMBLER_OPTIONS
LISTING_DATASET
OBJECT_DATASET
ASSEMBLER_MACRO_LIBRARIES
COMPILE_ERROR_FEEDBACK_ENABLED
ERROR_FEEDBACK_FILE_PREFIX
COMPILE_ADDITIONAL_JCL
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
ADDED_STEP_ADDITIONAL_JCL
ADDED_STEP_OPTIONS
ADDED_STEP_ERROR_FEEDBACK
ADDED_STEP_ERROR_FEEDBACK_FILE_PREFIX

Setting up an Eclipse development environment 13

 Table 1. (continued)
Category Properties
RUNTIME_OPTIONS RUN_IN_BATCH
RUN_IN_BATCH_WITH_DEBUG
OPTIONS
ADDITIONAL_JCL
PROCEDURE_NAME
JOB_STEPS
PROGRAM_PARAMETERS_ENABLED
RUNTIME_OPTIONS_BEFORE_PROGRAM_PARAMETERS
PROGRAM_PARAMETERS_BEFORE_RUNTIME_OPTIONS
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
ADDED_STEP_ADDITIONAL_JCL
ADDED_STEP_OPTIONS

C_CPP_SETTINGS CPP_COMPILE_JCL_PROCEDURE_NAME
CPP_COMPILE_JOB_STEPS
CPP_COMPILE_OPTIONS
CPP_COMPILE_MACROS
CPP_LISTING_DATASET
CPP_OBJECT_DATASET
CPP_COMPILE_SYSEVENT
CPP_COMPILE_SYSLIB
CPP_COMPILE_USERLIB
CPP_COMPILE_ADDITIONALJCL
CPP_HOST_USER_VARIABLES
CPP_HOST_GLOBAL_VARIABLES
C_COMPILE_JCL_PROCEDURE_NAME
C_COMPILE_JOB_STEPS
C_COMPILE_OPTIONS
C_COMPILE_MACROS
C_LISTING_DATASET
C_OBJECT_DATASET
C_COMPILE_SYSEVENT
C_COMPILE_SYSLIB
C_COMPILE_USERLIB
C_COMPILE_ADDITIONALJCL
CPP_ADDED_STEP_ADDITIONAL_JCL
CPP_ADDED_STEP_OPTIONS
C_ADDED_STEP_ADDITIONAL_JCL
C_ADDED_STEP_OPTIONS
CPP_COMPILE_USEC

14 Developer for z/OS: Setting up an Eclipse Development Environment

Table 1. (continued)
Category Properties
MFS_SETTINGS COMPILE_JCL_PROCEDURE_NAME
COMPILE_DATASET
COMPILE_STEPNAMES
COMPILE_STEP2NAME
OBJECT_DATASET
LISTING_DATASET
COMPILE_SOR
COMPILE_SYSLIB
COMPILE_ADDITIONAL_JCL
ADDED_STEP_OPTIONS
ADDED_STEP_ADDITIONAL_JCL
HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES

Setting up an Eclipse development environment 15

 Table 1. (continued)
Category Properties
FILEMANAGER_SETTING COBOL_COMPILE_SYSLIB01
S COBOL_COMPILE_SYSLIB02
COBOL_COMPILE_SYSLIB03
COBOL_COMPILE_SYSLIB04
COBOL_COMPILE_SYSLIB05
COBOL_COMPILE_SYSLIB06
COBOL_COMPILE_SYSLIB07
COBOL_COMPILE_SYSLIB08
COBOL_COMPILE_SYSLIB09
COBOL_COMPILE_SYSLIB10
COBOL_COMPILE_REPLACE_FROM01
COBOL_COMPILE_REPLACE_FROM02
COBOL_COMPILE_REPLACE_FROM03
COBOL_COMPILE_REPLACE_FROM04
COBOL_COMPILE_REPLACE_FROM05
COBOL_COMPILE_REPLACE_TO01
COBOL_COMPILE_REPLACE_TO02
COBOL_COMPILE_REPLACE_TO03
COBOL_COMPILE_REPLACE_TO04
COBOL_COMPILE_REPLACE_TO05
COBOL_COMPILE_DBCS
COBOL_COMPILE_DECIMALPOINT_IS_COMMA
COBOL_COMPILE_ARITH_EXTEND
COBOL_COMPILE_MIXED_CASE_FIELD_NAMES
COBOL_COMPILE_MAX_RETURN_CODE
PLI_COMPILE_SYSLIB01
PLI_COMPILE_SYSLIB02
PLI_COMPILE_SYSLIB03
PLI_COMPILE_SYSLIB04
PLI_COMPILE_SYSLIB05
PLI_COMPILE_SYSLIB06
PLI_COMPILE_SYSLIB07
PLI_COMPILE_SYSLIB08
PLI_COMPILE_SYSLIB09
PLI_COMPILE_SYSLIB10
PLI_COMPILE_GRAPHIC
PLI_COMPILE_UNALIGNED
PLI_COMPILE_63BIT_BINARY
PLI_COMPILE_31DIGIT_DECIMAL
PLI_COMPILE_MAX_RETURN_CODE
HLASM_COMPILE_SYSLIB01
HLASM_COMPILE_SYSLIB02
HLASM_COMPILE_SYSLIB03
HLASM_COMPILE_SYSLIB04
HLASM_COMPILE_SYSLIB05
HLASM_COMPILE_SYSLIB06
HLASM_COMPILE_SYSLIB07
HLASM_COMPILE_SYSLIB08
HLASM_COMPILE_SYSLIB09
HLASM_COMPILE_SYSLIB10
HLASM_COMPILE_DBCS
HLASM_COMPILE_NOALIGN
HLASM_COMPILE_MAX_RETURN_CODE

16 Developer for z/OS: Setting up an Eclipse Development Environment

 Table 1. (continued)
Category Properties
ZUNIT_SETTINGS HOST_USER_VARIABLES
HOST_GLOBAL_VARIABLES
ZUNIT_PROCEDURE_NAME
ZUNIT_JOB_STEPS
ZUNIT_CONTINUE_ON_TEST_CASE_FAIL
ZUNIT_CONTINUE_ON_TEST_CASE_ERROR
ZUNIT_CONTINUE_ON_TEST_FAIL
ZUNIT_CONTINUE_ON_TEST_ERROR
ZUNIT_RUNNER_CONFIG_TARGET_CONTAINER
ZUNIT_RUNNER_RESULT_TARGET_CONTAINER
ZUNIT_ENABLE_RUNNER_TRACE
ZUNIT_ADDITIONAL_JCL

Setting property group options for editors, compilers,

preprocessors, and build
Use the property group editor to set editor, preprocessor, compiler, and build options for your source files.
Many of the property group tabs use the same pages to set options for editors, preprocessors, compilers,
and build operations. The following table lists the pages that are reused and the tabs that use them. For
more information about a property group page, click a link in the table.
This topic and its subtopics describe the content of the property group pages. For more information about
how the options are used by editors, preprocessors, compilers, and build, debug, and test operations, see
these topics:
• Setting up property groups for editing
• Setting up preprocessors
• Building a z/OS application using property groups
• Property group options for DBB user builds
• Using property groups for debug sessions
• Launching a debug session with property groups

Table 2. Property group pages that are used on multiple tabs

Page Remote Property Group Tabs Local Property Group Tabs
Name
Asse BMS C/C++ COBO Link MFS Run ZUnit Asse COBO PL/I REXX
mbler L and mbler L
PL/I
Runti ✓
me
Enviro
nment
s
Proce ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓
dures
and
Steps

Setting up an Eclipse development environment 17

 Table 2. Property group pages that are used on multiple tabs (continued)
Page Remote Property Group Tabs Local Property Group Tabs
Name
Asse BMS C/C++ COBO Link MFS Run ZUnit Asse COBO PL/I REXX
mbler L and mbler L
PL/I
“Local ✓ ✓ ✓
Compi
ler
Optio
ns” on
page
28
Local ✓ ✓ ✓
Prepr
ocess
or
JCL ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓
Substi
tution
“Edito ✓ ✓ ✓
r
Config
uratio
ns
(remo
te
prope
rty
group)
” on
page
36
“Edito ✓ ✓
r
Config
uratio
ns
(local
prope
rty
group)
” on
page
37
Editor ✓ ✓
Optio
ns
Remo ✓ ✓ ✓ ✓
te
Librari
es

18 Developer for z/OS: Setting up an Eclipse Development Environment

Substitution variables in property group pages
You can use substitution variables in property group pages to increase their flexibility and portability.
The property group pages support the following substitution variables:

Variable Description Where it is allowed

<HLQ> The current high-level qualifier. Any field that takes
a data set name.
This variable gets its value from two different places, depending on
where you are using it in the product.
• In the z/OS Projects view, <HLQ> comes from the HLQ property
that is set on the subproject. The values available for <HLQ> in
the subproject come from the filters that you set in the Remote
Systems view. In a subproject, <HLQ> resolves to the value that is
set on the subproject.
• In the Remote Systems view, the <HLQ> is the leftmost qualifier
of the fully qualified data set member that you selected for the
action.

<JOBNAME> A generated job name for batch jobs. JCL job card on the
JCL Job Card and
Data Set page.
<MEM> The current data set member that you selected and upon which Any field that takes
the action is run. If you are building a subproject, it is the current a member name.
member that is processed in the course of the subproject build.
<USERID> The user ID that you used to connect to the remote system.

Choosing the Db2, CICS, or IMS runtime environment

Use the Runtime Environments page of the property group editor to choose Db2, CICS, or IMS as a
runtime environment for COBOL and PL/I applications.
The Runtime Environments page is available on the COBOL and PL/I property group tabs.
You can set the following runtime options:
• Db2: Indicates use of Db2, by using either the integrated Db2 coprocessor or a separate step.
• CICS: Indicates use of CICS, by using either the integrated CICS translator or a separate step. When
you select this option, the list is activated. Select the level of CICS that you are using on MVS. This
option determines the syntax that is used for content assistance in an edit session. The CICS level can
be changed or displayed in an edit session by using the CICSLevel editor command.
Tip: For more information about how to use the Db2 and CICS options, see the related links.
• IMS: Select this checkbox to enable IMS support. Choosing this option causes the IMS library field to
be displayed on the Procedures and Steps page.
Choosing the Db2 or CICS runtime environment adds the following options to the PARM card:
• The Db2 option:
– For COBOL: SQL
– For PL/I: PP(SQL),LIB
• The CICS option:
– For COBOL: CICS
– For PL/I: SYSTEM(CICS),PP(MACRO,CICS)

Setting up an Eclipse development environment 19

 These additions count toward the 100-character limit in the Compiler Options field of the Procedures
and Steps page.

Integrating Db2 support with remote COBOL and PL/I programs

You can integrate Db2 support into your build procedures for remote COBOL and PL/I programs.
To use Db2 precompilation support with remote COBOL and PL/I programs:
1. Edit the property group that is associated with the remote COBOL or PL/I program.
2. Click the COBOL or PL/I tab to open the COBOL Settings or PL/I Settings page.
3. On the Runtime Environments page, select the Db2 checkbox.
This action enables use of the integrated Db2 coprocessor.
4. Optional: If you want to use a separate Db2 precompiler, do these steps:
a) Open the Procedures and Steps page of the COBOL Settings or PL/I Settings.
b) Select either ELAXFCOP (for COBOL) or ELAXFPLP for PL/I and then click Enable Procedure.
If you are using a separate Db2 precompiler, you can specify the properties for the precompiler by
selecting a step under the ELAXFCOP or ELAXFPLP procedure. The Step Options area opens so that you
can specify the properties and options to be passed to the Db2 precompiler.

Adding CICS translation support to COBOL and PL/I applications

You can embed EXEC CICS statements into COBOL or PL/I code if you have a CICS translator available. If
your workbench is properly configured, these EXEC CICS statements are automatically expanded during
syntax checks and compilations by your CICS translator.

Integrated and separate CICS and Db2 steps

If your COBOL or PL/I programs use CICS or Db2, you can indicate whether to use the integrated CICS
translator or Db2 coprocessor or a separate step. Settings on the COBOL and PL/I Procedures and Steps
window control how JCL for these procedures is generated.

With COBOL programs

If you select DB2 on the Runtime Environments window and the ELAXFCOP procedure is disabled,
then ELAXFCOC is generated with PARMs that tell the compiler to use the integrated Db2 coprocessor.
However, if you select Db2 and the ELAXFCOP procedure is enabled, then ELAXFCOC is generated with
PARMs that tell the compiler not to use the integrated Db2 coprocessor. Instead, it uses the separate step
(ELAXFCOP). In either case, the compiler is started with ELAXFCOC, but whether it uses the integrated
Db2 coprocessor depends on the PARMs passed.
If you select CICS on the Runtime Environments window and the ELAXFCOT procedure is disabled,
then ELAXFCOC is generated with PARMs that tell the compiler to use the integrated CICS coprocessor.
However, if you select CICS and the ELAXFCOT procedure is enabled, then ELAXFCOC is generated
with PARMs that tell the compiler not to use the integrated CICS coprocessor. Instead, it uses the
separate step (ELAXFCOT). In either case, the compiler is started with ELAXFCOC, but whether it uses the
integrated CICS coprocessor depends on the PARMs passed.

With PL/I programs

If you select Db2 on the Runtime Environments window and the ELAXFPLP procedure is disabled,
then ELAXFPL1 is generated with PARMs that tell the compiler to use the integrated Db2 coprocessor.
However, if you select Db2 and the ELAXFPLP procedure is enabled, then ELAXFPL1 is generated with
PARMs that tell the compiler not to use the integrated Db2 coprocessor. Instead, it uses the separate step
(ELAXFPLP). In either case, the compiler is started with ELAXFPL1, but whether it uses the integrated Db2
coprocessor depends on the PARMs passed.
If you select CICS on the Runtime Environments window and the ELAXFPLT procedure is disabled,
then ELAXFPL1 is generated with PARMs that tell the compiler to use the integrated CICS coprocessor.

20 Developer for z/OS: Setting up an Eclipse Development Environment

 However, if you select CICS and the ELAXFPLT procedure is enabled, then ELAXFPL1 is generated with
PARMs that tell the compiler not to use the integrated CICS coprocessor. Instead, it uses the separate
step (ELAXFPLT). In either case, the compiler is started with ELAXFPL1, but whether it uses the integrated
CICS coprocessor depends on the PARMs passed.

Setting options for procedures and steps

Use the Procedures and Steps pages of the property group editor to edit, add, remove, or alter the order
of the supplied procedures and to display or edit step options.
The Procedures and Steps page is available on the Assembler, BMS, C/C++, COBOL, Link, MFS, PL/I,
Run, and ZUnit property group tabs.
The Procedure and step table lists the procedures and steps that are defined for the property group and
their status. It includes the following columns:
• Procedure Name: Displays the name of the procedures that are used to generate the steps. By default,
this option is set to match a procedure that is included with the product.
• Step Name: Displays the step name that is specified in the procedure. This step name is used to
generate any override DD cards or statements in the generated JCL, remote project builds, or remote
syntax check.
• Status: Indicates whether the step is enabled or disabled. This column is displayed only on the C/C++,
COBOL, and PL/I Procedures and Steps page.
You can set the following options for procedures and steps:
• Click a step name to display the options in the Step options area of the page.
• To change the status of a procedure, click the Status cell in that procedure's row and then click Enable
Procedure or Disable Procedure.
• Click Add Step to add a step.
The Add a New Step area of the page opens.
• Click Remove Step to remove the selected step from the procedure.
• Click Up or Down to move the selected step up or down in the procedure.
• When you select a step from the table, its name is displayed in the list below the table, and the options
that are defined for it are displayed in the Step options area of the page. To edit the procedure or step
name, click Edit beside the list and edit the names that are shown in the Procedure Name and Step
Name fields.
• Click Check Data Sets to check that data sets specified in the step options field exist on the remote
system.
Note: If a data set name contains the <HLQ> variable substitution, Check Data Sets cannot validate
the data set name.
• For more information about specific step options, see the following topics:
– “Assembler step options” on page 22
– “BMS step options” on page 22
– C and C++ step options
– “CICS translator step options” on page 23
– “COBOL and PL/I step options” on page 23
– “Db2 precompiler step options” on page 25
– “Link step options” on page 26
– “MFS step options” on page 25
– “Runtime step options” on page 27

Setting up an Eclipse development environment 21

 Assembler step options
Use the Assembler Step Options to edit the ASM step of the ELAXFASM JCL procedure that is included
with the product. Before you start, verify that the ELAXFASM procedure is customized for your site. For
more information about customizing the ELAXF* JCL procedures, see ELAXF* remote build procedures.

Purpose
The options that you specify on this window are used to generate JCL for the selected procedure.
Tip: For fields that take partitioned data sets as their value, you can drag a partitioned data set name from
the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in the
field. To change the order of partitioned data set names in a field, place the cursor in the field and click
Change Order from the menu.

Fields
Assembler options: The list of assembler options. Separate multiple entries with spaces. This list
constitutes a PARM parameter for the EXEC statement that is used to assemble your program. This field
is limited to 100 characters and the limit is imposed by the JCL processing. Developer for z/OS displays a
warning when this limit is reached. This limit includes not only the characters you type into this field, but
also any parameters that are concatenated with these parameters.
Note: If you reach this limit because of several assembler options that are specified, check your JES
listing to ensure that you are not specifying duplicate assembler options. Your JCL assembler procedure
must contain the default assembler options that are required for error feedback, and any site-specific
standards for assembler options.
Listing output data set: The name of the listing data set used for the assembly. The listing data set must
be a partitioned data set. This data set is used to make up a SYSPRINT card for the assembly.
Object deck data set: The name of the object deck data set used for the assembly. The object deck data
set must be a partitioned data set. This data set is used to make up a SYSLIN card for the assembly.
Macro libraries: The list of partitioned data sets containing segments of source that are the macro files.
These data set names must be separated by spaces. This field is used only by the z Systems LPEX Editor
for both copy libraries and macro libraries. It is not used by the HLASM Editor.
Copy libraries: A list of partitioned data sets containing copybooks. Separate data set names by spaces.
This field is used only by the HLASM Editor. It is not used by the z Systems LPEX Editor. The z Systems
LPEX Editor uses the Macro libraries field to locate copybooks.
Support Error Feedback: Select this checkbox to log errors that are generated by the assembler.
Data set qualifier for compiler errors: Errors that are generated by the assembler are logged to a file that
is named with this qualifier. This function is supported only if Support Error Feedback is enabled.
Additional JCL: Use this field to specify your own JCL. Extra data definitions (DD cards) can be specified
here. The contents of this field are echoed at the end of the assembly step. You must specify syntactically
correct JCL.

BMS step options

Use the BMS Step Options to edit the ASMMAP step of the ELAXFBMS JCL procedure that is included
with the [Link] you start, verify that the ELAXFBMS procedure is customized for your site. For
more information about customizing the ELAXF* JCL procedures, see ELAXF* remote build procedures.

Purpose
The options that you specify on this window are used to generate JCL for the selected procedure.

Fields
BMS Map Object Library: The location where the generated physical map object is placed.

22 Developer for z/OS: Setting up an Eclipse Development Environment

BMS DSECT Step Name: The name of the step for assembling macros to produce the symbolic map.
BMS DSCTLIB Library: The location where the symbolic map is placed.
Note: For fields that take partitioned data sets as their value, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.

CICS translator step options

Use the CICS Translator Step Options to specify properties and options to be passed to the CICS
[Link] you start, verify that the ELAXFCOT procedure for COBOL or the ELAXFPLT procedure for
PL/I is customized for your site. For more information about customizing the ELAXF* JCL procedures, see
ELAXF* remote build procedures.

Purpose
The options that you specify on this window are used to generate JCL for the selected procedure. The
information that you provide on this window pertains to remote COBOL or PL/I compiler options.

Fields
Options: Specify any options that must be passed to the CICS translator. Separate multiple entries with
spaces. This field is limited to 100 characters.
SYSLIB: Specify SYSLIB data set names. Separate multiple entries with spaces. You can drag a
partitioned data set name from the Remote Systems view, z/OS Projects view, or Remote z/OS Search
results view and drop it in the field. To change the order of partitioned data set names in a field, place the
cursor in the field and click Change Order from the menu.

COBOL and PL/I step options

Use the COBOL and PL/I Compile Step Options to edit the COBOL compile step of the ELAXFCOB JCL
procedure or the PLI compile step of the ELAXFPL1 JCL procedure that is included with the product.
Before you start, verify that the ELAXFCOB and ELAXFPL1 procedures are customized for your site. For
more information about customizing the ELAXF* JCL procedures, see ELAXF* remote build procedures.

Purpose
The options that you specify on this window are used to generate JCL for the selected procedure. The
information that you provide on this window pertains to remote COBOL or PL/I compiler options. Use the
Local Compiler Options page to set options for local compilations.
Note: For fields that take partitioned data sets as their value, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.

Fields
Append compiler options to the PARM card: Select this checkbox to append the compiler options to
the JCL procedure PARM card. Clear it to replace the options currently specified in the PARM card. This
checkbox is enabled when you type a value into the Compiler options field.
Compiler options: The list of COBOL or PL/I compiler options, separated by spaces. This list constitutes a
PARM parameter for the EXEC statement used to compile your program.
Note: Your JCL compile procedure should contain the default compiler options required for error
feedback, as well as any site-specific standards for compiler options.
If you are using COBOL and specifying a list of compiler options that is too long to include in the generated
JCL, the OPTFILE compiler option will be generated, and the specified compiler option will be written in

Setting up an Eclipse development environment 23

 an inline file in the generated JCL card FELOPTF, which is referenced by the SYSOPTF card by default in
the ELAXFCOC JCL compiler procedure. This can be tailored in your JCL compile procedure for COBOL.
See the related topics for more information about the OPTFILE compiler option.
If you are using PL/I, and your compiler options contain more than 100 characters, a +DD:FELOPTF
compiler option is generated which directs PL/I to reference the JCL card FELOPTF that contains your
compiler options.
• For COBOL, ELAXMGUX is a user exit responsible for obtaining error records from the compilation. There
must be a STEPLIB to the data set containing the member ELAXMGUX, or ELAXMGUX must be in the LPA
or system load module libraries. See the compiler options reference in the COBOL Programming Guide
for details on specific options.
• For PL/I, the compiler option XINFO(XML) must be specified for error messages to be routed to the
task list. See the PL/I Programming Guide for details on specific options.
Listing output data set: The name of the listing data set used for the compilation. The listing data set
should be a partitioned data set. This data set is used to make up a SYSPRINT card for the compilation.
Debug data set: The name of the debug side file data set where the compiler generates the debug side
files. This option is only valid if your compiler's TEST option has its SEPARATE suboption set. The debug
side file data set is used to generate the SYSDEBUG DD card during compilation. If no value is specified
in this field, the SYSDEBUG DD card is not generated. Debug Tool also uses this side file. The SYSDEBUG
data set can be F or FB, with LRECL ranging from 80 to 1024.
Object deck data set: The name of the object deck data set used for the compilation. The object deck
data set should be a partitioned data set. This data set is used to make up a SYSLIN card for the
compilation.
SYSLIB: Specify libraries for resolving copybooks or include files. To add a library to this list, click Add.
To reorder the list, click the Up and Down buttons. To delete a library from the list, select it and click
Remove.
COPYLOC: Specify libraries and set copybook locations. The copybook added using COYPLOC are added
to the list of libraries at the tail end. You can load UNIX based copybooks in this way particularly. To add
UNIX files, PATH is used instead of DSN (for MVS files).
Support Error Feedback: Select this checkbox to log errors generated by the compiler.
Data set qualifier for compiler errors: Errors generated by the compiler are logged to a file that is named
with this qualifier. This function is supported only if Support Error Feedback is enabled.
Additional JCL: Specify your own JCL, such as additional data definitions (DD cards). The contents of this
field are echoed at the end of the compilation step. You must specify syntactically correct JCL.
IMS library: Name your IMS library. Specify only one entry. This field appears only when IMS is selected
on the Runtime Environments page.

Using COPYLOC in property group

Use the COPYLOC command in the property group for mixed locations for copybooks and set the
copybook locations in the compiler options.
COBOL V6.2 adds support for mixed locations for copybooks and allowing copybook locations to be set
in the compiler options. This support is provided by the COPYLOC command. For more information, see
Quick Look: COBOL 6.2 COPYLOC Option.
The compiler checks the SYSLIB locations first. Then it checks locations specified in the COPYLOC
compiler option. The search for a COPYLOC member is performed according to the following rules:
• If an explicit library name is specified in the COPYLOC statement, the name is assumed to correspond to
a ddname that has been allocated to a concatenation of data sets in which the compiler will search for
the copy member. If no library name is specified in the COPYLOC statement, the concatenation of data
sets allocated to the SYSLIB ddname is searched.

24 Developer for z/OS: Setting up an Eclipse Development Environment

• If the copy member was not found during the above search, all locations specified via the COPYLOC
option will be searched in the order that they were specified. These locations can include a mix of z/OS
UNIX directories and PDS or PDSE data sets.
To use the COPYLOC command, you need to add COPYLOC statements to the remote compiler options
field in the property group.
1. Create a COBOL property group and associate it with the COBOL file.
2. On the COBOL Settings page, click Procedures and Steps.
3. Expand the ELAXFCOC procedure and click the COBOL step.
4. Scroll to the Compiler options field.
5. Add COPYLOC statements to the Compiler options field.
6. Edit the file. Copybooks are resolved using the COPYLOC statements.
Note:
Do not use spaces in the COPYLOC statement. You can use spaces to separate multiple COPYLOC
statements.

Db2 precompiler step options

Use the Db2 Precompiler Step Options to specify properties and options to be passed to the Db2
[Link] you start, verify that the ELAXFCOP procedure for COBOL or ELAXFPLP procedure for
PL/I is customized for your site. For more information about customizing the ELAXF* JCL procedures, see
ELAXF* remote build procedures.

Purpose
The options that you specify on this window are used to generate JCL for the selected procedure. The
information that you provide on this window pertains to remote COBOL or PL/I compiler options.

Fields
Options: Specify Db2 preprocessing options; separate multiple options with spaces. This field is limited to
100 characters.
SYSLIB: Specify SYSLIB for Db2 preprocessing; separate multiple entries with spaces.
Database Request Module Location (DBRM): The main output from the precompiler is a database
request module (DBRM). A DBRM is a data set that contains SQL statements and remote system variable
information that is extracted from the source program during program preparation. The purpose of a
DBRM is to communicate your SQL requests to Db2 during the bind process. Specify only one entry.
SYSTSIN Instructions: Type Db2 Plan instructions in this field. The field is echoed into the generated
JCL. Currently, a sample is specified but commented out. You can uncomment the sample and make any
necessary changes. The entry field must start with //SYSTSIN DD DD * followed by instructions or with
a pointer to a data set containing the instructions.
Note: For fields that take partitioned data sets as their values, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.

MFS step options

Use the MFS Compiler Options to edit an MFS compilation step that is included with the product.

Purpose
The options that you specify on this window are used to generate JCL for the selected procedure.

Setting up an Eclipse development environment 25

 Note: For fields that take partitioned data sets as their value, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.

Fields
Compiler options: Use this field to override the default compiler options in the JCL procedure. Separate
multiple options by spaces. This list constitutes a PARM parameter for the EXEC statement used to
compile your program. You must specify syntactically correct options because they are not verified in the
property group editor.
Note: Your JCL compile procedure should contain the default compiler options as well as any site-specific
standards for compiler options.
Compile Step2 name: The name of step 2 in the JCL compilation procedure. Do not change this value
without consulting with the system programmer who set up and customized the JCL procedure.
FORMAT library: Specify a partitioned data set containing device format definitions.
Listing output data set: The name of the listing data set used for the compilation. The listing data set
should be a partitioned data set. This data set is used to make up a SYSPRINT card for the compilation.
SYSLIB: Specify libraries for resolving copybooks or include files. To add a library to this list, click Add.
To reorder the list, click the Up and Down buttons. To delete a library from the list, select it and click
Remove.
Additional JCL: Specify your own JCL, such as additional data definitions (DD cards). The contents of this
field are echoed at the end of the compilation step. You must specify syntactically correct JCL.

Link step options

Use the Link Step Options to specify link settings, including link options and JCL-related options and
properties.

Fields
Link options: Specify any options that must be passed to the linkage editor. This field is limited to 100
characters.
Link libraries: The names of the libraries to link your code with. Separate multiple libraries with spaces.
Specify the position of the link libraries: Select this checkbox to leave a place holder for the libraries
that might already be listed in your procedure.
How many existing link library data sets precede this entry? Specify how many libraries you want in
your expanded JCL before the link libraries specified in the Link libraries field.
Use specified link instructions: Select this checkbox to pass link instructions to the linkage editor.
Selecting this check box activates the text-entry pane, where you can enter the link instructions.
Note: If the link instructions are being used and the specified instructions already include the required
system object (i.e. - INCLUDE OBJ0000), the JCL generator will not generate the required system
INCLUDE instruction prior to the link instructions you specified. You need to include the proper objects in
the order you want.
Load module location: The data set where your load module must be placed after the link step.
Additional JCL: Specify any additional JCL. You might use this field to override any default values defined
in the step by your system administrator.
Note: For fields that take partitioned data sets as their values, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.

26 Developer for z/OS: Setting up an Eclipse Development Environment

Runtime step options
Use the Runtime Step Options to specify the runtime settings, including options and JCL-related options
and properties.
Program parameters: Specify parameters to be passed to the program. This field is limited to 100
characters.
Runtime options: Specify options to be invoked at run time. This field is limited to 100 characters.
Select the order of Runtime options and Program parameters: Use these options to determine the
order in which you are passing program parameters and runtime options. Your Language Environment®
runtime options might be altered to switch the order of runtime options and program parameters.
By default, for COBOL programs, select Program parameters/Runtime options. For PL/I, C/C++, and
Assembler programs, select Runtime options/Program parameters.
Additional JCL: Specify any additional JCL. You might use this field to override any default values defined
in the step by your system administrator.

Customizing build steps

You can customize the build procedures that are designed by your MVS system administrator by
overriding the default values used in the steps.
You must know the names of the steps within these build procedures and what values must be modified.
Your MVS system administrator can provide you with this information.
You must customize build steps before you attempt to build your COBOL, PL/I, or Assembler source code.
The following steps can be used to customize a build step for COBOL source code, but you can use a
similar process to customize a build step for PL/I or Assembler source code.
1. Click the COBOL, PL/I, or Assembler tab of the property group editor.
2. Click Procedures and Steps.
3. For COBOL or PL/I, select the procedure you want to customize in the table and click Enable
procedure.
The procedure must be enabled before you can customize it.
4. Click Add Step.
The Add a New Step area opens.
5. Type the name of the step you want to customize in the Step Name field.
Note: If no step with the specified name exists in the selected procedure, the build procedure returns
a JCL error when submitted. You can add only that steps that exist in the procedure that is designed by
your MVS system administrator.
6. Specify any options that must be passed to the step in the Options field.
7. Specify any additional JCL in the Additional JCL field.
For example, you might use this field to override any default values defined in the step by your MVS
system administrator.
8. Click OK.
The customized build step is added under the selected procedure in the table.
You can now modify the step definition by double-clicking it. You can also change the order in which steps
are run by selecting a step and clicking Up and Down.

Setting compiler options for show dependencies and remote syntax check
To use the show dependencies and remote syntax check functions, you must set up appropriate compiler
options.
Developer for z/OS provides show dependencies and remote syntax check functions that detect
dependencies for COBOL, PL/I, and Assembler programs. These functions use the COBOL and PL/I

Setting up an Eclipse development environment 27

 compilers and High Level Assembler to locate the copy members, include files, and macros that are
needed to compile a program properly. These functions are available from a number of locations in the
Developer for z/OS interface:
• From the z/OS Projects view, select a local or remote COBOL or PL/I file or a remote Assembler file, or a
local project that contains COBOL or PL/I files and then select Show Dependencies.
Note: The Show Dependencies action is not supported for sequential data sets.
• From the Work Offline wizard, select Show Dependencies on the Show Dependencies for Selected
Resources page.
• From the z/OS Projects view or an editor, select or open a COBOL, PL/I, or Assembler file and then
select Remote Syntax Check or press Ctrl+Alt+R.
To set compiler options for a show dependencies or remote syntax check operation, do these steps:
1. On the Procedures and Steps page of the COBOL, PL/I, or Assembler tab in the property group editor,
expand the ELAXFCOC, ELAXFPL1, or ELAXFASM procedure name.
2. Double-click the COBOL, PLI, or ASM step.
The Step Options area opens.
3. Select the Support Error Feedback check box.
This checkbox prompts the compiler to allocate an XML file during show dependencies or remote
syntax check operations. The show dependencies and syntax check operations parse this XML file to
display dependent files.
4. In the Data Set Qualifier for Compiler Errors field, type a qualifier to which you have access to
allocate data sets.
This data set qualifier is used as a prefix for the names of the data sets that are allocated during the
syntax check, show dependencies, and rebuild process.
If show dependencies or remote syntax check requests do not succeed after you set these options, check
that the TSO command server is configured properly. A simple way to check this server is to allocate a
data set from the z/OS Projects view or Remote Systems view.

Local Compiler Options

Use this page in a local property group to specify options for local COBOL or PL/I builds and compilations,
or in a remote property group to resolve local copy and include libraries in the COBOL Editor or PL/I Editor.
The z Systems LPEX Editor does not use this page to resolve local copy or include libraries.
Compiler options: Specify options to be passed to the local COBOL or PL/I compiler. Separate multiple
options with commas.
SYSLIB: Specify libraries for resolving copybooks or include files. To add a library to this list, click Add.
To reorder the list, click the Up and Down buttons. To delete a library from the list, select it and click
Remove.
The "Add a folder" window supports global patterns, such as **/COPY. To enter a global pattern, click
Text Input and type the folder search strings into the text pane. Enter one global pattern per line. You
can also use the ${project_loc} variable to help generalize project builds. This variable specifies the
project location. It can be used to add the location on disk of the project. If you must pass the name of
a folder in your project to your preprocessor, you can specify it as ${project_loc}\folder1. Upon
invocation of the preprocessor, ${project_loc} is substituted.
Environment variables: Specify any environment variables that are required by the source program.
Source contains EXEC CICS statements: Select this check box to start a COBOL or PL/I preprocessor to
process EXEC CICS statements in your source. Checking this box activates CICS options.
CICS options: Specify any options to be passed to the preprocessor. The product can provide the correct
Preprocessor options for the version of CICS that is installed on the workstation. This field is limited to
100 characters.

28 Developer for z/OS: Setting up an Eclipse Development Environment

Defining copy, include, and macro libraries
Property groups provide multiple places where you can define copy, include, and macro libraries for
local and remote source files. These multiple locations provide flexibility for writing code, checking
dependencies, and compiling code across a hybrid system that includes files on your workstation client
or a Git repository (local files), and files on an MVS or z/OS UNIX System Services system (remote files).
Use this table to understand where to define copy, include, and macro libraries so that the product
editors can find dependent [Link] High Level Assembler files, the HLASM Editor and the z Systems LPEX
Editor locate and support copy and macro files differently. For a summary of defining libraries for the two
editors, see “Copy and macro library support in HLASM files” on page 32.
Note: Remote property groups include pages and fields for specifying local libraries and remote libraries.
When both local and remote libraries are defined in a remote property group, the local libraries are
searched first. This search order applies only to resolving copy or include files. It does not apply to
compilation on a remote system. Compilers on a remote system search only the remote libraries for copy,
include, or macro files.
Although the Assembler page of remote property groups contains fields for defining local macros, local
macros are not supported in remote property groups.

Table 3. Where to define copy, include, and macro libraries

And the copy, Define copy, include, or macro libraries here:
If the source include, or
file is on a macro file is on Property Tab Page Field
a Group Location

Macro Libraries
Assembler Local Options
Copy Libraries1

Local system Local system Local Compiler

COBOL or PL/I SYSLIB
Options
Local REXX
REXX SYSLIB
Options
Remote Macro
Libraries >
Connection
name2
Remote Macro
Local system Libraries >
Remote Library table3
Assembler
Libraries Remote Copy
Remote system Local system Libraries >
Connection
name2
Remote Copy
Libraries >
Library table1
COBOL or PL/I Copy Libraries Library table
Include
REXX All fields
Libraries

Setting up an Eclipse development environment 29

 Table 3. Where to define copy, include, and macro libraries (continued)
And the copy, Define copy, include, or macro libraries here:
If the source include, or
file is on a macro file is on Property Tab Page Field
a Group Location

Procedures and Macro libraries3

Assembler steps > Step
options Copy libraries1

Procedures and
Remote system Remote system
COBOL or PL/I steps > Step SYSLIB
options

Remote system Remote REXX

REXX SYSLIB
Options
Assembler Local Options Copy libraries1
Local Compiler
COBOL or PL/I SYSLIB
Local system Remote system Options
Local REXX
REXX SYSLIB
Options

1. These fields are used only by the HLASM Editor. They are not used by the z Systems LPEX Editor.
2. For remote macro and copy libraries to be found, you must specify a connection name and be
connected to the z/OS system.
3. This field is used only by the z Systems LPEX Editor. For remote files, the HLASM Editor searches the
[Link] library by default, and no property group definitions are necessary.

Defining libraries for local projects and files

You can define local or remote libraries that can be used for real-time syntax checking and open file
operations in local Assembler, COBOL, PL/I, and REXX files that are open in the [Link] topic describes
how to define local and remote libraries for COBOL, PL/I, and REXX files. For High Level Assembler files,
the HLASM Editor and the z Systems LPEX Editor locate and support copy and macro files differently. For a
summary of defining libraries for the two editors, see “Copy and macro library support in HLASM files” on
page 32.

Before you start

Define a local property group for a local COBOL, PL/I, or REXX file, or associate an existing local property
group with the file on which you want to run operations, such as real-time syntax checking and open
copybook or include file.
When you run operations that require access to copybooks and include files from local source files, the
editors use property group settings to locate the files:
• It locates local files by using the SYSLIB field or Environment variables field of the Local Compiler
Options page for COBOL or PL/I files, and the Local REXX options page for REXX files. These fields
specify an ordered list of local file paths to search for copybooks, include files, or macros.
• It locates remote copy and include files by using the Copy Libraries page for COBOL, or the Include
Libraries page for PL/I or REXX.
The editors search these libraries in the following order:
1. If both local and remote libraries are defined in the property group, the editors search the local
libraries first and then the remote libraries.
2. If no local libraries are defined, the editors search only the remote libraries.

30 Developer for z/OS: Setting up an Eclipse Development Environment

3. If no remote libraries are defined, the editors search only the local libraries.

Defining local libraries

1. To define libraries:
2. In the z/OS Projects view, right-click a local project or file and click Property Group > Edit Associated
Property Group.
The property group editor opens.
3. Click the COBOL, PL/I, or REXX tab at the bottom of the editor.
4. To set the local libraries, choose Local Compiler Options or Local REXX Options from the list of
categories on the left.
5. In the SYSLIB field, specify the local file path of the library. To specify local libraries other than
SYSLIB, use the Environment variables field.
Tip: The "Add a folder" window supports global patterns, such as **/COPY. To enter a global pattern,
click Text Input and type the folder search strings into the text pane. Enter one global pattern per line.

Defining remote libraries

When you define remote libraries for a local project or file, the following actions or features are disabled
for that project or file:
• Show remote dependencies
• Local preprocessor support
1. To set the remote libraries, choose Copy Libraries, Include Libraries, or Remote Libraries from the
list of categories at the left.
2. From the Connection name list, choose a remote system.
3. Click Add, Edit, or Remove to add copy or include libraries to the table, edit the entries in the table, or
remove entries from the table.
When you click Add or Edit, a window opens prompting you for a library name and a data set name.
4. In the Library name field, type a name for the library.
For example, type SYSLIB.
• The table can have only one SYSLIB entry.
• The table allows for the specification of a name other than SYSLIB for the library, as in the following
examples. The editor searches the partitioned data sets defined in MYLIB instead of SYSLIB. If you
have the following statements in COBOL or PL/I code you can use this field to define the library name
MYLIB.
– COBOL example: COPY MYFILE OF MYLIB.
– PL/I example: %INCLUDE MYLIB (MYFILE);
5. In the Library path field, type one or more partitioned data set names to search and click OK.
Separate multiple data set names with space, as in the following example. The editor searches the
data sets in the order listed.
The following screen capture shows an example of remote copy libraries defined for a local project:

Defining macro files for Assembler programs (z Systems LPEX Editor)

You can define macro files for remote Assembler resources that are open in the z Systems LPEX Editor
in a remote property group or on the HLASM Parser preference page. For local Assembler resources,
you must define them in the HLASM Parser preference page. This topic describes how the z Systems
LPEX Editor locates macro files. For High Level Assembler files, the HLASM Editor and the z Systems LPEX

Setting up an Eclipse development environment 31

 Editor locate and support copy and macro files differently. For a summary of defining libraries for the two
editors, see “Copy and macro library support in HLASM files” on page 32.
You can define the location of IBM supplied base macro files and user macro files in two locations:
• In a remote property group that is associated with a resource.
• In the HLASM Parser preference page. For more information about this preference page, see Setting
HLASM Parser preferences.
You can use a user macro file to hide the IBM shipped macros defined in the base macro file from the
HLASM parser or to define custom macro syntax to the parser.
Important: User macro file definitions in remote property groups take precedence over the user macro
definitions on the HLASM Parser preference page. If an Assembler resource has a remote property group
associated with it, but the user macro file is not defined in the property group, then no user macro file is
used.
To define macro files in a remote property group:
1. Open a remote property group and click the Assembler tab.
The Assembler Settings page opens.
2. Click Editor Options in the navigation pane.
The Editor Options page opens.
3. To specify the macro file that stores the IBM-supplied macro definitions, in the Base Macro File
field, click Browse to navigate to the location of the macro file, or type the fully qualified name of
the file by using a drive letter or UNC path. You can use environment variables such as %ENVVARS%
\[Link], where %ENVVARS% points to the location of the file. You can also specify a
partitioned data set member or a sequential data set.
4. To specify a user macro file that stores user macro definitions, do these steps:
a) Create a user macro file with any file-name extension.
b) In the User Macro File field, click Browse to navigate to the location of the macro file, or type the
fully qualified path of the file, for example, \\HOSTNAME\MyFolder\my_macro_file.dat. You
can use environment variables such as %ENVVARS%\[Link], where %ENVVARS% points to
the location of the file. You can also specify a partitioned data set member or a sequential data set.
5. Optionally, specify the CICS level that the HLASM parser is to use when EXEC CICS statements are
encountered.
6. Press Ctrl+S to save your changes.
If you modify the base macro file, you need to reload it in the editor by doing one of these steps:
• Type the following command in the editor command line:

reloadTPFMacrosFile

• Right-click in the editor and select Reload Base Macros File.

To reload a user macro in the z Systems LPEX Editor, do one of these steps:
• Type the following command in the editor command line:

reloadUserMacrosFile

• Right-click in the editor and select Reload User Macros File.

Copy and macro library support in HLASM files

IBM Developer for z/OS supports two editors for HLASM files: the HLASM Editor and the z Systems
LPEX Editor. Both of these editors support copy and macro libraries, and both support local custom
macros. Additionally, the z Systems LPEX Editor supports base and remote custom macro files. For more
information about defining base and custom macro files for the z Systems LPEX Editor, see “Defining
macro files for Assembler programs (z Systems LPEX Editor)” on page 31. The HLASM Editor and the

32 Developer for z/OS: Setting up an Eclipse Development Environment

z Systems LPEX Editor both use property groups to locate copy and macro files, but they use different
pages and fields. Use the information in this topic to understand how each editor resolves copy and macro
libraries and how to set up property groups for copy and macro library support in HLASM files.

Summary of copy and macro library support

HLASM Editor
The HLASM Editor uses the Copy Libraries lists in local and remote property groups to resolve copy
libraries. It resolves local macro files by searching the Macro Libraries list in local property groups.
It resolves remote macro files by searching [Link] on a remote system. To resolve macros in
[Link] for source files on a remote system, you do not have to set this up in a remote property
group. To resolve macros in [Link] for source files on a local system, you must point to a
remote connection in a local property group.
z Systems LPEX Editor
The z Systems LPEX Editor uses the Macro Libraries fields in local and remote property groups to
resolve both copy files and macro files. It does not make use of the Copy Libraries fields. It does not
support the resolution of local copy or macro files from remote source files.

Property group settings

You can use this table to determine where to define the location of copy and macro files for each editor.
Note: Remote property groups include pages and fields for specifying local libraries and remote libraries.
When both local and remote libraries are defined in a remote property group, the local libraries are
searched first. This search order applies only to resolving copy or include files. It does not apply to
compilation on a remote system. Compilers on a remote system search only the remote libraries for copy,
include, or macro files.
Although the Assembler page of remote property groups contains fields for defining local macros, local
macros are not supported in remote property groups.

Setting up an Eclipse development environment 33

 Table 4. Defining the location of copy and macro files for HLASM source
Editor Location of Define local Define local Define remote Define remote
source file copy libraries macro libraries copy libraries macro libraries
in in in in
HLASM Editor Local Property Property Property Property
Group: Group: Group: Group:
Local Local Local Local
Tab: Tab: Tab: Tab:
Assembler Assembler Assembler Assembler
Page: Local Page: Local Page: Page:
Options Options Remote Remote
Field: Copy Field: Macro Libraries Libraries
Libraries Libraries Fields: Fields:
Connection Connection
name and name. The
Library editor
Name/ searches for
Library Path macro files
table in in the
theRemote [Link]
Copy IB library of
Libraries the
section connection
name. The
connection
name can be
defined in
either the
Remote
Copy
Libraries
section or
the Remote
Macro
Libraries
section.

Remote Property Not supported Property No definition

Group: Group: needed. The
Remote Remote editor searches
Tab: Tab: for macro files
Assembler Assembler in the
[Link]
Page: Local Page:
library of the
Options Procedures
z/OS system
Field: Copy and Steps
where the
Libraries Fields: source file is
Assembler located. If a
Step macro is not in
Options the
area:Copy [Link]
libraries library, it is not
field found.
34 Developer for z/OS: Setting up an Eclipse Development Environment
Table 4. Defining the location of copy and macro files for HLASM source (continued)
Editor Location of Define local Define local Define remote Define remote
source file copy libraries macro libraries copy libraries macro libraries
in in in in
z Systems LPEX Local Property Property Property Property
Editor Group: Group: Group: Group:
Local Local Local Local
Tab: Tab: Tab: Tab:
Assembler Assembler Assembler Assembler
Page: Local Page: Local Page: Page:
Options Options Remote Remote
Field: Macro Field: Macro Libraries Libraries
Libraries Libraries Fields: Fields:
Connection Connection
name and name and
Library Library
Name/ Name/
Library Path Library Path
table in the table in the
Remote Remote
Macro Macro
Libraries Libraries
section. section.

Remote Not supported Not supported Property Property

Group: Group:
Remote Remote
Tab: Tab:
Assembler Assembler
Page: Page:
Procedures Procedures
and Steps and Steps
Fields: Fields:
Assembler Assembler
Step Step
Options Options
area:Macro area:Macro
libraries libraries
field field

Local Options
Use this page to specify local macro and copy libraries for Assembler source files. For information about
configuring macro files for local Assembler resources open in the z Systems LPEX Editor, see Setting

Setting up an Eclipse development environment 35

 HLASM Parser preferences. For a summary of copy and macro library support for the HLASM and z
Systems LPEX Editor, see “Copy and macro library support in HLASM files” on page 32.
Note: Remote property groups include pages and fields for specifying local libraries and remote libraries.
When both local and remote libraries are defined in a remote property group, the local libraries are
searched first. This search order applies only to resolving copy or include files. It does not apply to
compilation on a remote system. Compilers on a remote system search only the remote libraries for copy,
include, or macro files.
Although the Assembler page of remote property groups contains fields for defining local macros, local
macros are not supported in remote property groups.
To add a macro or copy library, click Add and then use the "Add a folder" window to choose a folder. The
"Add a folder" window supports global patterns, such as **/COPY. To enter a global pattern, click Text
Input and type the folder search strings into the text pane. Enter one global pattern per line.
Use the Edit and Remove buttons to change or delete an entry from this list. Use the Up and Down
buttons to reorder the entries in the list.
The Copy Libraries list is used only by the HLASM Editor.

Editor Configurations (remote property group)

Use this page to define the location of called program search libraries and to configure a preprocessor for
COBOL or PL/I source program files. When you configure a preprocessor in the property group, the editor
can start the preprocessor and identify any coding issues before compilation.
Called program search libraries: Specify the local directory paths or remote libraries where the editor
searches for files that are referred to in statements such as the CALL statement. The Open File, Browse
File, and View File editor commands use these libraries to find called files. This field does not set copy
and include libraries. Use the SYSLIB field to define copy and include libraries.
Note: For fields that take partitioned data sets as their value, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.
Use local preprocessors: Choose this option to use a local preprocessor. Use the Local Preprocessor
page to set preprocessor options.
Use preprocessor extension: Choose this option to use an installed preprocessor extension. Choose a
preprocessor extension from the Preprocessor extension list.
Note: This option is displayed only when one or more preprocessor extensions are installed in the product
workspace. If this option is not displayed on the page, then no preprocessor extension is installed in the
product workspace. For more information about configuring a preprocessor extension, see the related
topics.
Use remote preprocessors: Choose this option to use a remote preprocessor. Use the fields in the
Remote preprocessor configuration area of this page to set remote preprocessor options.
REXX or CLIST invoking preprocessor: Specify the name of the REXX script or CLIST on the
remote system that starts remote preprocessors. It must be a partitioned data set member. It can
be a user-defined script or the sample PL/I macro preprocessor FEKRNPLI, located by default in
[Link](FEKRNPLI).
Preprocessor output location: Specify the fully qualified name of an output file to be generated and
downloaded from the remote system to the workstation after a remote preprocessor is started. It must be
either a partitioned data set member or a sequential data set. If you specify a partitioned data set name
without a member name, such as [Link]( ), the member name of the program that you are editing is
used.
High-level qualifier for preprocessor data: Specify a qualifier to be used to allocate a temporary
sequential data set. The product writes data to this data set to be read by the REXX script or CLIST

36 Developer for z/OS: Setting up an Eclipse Development Environment

 on the remote system. The sequential data set is deleted after the REXX script or CLIST runs successfully.
If the script fails, the data set is not deleted.
Preprocessor parameters: Specify any additional information that is needed for the REXX script or CLIST
to start the remote preprocessors.
PL/I: If you specify the FEKRNPLI PL/I macro preprocessor, then the following preprocessor parameters
are needed for it to run successfully. For full instructions on using the preprocessor and a complete list of
options you can specify, see the comments in the header of the FEKRNPLI member.
• Specify an output listing sequential data set in a <SYSPRINT>dataSetName</SYSPRINT> parameter.
The sequential data set that you specify in this parameter must be allocated before you run the
preprocessor.
• If your compiler options contain more than 100 characters, specify a compiler options file in
an <OPTIONS>dataSetName</OPTIONS> parameter. You can specify a sequential data set or a
partitioned data set member.
Important: To use a compiler options file, you must also specify +DD:OPTIONS in the Compiler options
field of the PL/I Compile Step Options section on the Procedures and Steps page in the property
group.

Editor Configurations (local property group)

Use this page to define the location of called program search libraries and to configure a preprocessor.
When you configure a preprocessor in the property group, the editor can start the preprocessor and
identify any coding issues before compilation.
Local libraries: Specify the local folder where the editor searches for files that are referred to in
statements such as the CALL statement. Separate multiple folders with semicolons (;). The Open File
and Browse File editor commands use these libraries to find local called files. This field does not set copy
and include libraries. Use the SYSLIB field to define copy and include libraries.
Connection name: To define a remote library, select a remote connection from this list.

Setting up an Eclipse development environment 37

 Remote libraries: Specify the remote data sets where the editor searches for files that are referred to in
statements such as the CALL statement. The Open File, Browse File, and View File editor commands
use these libraries to find remote called files. This field does not set copy and include libraries. Use the
SYSLIB field to define copy and include libraries.
Note: For fields that take partitioned data sets as their value, you can drag a partitioned data set name
from the Remote Systems view, z/OS Projects view, or Remote z/OS Search results view and drop it in
the field. To change the order of partitioned data set names in a field, place the cursor in the field and
click Change Order from the menu.
Use local preprocessors: Choose this option to use a local preprocessor. Use the Local Preprocessor
page to set preprocessor options.

Local preprocessor options

You can define and select which local preprocessor options to use to build local and remote COBOL and
PL/I programs.
The Local Preprocessor page is available on the COBOL and PL/I property group tabs.
You use the Local Preprocessor page of the property group editor to specify information about local
preprocessors to be started before the local COBOL or PL/I compiler. For more information about setting
local preprocessor options, see the related links.

Setting local preprocessor options

You can set options for local preprocessors.
Define a property group on a local or remote system.
Local preprocessor support is available for the following compilation or syntax check operations:
• Local syntax check of a local or remote file.
Limitations:
– Local syntax check is deprecated. This action is available only on Windows.
– Local syntax checking does not support shift-out-shift-in (SOSI) sources. The importer that is used to
do the local syntax check supports only UTF-8 encoding. Translating CP-930 and other SOSI sources
into UTF-8 alters the column locations for some characters, and this alteration results in unexpected
errors.
• Build of a local or remote project.
• Show Dependencies on a local or remote project or local or remote file.
Note: Only files that were not created by a preprocessor step can be considered dependencies. If a
preprocessor step creates several include files that are eventually passed to another preprocessor or
the compiler, those generated include files are not considered dependencies.
Tip: When you use local preprocessors with remote files, the output files are generated to the
RemoteSystemTempFiles > Build Output folder in the file tree.
Limitation: The local include preprocessor is not supported on macOS clients.
To define options for local preprocessors:
1. Open a property group in the property group editor.
2. Open the Local Preprocessor page of the Local COBOL Settings or Local PLI Settings.
The Local Preprocessor page contains two sections. The Local Preprocessor section shows all
preprocessors that were added the property group. There are two ways to work with this list:
• Select the checkbox next to a preprocessor name to enable the preprocessor to run before
a compilation or syntax check operation. This action is called selecting a preprocessor. The
preprocessor is activated for execution only when the checkbox is selected.

38 Developer for z/OS: Setting up an Eclipse Development Environment

 • Select the preprocessor name in the list to display the options that are set for it in the Preprocessor
Options section. This action is called highlighting a preprocessor.
The Preprocessor Options section shows the options for the selected preprocessor.
Preprocessor Description
Type a description, such as Include preprocessor.
Preprocessor Name (fully qualified)
Type the name of the include preprocessor. You can use the ${bundle:packageName}/
path variable to point to an installed plug-in that contains the preprocessor. The default
value is ${bundle:[Link]}/bin/operatingSystem/
PPINCL01, where operatingSystem is macos or win32. In version 14.1.4 or earlier, you can use the
${INSTDIR} variable to point to the product installation directory. This variable is used to find the
include preprocessor that is shipped with the product.
Preprocessor Arguments
Enter any arguments that you are passing to your preprocessor. These arguments would be
entered as though you were passing them to your preprocessor from the command prompt. The
arguments might include the fully qualified path of the file that is being preprocessed. If your
arguments include the fully qualified name of the XML file, or output file that is being produced by
your preprocessor, the XML file and output file must be created in the BuildOutput folder of the
local project.
Preprocessor Output File Name
Enter the name of the expanded file that your preprocessor produces. This file name must be
unqualified. The Output file must be generated in the BuildOutput folder of the local project.
Support Error Feedback
Select this checkbox to log errors that are generated by the preprocessor. Selecting this check box
enables the Error Feedback XML File Name field. This option is enabled by default.
Error Feedback XML File Name
Specify the name of the XML file to be generated for error feedback. This XML file must be
unqualified because it must be created in the BuildOutput folder of the local project.
Environment Variables (Set Statements)
Specify any environment variables to be passed to the preprocessor. This field contains a value for
the SYSLIB, but you must change the value to point to the folder that contains your include files.
You can also use variables in any of the entry fields to help generalize project builds. For a list of
variables that you can use to define options for local preprocessors, see the related topics.
When the local preprocessor is started by the syntax check, build, or show dependencies action, the
current directory for this action is the BuildOutput folder of the local project. The XML file and
expanded source file that your preprocessor create must be created in this folder.
3. Save the property group to save the changes you made.
If you are using local preprocessors on a remote file, the build output is in the
RemoteSystemTempFiles/Build Output folder. You can find this folder by going to the systems
file navigator and navigating to your workspace location. Inside your workspace folder is the
RemoteSystemTempFiles folder.

Variables in local preprocessor options

To help generalize project builds, you can use variables in any of the fields on the Local Preprocessors
page of the Local COBOL Settings or Local PLI Settings page of a property group.
${bundle:packageName}/path
The location of an unpacked bundle, or plug-in, where a local preprocessor is defined. You can use
this variable to point to a local preprocessor plug-in that is installed in the product. packageName is
the plug-in name and path is the location of the preprocessor in the plug-in.

Setting up an Eclipse development environment 39

 ${project_loc}
The project location. It can be used to add the location on disk of the project. If you must pass
the name of a folder in your project to your preprocessor, you can specify it as ${project_loc}
\folder1. Upon invocation of the preprocessor, ${project_loc} is substituted.
${rdz_cache_home}
When you use a local preprocessor with a remote file, it might be necessary to reach
the root cache location. This location is the Developer for z/OS cache location that is
described in the ${rdz_cache_sysn} variable explanation. This variable does not include the
FttRemoteTempFiles\RSE Connection Name subfolders. The BuildOutput folder for a local
syntax check of a remote file is in the ${rdz_cache_home} location. This folder is the one from which
the local preprocessor is started.
Limitations:
• Local syntax check is deprecated. This action is available only on Windows.
• Local syntax checking does not support shift-out-shift-in (SOSI) sources. The importer that is used
to do the local syntax check supports only UTF-8 encoding. Translating CP-930 and other SOSI
sources into UTF-8 alters the column locations for some characters, and this alteration results in
unexpected errors.
${rdz_cache_sysn}
When you use a local preprocessor with a remote file, it might be necessary to be able to point
to your file in the Developer for z/OS download location. This location depends on your workspace
location. The local syntax of a remote file downloads your compilation dependencies. The download
location is the Developer for z/OS cache location. When you request a local syntax check of a remote
file, the preprocessor must be running on the remote system. A combination of a preprocess and a
compilation is performed on the remote system, and a list of build dependencies is created. This list
is the same list of files that is displayed when you perform the Show Dependencies operation on
the file. This list is the same list of files that you see when you click Dependent Files on the Check
Dependencies window from the Syntax Check > Local action. These files are downloaded to the
cache location. You might need to point to a file or a folder with the ${rdz_cache_sysn} variable. If a
data set member [Link](MEM1) is one of your dependent files, for example, you
might need to point to the cache location of that file for your local preprocessor to consume. One
way to do that is to set an environment variable to the folder that contains the downloaded member.
You can do set this variable in the preprocessor environment variable entry field: SET SYSLIB=$
{rdz_cache_sysn}\USERID\[Link]. The parent of the folder corresponding to
the data set is the high-level qualifier of the data set name that contains the member. The variable
${rdz_cache_sysn} is substituted with Developer for z/OS cache location FttRemoteTempFiles\RSE
Connection Name.
Limitations:
• Local syntax check is deprecated. This action is available only on Windows.
• Local syntax checking does not support shift-out-shift-in (SOSI) sources. The importer that is used
to do the local syntax check supports only UTF-8 encoding. Translating CP-930 and other SOSI
sources into UTF-8 alters the column locations for some characters, and this alteration results in
unexpected errors.
${resource_fn}
The unqualified file name of the current resource that is being preprocessed. If you built a project,
and there were 3 COBOL files in your project, [Link], [Link], and [Link], for each
preprocess during the project build a value would be assigned to that variable. The value would be
either RED, WHITE, or BLUE. This variable is of value when you are specifying preprocessor values
on the project. For example, specifying ${resource_fn}_PP1.dek in the Preprocessor Output File
Name entry field leads to output files RED_PP1.dek, WHITE_PP1.dek, and BLUE_PP1.dek, in the
BuildOutput folder.
${resource_loc}
The location on disk of the resource that is being preprocessed. If the preprocessor requires the exact
location of the file on disk to preprocess it, you can use this variable, and upon invocation, the value

40 Developer for z/OS: Setting up an Eclipse Development Environment

 of the resource location on disk is substituted. When you request a local syntax check of a remote
file, the value of ${resource_loc} in the local preprocessor options is the location of the file in the
Developer for z/OS cache.
Limitations:
• Local syntax check is deprecated. This action is available only on Windows.
• Local syntax checking does not support shift-out-shift-in (SOSI) sources. The importer that is used
to do the local syntax check supports only UTF-8 encoding. Translating CP-930 and other SOSI
sources into UTF-8 alters the column locations for some characters, and this alteration results in
unexpected errors.
${INSTDIR}
The product installation directory. In version 14.1.4 or earlier, you can use the ${INSTDIR} variable to
point to the product installation directory. This variable is used to find the include preprocessor that is
shipped with the product.

Using the local include preprocessor

The local include preprocessor allows for the incorporation of external source files into programs by using
include directives other than the PL/I directive %INCLUDE or COBOL COPY statement.
Create a local property group and associated it with a local COBOL or PL/I source file or local project.
Limitation: The local include preprocessor is not supported on macOS clients.
You can set content type associations for the include preprocessor to define which file extensions the
preprocessor searches when it looks for copy and include files. For instructions for defining content
type associations, see the related topics. When you define content type associations for the include
preprocessor, the product passes an EXT( ) parameter to the include preprocessor that contains a list of
allowable file extensions, such as EXT("cpy","inc","mac").
The local include preprocessor is in the [Link] plug-in that is
unpacked when you install the product. You can use the local include preprocessor with an individual
COBOL or PL/I program or a local z/OS project that contains one or more COBOL or PL/I programs. You
can also use it alone or as part of a multi-preprocessor build operation.
• When the include preprocessor is the only preprocessor that is called before a compilation, the input file
is the COBOL or PL/I program that was selected for a Syntax Check or Show Dependencies operation.
• When the include processor is called for a project build, each COBOL or PL/I program in the project is
processed and then compiled. The input file in this case is the current COBOL or PL/I source that is
being processed.
• When the include preprocessor is called as part of a multiple-preprocessor operation and is started
after a previous preprocessor, the input file to the include preprocessor is the output file from the
previous active preprocessor. This file is the one listed in the Preprocessor Output File Name entry
field of previous active preprocessors. For more information about setting up multiple-preprocessor
operations, see “Using multiple local preprocessors” on page 43.
To use the local include preprocessor:
1. Open the property group editor for the property group that is associated with the resource or project
and open to the PL/I page.
2. From the list on the left, click Local Preprocessor to open the Local Preprocessor page.
3. Click New.
4. Complete the fields in the Preprocessor Options section of the Local Preprocessor page.
Preprocessor Description
Type a description, such as Include preprocessor.
Preprocessor Name
Type the name for the include preprocessor. The default
value is ${bundle:[Link]}/bin/operatingSystem/

Setting up an Eclipse development environment 41

 PPINCL01, where operatingSystem is macos or win32. The ${bundle} variable points to an
unpacked bundle or plug-in. This variable is used to find the include preprocessor.
Note: If you are using a property group created in V14.1.4 or an earlier release, then a
Preprocessor Name that uses the ${INSTDIR} variable to point to the installation directory
remains valid. For version 14.1.5, the PPINCL01 preprocessor is included both in the product
installation path and in the [Link] plug-in.
Preprocessor Arguments
The include preprocessor can take the following arguments:
• TRACE(ON|OFF) On the workstation, this option provides more output to the TPF Remote
Console. On 390 systems, this option provides more JES output. This output is intended for
use by an IBM technical support representative and must not be used during the regular
course of development because it increases the amount of unwanted output and can decrease
performance. If you must contact your IBM technical support representative for problem
determination, you can copy this output it into your correspondence. The default for this option is
TRACE(OFF). If the option is not specified, the default value is used.
• FORMAT(ON|OFF) On the workstation and on 390 systems, this option changes the readability
of the XML generated for error messages. FORMAT(ON) causes the statement table to be written
in six columns, making the XML file more readable. Setting this option significantly decreases the
performance of parsing the XML file, causing operations to take longer. The default for this option
is FORMAT(OFF). If the option is not specified, the default value is used.
• NOCOPY(ON|OFF) If your source contains COPY REPLACE statements, the include preprocessor
does not support processing the COPY REPLACE statement. The preprocessor does not replace
strings in the copy file, nor does it find the member name that is specified in the COPY REPLACE
statement. To avoid this problem, use the NOCOPY(ON) preprocessor option. This option allows
the -INC and ++INCLUDE statements to be processed, but the COPY statements and the
%INCLUDE statements are not processed by the include preprocessor. The compiler processes
those statements after the preprocessor.
If your source contains COPY statements with the member name enclosed in quotation marks
or apostrophes, the include preprocessor does not support processing these statements. To
avoid this problem, use the NOCOPY(ON) preprocessor option. This option allows the -INC and +
+INCLUDE statements to be processed, but the COPY statements and the %INCLUDE statements
are not processed by the include preprocessor. The compiler processes those statements after
the preprocessor.
• CMT(ON|OFF) When you specify CMT(ON) and open an expanded source file, the include
preprocessor comments the original COPY or INCLUDE statement, places the copybook or
include file into the source file, and then places another comment to indicate the end of the
copybook or include file. The expanded copybook or include file and the comments look like this
example:

* COPY ABC
01 XYZ PIC X
01 FIRST PIC 9

• For more information about showing expanded source, see the related topics.
Restriction: By default, this field is empty. If you define content types for the include preprocessor
and you specify any preprocessor arguments in this field, then you must manually add any file
extensions that you want the preprocessor to recognize by using the EXT( ) argument, such as
EXT("cpy","inc"," ").
Preprocessor Output File Name
Specify a file name to be used for preprocessor output. If you omit this option, an output file name
is generated.
Support Error Feedback
Select this checkbox to log errors that are generated by the preprocessor. Selecting this checkbox
enables the Error Feedback XML File Name field. This option is enabled by default.

42 Developer for z/OS: Setting up an Eclipse Development Environment

 Error Feedback XML File Name
Specify the unqualified name of the XML file to be generated for error feedback. If you omit this
option, an error feedback XML file name is generated.
Environment Variables (Set Statements)
Specify any environment variables to be passed to the preprocessor. This field contains a value for
the SYSLIB, but you must change the value to point to the folder that contains your include files.
The path length for the SYSLIB environment variable is limited to 4 K. No error message is issued
for lengths that exceed 4 K, but SYSLIB statements greater than 4 K might cause syntax check
operations to end abnormally in the include preprocessor program.

Using multiple local preprocessors

You can process your source files with multiple local, site-developed preprocessors.
You must define a property group on a local or remote system.
Multiple local preprocessor support is available for the following compilation or syntax check operations:
• Local syntax check of a local file.
Limitations:
– Local syntax check is deprecated. This action is available only on Windows.
– Local syntax checking does not support shift-out-shift-in (SOSI) sources. The importer that is used to
do the local syntax check supports only UTF-8 encoding. Translating CP-930 and other SOSI sources
into UTF-8 alters the column locations for some characters, and this alteration results in unexpected
errors.
• Build of a local project.
• Show Dependencies on a local project or local file.
Note: Only files that were not created by a preprocess step can be considered dependencies. If a
preprocess step creates several include files that are eventually passed to another preprocessor or the
compiler, those generated include files are not considered dependencies.
• Local syntax check of a remote file.
You can specify up to 10 local preprocessors for a single build operation.
To define and enable multiple local preprocessors:
1. Open a property group in the property group editor.
2. Open the Local Preprocessors page of the Local COBOL Settings or Local PLI Settings.
The Local Preprocessors page contains two sections: the Preprocessors section shows all
preprocessors in the property group. There are two ways to work with this list:
• Select the checkbox next to a preprocessor name to enable the preprocessor to execute before
a compilation or syntax check operation. This action is called selecting a preprocessor. The
preprocessor is activated for execution only when the checkbox is selected.
• Select the preprocessor name in the list to display the options that are set for it in the Preprocessor
Options section. This action is called highlighting a preprocessor.
The Preprocessor Options section shows the options for the selected preprocessor. On this page, you
can do the following tasks:
• “Adding a preprocessor to a property group” on page 44
• “Editing a preprocessor definition” on page 44
• “Removing a preprocessor from a property group” on page 45
• “Adding the same preprocessor with different options” on page 45
• “Selecting one or more preprocessors to run before a compilation” on page 46
3. Click Finish to save the changes you made.

Setting up an Eclipse development environment 43

 The source program [Link] has different synonyms for COPY. The programmer writes a
preprocessor, named [Link] that processes –GET statements in the source. The output of that
preprocessor is an XML file named mysource_PP1.xml and a DECK file named mysource_PP1.dek
that is passed on to the next step.
The output file mysource_PP1.dek contains –INC statements that also must be processed. The
programmer chooses to use the –INC preprocessor for the second preprocessor step. The output of
that step is an XML file named mysource_PP2.xml and a DECK file named mysource_PP2.dek that is
passed on to the compiler.
The compiler receives mysource_PP2.dek from the second preprocessor step. By now, the –GET
statements and the –INC statements are removed from the source, and the DECK file that is being
processed contains only valid COBOL statements.
To set up the preprocessor steps in a property group for this scenario, the programmer adds two
preprocessor definitions, in the following order, to the property group for compiling the source:
1. Remove -GET
The Remove -GET preprocessor has the following preprocessor options specified:
Preprocessor Description: Remove -GET
Preprocessor Name (fully qualified): C:\mypreprocs\[Link]
Preprocessor Output File Name: ${resource_fn}_PP1.dek
Support Error Feedback: The checkbox is selected.
Error Feedback XML file Name: ${resource_fn}_PP1.xml
2. Remove -INC
The Remove -INC preprocessor has the following preprocessor options specified:
Preprocessor Description: Remove -INC
Preprocessor Name (fully qualified): “$
{bundle:[Link]}/bin/operatingSystem/PPINCL01
Preprocessor Output File Name: ${resource_fn}_PP2.dek
Support Error Feedback: The checkbox is selected.
Error Feedback XML file Name: ${resource_fn}_PP2.xml

Adding a preprocessor to a property group

You can define a local, site-developed preprocessor and add it to a property group.
You must define a property group on a local or remote system.
To add a preprocessor to a property group:
1. Open a property group in the property group editor.
2. Open the Local Preprocessors page of Local COBOL Settings or Local PLI Settings.
3. In the Preprocessors section, click New.
The fields in the Preprocessor Options section are cleared.
4. Complete the field.
See the context-sensitive help for a detailed description of the fields.
5. Click Ctrl+S to save your changes or New to add another preprocessor to the list.

Editing a preprocessor definition

You can edit a local, site-developed preprocessor definition in a property group.
You must define a property group on a local or remote system.
To edit a preprocessor definition in a property group:
1. Open a property group in the property group editor.
2. Open the Local Preprocessors page of Local COBOL Settings or Local PL/I Settings.
3. In the Preprocessors section, highlight a preprocessor name.

44 Developer for z/OS: Setting up an Eclipse Development Environment

 The fields in the Preprocessor Options section show the current options for the highlighted
preprocessor.
4. Edit the fields.
See the context-sensitive help for a detailed description of the fields.
5. Press Ctrl+S to save your changes.

Removing a preprocessor from a property group

You can remove a local, site-developed preprocessor from a property group.
You must define a property group on a local or remote system.
This action deletes a preprocessor definition from a property group. If you want to prevent a preprocessor
from running, but keep the preprocessor definition, clear the checkbox next to the preprocessor name.
To remove a preprocessor from a property group:
1. Open a property group in the property group editor.
2. Open the Local Preprocessors page of Local COBOL Settings or Local PL/I Settings.
3. In the Preprocessors section, highlight the name of the preprocessor definition you want to delete.
4. Click Remove.
The preprocessor definition is deleted from the property group.
5. Click Ctrl+S to save your changes.

Adding the same preprocessor with different options

You can call the same preprocessor more than once for a single build operation by adding it to a property
group multiple times with different options.
You must define a property group on a local or remote system.
You can run the same preprocessor multiple times with different options by adding it to the property
group multiple times. If your site has a preprocessor that takes an argument that tells the preprocessor
to look for certain statements in the source program, for example, you can define one entry in the
Preprocessors list that tells the preprocessor to look for GOTO statements and another that looks
for DISPLAY statements. Each definition points to the same preprocessor, but runs it with different
arguments.
To add multiple entries for the same preprocessor with different options:
1. Open a property group in the property group editor.
2. Open the Local Preprocessors page of Local COBOL Settings or Local PL/I Settings.
3. In the Preprocessors section, click Add.
The fields in the Preprocessor Options section are cleared.
4. In the Preprocessor Name (fully qualified) field, specify the preprocessor name or to choose to the
preprocessor file name, click Browse.
5. In the Preprocessor Description field, specify a unique description for this instance of the
preprocessor.
The description is used as the label in the list of preprocessors in the Preprocessors section. The
descriptions that you write for each instance must uniquely identify which instance is being run. To
continue the example that is given above, you can type Locate GOTO for the first instance and
Locate DISPLAY for the second.
6. Complete the remaining fields with the options that you want for the first execution of the
preprocessor.
For a detailed description of the fields, see the context-sensitive help.
7. Click Add again to clear the fields and add another entry to the Preprocessors list.
8. In the Preprocessor Name (fully qualified) field, specify the same preprocessor name.
9. In the Preprocessor Description field, specify a unique description for the second instance of the
preprocessor.

Setting up an Eclipse development environment 45

 10. Complete the remaining fields with the options that you want for the second execution of the
preprocessor.
11. Click Ctrl+S to save your changes or Add to add another preprocessor to the list.

Selecting one or more preprocessors to run before a compilation

You can select multiple local preprocessors to run before a compilation.
You must define a property group on a local or remote system and define one or more preprocessors in
the property group.
To select one or more preprocessors to run before a compilation:
1. Open a property group in the property group editor.
2. Open the Local Preprocessors page of the Local COBOL Settings or Local PL/I Settings.
3. In the Preprocessors section, click the checkbox beside each preprocessor you want to run.
You can select up to 10 local preprocessors for a single build operation. The preprocessors are run in
the order that is shown in this list. If no preprocessors are selected, then the source file is compiled
without the preprocessor step.
4. To change the order in which the preprocessors run, highlight a preprocessor name in the list and click
Up or Down.
The last preprocessor that is selected in the list is the last preprocessor run. The output of that
preprocessor, which is the name of the file in the Preprocessor Output File Name field is the name of
the file that is passed to the COBOL or PL/I compiler.
5. Click Ctrl+S to save your changes.

Creating a custom build process

You can use the Developer for z/OS extensible error feedback mechanism to create a custom build
process. This mechanism allows for linking multiple preprocessors by capturing the feedback from one
preprocessor for use as an input to another.
Read about the Developer for z/OS “Extensible error feedback mechanism” on page 46. This mechanism
allows for capturing error feedback from a program and display it in the Remote Error List. It is also the
mechanism that allows for linking multiple preprocessors.
To set up a custom build process that involves multiple preprocessors:
1. Set up the client for error feedback.
2. Link multiple preprocessors by using the Local Preprocessors property page.

Extensible error feedback mechanism

The error feedback mechanism captures and displays error messages that are generated during remote
build, remote syntax check, or show dependencies of COBOL and PL/I language source files with the
integrated Db2 coprocessor and CICS translator. This mechanism can be extended to support custom
preprocessors and more languages, such as Assembler.
The base function of the Developer for z/OS error feedback mechanism supports error feedback for
remote build, remote syntax check, or show dependencies of COBOL and PL/I language source files.
Errors that result from a remote build or a remote syntax check of a COBOL or PL/I program are reported
to the Remote Error List.
Restriction: The error feedback mechanism supports remote build, remote syntax check, and show
dependencies operations only. It does not support the Generate JCL actions.
The error feedback process depends on an XML file that is created during COBOL or PL/I compilation
with the Enterprise version of the COBOL or PL/I compiler. This base function supports error feedback
with the Enterprise versions of COBOL and PL/I as they support the integrated Db2 coprocessor and CICS
translator, thus allowing the errors from the coprocessor or translator to be fed back with the correct line
numbers. This function is provided without any setup or user action required.

46 Developer for z/OS: Setting up an Eclipse Development Environment

This error feedback mechanism is extensible: with some setup on the client workspace, it can be
extended to also provide error feedback from custom preprocessors and from other language source
files, such as Assembler. The mechanism defines an XML schema that you can use to create an XML file
to report errors from custom preprocessors or other languages in the Remote Error List. The following
topics describe how to create and use this XML file.

Error feedback for COBOL and PL/I

Error feedback for COBOL and PL/I depends on an XML file that is generated during the compilation or
syntax check process on the remote system. The COBOL and PL/I compilers write the errors to any data
set member or sequential data set that is referred to by the SYSXMLSD DD card in the JCL being used for
compilation or syntax check.
During remote build, remote syntax check or show dependencies operations, the Developer for z/OS
product generates JCL to run the JCL procedures that the user specified in the properties and submits the
generated JCL on behalf of the user. During JCL generation for these operations, the Developer for z/OS
product allocates a sequential data set based on the Data Set Qualifier for Compile Errors field of the
COBOL or PL/I Compile Step Options window and refers to it using the SYSXMLSD DD card to establish
the handshake between the COBOL or PL/I compiler processes on the remote system and Developer for
z/OS compilation and syntax check operations. Because the Developer for z/OS product allocates this
data set, it also tracks it, locates it when the compilation or syntax check operation is complete, parses it,
and populates the remote error list.

Error feedback extension

The same scheme that is used for error feedback for COBOL and PL/I can be used to extend the error
feedback scheme to support other languages and custom preprocessors. The error feedback extensibility
scheme works only when you use the Developer for z/OS build process. The Related Tasks describe how
to set up the Developer for z/OS client to take advantage of the extensible error feedback mechanism.

Error feedback XML schema

The error feedback XML schema defines tags that are used to define an error feedback XML file.

XML schema
The following sample shows the XML schema for the error feedback file. For a description of the tags, see
“Error feedback tags” on page 48.

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema xmlns:xsd="[Link]
<xsd:element name="OUTFILECOUNT" type="xsd:string"/>
<xsd:element name="FILENUMBER" type="xsd:string"/>
<xsd:element name="PACKAGE">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="FILEREFERENCETABLE" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="MESSAGE" maxOccurs="unbounded" minOccurs="0"/>
<xsd:element ref="OUTFILEREFERENCETABLE" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="STATEMENTTABLE" maxOccurs="1" minOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="FILENAME" type="xsd:string"/>
<xsd:element name="MESSAGE">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="MSGNUMBER" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="MSGLINE" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="MSGFILE" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="MSGTEXT" maxOccurs="1" minOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="OUTFILE">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="OUTFILENUMBER" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="OUTFILENAME" maxOccurs="1" minOccurs="1"/>

Setting up an Eclipse development environment 47

 </xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="MSGNUMBER" type="xsd:string"/>
<xsd:element name="OUTFILEREFERENCETABLE">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="OUTFILECOUNT" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="OUTFILE" maxOccurs="unbounded" minOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="BUILD">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="PACKAGE" maxOccurs="1" minOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="MSGTEXT" type="xsd:string"/>
<xsd:element name="OUTFILENUMBER" type="xsd:string"/>
<xsd:element name="FILECOUNT" type="xsd:string"/>
<xsd:element name="OUTFILENAME" type="xsd:string"/>
<xsd:element name="MSGLINE" type="xsd:string"/>
<xsd:element name="FILE">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="FILENUMBER" maxOccurs="1" minOccurs="1"/>
<xsd:element ref="FILENAME" maxOccurs="1" minOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="MSGFILE" type="xsd:string"/>
<xsd:element name="STATEMENTTABLE" type="xsd:string"/>
<xsd:element name="FILEREFERENCETABLE">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="FILECOUNT" maxOccurs="1" minOccurs="1"/>
<xsd:element maxOccurs="unbounded" ref="FILE" minOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

Error feedback tags

The format of the error feedback file originated with the PL/I compiler XML format. This file format takes
several enhancements to allow for the following options:
• User-written builders that create multiple files, rather than a single output file.
• The ability to determine whether an input file was an original file that the user started with, or if the file
is an intermediate file that was created as the result of a processing step, by checking to see whether
the first reference of the file was in the FILEREFERENCETABLE or OUTPUTFILEREFERENCETABLE.
• The ability to chain several processing steps together, and be able to map any line in the ultimate output
to whichever line in the original source.
The error feedback file contains the following tags:
BUILD
This tag is an all-encompassing tag that is used to denote the beginning and the ending of the
processing.
PACKAGE
This tag is also an encompassing tag that is only enveloped by the BUILD tag. This tag is only for
compatibility with the compiler error feedback file.
FILEREFERENCETABLE
This tag is used to encompass tags that describe the files that are used during the processing.
FILECOUNT
This tag describes the number of files that were used during processing.
FILE
This tag describes an individual file that is used during the processing.

48 Developer for z/OS: Setting up an Eclipse Development Environment

FILENUMBER:
This tag describes the number that is assigned to the input file by the processor.
FILENAME
This tag is the file name of the file that is used during the processing. It is the name of the file that
corresponds with the FILENUMBER tag.
MESSAGE
This tag describes a message that is produced by the processor.
MSGNUMBER
This tag describes the message number of the message that was produced by the processor.
MSGLINE
This tag describes the line in the input file that caused the processor to produce the message.
MSGFILE
This tag describes the file number of the input file that caused the processor to produce the message.
MSGTEXT
This tag is the text of the message that is produced by the processor.
OUTFILEREFERENCETABLE
This tag describes the files that are produced by the processor. This tag is newly added. It was
developed for describing multiple files that can be generated during a single process. These files can
be used as input to any processing steps that might follow the current processing.
OUTFILENUMBER
This tag describes the file number of an individual file that is produced by the processor.
OUTFILENAME
This tag describes the file name of an individual file that is produced by the processor.
STATEMENTTABLE
This tag describes the statements that are produced during a process. This tag is a newly added tag
that serves to describe each statement in the output file. The description is an ordered quad. Each
entry is read as follows: (A,B,C,D), where:
A = Line number that is written in the output file.
B = File number of the output file.
C = Line number of the input file that was read to generate line number A in File number B.
D = File number of the input file that contained line number C, which was read to generate line
number A in file number B.

PL/I program for generating error feedback XML and creating expanded source
The following sample PL/I program, TMPLT00, generates a sample error feedback XML document. The
sample is for illustration purposes only.
Certain data structures in the program were chosen not for their effectiveness, but for the sake of keeping
the example small to increase comprehension. The messages that are written in the XML file are not
checked for the need of entity reference substitutions within the messages. This sample is similar to an
include file preprocessor. The preprocessor reads a COBOL file and writes what it reads to an expanded
source file. As reads the COBOL source, the preprocessor looks for lines that have FRAGMENT member;
beginning in column 1. When a line that matches this description is found, the preprocessor looks for the
member in the FRAGMNT DD card concatenation. If the file is not found on DASD, an error message is
saved and is emitted in the error feedback XML file. If the file is found on DASD, the file is opened, and
processing continues with that file, writing its contents to the expanded source file. The expanded source
file consists of the original source file and all of the fragment files that the preprocessor resolves.

TMPLT00 : Procedure (MYARGS ) options (main) ;

dcl MYARGS CHAR(100) VARYING;
dcl a char(100) varying;
dcl sourcefn char(100) varying init("");
dcl xmlfn char(100) varying init("");
dcl outfn char(100) varying init("");
dcl fragin file record input;
dcl xin file record input;
dcl xout file record output;

Setting up an Eclipse development environment 49

 dcl eof bit(1) init('0'b);
dcl copyeof bit(1) init('0'b);
dcl copyerr bit(1) init('0'b);

dcl dsn char(255)varying init("");

dcl fn char(255)varying init("");
dcl fileattrs char(100)varying init("");

dcl ZFLDATA ext('ZFLDATA')

entry( char(255) varyingz byaddr,
char(255) varyingz byaddr,
char(100) varyingz byaddr )
returns( byvalue fixed bin(31) )
options ( nodescriptor );

/*
dcl ZFLDATA ext('ZFLDATA')
entry( ptr byvalue,
ptr byvalue,
ptr byvalue)
returns( byvalue fixed bin(31) )
options ( nodescriptor );
*/
/************************************/
/*DATA STRUCTURES FOR XML FILE */
/************************************/
dcl 1 resourceNode BASED (resourceHead),
2 fileName char(100) varying,
2 fileNum fixed bin(15),
2 nextResource ptr;
dcl resourceHead ptr;

dcl 1 stmtTblNode BASED (stmtTblHead),

2 oln fixed bin(15),
2 ofn fixed bin(15),
2 iln fixed bin(15),
2 ifn fixed bin(15),
2 nextStmt ptr;
dcl 1 stmtTblHead ptr;

dcl 1 errorMsgNode BASED (errorMsgHead),

2 errfileNum fixed bin(15),
2 errStmtNum fixed bin(15),
2 errMsgID char(8) varying,
2 errMsgTxt char(200) varying,
2 nextErr ptr;
dcl 1 errorMsgHead ptr;

dcl (pfn, pfileattrs, pdsn) ptr;

/***********************************/
/* on units */
/***********************************/
on endfile(xin) eof = '1'b;
on endfile(fragin) copyeof = '1'b;
on UNDEFINEDFILE(fragin) copyerr = '1'b;
/*************************************/
/* open files */
/*************************************/
/* call processParms; */
/*************************************/
/* open files */
/*************************************/
/*open file(xin) title('/C:\SEQSAVE\DATA\[Link]');*/
/*open file(xout) title('/C:\SEQSAVE\DATA\[Link]');*/

/* open file(xin) title('/'||sourcefn); */

/* open file(xout) title('/'||outfn); */
/* int getFileData(char * dsn, char *fn, char *fileattrs)*/
fn = "DD:XIN";
fileattrs = "rb+,type=record";

pfn = addr(fn);
pfileattrs = addr(fileattrs);
pdsn = addr(dsn);

rc = ZFLDATA(dsn, fn, fileattrs);

display("DSN = "||DSN);
open file(xin);
open file(xout);

/*************************************/
/* process source file */

50 Developer for z/OS: Setting up an Eclipse Development Environment

/*************************************/
read file(xin) into(a);
do while( eof = '0'b );
call processLine;
read file(xin) into(a);
end;
close file(XIN);
close file(XOUT);
DISPLAY (MYARGS);
display (getenv('PATH'));

/***************************************************/
/* Show the configuration of the 3 towers. */
/***************************************************/
processParms: proc;
dcl xmlstart fixed bin(31);
dcl xmlend fixed bin(31);
dcl xmlfnlen fixed bin(31);
dcl outfnstart fixed bin(31);
dcl outfnend fixed bin(31);
dcl outfnlen fixed bin(31);
dcl fntest1 char(100) varying;
DCL filename2 char(10) varying init('filename');
xmlstart = INDEX(MYARGS,'XML(',1);
xmlend = INDEX(MYARGS,')',xmlstart);
xmlfnlen = xmlend - xmlstart;
xmlfnlen = xmlfnlen - 4;

outfnstart = INDEX(MYARGS,'OUT(',1);
outfnend = INDEX(MYARGS,')',outfnstart);
outfnlen = outfnend - outfnstart;
outfnlen = outfnlen - 4;

sourcefn = SUBSTR(MYARGS,1,xmlstart - 2);

xmlfn = SUBSTR(MYARGS,(xmlstart+4),xmlfnlen);
outfn = SUBSTR(MYARGS,(outfnstart+4),outfnlen);

display('sourcefn = '||sourcefn);
display('xmlfn = '||xmlfn);
display('outfn = '||outfn);
end processParms;
/***************************************************/
/* Show the configuration of the 3 towers. */
/***************************************************/
processLine: proc;
dcl fraglen fixed bin(31);
fraglen = LENGTH("FRAGMENT");
display(a);
IF SUBSTR(a,1,fraglen) = "FRAGMENT" THEN
DO;
call processFragment;
END;
ELSE
DO;
write file(xout) from(a);
END;

end processLine;
/***************************************************/
/* Show the configuration of the 3 towers. */
/***************************************************/
processFragment: proc;
dcl pos fixed bin(31);
dcl fragname char (100) varying;
pos = index( a, ';', 1 );
fragname = substr(a,10,(pos - 10));
open file(fragin) title('/'||fragname);
if copyerr = '0'b then
do;
read file(fragin) into(a);
do while( copyeof = '0'b );
write file(xout) from(a);
read file(fragin) into(a);
end;
close file(fragin);
end;
else
do;
DISPLAY ("FILE NOT FOUND ERROR!!");

Setting up an Eclipse development environment 51

 copyerr = '0'b;
end;

end processFragment;
/***************************************************/
/* Show the configuration of the 3 towers. */
/***************************************************/
saveError: proc;

dcl jx fixed bin(31);

put skip list( '' );

end saveError;
/***************************************************/
/* Show the configuration of the 3 towers. */
/***************************************************/
storeStmtTbl: proc;

dcl jx fixed bin(31);

put skip list( '' );

end storeStmtTbl;

/***************************************************/
/* Show the configuration of the 3 towers. */
/***************************************************/
write_XML: proc;

dcl jx fixed bin(31);

put skip list( '' );

end write_XML;

End TMPLT00 ;

C program for error feedback

The following sample C program, ZFLDATA, dynamically queries the DSName for a passed-in DDName.
The PL/I sample program in Related References illustrates the call to this C program to query the DSName
for the SYSXMLSD DDName for error feedback.
As part of the processing, TMPLT00 calls a C routine called ZFLDATA. This routine has a single purpose.
It takes a data set DD name, and if possible, it returns the data set name that the DD name refers to. The
following example shows the source for ZFLDATA.

#include <stdio.h>
#include <string.h>
#define FILENAMEMAX 255
#define ATTRMAX 100

int main(void)
{
FILE *stream;
char dsn[FILENAMEMAX];
char filename[FILENAMEMAX];
char fileattrs[ATTRMAX];
int rc;
int getFileData(char * dsn, char * filename, char * fileattrs);

memset(filename ,'\0',sizeof(filename));
memset(filename ,'\0',sizeof(fileattrs));
memcpy(filename ,"DD:SYSXMLSD",sizeof("DD:SYSXMLSD"));
memcpy(fileattrs ,"a+",
sizeof("a+"));

rc = ZFLDATA(dsn,filename,fileattrs);

if (rc != 0)
printf("fldata failed\n");

52 Developer for z/OS: Setting up an Eclipse Development Environment

 else
printf("filename is %s\n",dsn);
}

int ZFLDATA(char * dsn, char *fn, char *fileattrs)

{
fldata_t fileinfo;
fldata_t * fileinfoptr;
int rc;
FILE *stream;

/******************************************************/
/*Get a stream for the file and attributes passed in */
/******************************************************/
stream = fopen(fn,fileattrs);
if (stream == NULL)
{
perror("***FAILURE OPENING FILE*****");
}

/******************************************************/
/*Get the actual data set name on DASD from fldata */
/******************************************************/
memset(dsn ,'\0',
sizeof(dsn));
fileinfoptr = &fileinfo;
rc = fldata(stream, dsn, &fileinfo;);
if (rc != 0)
{
printf("fldata failed\n");
}
else
{
memcpy (dsn,
fileinfoptr->__dsname,
strlen(fileinfoptr->__dsname));
}
fclose(stream);
return rc;
}

COBOL snippet for generating error feedback XML file

The following COBOL program snippet demonstrates a few concepts that you might find helpful when you
create your own preprocessor.
The snippet sets up file variables for the input file for the preprocessor. SYSIN is used to as the input
variable. By default, the SYSIN variable is set when the JCL for invocation is generated. The file variables
for SYSXMLSD and SYSOUT are declared as well.
The PERFORM Extract-DDDSN statement in the snippet performs a paragraph that calls DYNQUERY. The
output of DYNQUERY is similar to the output of ZFLDATA. The processing is different, and it is written in
Assembler. If your site does not have a C compiler, but you have High Level Assembler, you might decide
to call DYNQUERY from your preprocessor to retrieve the data set name from a DD name.
The PERFORM Write-xml-line statement performs a paragraph that writes the lines of an XML file in
UTF-8. If you write your XML file in UTF-8, make sure to include ERRWDZ as one of the qualifiers in the
Data Set Qualifier for Compiler Errors entry field when you add a step for your preprocessor in the
Property Group Editor.

Identification DIVISION.
Program-ID. MPREPROC.
Environment DIVISION.
Input-output section.
File-control.
Select in-file
Assign to SYSIN
* Organization is line sequential
File status is in-file-status.
Select out-file
Assign to outfile
* Organization is line sequential
File status is out-file-status.
Select xml-file

Setting up an Eclipse development environment 53

 Assign to SYSXMLSD
* Organization is line sequential
File status is xml-file-status.
Data Division.
File section.
Fd in-file
label records are standard
* recording mode is f
record contains 80 characters
block contains 0 records
data record is Input-data.
01 Input-data pic x(80).
Fd out-file
label records are standard
* recording mode is f
record contains 80 characters
block contains 0 records
data record is output-data.
01 output-data pic x(80).
Fd xml-file
label records are standard
* recording mode is v
* 16383 - word for storing the record length
record varying from 1 to 16379 characters
DEPENDING ON xml-length
block contains 0 records
data record is xml-data.
01 xml-data pic x(16379).
*
* To run this, use a ddname
* //OUTFILE DD DSN=[DATASET](MEMBER),DISP=SHR
*
Working-Storage Section.
01 Source-name pic x(54).
01 Target-name pic x(54).
01 Reverse-data pic x(16379).
01 Temp-data pic x(16379).
01 Nat-data pic n(16379) USAGE National.
01 Num-chars pic 99999.
01 xml-length pic 9(5).
01 Program-flags.
05 in-file-status pic xx value "00".
88 inputfile-success value "00".
05 out-file-status pic xx value "00".
88 outputfile-success value "00".
05 xml-file-status pic xx value "00".
88 xmlfile-success value "00".
05 In-file-count pic 999.
05 Out-file-count pic 999.
05 Input-eof pic x value " ".
05 line-cursor pic 99999.
05 line-cursor-end pic 99999.

=================
=================
=================
01 ddname-routine-data.
05 ddname pic x(8).
05 dsn pic x(54).
05 spacestart pic 99.
05 spaceend pic 99.
=================
=================
=================
Procedure DIVISION .
mainline SECTION.
=================
=================
=================
PERFORM Extract-dsnnames
* Open the input and output files
OPEN INPUT in-file
if not inputfile-success
display 'Error opening input file ' in-file-status
stop run
end-if
OPEN OUTPUT out-file
if not outputfile-success
display 'Error opening output file ' out-file-status
stop run
end-if
OPEN OUTPUT xml-file

54 Developer for z/OS: Setting up an Eclipse Development Environment

 if not xmlfile-success
display 'Error opening xml file ' xml-file-status
stop run
end-if
=================
=================
=================
Perform until Input-eof IS EQUAL TO "1"
=================
=================
=================
READ in-file into Temp-data at end move "1" to Input-eof
END-READ
IF Input-eof IS EQUAL TO "0"
PERFORM Process-line
End-IF
End-perform.
=================
=================
=================
PERFORM Generate-xml-end-package
goback
.
* Output: Source-name, Target-name
Extract-dsnnames.
MOVE SPACES to ddname
MOVE "SYSIN" to ddname
PERFORM Extract-DDDSN
MOVE SPACES to Source-name
MOVE dsn to Source-name
MOVE SPACES to ddname
MOVE "OUTFILE" to ddname
PERFORM Extract-DDDSN
MOVE SPACES to Target-name
MOVE dsn to Target-name
.
* Input: DDNAME
* Output: DSN
Extract-DDDSN.
MOVE SPACES TO dsn
CALL "DYNQUERY" USING DDNAME, DSN.
IF RETURN-CODE > 0 THEN
DISPLAY "Error retrieving DSN for DDNAME " DDNAME
DISPLAY "Return Code = " RETURN-CODE
EVALUATE RETURN-CODE
WHEN 1080
DISPLAY "DD for " DDNAME " was not found"
STOP RUN
WHEN OTHER
STOP RUN
END-EVALUATE
END-IF
PERFORM Remove-DSN-Spaces
=================
=================
=================
Generate-xml-end-package.
MOVE SPACES TO Temp-data
MOVE end-package TO Temp-data
PERFORM Write-xml-line
=================
=================
=================

Write-xml-line.
* Assume text to be written to xml-file is in Temp-data
* Convert text to UTF-8 text
Move Temp-data to Nat-data
Move Function Display-of(Nat-data, 01208)
to xml-data
* Calculate length of UTF-8 text
Move Function Reverse(Temp-data) to Reverse-data
Move 0 to Num-chars
INSPECT Function Reverse(Temp-data)
TALLYING Num-chars FOR LEADING SPACES
Compute Num-chars = Function Length(Temp-data) - Num-chars
Compute xml-length = Function LENGTH(
Function Display-of(Nat-data(1:Num-chars),
01208)
)
WRITE xml-data

Setting up an Eclipse development environment 55

 .
End program MPREPROC.

Assembler program for error feedback

The following sample Assembler program dynamically queries the DSName for a passed-in DDName. The
COBOL sample program in Related References illustrates the call to this Assembler program to query the
DSName for the SYSXMLSD DDName for error feedback.

DYNQUERY TITLE 'Test the MVS DYNALLOC feature'

DYNQUERY CSECT
DYNQUERY AMODE ANY
DYNQUERY RMODE ANY
***************************************************************
* This program will dynamically query the specified DDNAME *
* that is passed to the program and return the DSNAME for *
* the specified DDNAME, including member name if applicable. *
* RC 1080 means DDNAME not found. *
* *
* Syntax from COBOL: *
* 01 DDNAME PIC X(8). *
* 01 DSNAME PIC X(54). *
* *
* CALL DYNQUERY USING DDNAME, DSNAME. *
* *
* Author: *
* IBM *
***************************************************************
*
* Standard Prolog
*
START STM R14,R12,12(R13) Save registers
LR R12,R15 Get base address
USING DYNQUERY,R12 Establish addressability
ST R13,SAVE+4 Forward link of save areas
LA R10,SAVE Address of our save area
ST R10,8(,R13) Backward link of save areas
LR R13,R10 Our save area is current one
*
L R2,0(,R1) Get addr of DDNAME parm
L R3,4(,R1) Get addr of full DSNAME parm
MVC DDNAME,0(R2) Copy DDNAME
MVC DSNAMEM(DSNAMEL),BLANKS Clear to blanks
MVC DSNAME(L'DSNAME),BLANKS Clear to blanks
MVC MEMNAME(L'MEMNAME),BLANKS Clear to blanks
*
L R1,RBPTR
LA R1,0(,R1)
USING S99RB,R1
XC S99RB(RBLEN),S99RB
MVI S99RBLN,RBLEN
MVI S99VERB,S99VRBIN
OI S99FLG11,S99NOCNV
LA R6,TUPL
ST R6,S99TXTPP
*******************************
* Set up the DDNAME parameter *
*******************************
LA R5,TUDDN1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINDDNAM)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DDNAME)
MVC S99TUPAR(L'DDNAME),DDNAME
DROP R5
*******************************
* Set up the DSNAME parameter *
*******************************
LA R5,TUDSN1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRTDSN)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSNAME)
MVC S99TUPAR(L'DSNAME),DSNAME
DROP R5
*********************************
* Set up the MEMBER parameter *
*********************************
LA R5,TUMEM1
USING S99TUNIT,R5

56 Developer for z/OS: Setting up an Eclipse Development Environment

 MVC S99TUKEY,=AL2(DINRTMEM)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'MEMNAME)
MVC S99TUPAR(L'MEMNAME),MEMNAME
DROP R5
*********************************
* Set up the DSORG parameter *
*********************************
LA R5,TUORG1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRTORG)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSORG)
MVC S99TUPAR(L'DSORG),DSORG
DROP R5
*********************************
* Set up the DSTYPE parameter *
*********************************
LA R5,TUTYP1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRTTYP)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSTYP)
MVC S99TUPAR(L'DSTYP),DSTYP
DROP R5
*********************************
* Set up the STATUS parameter *
*********************************
LA R5,TUSTAT1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRTSTA)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSSTAT)
MVC S99TUPAR(L'DSSTAT),DSSTAT
DROP R5
*********************************
* Set up the DSTYPE parameter *
*********************************
LA R5,TUDSNT1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRDSNT)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSDSNT)
MVC S99TUPAR(L'DSDSNT),DSDSNT
DROP R5
*********************************
* Set up the REC ORG parameter *
*********************************
LA R5,TURECO1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRRECO)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSRECO)
MVC S99TUPAR(L'DSRECO),DSRECO
DROP R5
*********************************
* Set up the PATH parameter *
*********************************
LA R5,TUPATH1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRPATH)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSPATH)
MVC S99TUPAR(L'DSPATH),DSPATH
DROP R5
*********************************
* Set up the PATHOPTS parameter *
*********************************
LA R5,TUPOPT1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRPOPT)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSPOPT)
MVC S99TUPAR(L'DSPOPT),DSPOPT
DROP R5
*********************************
* Set up the PATHMODE parameter *
*********************************
LA R5,TUPMODE1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRPMDE)
MVC S99TUNUM,=X'0001'

Setting up an Eclipse development environment 57

 MVC S99TULNG,=AL2(L'DSPMODE)
MVC S99TUPAR(L'DSPMODE),DSPMODE
DROP R5
*********************************
* Set up the FILEDATA parameter *
*********************************
LA R5,TUFDAT1
USING S99TUNIT,R5
MVC S99TUKEY,=AL2(DINRFDAT)
MVC S99TUNUM,=X'0001'
MVC S99TULNG,=AL2(L'DSFDAT)
MVC S99TUPAR(L'DSFDAT),DSFDAT
DROP R5
*******************************
* Set up the extension block *
*******************************
LA R5,RBX
ST R5,S99S99X
USING S99RBX,R5
XC S99RBX(RBXLEN),S99RBX Clear the RB extension 02140000
MVC S99EID,=CL6'S99RBX'
MVI S99EVER,S99RBXVR
* MVI S99EOPTS,S99EIMSG+S99EWTP
MVI S99EMGSV,S99XINFO
DROP R5
*
DROP R1
LA R1,RBPTR
DYNALLOC
LTR R15,R15
BZ OK
*
* DYNQUERY failed
*
LA R1,RB
USING S99RB,R1
SR R15,R15 Clear R15
ICM R15,3,S99ERROR Get the error from DYNALLOC
DROP R1
B EXIT
*
OK DS 0H DYNQUERY successful
*******************************
* Get the DSNAME value *
*******************************
LA R5,TUDSN1
USING S99TUNIT,R5
MVC DSNAME,S99TUPAR
DROP R5
*******************************
* Get the MEMBER value *
*******************************
LA R5,TUMEM1
USING S99TUNIT,R5
MVC MEMNAME,S99TUPAR
DROP R5
*******************************
* Get the DSORG value *
*******************************
LA R5,TUORG1
USING S99TUNIT,R5
MVC DSORG,S99TUPAR
DROP R5
*******************************
* Get the DSTYP value *
*******************************
LA R5,TUTYP1
USING S99TUNIT,R5
MVC DSTYP,S99TUPAR
DROP R5
*******************************
* Get the STATUS value *
*******************************
LA R5,TUSTAT1
USING S99TUNIT,R5
MVC DSSTAT,S99TUPAR
DROP R5
*******************************
* Get the DSNTYPE value *
*******************************
LA R5,TUDSNT1
USING S99TUNIT,R5

58 Developer for z/OS: Setting up an Eclipse Development Environment

 MVC DSDSNT,S99TUPAR
DROP R5
*******************************
* Get the REC ORG value *
*******************************
LA R5,TURECO1
USING S99TUNIT,R5
MVC DSRECO,S99TUPAR
DROP R5
*******************************
* Get the PATH value *
*******************************
LA R5,TUPATH1
USING S99TUNIT,R5
MVC DSPATH,S99TUPAR
DROP R5
*******************************
* Get the PATHOPTS value *
*******************************
LA R5,TUPOPT1
USING S99TUNIT,R5
MVC DSPOPT,S99TUPAR
DROP R5
*******************************
* Get the PATHMODE value *
*******************************
LA R5,TUPMODE1
USING S99TUNIT,R5
MVC DSPMODE,S99TUPAR
DROP R5
*******************************
* Get the FILEDATA value *
*******************************
LA R5,TUFDAT1
USING S99TUNIT,R5
MVC DSFDAT,S99TUPAR
DROP R5
*******************************
* Check the values *
*******************************
SR R15,R15
CLI DSNAME,C' '
BE CHKMEM
*
* DSNAME is found
*
MVC DSNAMEM,DSNAME
CHKMEM CLI MEMNAME,C' '
BE DONE
*
* MEMBER is found
*
MVI PARENO,C'('
MVC MBRNAME,MEMNAME
MVI PARENC,C')'
*
DONE DS 0H
MVC 0(DSNAMEL,R3),DSNAMEM
*
* Standard Epilog
*
EXIT L R13,4(,R13) Restore previous save area
L R14,12(,R13) Restore reg 14
LM R0,R12,20(R13) Restore remaining regs
BR R14 Return to invoker
*
SAVE DS 18F Save area
*
RBPTR DC A(X'80000000'+RB)
DS 0F
RB DC XL(RBLEN)'00'
RBLEN EQU S99RBEND-S99RB
DS 0F
RBX DC XL(RBXLEN)'00'
RBXLEN EQU S99ERSN-S99RBX+L'S99ERSN
TUPL DC A(TUDDN1)
DC A(TUDSN1)
DC A(TUMEM1)
DC A(TUORG1)
DC A(TUTYP1)
DC A(TUSTAT1)
DC A(TUDSNT1)

Setting up an Eclipse development environment 59

 DC A(TURECO1)
DC A(TUPATH1)
DC A(TUPOPT1)
DC A(TUPMODE1)
DC A(X'80000000'+TUFDAT1)
*
TUDDN1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+8)'00'
TUDSN1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+44)'00'
TUMEM1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+8)'00'
TUORG1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+2)'00'
TUTYP1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+1)'00'
TUSTAT1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+2)'00'
TUDSNT1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+2)'00'
TURECO1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+2)'00'
TUPATH1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+128)'00'
TUPOPT1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+4)'00'
TUPMODE1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+4)'00'
TUFDAT1 DC XL(L'S99TUKEY+L'S99TUNUM+L'S99TULNG+1)'00'
*
DS 0F
DC CL4'DDN'
DDNAME DC CL8' '
DS 0F
DC CL4'DSN'
DSNAME DC CL44' '
DS 0F
DC CL4'MEM'
MEMNAME DC CL8' '
DS 0F
DC CL4'ORG'
DSORG DC XL2'0000'
DS 0F
DC CL4'TYP'
DSTYP DC X'00'
DS 0F
DC CL4'STA'
DSSTAT DC X'00'
DS 0F
DC CL4'DTY'
DSDSNT DC X'00'
DS 0F
DC CL4'ROR'
DSRECO DC X'00'
DS 0F
DC CL4'PTH'
DSPATH DC CL128' '
DS 0F
DC CL4'POP'
DSPOPT DC XL4'00'
DS 0F
DC CL4'PMD'
DSPMODE DC XL4'00'
DS 0F
DC CL4'FDT'
DSFDAT DC X'00'
*
DSNAMEM DC CL44' '
PARENO DC C' '
MBRNAME DC CL8' '
PARENC DC C' '
DSNAMEL EQU *-DSNAMEM
BLANKS DC CL(DSNAMEL)' '
*
R0 EQU 0 MIN00280
R1 EQU 1 MIN00280
R2 EQU 2 MIN00280
R3 EQU 3 MIN00280
R4 EQU 4 MIN00280
R5 EQU 5 MIN00280
R6 EQU 6 MIN00280
R7 EQU 7 MIN00280
R8 EQU 8 MIN00280
R9 EQU 9 MIN00280
R10 EQU 10 MIN00280
R11 EQU 11 MIN00280
R12 EQU 12 MIN00280
R13 EQU 13 MIN00280
R14 EQU 14 MIN00280
R15 EQU 15 MIN00280
*
IEFZB4D0
IEFZB4D2

60 Developer for z/OS: Setting up an Eclipse Development Environment

 *
END

Setting up the client for error feedback

You can set options in the property group of a program to support error feedback.
You can use one of the following three scenarios for setting program properties to support error feedback:
• “Supporting error feedback for COBOL and PL/I programs” on page 61 (default support)
• “Supporting error feedback for custom preprocessors” on page 61
• “Supporting error feedback for other languages” on page 67

Supporting error feedback for COBOL and PL/I programs

The Developer for z/OS product supports error feedback for COBOL and PL/I programs with default
property settings for COBOL and PL/I source files. These properties work together to support error
feedback.
The COBOL and PL/I Compile Step Option windows include a checkbox and field to allow users to
indicate whether the step supports error feedback. If you select this checkbox, then the field below
it is enabled to specify the error feedback qualifier. For COBOL and PL/I, because error feedback is
supported by default, the checkbox is selected by default and the text box contains the default values of
<HLQ>.ERRCOB and <HLQ>.ERRPLI for COBOL and PL/I.

Supporting error feedback for custom preprocessors

You can set custom preprocessor properties for supporting error feedback.
To set up properties to support error feedback for custom preprocessors, do these steps:
1. From a properties window, open the Add a New Step or User-Defined Step Options window.
To open these windows, do the following steps:
a) From the Assembler Settings, COBOL Settings, or PL/I Settings page of the properties window,
select the Procedures and Steps tab.
b) Select the procedure name to which you want to add a custom step or that has an existing custom
step.
c) To enable the procedure, click Enable procedure.
A procedure must be enabled before you can add a step to it or edit an existing step.
d) Click Add step to open the Add a New Step window or Edit step to open the User-Defined Step
Options window.
2. Click the Support Error Feedback check box.
The Data Set Qualifier for Compiler Errors field is activated.
3. Specify the error feedback qualifier that is used to generate the SYSXMLSD DD card in the JCL.
If your preprocessor writes the XML file in UTF-8, then make sure the qualifier name that is specified
includes ERRWDZ. Files with ERRWDZ as a qualifier are transferred in binary format to avoid any code
page translations. To handle the file transfer, a default mapping for **ERRWDZ is defined in the z/OS
File System Mappings view.
See the Related References for samples of JCL and an XML file that is generated for error feedback for a
custom preprocessor.

Sample JCL procedure for starting custom preprocessors

This example shows a sample JCL procedure for starting a custom preprocessor.
The sample JCL procedure ELAXFCP1 is used when you start the include preprocessor that is supplied
with the Developer for z/OS product. This JCL procedure must be used as a template to create a JCL
procedure that starts your own custom preprocessor. ELAXFCP1 was copied to ELAXFCP9 and altered to
call TMPLT00.

//ELAXFCP9 PROC LNGPRFX='IGYV3R40',

Setting up an Eclipse development environment 61

 // CICSLOD='[Link]',
// DB2LOD='DSN.DSN7',
// LODPRFX='FOWLERM'
//*
//PREPROC1 EXEC PGM=TMPLT00,REGION=0M,
// PARM=('TRACE(ON)')
//STEPLIB DD DISP=SHR,DSN=[Link]
// DD DISP=SHR,DSN=&LODPRFX..I1.L1;
//SYSPPOUT DD DSN=&&TEMPFILE;,DISP=(MOD,PASS),
// UNIT=SYSALLDA,SPACE=(1800,(2500,2500))
//*
//COBOL EXEC PGM=IGYCRCTL,REGION=0M,
// PARM=('EXIT(ADEXIT(ELAXMGUX))',
// 'ADATA',
// 'LIB',
// 'TEST(ALL,SYM,SEP)',
// 'LIST',
// 'FLAG(I,I)'&CICS;&DB2;&COMP;)
//STEPLIB DD DSNAME=[Link],
// DISP=SHR
// DD DSNAME=&LNGPRFX..SIGYCOMP;,
// DISP=SHR
// DD DSNAME=&CICSLOD..SDFHLOAD;,
// DISP=SHR
// DD DSNAME=&DB2LOD..SDSNLOAD;,
// DISP=SHR
// DD DSNAME=&DB2LOD..SDSNEXIT;,
// DISP=SHR
//SYSIN DD DISP=(OLD,DELETE),DSN=&&TEMPFILE;
//SYSLIN DD DUMMY
//SYSLIB DD DUMMY
//SYSADATA DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT2 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT3 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT4 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT5 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT6 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT7 DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//*

Sample XML file generated for error feedback support for a custom preprocessor
The following sample shows an XML file that is generated for error feedback for a custom preprocessor.
The key aspects of this sample XML file are in the <SOURCE-EXPANSION-INFO> section. It contains
information that is used to correlate line numbers in the original source file that is submitted to
the preprocessor with line numbers in the preprocessed file that is submitted to the compiler.
This correlation enables the compiler-generated XML file to report errors against the correct line
number. The <SOURCE-GENERATION-INFO> section describes which source line numbers generate
which preprocessed line numbers. So, for example, if line 1 of the source file does not generate
anything, then <SOURCE-LINE-NUMBER> and <SOURCE-LINE-NUMBER-GENERATED> have the same
value. If source line 15 represents the preprocess statement and expands into one line, then <SOURCE-
LINE-NUMBER> has a value of 15 and <SOURCE-LINE-NUMBER-GENERATED> has a value of 16.
Similarly, if source line 15 gets expanded into multiple lines, the number of <SOURCE-LINE-NUMBER>
and <SOURCE-LINE-NUMBER-GENERATED> matches the number of lines that source line 15 was
expanded to. </SOURCE-LINE-NUMBER-GENERATED></SOURCE-LINE-NUMBER></SOURCE-LINE-
NUMBER-GENERATED></SOURCE-LINE-NUMBER></SOURCE-LINE-NUMBER-GENERATED></SOURCE-
LINE-NUMBER></SOURCE-GENERATION-INFO></SOURCE-EXPANSION-INFO>

<PACKAGE>
<FILEREFERENCETABLE>
<FILECOUNT>00001</FILECOUNT>
<FILE>
<FILENUMBER>00001</FILENUMBER>
<FILENAME>[Link](BADPRINT)</FILENAME>
</FILE>
</FILEREFERENCETABLE>
<SOURCE-EXPANSION-INFO>
<ORIGINAL-SOURCE-FILE-NAME>
[Link](BADPRINT)
</ORIGINAL-SOURCE-FILE-NAME>
<PREPROCESSED-FILE-NAME>
[Link].H01

62 Developer for z/OS: Setting up an Eclipse Development Environment

</PREPROCESSED-FILE-NAME>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00001</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00001
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00002</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00002
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00003</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00003
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00004</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00004
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00005</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00005
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00006</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00006
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00007</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00007
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00008</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00008
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00009</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00009
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00010</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00010
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00011</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00011
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00012</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00012
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00013</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00013
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00014</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>

Setting up an Eclipse development environment 63

 00014
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00015</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00015
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00015</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00016
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00016</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00017
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00017</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00018
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00018</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00019
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00019</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00020
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00020</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00021
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00021</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00022
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00022</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00023
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00023</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00024
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00024</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00025
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00025</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00026
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
</SOURCE-EXPANSION-INFO>
<MESSAGE>
<MSGNUMBER>PREERR05</MSGNUMBER>
<MSGLINE>00023</MSGLINE>
<MSGFILE>00001</MSGFILE>
<MSGTEXT>Line 23 in original source</MSGTEXT>
</MESSAGE>

64 Developer for z/OS: Setting up an Eclipse Development Environment

</PACKAGE>
$lt;/FILEREFERENCETABLE><PACKAGE>
$lt;FILEREFERENCETABLE>
<FILECOUNT>00001</FILECOUNT>
<FILE>
<FILENUMBER>00001</FILENUMBER>
<FILENAME>[Link](BADPRINT)</FILENAME>
</FILE>
</FILEREFERENCETABLE>
<SOURCE-EXPANSION-INFO>
<ORIGINAL-SOURCE-FILE-NAME>
[Link](BADPRINT)
</ORIGINAL-SOURCE-FILE-NAME>
<PREPROCESSED-FILE-NAME>
[Link].H01
</PREPROCESSED-FILE-NAME>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00001</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00001
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00002</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00002
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00003</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00003
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00004</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00004
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00005</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00005
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00006</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00006
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00007</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00007
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00008</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00008
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00009</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00009
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00010</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00010
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00011</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00011
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>

Setting up an Eclipse development environment 65

 <SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00012</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00012
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00013</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00013
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00014</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00014
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00015</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00015
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00015</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00016
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00016</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00017
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00017</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00018
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00018</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00019
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00019</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00020
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00020</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00021
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00021</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00022
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00022</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00023
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00023</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00024
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00024</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00025

66 Developer for z/OS: Setting up an Eclipse Development Environment

 </SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
<SOURCE-GENERATION-INFO>
<SOURCE-LINE-NUMBER>00025</SOURCE-LINE-NUMBER>
<SOURCE-LINE-NUMBER-GENERATED>
00026
</SOURCE-LINE-NUMBER-GENERATED>
</SOURCE-GENERATION-INFO>
</SOURCE-EXPANSION-INFO>
<MESSAGE>
<MSGNUMBER>PREERR05</MSGNUMBER>
<MSGLINE>00023</MSGLINE>
<MSGFILE>00001</MSGFILE>
<MSGTEXT>Line 23 in original source</MSGTEXT>
</MESSAGE>
</PACKAGE>
$lt;/FILEREFERENCETABLE>

Supporting error feedback for other languages

The Developer for z/OS product provides error feedback support for COBOL and PL/I, but you can set
properties for supporting error feedback for other languages, such as Assembler.
To set up properties to support error feedback for other languages, such as Assembler, do these steps:
1. From a properties window, open the language-specific Compile or Assemble Step Options window.
To open this window, do the following steps:
a) From the Assembler Settings, COBOL Settings, or PL/I Settings page of the properties window,
select the Procedures and Steps tab.
b) Select the procedure name for the compilation or assemble step.
c) To enable the procedure, click Enable procedure.
A procedure must be enabled before you can edit the step.
d) Click Edit step to open the Compile or Assemble Step Options window.
2. Select the Support Error Feedback check box.
The Data Set Qualifier for Compiler Errors field is activated.
3. Specify the error feedback qualifier that is used by Developer for z/OS to generate the SYSXMLSD DD
card in the JCL.
Your error feedback program writes the error feedback XML file to the data set specified by the
SYSXMLSD Card. If your error feedback program writes the XML file in UTF-8, make sure the qualifier
name that is specified includes ERRWDZ. Developer for z/OS transfers files with ERRWDZ as a qualifier
in binary format to avoid any code page translations. To handle the file transfer, a default mapping for
**ERRWDZ is defined in the z/OS file system mappings.

Building the sample preprocessor TMPLT00

Learn how to build the sample PL/I preprocessor TMPLT00.
TMPLT00 is an ILC (Inter-Language Communication) program. It is a PL/I program that calls a C module to
get the data set name associated with a DD card. The C module that is called is ZFLDATA.
To see the code for TMPLT00, refer to “PL/I program for generating error feedback XML and creating
expanded source” on page 49.
To see the code for ZFLDATA, refer to “C program for error feedback” on page 52
To build the sample preprocessor TMPLT00, do these steps. Click the links in the following procedure for
further instructions for each step:
1. Create a z/OS project.
2. Create two MVS subprojects: one for TMPLT00 and one for ZFLDATA.
3. Create a property group named "Property Group for C Parts" for the ZFLDATA subproject with the
following property settings:

Setting up an Eclipse development environment 67

 Table 5. Property Group for C Parts
Property Group Page Property Group Settings
Property Group Select the following categories:
Categories
• C/C++ Settings
• JCL Job Card and Data Set
• Link Options
• Runtime Options

C/C++ Settings On the Procedures and Steps page:

• Enable the ELAXFCPC procedure.
• Specify the following options for the C step:
Compiler options: TEST SOURCE NOMAR NOSEQ NOLIST
Object Deck Data Set: <HLQ>.[Link]
System Libraries: [Link]
Event File Data Set: <HLQ>.SYSEVENT
Additional JCL: Include any additional JCL required by your site.

Link Options On the Procedures and Steps page:

• Enable the ELAXFLNK procedure.
• Specify the following options for the LINK step:
Link libraries: [Link] [Link]
Use specified link instructions: ORDER CEESTART
Load module location: <HLQ>.LOAD
Additional JCL: Include any additional JCL required by your site.

Runtime Options On the Procedures and Steps page:

• Enable the ELAXFGO procedure.
• Specify the following options for the RUN step:
Run in batch with debugger: Select this radio button.
Runtime options/Program parameters: Select this radio button.
Additional JCL:

//SYSXMLSD DD DSN=&amp;SYSUID..TEMP.WSEDSF1,DISP=(NEW,CATLG),
DCB=(RECFM=VB,LRECL=16383,BLKSIZE=27998),
SPACE=(TRK,(200,40))

4. Create a property group named “Property Group for PL/I Parts” for the TMPLT00 subproject with the
following property settings:

Table 6. Property Group for PL/I Parts

Property Group Page Property Group Settings
Property Group Select the following categories:
Categories
• PL/I Settings
• JCL Job Card and Data Set
• Link Options
• Runtime Options

68 Developer for z/OS: Setting up an Eclipse Development Environment

 Table 6. Property Group for PL/I Parts (continued)
Property Group Page Property Group Settings
PL/I Settings On the Procedures and Steps page:
• Enable the ELAXFPLP procedure.
• Specify the following options for the PLI step:
Object deck data set: <HLQ>.[Link]
SYSLIB: <HLQ>.[Link]
Support Error Feedback: Select this check box.
Data Set qualifier for compiler errors: <HLQ>.ERRPLI
Additional JCL: Include any additional JCL required by your site.

Link Options On the Procedures and Steps page:

• Enable the ELAXFLNK procedure.
• Specify the following options for the LINK step:
Link libraries: <HLQ>.[Link] [Link]
[Link]
Use specified link instructions: ORDER CEESTART
Load module location: <HLQ>.LOAD
Additional JCL: Include any additional JCL required by your site.

Runtime Options On the Procedures and Steps page:

• Enable the ELAXFGO procedure.
• Specify the following options for the RUN step:
Run in batch: Select this radio button.
Runtime options/Program parameters: Select this radio button.
Additional JCL: Include any additional JCL required by your site.

Running the sample preprocessor TMPLT00

Learn how to run the sample PL/I preprocessor TMPLT00.
The sample PL/I preprocessor TMPLT00 is run as part of a build operation for a COBOL program. The
preprocessor runs with the COBOL program as input. The output of the preprocessor is used as input to
the compiler. The preprocessor runs when you select the Rebuild Subproject, Syntax Check > Remote,
or Show Dependencies actions for a COBOL program. See “Sample code walk-through” on page 70 for
an example of this process.
To start the preprocessor, the build properties of your COBOL property group must include a call to the
preprocessor. Set the following build properties in your COBOL property group:

Setting up an Eclipse development environment 69

 Table 7. Property Group for COBOL Parts
Property Group Page Property Group Settings
COBOL Settings On the Procedures and Steps page:
• Enable the ELAXFCP9 procedure.
• Add a step that is called PREPROC1 and set the following step options:
Support Error Feedback: Select this check box.
Data Set Qualifier for Compiler Errors: <HLQ>.FRAGDMO
Additional JCL: Include any additional JCL required by your site, such
as:

//[Link] DD DSN=<HLQ>.[Link],DSP=SHR

Runtime Options On the Procedures and Steps page:

• Enable the ELAXFCP9 procedure.
• Specify the following options for the COBOL step:
Copy Libraries: <HLQ>.[Link]
Support Error Feedback: Select this check box.
Data Set qualifier for Compiler Errors: <HLQ>.ERRCOB
Additional JCL: Include any additional JCL required by your site.

Sample code walk-through

The sample code snippets illustrate how the output from preprocessors can be linked by using the
Developer for z/OS error feedback mechanism and multiple preprocessor support.

Code snippets
This example makes reference to the following code snippets:
COBOL segment
The following COBOL program segment is from the DEMODATA source code. This program was
preprocessed and compiled. The lines that begin with FRAGMENT are at line 48, 55, and 74. The
misspelled display statement "DSPLAY" is at line 54. The member NOTTHERE is intentionally missing
from the FRAGMNT concatenation so that the preprocessor flags an error at that line.

Procedure Division.
FRAGMENT HELLO;
Initialize Program-pass-fields
Program-other-fields
Program-flags.
copy MYINC6.
Perform until Loop-done
Dsplay " "
FRAGMENT NOTTHERE;
Display "Enter a name or Q to quit:"
Move Spaces to Input-name
Accept Input-name
IF Input-name = Spaces
Move "Q" to Input-name
End-IF

Move 1 to Char-count
Inspect Input-name Tallying Char-count For Leading Spaces
Move Input-name(Char-count: 30 - Char-count) to Temp-name

If function upper-case (Temp-name) = "Q"

or Temp-name = Spaces
Set Loop-done to true
Else
Call 'PrintApp' using Program-pass-fields
End-if
End-perform.

70 Developer for z/OS: Setting up an Eclipse Development Environment

 FRAGMENT BYE;
Goback.

Fragment [Link](BYE)

***************************************************
*BYE
***************************************************

Fragment [Link](HELLO)

**************************************************
*HELLO
***************************************************

Preprocessor output
The code sample at the end of this section shows the output XML file of the preprocessor. The
preprocessor XML file contains a set of values for the source that is read in <FILEREFERENCETABLE>.
This XML file also has the messages that the preprocessor generated between the <MESSAGE> tag.
The <OUTFILEREFERENCETABLE> values describe the output files that the preprocessor created for
consumption by the compiler. The <STATEMENTTABLE> values describe each output line that the
preprocessor created. Each of the ordered quads describes a single output line in the following way:

(oln,ofn,iln,ifn)

oln
Output line number:the line number in the expanded source file.
ofn
Output file number. A preprocessor often emits only a single output file, but it is possible for a
preprocessor to write out copy members to be fed to the compiler.
iln
Input line number: the line number from the input file that was processed to cause the output line to
be written.
ifn
Input file number: the file number of the input file that is being read. It contains the line of input that
is described by iln.
From the preprocessor XML file, the following information can be determined:
• The program that was preprocessed was [Link](DEMODATA).
• The files that are used during the preprocess were [Link](DEMODATA),
[Link](HELLO), and [Link](BYE).
• The preprocessor produced a single output file, [Link].H01.
• The preprocessor error DD:FRAGMNT(NOTTHERE) not found occurred on line 55 of the input source
file 1, [Link](DEMODATA).
• The statement table entry (48,1,1,2) indicates that line 48 of the output file 1,
[Link].H01, was written as a result of reading line number
1 of input file 2, [Link](HELLO).

Setting up an Eclipse development environment 71

 <?xml version="1.0" standalone="yes"?>
<BUILD>
<PACKAGE>
<FILEREFERENCETABLE>
<FILECOUNT>3</FILECOUNT>
<FILE>
<FILENUMBER>1</FILENUMBER>
<FILENAME>
[Link](DEMODATA)
</FILENAME>
</FILE>
<FILE>
<FILENUMBER>2</FILENUMBER>
<FILENAME>
[Link](HELLO)
</FILENAME>
</FILE>
<FILE>
<FILENUMBER>3</FILENUMBER>
<FILENAME>
[Link](BYE)
</FILENAME>
</FILE>
</FILEREFERENCETABLE>
<MESSAGE>
<MSGNUMBER>DEMO9999E</MSGNUMBER>
<MSGLINE>55</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
DD:FRAGMNT(NOTTHERE) not found
</MSGTEXT>
</MESSAGE>
<OUTFILEREFERENCETABLE>
<OUTFILECOUNT>
1
</OUTFILECOUNT>
<OUTFILE>
<OUTFILENUMBER>
1
</OUTFILENUMBER>
<OUTFILENAME>
[Link].H01
</OUTFILENAME>
</OUTFILE>
</OUTFILEREFERENCETABLE>
<STATEMENTTABLE>
(1,1,1,1);(2,1,2,1);(3,1,3,1);(4,1,4,1);(5,1,5,1);(6,1,6,1);
(7,1,7,1);(8,1,8,1);(9,1,9,1);(10,1,10,1);(11,1,11,1);(12,1,12,1);
(13,1,13,1);(14,1,14,1);(15,1,15,1);(16,1,16,1);(17,1,17,1);(18,1,18,1);
(19,1,19,1);(20,1,20,1);(21,1,21,1);(22,1,22,1);(23,1,23,1);(24,1,24,1);
(25,1,25,1);(26,1,26,1);(27,1,27,1);(28,1,28,1);(29,1,29,1);(30,1,30,1);
(31,1,31,1);(32,1,32,1);(33,1,33,1);(34,1,34,1);(35,1,35,1);(36,1,36,1);
(37,1,37,1);(38,1,38,1);(39,1,39,1);(40,1,40,1);(41,1,41,1);(42,1,42,1);
(43,1,43,1);(44,1,44,1);(45,1,45,1);(46,1,46,1);(47,1,47,1);(48,1,1,2);
(49,1,2,2);(50,1,3,2);(51,1,49,1);(52,1,50,1);(53,1,51,1);(54,1,52,1);
(55,1,53,1);(56,1,54,1);(57,1,55,1);(58,1,56,1);(59,1,57,1);(60,1,58,1);
(61,1,59,1);(62,1,60,1);(63,1,61,1);(64,1,62,1);(65,1,63,1);(66,1,64,1);
(67,1,65,1);(68,1,66,1);(69,1,67,1);(70,1,68,1);(71,1,69,1);(72,1,70,1);
(73,1,71,1);(74,1,72,1);(75,1,73,1);(76,1,1,3);(77,1,2,3);(78,1,3,3);
(79,1,75,1);(80,1,76,1);(81,1,77,1);(82,1,78,1);(83,1,79,1);
</STATEMENTTABLE>
</PACKAGE>
</BUILD>

Figure 1. Output XML file

Compiler output
The code sample at the end of this section shows the output XML file of the compiler. The compiler XML
file is generated by the compiler when the appropriate compiler options are used. These compiler options
are inserted automatically when a syntax check, build, or show dependencies operation is performed.
The compiler XML file has a slightly different format than the preprocessor XML file. User-written
preprocessors and builders must follow the preprocessor XML file format.

72 Developer for z/OS: Setting up an Eclipse Development Environment

The compiler XML file shows that there is a compilation error: &quot;DSPLAY&quot; was
invalid. Skipped to the next verb, period or procedure-name definition.
This error pertains to line 56 of input file 1, [Link].H01.
The compiler reports only errors against the file that was fed to it. The compiler does
not know about [Link](DEMODATA). It knows about input file number 1,
[Link].H01. From the naming convention, and from the
JCL procedure that was used to invoke the preprocessor and compiler, you can determine that
[Link].H01 is a temporary file that is deleted once the job is
complete.
Combining the two XML files, you can find the correct line of source to map the compilation error back to:
• The compilation error was reported against file number 1.
• The compiler FILEREFERENCETABLE indicates that file 1 is
[Link].H01.
• From the preprocessor XML file, you can find the file
[Link].H01 in the OUTFILEREFERENCETABLE. It has an
OUTFILENUMBER of 1. So, the output file number is 1, and the output line number is 56.
Expressed another way:

oln = 56
ofn = 1

From the STATEMENTTABLE, you need to find iln, and ifn, where the ordered quad is (56,1,iln,ifn). From
this information, you can determine the following values:

iln = 54
ifn = 1

In summary, the compiler reported an error at line 56 in file

[Link].H01. This line corresponds to line 54 in
[Link](DEMODATA). The compilation error is reported against line 54 of file
[Link](DEMODATA).

<?xml version="1.0" standalone="yes"?>

<!-- ************************************************************************************ -->
<BUILD>
<PACKAGE>
<FILEREFERENCETABLE>
<FILECOUNT>2</FILECOUNT>
<FILE>
<FILENUMBER>1</FILENUMBER>
<FILENAME>[Link].H01</FILENAME>
</FILE>
<FILE>
<FILENUMBER>2</FILENUMBER>
<FILENAME>[Link](MYINC6)</FILENAME>
</FILE>
</FILEREFERENCETABLE>
<MESSAGE>
<MSGNUMBER>IGYPS2112-E</MSGNUMBER>
<MSGLINE>55</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
The "PERFORM" statement did not have a matching scope terminator. A scope terminator was
assumed on line 82. The execution results may not be correct.
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS2072-S</MSGNUMBER>
<MSGLINE>56</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
"DSPLAY" was invalid. Skipped to the next verb, period or procedure-name definition.
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS0002-E</MSGNUMBER>

Setting up an Eclipse development environment 73

 <MSGLINE>57</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
A character other than "*", "D", "/" or "-" was found in column 7. A blank was assumed.
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS2008-E</MSGNUMBER>
<MSGLINE>57</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
A period was required before procedure-name "T". A period was assumed before "T".
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS2145-E</MSGNUMBER>
<MSGLINE>57</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
A period was required. A period was assumed before "NOTTHERE".
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS2015-I</MSGNUMBER>
<MSGLINE>57</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
The paragraph or section prior to paragraph or section "NOTTHERE" did not contain any
statements.
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS2145-E</MSGNUMBER>
<MSGLINE>58</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
A period was required. A period was assumed before "DISPLAY".
</MSGTEXT>
</MESSAGE>
<MESSAGE>
<MSGNUMBER>IGYPS2113-E</MSGNUMBER>
<MSGLINE>75</MSGLINE>
<MSGFILE>1</MSGFILE>
<MSGTEXT>
The explicit scope terminator "END-PERFORM" was found without a matching verb. The scope
terminator was discarded.
</MSGTEXT>
</MESSAGE>
</PACKAGE>
</BUILD>

JCL substitution
Use JCL substitution to add user or global variables to the JCL that is generated by Developer for z/OS.
The JCL Substitution page is available on the Assembler, BMS, C/C++, COBOL, Link, MFS, PL/I, Run,
and ZUnit property group tabs.

Adding user variables and variable values for JCL substitution

The windows for specifying user variables and variable values for JCL procedures allow for adding,
editing, and removing user variables and values.
The same process can be used to add user variables and values for JCL procedures on any of the JCL
Substitution pages in the property group editor. The following process shows how to add user variables
and variable values for a COBOL program.
1. To add a user variable and parameter value for a JCL procedure that is used with a COBOL program,
open the COBOL Settings page of the property group editor.
2. In the left pane of the window, select JCL Substitution.
3. Click Add User Variable.
The Add User Variable window opens.
4. Type the variable name in the Variable name field.

74 Developer for z/OS: Setting up an Eclipse Development Environment

5. Type the value of the variable in the Variable value field.
6. Click OK.
The variable name and value are added to the table.
7. Repeat steps 1-6 as necessary to add the rest of your variables and values.
When you specify variable names and values on a JCL Substitution page and then generate JCL or trigger
a remote build or syntax check, a SET statement is generated just before the EXEC PROC statement.
Assume that you create the following variable names and values:

Variable Name Variable Value

PARM LIST
ERRFDBK [Link]

The following SET statement is generated:

//SETSTMT SET PARM=LIST,

// ERRFDBK=[Link]

Editing user variables and variable values

The windows for specifying user variables and variable values for JCL procedures allow for editing,
adding, and removing user variables and values.
The same process can be used to edit user variables and values for JCL procedures on any of the JCL
Substitution pages. The following process shows how to edit user variables and variable values for a
COBOL program.
1. To edit a user variable and parameter value for a JCL procedure that is used with a COBOL program,
open the COBOL Settings page of the property group editor.
2. In the left pane of the window, select JCL Substitution.
3. Select the entry that you want to edit in the User Variablestable.
4. Click Edit.
The Edit User Variable window opens.
5. Change the variable name in the Variable name field.
6. Change the value of the variable in the Variable value field.
7. Click OK.
The variable name and value are changed in the table.
8. Repeat steps 1-7 as necessary to edit the rest of your variables and values.

Removing user variables and variable values

The windows for specifying user variables and variable values for JCL procedures allow for adding,
editing, and removing user variables and parameters.
The same process can be used to remove user variables and values for JCL procedures on any of the JCL
Substitution pages. The following process shows how to remove user variables and variable values for a
COBOL program.
1. To remove a user variable and variable value for a JCL procedure that is used with a COBOL program,
open the COBOL Settings page of the property group editor.
2. In the left pane of the window, select JCL Substitution.
3. Select the variable name and value that you want to remove.
4. Click Remove.
A confirmation window opens.
5. Click Yes to remove the variable name and value.

Setting up an Eclipse development environment 75

 The variable name and value are removed from the table.
6. Repeat these steps as necessary to remove any other variables and values you no longer want.

Inserting global variables

You can add global JCL substitution variables to your JCL procedures.
The same process can be used to add global variables for JCL procedures on any of the JCL Substitution
tab pages.
The following process shows how to add global variables for a COBOL program.
1. To add a new global variable for a JCL procedure that is used with a COBOL program, open the COBOL
Settings page of the property group editor.
2. In the left pane of the window, select JCL Substitution.
3. Click Insert Global Variable.
The Insert Global Variable window opens.
4. Select a variable name from the table.
5. Click Insert.
The variable name and value are added to the table. Repeat these steps as necessary to add other
global variables.
When you add global variables to the JCL Substitution page and then generate JCL or trigger a remote
build or syntax check, a SET statement is generated just before the EXEC PROC statement. The following
global variables are available:
PDS
Resolves to the partitioned data set to which the source member belongs.
TCPIPADD
Resolves to the workstation IP address.
MEM
Resolves to the source member for which a build, syntax check, or JCL generation action was
requested.
HLQ
Resolves to the high-level qualifier of the resource for which the build, syntax check, or JCL generation
action was requested.
MSUBSTR
Returns the member name substring that is based on starting and ending indexes that you specify.
USERID
Resolves to the user ID that is used to log on to the remote system.
Assume that an installation customized the COBOL compilation JCL procedure to add a custom
preprocess step, for example, that expands the COBOL source and would like to write the output of
that preprocess to a separate partitioned data set. The preprocessed member can be the input to the
compilation step. The preprocessed member has the same name as the original COBOL source file, and
the preprocessed output is written to a separate data set. To write the output from the preprocess step to
a partitioned data set, you can add the following DD statements to the procedure:

//*custom - preprocess
//SYS012 DD DSN=[Link](&MEM),DISP=SHR ---> Writes the pre-processed output to [Link](&MEM)
//...
//*compile step
//[Link] DD DSN=[Link](&MEM),DISP=SHR
//.....

&MEM resolves to the source member for which a build, syntax check, or JCL generation action is
requested, so the user can use the JCL Substitution page to insert the global variable MEM in the
properties for the MVS subproject and does not have to insert it for every member.

76 Developer for z/OS: Setting up an Eclipse Development Environment

Configuring other Eclipse client options
Configure the other Developer for z/OS tools for your Eclipse client workspace.

Updating workspace configurations and preferences

The server can be configured to automatically download configuration and preference updates to the
client. When updates are available, the client is prompted to install the updates when you connect to a
remote system.
If updates for Developer for z/OS configurations and preferences are available when you connect to a
remote system, the Updates Available window opens with one of the following messages:
• CRRZI0520I Updates to your configuration and preferences are available.
Select the configuration files to update and click OK to accept them.
• CRRZI0531I The product has been configured to require users to install all
available configuration and preference updates. Click OK to update your
configuration files and preferences.
If the server is configured to support product and configuration groups, this message might also include
a Configuration group list. Configuration groups and the ability to select or refuse updates are controlled
by parameters in the [Link] file on the remote system. This window lists the
updates that are available for installation. The following configurations and preferences can be enabled
for automatic update:
• Eclipse settings. These configuration files update the settings in the Preferences page. For general
information about Eclipse workbench preferences, see Preferences. For specific information about
Developer for z/OS preferences, see “Setting preferences for z/OS tools” on page 80.

Attention: Code templates are among the Eclipse preferences that can be exported to a remote
system and distributed to clients by using the push-to-client feature. Before you create or edit
code templates, be sure that you know which templates are local (created on your workstation)
and which are remote (delivered to your workstation by using push-to-client). If you edit a
remote template but do not give it a unique name, your edits might be overwritten when you
connect to the remote system.
• Remote system connections. These configuration files update the remote system connections that
are defined in the Remote Systems view. For information about remote system connections, see
Connecting to a z/OS system.
• Host-based projects. These configuration files update z/OS projects that are defined on the remote
system. For more information about host-based projects, see Host-based projects.
• Property groups. These configuration files update all property groups that are defined for the remote
system. For more information about property groups, see “Defining resource options with property
groups” on page 2.
• Default values. These configuration files update default values for a remote system. For more
information about default values, see “Configuring default property values” on page 9.
• z/OS file system mappings. These configuration files update the z/OS file system mappings that are
defined for the remote system. For information about file system mappings, see “Mapping data sets and
partitioned data set members” on page 97. Three types of z/OS file system mapping configuration files
are available:
– Resource mappings are defined for specific data sets on a remote system.
– Bidirectional conversion tables are defined for systems that use bidirectional code pages.
– System mappings are defined for a remote system.
• Menu Manager menus and actions. These configuration files update the menus and actions that
are defined by using the Menu Manager preference pages. For more information about using Menu
Manager, see Creating menu actions in Menu Manager.
To install the configuration updates:

Setting up an Eclipse development environment 77

 1. If you are prompted to choose a Configuration group, select one from the list.
The choice that you make sets the configuration group for the workspace. After you choose a
configuration group, you cannot change it. On subsequent remote system connections, you can
download configurations from the default group or from the group you select the first time you connect
to the remote system. If you must access and download configurations from another configuration
group, you must connect by using a different workspace. For more information about creating a
workspace, see Switching workspaces.
2. If you are required to install all updates, click OK.
The configuration files and preferences are updated.
3. If you are allowed to select or refuse updates, do these steps:
a) Select the checkbox next to the configuration files you want to update.
To update all files that are shown, click Select All. Some configurations, such as Eclipse
Preferences, offer you the opportunity to select specific configuration files to export. To see the
list of configuration files, expand the configuration.
b) Optional: To prevent future notifications of configuration and preference updates, select the
checkbox next to Do not notify me of future updates.
If you select this option, you can reverse this choice and begin receiving updates again by setting
an option on the Configuration Files preference page. For more information about this preference
page, see the related topics.
c) Click OK.
The selected configuration files and preferences are updated.
Unless you select the Do not notify me of future updates option, the push-to-client feature handles
future updates according to the preference setting on the Configuration Files preference page:
• Notify me of all updates: When this option is set, you are prompted to update any available
configurations and preferences each time you connect to the remote system. If you do not select all of
the updates or if any new updates become available, you are prompted to install them.
• Notify me of updates that I have not rejected: When this option is set, you are not prompted to update
previously rejected configurations the next time you connect, even if they are updated on the server.
• Do not notify me of updates: When this option is set, you are never notified of updates. Selecting the
Do not notify me of future updates option on the Updates Available window sets this preference
option.
As an example, assume that the push-to-client feature prompts you to update the following
configurations when you connect to the remote system.
• Property Group Configuration Files
• Eclipse Preferences
• z/OS File System Mapping Configuration Files
If you choose to update the Property Group Configuration Files and the Eclipse Preferences, but not the
z/OS File System Mapping Configuration Files, then the next time you connect, the Updates Available
window prompts you according to the Configuration Files preference:

Configuration Files preference Updates Available actions

Notify me of all updates The window opens and prompts you to install z/OS
File System Mapping Configuration Files (because
you did not update them previously) and any other
newly updated configurations.
Notify me of updates that I have not rejected The window opens if any new updates exist, except
for z/OS File System Mapping Configuration Files.
The window does not prompt update for z/OS File
System Mapping Configuration Files.

78 Developer for z/OS: Setting up an Eclipse Development Environment

 Configuration Files preference Updates Available actions
Do not notify me of updates The window does not open.

Adding capabilities to the workbench

IBM Developer for z/OS is configured to enable a set of capabilities that support traditional mainframe
development in Assembler, COBOL, and PL/I languages. The Eclipse workbench includes additional
capabilities that support development in other languages such as C/C++ and Java™. Use the General
> Capabilities preference page to enable other capabilities that are not exposed in the default Developer
for z/OS client configuration.
The default Developer for z/OS capabilities are an enhancement added in Developer for z/OS version 15.0
to filter out preferences, perspectives, views, or wizards that are not relevant to traditional mainframe
development in Assembler, COBOL, and PL/I languages. If you open Developer for z/OS version 15.0
on a workspace that was created in an earlier version, and you notice the absence of preferences,
perspectives, views, or wizards that you are accustomed to seeing, follow the instructions to enable the
default Eclipse capabilities.
When you start Developer for z/OS the first time using a new workspace, the following Capabilities are
enabled in Preferences > General > Capabilities:
__ • CICS Application Development > CICS Application Development
__ • Db2 for z/OS Development
__ • Development > Debug Support
__ • IBM Debug Tool Plugins
__ • Team > Core Team Support
Note:
• To create plug-ins or work with Java source, XML files, or JSON files, enable the appropriate
capabilities.
• To list all perspectives and wizards, including those from disabled capabilities, select the Show All
option on the Window > Open Perspective > Other Open Perspective window or the Show All
Wizards option on the File > New > Other "Select a wizard" window.
Limitations:
When the Java Development capability is disabled, the following limitations apply:
• In the Resource perspective double-clicking on a file or selecting a file and pressing F3 does not open
the file in an editor. In addition, there is no Open or Open With menu action. To enable these functions,
enable the Java Development capability.
• Some Java wizards such as those for creating a new Java Class or Java Interface continue to show in
the File > New > Other "Select a wizard" window.
• To add capabilities to the workbench:
a) Open the Capabilities preference page.
b) Select the capabilities you want to add.
c) Click Apply and Close.
• To enable the default Eclipse capabilities, rather than the default Developer for z/OS capabilities, click
Restore Defaults and then click Apply and Close.
The following capabilities are the Eclipse defaults:
__ – Development > Debug Support
__ - Ant Development
__ - Debug Support
__ - Java Development

Setting up an Eclipse development environment 79

 __ - Plug-in Development
__ – Team
__ - Core Team Support
__ - CVS Support

Setting preferences for z/OS tools

Several categories of preference settings directly affect z/OS application development in the z/OS
Integrated Development Environment.
Select the links in this list for more information about preference settings for the z/OS Integrated
Development Environment.
• Client Certificates
• Remote Systems > z/OS
– MVS Files
• “Tracing” on page 83
• z/OS Solutions
– Setting z/OS UNIX subproject preferences

Setting preferences for client certificate authentication

Use the Client Certificates preference page to specify preferences for client certificate authentication.
With client certificate authentication, you can authenticate with remote systems by using a security
device such as an integrated circuit card (like a smart card). Developer for z/OS relies on the Java
Cryptographic Service Provider (Java CSP) for the retrieval of the certificates. The certificates are used
solely for client certificate authentication. All updates to the certificates are outside the scope of
Developer for z/OS.
To set up client certificates on your workstation:
1. Specify values for these fields:
Java Cryptography Extension (JCE) provider
Specify the name of the security provider as provided by the vendor that supplies the cryptography
software that is used to access the certificates.
Keystore type
Specify the keystore type that the Java CSP uses for retrieving the certificates that are stored in
the Microsoft Cryptography API (MS-CAPI) keystore. Use the name of the keystore that the security
provider gives.
hostIdMappings object identifier (OID)
Specify the hostIdMappings OID. Do not change the value that is specified on the preferences
page from the default value of [Link].2.18.1 unless instructed otherwise by the systems
administrator. The hostIdMappings extension (Object Identifier 1 3 18 0 2 18 1) is an IBM
extension that is also available for public use. The security software on the remote system (such as
RACF®) automatically maps a valid certificate to the RACF user ID that is provided in the extension.
Changing this value might cause the certificate authentication to fail.
2. To ensure that each keystore has a unique alias, select the Ensure unique aliases check box.
Note: Select this option only when you are using the Sun MSCAPI Java Cryptography Extension (JCE)
Provider and only when the aliases are not unique. Do not select this option for other JCE providers.
3. To filter certificates by key usage, select one or more of these checkboxes that are listed under
Certificate key usage:
__ Digital signature
__ Non-repudiation
__ Key encipherment

80 Developer for z/OS: Setting up an Eclipse Development Environment

 __ Data encipherment
__ Key agreement
__ Certificate signing
__ CRL Signing
__ Encipher only
__ Decipher only
For information about the types of key usage, see "Key usage extensions and extended key usage."
Tip: You can filter by key usage alone or combined with filtering by hostIdMappings OID.

Setting preferences for configuration updates

Use the Configuration Files preference page to set options for automatically updating your workspace
when you connect to a remote system.
Restriction: The system administrator has the ability to prevent users from rejecting configuration
updates. If the remote system has been configured to prevent you from rejecting updates, the options on
this page are not available and all configurations and preferences must be updated when you connect to
the remote system.
1. In the Preferences window, navigate to Remote Systems > Configuration Files.
2. Select one of the following options:
• Notify me of all updates Each time you connect to the remote system you are notified of all
available updates. Notifications continue until you install the updates.
• Notify me of updates that I have not rejected Each time you connect to the remote system,
you are notified of available updates for the configurations and preferences you have updated
previously. If, on previous connections, you have rejected any updates, you are no longer notified of
them.
• Do not notify me of updates The product never notifies you that configuration and preference
updates are available.
• Clear Cached Files: Click this button to reset the configuration settings for the current workspace.
This action is helpful if the configuration files become corrupted or out-of-sync with the remote
system. Clearing the cache allows new settings to be imported from the remote system to the
current workspace.
Clear Cached Files is intended primarily for push-to-client administrators to use when they are
preparing a push-to-client environment. It can also be used by non-administrators to resynchronize
downloaded configurations with the remote system or group from which you downloaded them. For
more information about resetting workspace configuration files, see the related links.
3. Click OK to save the settings.

Setting preferences for MVS Files subsystems

Use the MVS Files page to set preferences for the MVS Files subsystem in the Remote Systems view.
To set preferences for MVS Files:
1. In the Preferences window, navigate to Remote Systems > z/OS > MVS Files .
2. Use the MVS Files page to set the following preferences:
Large Partitioned Data Set The options in this area determine how large partitioned data sets are
handled in the Remote Systems view.
• Show warning message on expansion: Select this checkbox to display a warning message when
expanding large partitioned data sets, which can take a long time.
• Maximum number of members expanded without warning: If you select the Show warning
message on expansion option, use this field to set the number of members to allow before the
warning is displayed. The default value is 5000.

Setting up an Eclipse development environment 81

 • Show warning message on adding to subproject: Select this checkbox to display a warning
message when adding large partitioned data sets to a subproject.
• Maximum number of members added to subproject without warning: If you select the Show
warning message on adding to subproject option, use this field to set the number of members to
allow before the warning is displayed. The default value is 50.
• Maximum results for Find Member: Specify the maximum number of search results to return with
the Find Member action. The default value is 1000 members.
Generation Data Set Label: There are two options for displaying generation data sets:
• Absolute generation and version numbers (Relative generation number): Shows the absolute
generation and version numbers followed by the relative generation number, such as
G0005V00(-1).
• Relative generation number (Absolute generation and version numbers): Shows the relative
generation number followed by the absolute generation and version number, such as
-1(G0005V00).
Sort Order for Data Sets: The options in this area determine the order of data sets in the Remote
Systems view and the z/OS Projects view:
• By type: Select this option to list partitioned data sets followed by sequential data sets.
• By name: Select this option to list all data sets in alphabetical order, regardless of data set type.
Default expansion page size for filters and data sets: Specify the number of data sets or data set
members to show in the Remote Systems view when you expand a filter or partitioned data set.
All other entries remain hidden until you bring them into view. You can override this number for a
particular filter or data set. The default value is 50.
Show warning message on deleting alias: Select this checkbox to display a warning message when
you delete a data set alias.
Process member aliases on module copy: Select this check box to enable the primary load module
and all its aliases to be copied together.
Show members with non-standard name: Select this check box to enable the Remote Systems
view to display members with lowercase names or names containing nonstandard character sets. This
option is disabled by default.
Enable editing of files with control codes: Select this checkbox to allow MVS text files that contain
control codes to be opened in edit mode. When this checkbox is selected, UTF-8 is used as the default
local code page mapping for new connections. Connections that exist are not affected.
Show missing property group warning message on opening files: Select this checkbox to open the
Missing Property Group window when a COBOL or PL/I file is opened and the file does not have a
property group associated with it. This preference is selected by default. If you disable the Missing
Property Group window by selecting Do not show this window again, this preference is cleared.
Verification of property group association is not performed for sequential data sets.
Default action for opening MVS files: Choose the action to be executed when you double-click a
sequential data set name or partitioned data set member name in the Remote Systems view:
• Open - Opens the file for editing in the default editor. This setting is the default.
• View - Opens the file for editing, without locking the file, in the default editor.
• Browse - Opens the file in read-only mode in the default editor.
For more information about each of these actions, see the related topics.
Restriction: Dragging a file from the Remote Systems view to the editor opens the file in edit mode
in the default editor that is associated with the file extension. Setting the Default action for opening
MVS Files preference does not change this behavior.
Default action for opening copybooks: Choose the action to be executed when you double-click a
copybook name or choose the Open Declaration action for a copybook.

82 Developer for z/OS: Setting up an Eclipse Development Environment

 Automatically recall migrated SYSLIB data sets: Select this checkbox to attempt to recall a migrated
data set that is found in the SYSLIB during copybook or include file resolution when editing a source
file. Since recalling data sets may take some time, using this option can lengthen the parsing and
dependency resolution process.
Note: If your system administrator has configured the server to hide migrated data set actions on
the client, then selecting this checkbox has no effect. For more information about this configuration
option, see "Defining extra Java startup parameters with _RSE_JAVAOPTS" in the IBM Explorer for z/OS
Host Configuration Guide.
Enable logical NOT symbol conversion in COBOL source: Select this checkbox to specify an
alternative logical NOT symbol for COBOL files. This preference is disabled by default.

Setting preferences for Remote z/OS Search

Use the Remote z/OS Search preferences page to set options for remote z/OS search results.
The Remote z/OS Search view provides controls that help you work with search results more efficiently:
• A search operation can return search results incrementally so that you can begin working with search
results before all results are returned. You can specify how frequently the search results are updated.
• The Remote z/OS Search view can show you a preview of file contents in a pop-up window. This
preview helps you better understand what is in a file before opening it in an editor. You can specify the
timing and size of the preview window.
1. In the Preferences window, navigate to Remote Systems > z/OS > Remote z/OS Search.
2. Specify the following options:
Result update frequency: To specify how frequently search results are updated, slide the control to
a higher setting for more frequent updates or to a lower setting for less frequent updates. A higher
frequency returns a smaller result set with each update and a lower frequency returns a larger result
set with each update.
Preview contents in Remote z/OS Search view: To enable the preview window, select the checkbox.
To disable the preview window, clear this check box. When this checkbox is selected, the remaining
fields in the Search result preview group are enabled.
Time in miliseconds until preview is activated: To control the timing of the preview window, type
a number in this field. This field controls how quickly the preview window opens after you place the
mouse pointer over a result string. The higher the number, the slower the response time.
Number of lines before current line and Number of lines after current line: To control the size of the
preview window, select a number in these fields. You can select a number between 1 and 9.
3. Click OK to save the preference settings.

Tracing
You can set varying tracing levels for specific Developer for z/OS components.
During tracing, trace entries are produced and placed in the workspace\.metadata\.trace file. The
number of entries and the amount of detail that is generated is determined by the setting of the tracing
level for various tracers. The tracers are listed on the Tracing preference page. A tracing level is specified
for each tracer, and, if tracing is enabled, the .trace file is populated with entries that contain a level
equal to or less than the specified level. A trace shows the flow of the execution of a program and can
help with troubleshooting and debugging problems.
To set tracing levels for Developer for z/OS components, do these steps:
1. In the Preferences window, click Tracing.
The Tracer Name list displays components for which tracing is available. The default tracing level
for [Link] is FINEST. The default for the remaining components is
NONE, which means that no tracing is done for the component. Other available tracing levels include
the following values:

Setting up an Eclipse development environment 83

 • FINE - records trace data for basic debugging information such as input and output date.
• FINER - records trace data such as conversion data and traps that are to be ignored.
• FINEST - records trace data such as entry and exit data for methods.
2. To include trace entries regardless of their levels, change the tracing level to FINEST.
The volume of data generated is greater, but might provide the information that is required to solve
some problems.
3. Click Restore Defaults after the trace is captured.

z/OS Solutions preferences

Use the z/OS Solutions preference page to set general preferences for z/OS projects, subprojects, and
files.

Purpose
You can set the following preferences on this page.
Show warning message on opening files
Opening large files can cause out-of-memory errors and a forced shutdown of the workbench. Select
this option to check the size of any file that is being opened (sequential data sets, partitioned data set
members, or local files) and display a warning if it is larger than the specified threshold. This warning
gives you the option to cancel the file open operation or continue it. This option is enabled by default,
and the default threshold is 2500 KB. To specify a different threshold, enter a value in the Maximum
file size to open without warning (in KB) field.
Prompt to add dependent files to MVS subprojects
Select this option to enable a prompt to add dependent files to MVS subprojects. This prompt is
displayed when you are editing a remote file and choose to open or browse a dependent file.
Display system name on remote subprojects (requires refresh on existing subprojects)
z/OS projects can contain subprojects with resources on multiple remote systems. Select this option
to display the name of the remote system on which the resources of each subproject are located.
Always prompt for a load module name during build
Select this option to enable Developer for z/OS to prompt you for a load module name when you
build a subproject, or when you generate JCL for a COBOL, PL/I, or Assembler file. Clear this option
to disable this prompt. When this option is cleared, the name of the member that is nominated as the
entry point is the load module name.

Supporting bidirectional languages

Notice: Bidirectional language support in IBM Developer for z/OS will continue with respect to current
available functionality but will not be extended to new capabilities.
Developer for z/OS provides tools that help you develop applications that use bidirectional languages like
Arabic and Hebrew.
The term bidirectional support applies to special software and special user interfaces added to Developer
for z/OS to support bidirectional languages like Arabic and Hebrew. Developer for z/OS provides tools that
you can configure and use for supporting bidirectional (bidi) languages.

Background and concepts

• “Bidirectional layout (or bidirectional format) terminology” on page 85
• “Bidirectional layout transformation (or bidirectional conversion)” on page 86
• “Smart logical ordering scheme” on page 86
• “Bidirectional layouts and tools” on page 87
• “Why special tools are required by smart logical layout” on page 87

84 Developer for z/OS: Setting up an Eclipse Development Environment

Using bidirectional support
• “Configuring bidirectional support” on page 88
• “Editing bidirectional data” on page 88
• “Using bidirectional file search” on page 88
• “Comparing bidirectional text” on page 89
• “Changing the bidirectional format of a file” on page 89
• “How bidirectional settings are inherited” on page 90
• “Setting bidirectional conversion support for an MVS system” on page 91
• “Setting bidirectional conversion support for a data set or partitioned data set member” on page 91
• “Setting bidirectional conversion support for an MVS system mapping” on page 92
• “Setting bidirectional conversion support for z/OS UNIX System Services” on page 93
• “Setting local build options for smart logical COBOL and PL/I files” on page 94

Bidirectional layout (or bidirectional format) terminology

Bidirectional text can be stored on the client or server system in different text layouts (different
bidirectional formats). A bidirectional layout specifies how bidirectional text is being stored on a system.
It can be defined by five basic bidirectional attributes for Arabic language, and by three attributes for
Hebrew.
Global or text orientation
Global orientation designates the direction in which the text is stored. It can be right-to-left (RTL) or
left-to-right (LTR). Contextual text orientation is not supported in Developer for z/OS.
Ordering scheme (or text type)
The ordering scheme defines the relationship between the order of text as stored in memory or
on external media and its order for correct display. Developer for z/OS recognizes three ordering
schemes:
• In the visual ordering scheme, text is stored in the same order as it is displayed.
• In the logical ordering scheme, text is stored in the order it is intended to be read. It must be
reordered for display by using an algorithm that assumes that the letters of the Latin alphabet have
a strong inherent left-to-right directionality and the letters of the Arabic or Hebrew alphabet have a
strong right-to-left inherent directionality. This implicit (or logical) algorithm recognizes segments by
their inherent directional characteristics and inverts segments automatically.
• In the smart logical ordering scheme, the text is processed with a special algorithm introduced in
Developer for z/OS to improve the data exchange between zSeries systems and Developer for z/OS.
This algorithm is described in more detail in “Smart logical ordering scheme” on page 86.
Text shaping
Text shaping applies to the Arabic script in which characters assume different shapes according to
their position in a word and how they connect to surrounding characters.
Symmetric swapping
Symmetric swapping designates when specific characters such as ( > [ { must be interchanged with )
< ] } to preserve the logical meaning of the presented text.
Numeric shaping
Numeric shaping designates whether numbers must be presented by using the European digit shapes
or the Arabic-Indic digit shapes.
No single combination of possible values of bidirectional layout attributes is predominant. Existing
applications process data with different possible combinations of these values. Therefore, when a
bidirectional data stream is passed to an application, it is important that the application recognizes the
associated text attributes.
Next: “Bidirectional layout transformation (or bidirectional conversion)” on page 86

Setting up an Eclipse development environment 85

 Bidirectional layout transformation (or bidirectional conversion)
Different systems and applications assume different bidirectional text layouts.
Earlier zSeries applications, for example, usually assume that bidirectional text is stored in visual order
(with various other bidirectional attributes). Most zSeries software infrastructure was developed before
common use of the logical ordering scheme and therefore ignores its existence. Newer development
platforms, such as Windows or Java/Swing, assume that bidirectional text is stored in a logical order
and reorders the text for presentation according to a bidirectional algorithm generally following the one
specified by Unicode. Most of the base software that is written on these platforms is not designed to
support data that is stored in visual order. Because of these platform differences, exchanging bidirectional
data between zSeries and Windows or Java/Swing platforms requires bidirectional text layout to be
transformed to display, edit, or use the data on the target system. This process of transforming
bidirectional text layout between incompatible systems is called bidirectional conversion.
Many existing client/server applications assume that bidirectional conversion is the responsibility of
bidirectional developers. This assumption causes problems of incompatibility and limitations because of
the different algorithms that different developers use to make the conversion.
The Developer for z/OS bidirectional language support tools free bidirectional developers from this task
to save development effort and make bidirectional software more portable. These tools consist of a user
interface for specifying host (zSeries) and client bidirectional layouts. The Developer for z/OS product
does bidirectional conversions automatically according to information you provide by using this interface.
It is the bidirectional developer's responsibility to understand the bidirectional layouts that are used in
your environment and to provide correct information about bidirectional layouts and encoding by using
the Developer for z/OS user interface. Visual LTR layout is assumed as the default layout for remote
systems, and Smart Logical LTR is assumed as the default layout for the client by most Developer for z/OS
components and tools.
Next: “Smart logical ordering scheme” on page 86

Smart logical ordering scheme

The smart logical layout scheme was introduced into the Developer for z/OS product to overcome
restrictions of the logical ordering scheme and to provide for the special requirements of programming
languages.
The smart logical layout was introduced in the Developer for z/OS product to solve two main problems:
Round-trip problem
The implicit (logical) reordering algorithm has known restrictions that do not allow for correct handling
of some strings that contain bidirectional text. As a result, users cannot easily generate certain
presentations. These restrictions also create ambiguity during visual to logical conversion, which is
performed when data is downloaded from a zSeries remote system to a Windows or Java client.
Complex expressions handling
Text that is written in formal languages (such as programming languages) must obey rules that dictate
the order of different tokens according to the appropriate syntax. If some of the tokens contain
right-to-left (RTL) letters, the reordering that is performed for presentation according to the regular
algorithm might cause the tokens to be displayed in an order different from the syntactical order. As a
result, structured bidirectional data can be broken by visual-to-logical conversion, which is unaware of
the data structure. Assume, for example, that a COBOL file on an MVS system contains the following
line of code in which the tokens are Arabic or Hebrew:

STRING "token1", "token2", "token3", "token4"

After visual-to-logical conversion, this row looks correct (the same as on the host) in any logical editor,
but is stored in the opposite order:

STRING "token4", "token3", "token2", "token1"

86 Developer for z/OS: Setting up an Eclipse Development Environment

Solving the round-trip problem
To solve the round-trip problem, the bidirectional conversion algorithm is supplied with a special option.
When this option is specified (that is, when the smart logical client layout is defined by a Developer for
z/OS user), bidirectional text with potential ambiguity is preceded automatically by LRM or RLM marks.
These marks are also called intra-token marks.

Solving the problem of complex expressions handling

Resolution of complex expressions problems is also based on use of LRM marks. Unfortunately, it is
not possible to resolve this problem with a generic solution because resolution depends on particular
language syntax. Visual-to-logical conversion for source programs that are written in COBOL, C/C++,
PL/I, HLASM, and XML was extended to support LRM marks insertion, when smart logical client layout is
defined by the Developer for z/OS user. Marks that are introduced by the smart logical algorithm to solve
language-dependent syntax problems are called inter-token marks.
Next: “Bidirectional layouts and tools” on page 87

Bidirectional layouts and tools

The smart logical layout is the Developer for z/OS default layout.
MFS editor, BMS editor, and other tools-generated code is in smart logical layout. The use of smart logical
format is encouraged. Bidirectional users who are working with smart logical data must understand the
following conditions:
• Correct language (file extension) definition is important when you work with smart logical program
sources. Incorrect language selection can cause incorrect bidirectional conversion and data corruption
because the smart logical algorithm is sensitive to programming language syntax.
• Only tools that support the smart logical layout that is described in this help system must be used for
work with smart logical files.
Next: “Why special tools are required by smart logical layout” on page 87

Why special tools are required by smart logical layout

To support correct processing of bidirectional data that contains marks, special handling was added to z
Systems LPEX Editor, file search windows, the text compare window, and compilers.
Developer for z/OS bidirectional users who are working on program development with remote visual files
have the following options:
• Use smart logical conversion for visual data (visual-to-logical conversion with marks) and use special
tools for handling smart logical data. The advantage of this approach is that data display and editing in
z Systems LPEX editor is identical to the data display and editing on the visual zSeries system. Search
and compare of smart logical files is supported as well. The disadvantage of this approach is that not all
tools were adapted to support smart logical data.
• Use standard visual-to-logical conversion (without marks) and use standard Eclipse tools. The
advantage of this approach is that all standard Eclipse tools support logical data without marks. The
disadvantages of this approach are that in some cases logical data is displayed differently from how it
is displayed on visual system, and there is potential for data corruption when multiple conversions are
performed or data is edited on a logical system.
• Use files in visual layout. Visual layout, although sparsely supported by Eclipse, might be useful for
special needs.
A special Change bidirectional format conversion utility allows conversion of files from one bidirectional
layout to another inside the Eclipse workspace.

Setting up an Eclipse development environment 87

 Configuring bidirectional support
You can configure Developer for z/OS for bidirectional support.
1. To configure the product:
a) On the Preferences window, select Bidirectional Development.
b) Choose one of these options:
• Select the Search and Replace bidirectional text in local files check box to replace the standard
Eclipse File Search window with its bidirectional counterpart that supports smart logical and visual
layouts.
• Select the Compare local files, containing bidirectional text check box to replace the Text
Compare window that is used for comparison of local and remote files with Visual Text Compare,
which supports smart logical file comparison.
2. To configure smart logical data editing in the z Systems LPEX editor:
a) On the Preferences window, navigate to General > Editors > File Association.
b) From the list of file types, click *.* or select individual file types that include bidirectional data.
c) In the Associated Editors pane, click Add.
d) On the Editor Selection window, click Internal Editors, select z Systems LPEX Editor, and then
click OK.
e) Click OK on the Preferences window to save the configuration changes.
“Editing bidirectional data” on page 88

Editing bidirectional data

You can edit bidirectional text in the z Systems LPEX editor in a special visual line.
To access the visual line, open the z Systems LPEX editor and click Source > Visual line from the menu or
press Alt+=. Bidirectional text editing in a visual line is visual (similar to a host editor). You can find more
information about z Systems LPEX Editor and its bidirectional support in z Systems LPEX Editor help. In
the visual line, you can do the following editing tasks:
• Press Alt+P to toggle Autopush mode.
By default, you are editing in Autopush mode, which simulates logical-like typing.
• Right-click to open the visual line menu.
• Press the up and down arrow keys to navigate to other text segments that include bidirectional text.
• Press Enter, change focus, or press an arrow key to save data that is entered in the visual line in smart
logical layout.
• Press Esc to clear the visual line without saving data that is entered into it.
Any data that you entered is lost.
“Using bidirectional file search” on page 88

Using bidirectional file search

Bidirectional file search allows for the correct processing of search strings that contain bidirectional
markers.
When you enable bidirectional support for file search, two checkboxes are added to the File Search
window:
• A Visual format checkbox beside the Containing text entry field.
• A Visual search in standard logical files check box under the File name patterns field.
The Visual format checkbox is also added to the Remote z/OS Search and Replace windows.

88 Developer for z/OS: Setting up an Eclipse Development Environment

• Select the Visual format checkbox to place the Containing text field in visual typing mode, which
might be familiar to host emulator bidirectional users.
The default mode is Auto-push. It can be toggled by pressing Alt+Numpad. Press Alt+NumLock to
toggle typing direction. Other key combinations familiar to IBM Personal Communications users might
be used as well. Text that is already inserted in the Containing text field is converted automatically to
visual format when the Visual format check box is selected and to logical format when it is cleared.
Use Visual format to search smart logical files.
• Select the Visual search in standard logical files checkbox to convert the target string to visual layout
before it is compared to a search pattern.
This setting allows for finding some strings that cannot be located otherwise with standard logical
search. Use Visual search in standard logical files to search regular logical files.
“Comparing bidirectional text” on page 89

Comparing bidirectional text

Bidirectional text compare is supported for local files, team compare and history, and remote file
compare.
Bidirectional text compare becomes available only when the Compare check box is selected in the
Bidirectional Development preference page and the files that are being compared are in smart logical
format. When you enable bidirectional support for comparing files, the Text Compare window is replaced
with the Bidirectional Text Compare window. The Bidirectional Text Compare window functions
similarly to the standard window, except that bidirectional format is indicated by <SL> following the
file name. Additionally, visual text compare offers the following benefits:
• Correct processing of bidirectional markers
• Visual typing of bidirectional data
• Saving changes in smart logical format
For bidirectional text compare, the Internal Find/Replace window is replaced by the Find/Replace
Visual Text window, which allows visual typing of bidirectional data and correct processing of smart
logical files. You can allow typing from right to left by pressing the Alt+NumLock keys, and you can make
autopush typing mode active by pressing the Alt+NumPad keys.
“Changing the bidirectional format of a file” on page 89

Changing the bidirectional format of a file

Each bidirectional file in the workspace can have a bidirectional format property that is associated with it.
This property has two possible values: Default for logical or visual files or Smart logical for files that are
created by using the smart logical algorithm.
You can use the Change file format window for the following purposes:
• Convert smart logical and logical data to visual layout, which might be necessary for local syntax
checking, as local compilers do not support LRM marks correctly.
Limitations:
– Local syntax check is deprecated. This action is available only on Windows.
– Local syntax checking does not support shift-out-shift-in (SOSI) sources. The importer that is used to
do the local syntax check supports only UTF-8 encoding. Translating CP-930 and other SOSI sources
into UTF-8 alters the column locations for some characters, and this alteration results in unexpected
errors.
• Convert files in visual layout to smart logical layout for editing with the z Systems LPEX editor.
• Convert BMS files that are created by previous versions of the Developer for z/OS product to smart
logical layout used by SFM, BMS, and other tools.
• Convert logical files to smart logical layout for correctly uploading them to the remote system.

Setting up an Eclipse development environment 89

 To view and change the bidirectional format of a file, do these steps:
1. Select a file in the Navigator and then select Change Bidi Format from the menu.
Note: This action is available for local files only. You cannot do this action for remote files.
2. To change the bidirectional format property of the file, select Change format property only.
3. To convert the file content to the required layout, select Change file format.
4. To define current and target bidirectional layouts, select settings from the Source attributes and
Target attributes areas.
For each of these attribute sets, you can choose the following settings:
Option Description
Visual When this option is selected, the file uses visual layout. When it is clear, the file
uses logical layout.
RTL When this option is selected, the file uses right-to-left file orientation. When it is
clear, the file uses left-to-right orientation.
Symmetric When this option is selected, certain characters such as ( > [ { are interchanged
Swap with ) < ] } to preserve the logical meaning of the presented text.
Note: This option is enabled for Visual RTL files only.

Numeric Swap When this option is selected, Arabic (European) digit shapes are interchanged with
Hindi digit shapes. This option toggles the file between Arabic (European) and
Hindi numbers. If the file includes Arabic numbers and you select this checkbox,
Arabic numbers are converted to Hindi. If the file includes Hindi numbers they are
converted to Arabic.
Note: This option is enabled for Visual RTL files only.

When the source and target settings for a particular attribute are the same, but conversion is
requested, the file layout is toggled from smart logical to logical or from logical to smart logical.
Next: “How bidirectional settings are inherited” on page 90

How bidirectional settings are inherited

The bidirectional format that is specified on a higher level is inherited automatically by a lower level.
You can define bidirectional settings on different levels of the Remote System Explorer hierarchy:
• MVS Files
• z/OS UNIX files
• Data set mappings
• Individual data sets and files
Inherit from properties (MVS) or Inherit from (z/OS UNIX) indicates the high-level resource from which
currently active bidirectional properties are inherited. You can override these inherited properties by using
the instructions in the following topics:
• “Setting bidirectional conversion support for an MVS system” on page 91
• “Setting bidirectional conversion support for a data set or partitioned data set member” on page 91
• “Setting bidirectional conversion support for an MVS system mapping” on page 92
• “Setting bidirectional conversion support for z/OS UNIX System Services” on page 93
Next: “Setting bidirectional conversion support for an MVS system” on page 91

90 Developer for z/OS: Setting up an Eclipse Development Environment

Setting bidirectional conversion support for an MVS system
Developer for z/OS provides special bidirectional properties for the MVS Files subsystem to allow correct
bidirectional layout conversions for MVS files that are transferred between the client and server.
There are two methods for specifying these bidirectional conversion options:
• Use a bidirectional conversion table
• Use manual bidirectional settings
To apply bidirectional conversion support to an MVS Files subsystem, do these steps:
1. In the Remote Systems view, right-click MVS Files under a z/OS connection
2. Click Properties.
The Properties window opens.
3. Click Code Pages in the list on the left.
4. Do one of the following steps:
• To use a bidirectional conversion table, do these steps:
a. Click Use the following Bidi Conversion Table (BCT). This option enables the field and the
Browse button.
b. Enter the name of a bidirectional conversion file you created or click Browse to look for and
select a conversion file.
c. To edit the current properties in the bidirectional conversion table, click Copy. The properties
are copied to the Current set of bidi options table, and you can click Edit to change the values
and Save as to save your changes to a new bidirectional conversion table.
• To use manual bidirectional settings, do these steps:
a. Click Use the following manual bidi settings. This option enables a set of default bidirectional
settings.
b. Click Edit to open a window that you can use to change the default settings.
c. Click Save as to save the current settings to a new bidirectional conversion table.
5. Click OK to apply the changes.
“Setting bidirectional conversion support for a data set or partitioned data set member” on page 91

Setting bidirectional conversion support for a data set or partitioned data set member
Developer for z/OS provides special bidirectional properties for MVS data sets and partitioned data set
members to allow correct bidirectional layout conversions for files that are transferred between the client
and server.
There are three methods for specifying these bidirectional conversion options:
• Inherit the bidirectional settings from the MVS Files subsystem
• Use a bidirectional conversion table
• Use manual bidirectional settings
To set bidirectional conversion support for a data set or partitioned data set member, do these steps:
1. Right-click a data set or member in the Remote Systems view.
2. Click Properties.
The Properties window opens.
3. Click Mapping in the list on the left.
4. In the Defined Language section, click Default to set bidirectional conversion options that are based
on the Workstation file extension field or Other to select a language for the file extension.
Bidirectional conversion in the Remote System Explorer is sensitive to the programming language in
which source code is written. You can usually assume that the Workstation file extension field selects
the correct language. In some cases, however, such as .cpy for COBOL and PL/I and .mac for PL/I

Setting up an Eclipse development environment 91

 and Assembler, the same file extensions can be used with different languages. Use the Other option to
select a specific language to associate with the file extension.
5. Do one of the following steps:
• To inherit the bidirectional settings from the MVS Files subsystem, click Inherit from properties for
MVS Files. If the MVS Files subsystem uses a bidirectional conversion table, the name of the table
is shown in parentheses and the properties that are inherited are shown in the Inherited set of bidi
options table. For more information about property inheritance, see the related topics.
• To use a bidirectional conversion table, do these steps:
a. Click Use the following Bidi Conversion Table (BCT). This option enables the field and the
Browse button.
b. Enter the name of a bidirectional conversion file you created or click Browse to look for and
select a conversion file.
c. To edit the current properties in the bidirectional conversion table, click Copy. The properties
are copied to the Current set of bidi options table, and you can click Edit to change the values
and Save as to save your changes to a new bidirectional conversion table.
• To use manual bidirectional settings, do these steps:
a. Click Use the following manual bidi settings. This option enables a set of default bidirectional
settings.
b. Click Edit to open a window that you can use to change the default settings.
c. Click Save as to save the current settings to a new bidirectional conversion table.
6. Click OK to apply the changes.
Next: “Setting bidirectional conversion support for an MVS system mapping” on page 92

Setting bidirectional conversion support for an MVS system mapping

Developer for z/OS provides special bidirectional properties for MVS system mappings to allow correct
bidirectional layout conversions for files that are transferred between the client and server.
There are three methods for specifying these bidirectional conversion options:
• Inherit the bidirectional settings from the MVS Files subsystem
• Use a bidirectional conversion table
• Use manual bidirectional settings
To set bidirectional conversion support for an MVS system mapping, do these steps:
1. Right-click a mapping criterion in the z/OS File System Mapping view
2. Click Edit.
The Edit Data Set Mapping window opens.
3. In the Defined Language section, click Default to set bidirectional conversion options that are based
on the Workstation file extension field or Other to select a language for the file extension.
Bidirectional conversion in the Remote System Explorer is sensitive to the programming language in
which source code is written. You can usually assume that the Workstation file extension field selects
the correct language. In some cases, however, such as .cpy for COBOL and PL/I and .mac for PL/I
and Assembler, the same file extensions can be used with different languages. Use the Other option to
select a specific language to associate with the file extension.
4. Do one of the following steps:
• To inherit the bidirectional settings from the MVS Files subsystem, click Inherit from properties for
MVS Files. If the MVS Files subsystem uses a bidirectional conversion table, the name of the table
is shown in parentheses and the properties that are inherited are shown in the Inherited set of bidi
options table. For more information about property inheritance, see the related topics.
• To use a bidirectional conversion table, do these steps:

92 Developer for z/OS: Setting up an Eclipse Development Environment

 a. Click Use the following Bidi Conversion Table (BCT). This option enables the field and the
Browse button.
b. Enter the name of a bidirectional conversion file you created or click Browse to look for and
select a conversion file.
c. To edit the current properties in the bidirectional conversion table, click Copy. The properties
are copied to the Current set of bidi options table, and you can click Edit to change the values
and Save as to save your changes to a new bidirectional conversion table.
• To use manual bidirectional settings, do these steps:
a. Click Use the following manual bidi settings. This option enables a set of default bidirectional
settings.
b. Click Edit to open a window that you can use to change the default settings.
c. Click Save as to save the current settings to a new bidirectional conversion table.
5. Click OK to apply the changes.
“Setting bidirectional conversion support for z/OS UNIX System Services” on page 93

Setting bidirectional conversion support for z/OS UNIX System Services

z/OS UNIX files that contain bidirectional data must use bidirectional conversion tables to perform
code page conversion for correctly transferring bidirectional data between the z/OS system and the
workstation.
You can use three methods to specify these options:
• You can use a bidirectional conversion table specific to the current resource.
• You can inherit the bidirectional settings from a parent resource.
• You can use manual bidirectional settings.
Note: Editing a remote C/C++ resource that has bidirectional conversion options causes the following
message to open: You are trying to open a bidirectional file in Remote C/C++
Editor. The z Systems LPEX Editor is the recommended editor for proper handling
of bidirectional files.
Do one of the following tasks:
• To apply a bidirectional conversion table to a z/OS UNIX file or folder, do these steps:
a) In the Remote Systems view, right-click a z/OS UNIX file or folder under a z/OS connection.
b) Click Properties.
The Properties window opens.
c) Click Bidirectional Settings in the list on the left.
d) Select the Use bidirectional conversion checkbox.
This option enables the remaining fields on the window. If the current resource cannot inherit
bidirectional properties from a parent (because, for example, the parent resource does not use
bidirectional conversion) the Resource inherits attributes from a parent button remains disabled.
e) Click OK to apply the changes.
• To inherit bidirectional settings, do these steps:
a) Click Resource inherits attributes from a parent.
b) Click OK to apply the changes.
• To specify bidirectional settings for the resource, click Resource has its own set of bidirectional
attributes.
You can specify bidirectional attributes by using a bidirectional conversion table or by using manual
settings:
• To use a bidirectional conversion table, do these steps:

Setting up an Eclipse development environment 93

 1. Click Bidirectional Conversion Table. This option enables the field and the Browse and New
buttons.
2. Enter the name of a bidirectional conversion file you created, or click Browse to look for and
select a conversion file or New to create a table. Click OK to apply the changes.
• To use manual bidirectional settings, click Manual Settings. Click OK to apply the changes.

Setting local build options for smart logical COBOL and PL/I files
By default, bidirectional-enabled projects use a setting that converts source and executable files to visual
layout.
This setting can cause errors if a source file contains an invisible LRM marker. When the following string
is included in a COBOL program, for example, the compiler issues an error message: IGYGR1056, which
indicates that the literal exceeds the length that is specified:

Although the literal declaration is visually correct, the compiler counts the invisible LRM marker and
issues the error message.
To prevent this type of error, set local build options as follows:
1. Open the Local COBOL Build Options or Local PL/I Build Options properties page.
2. In the Environment Variables field, type the set statement set bidiInput=Logical.
This statement prevents your source from being converted to visual format before compilation.

Enabling bidirectional support for database connections

To enable support for bidirectional languages on database connections, you must enable the Eclipse
Bidirectional development capabilities preference and also set the text layout to Visual on the Default
Bidi Settings page of the database connection properties.
1. In the Preferences window, select Bidirectional Development, and then select the Bidirectional
development capabilities checkbox and click Apply.
2. In the Preferences window:
a) Expand Data Management and select Bidirectional Settings.
b) Select the Enable support for interpreting bidirectional data in database tables checkbox.
c) Click Apply and Close.
3. In the Data perspective:
a) In the Data Source Explorer view, select a database connection.
b) Right-click and select Properties.
c) Select Default Bidi Settings, and then, from the Text Layout list, select Visual.
d) Set the text direction, and then click Apply and Close.

Remote-to-local file mapping

When you define a remote system, you map (associate) the lowest level qualifier in each MVS data set
name to a file name extension for the related workstation file in your subprojects. Developer for z/OS
includes a set of defined remote-to-local file mappings. The **COBOL file mapping, for example, maps
MVS files with a low-level qualifier COBOL to workstation files with the .cbl file name extension.

Mapping
A mapping indicates how Developer for z/OS processes file transfers between z/OS and the workstation;
specifically, the mapping indicates whether file transfers are based on an exchange of text (in which case
ASCII/EBCDIC conversions occur) or on an exchange of binary data. A mapping also helps you to know, at
a glance, the general purpose of a particular file.

94 Developer for z/OS: Setting up an Eclipse Development Environment

If you use the same low-level qualifier for several data sets, the same mappings affect file transfers for
each of those data sets. Given the mappings that are included in Developer for z/OS, for example, you can
transfer members of the partitioned data sets [Link] and [Link] to and from
workstation-based files that have the extension .cbl.
In the workbench, a preference that is related to the z Systems LPEX Editor causes workstation-based
files of a particular type to be treated in a particular way. In accordance with this preference, for example,
a file of type .cbl is presented with the syntax highlighting that is appropriate to a COBOL source file.
However, when the editor processes a z/OS-based data set, the mapping of a qualifier (like COBOL) to a
file name extension (like .cbl) determines how the data set is processed.
You can see remote-to-local file mappings in the z/OS File System Mapping view of the z/OS Projects
perspective. The following screen capture shows this view.
You can customize these mappings to match the naming conventions on your remote system either
through the z/OS File System Mapping view or on the Mapping page of the Properties window. For
more information about customizing these mappings, see “Mapping data sets and partitioned data set
members” on page 97. For more information about the properties of file mappings, see the remaining
sections of this topic.

Setting up an Eclipse development environment 95

 Workstation file extension
The type of a file is indicated by its workstation file extension. In the mappings that are shown in the
screen capture, a .cbl extension, for example, is considered to be a COBOL source file. Each file can
have only one file type. JCL with embedded COBOL source, for example, is not supported. The default
workstation file extension for a new mapping is undefined.

Transfer mode
The transfer mode can be either text, indicating that a conversion between ASCII and EBCDIC occurs, or
binary. The default transfer mode for a new mapping is text.

96 Developer for z/OS: Setting up an Eclipse Development Environment

 Code page
Each file can have only one code page, but you can specify a group of files as having the same code page.
When you specify code pages, specify both a local and a host code page and keep them consistent. The
default host and local code pages for a new mapping are inherited from the system properties of the
remote and local file systems.
For a list of supported host code pages, see “Supported host code pages” on page 100. The availability of
local code pages is based on the text file encodings that are supported by the Eclipse text editor. Be sure
to specify code pages to be consistent with the compiler settings of your files.

Priority
If a file matches more than one file mapping, the mapping with the highest priority is the one that applies.
In the following example, a file named [Link] matches both of these file mapping
definitions. Because the **COBOL mapping has the higher priority, its properties are applied during a file
transfer between the remote and local systems. It is transferred to the workstation with these file transfer
properties: .cbl file extension, text transfer mode, inherited workstation code page.

Mapping Workstation File Transfer Mode Host Code Page Local Code Page Priority
Criterion Extension
**COBOL .cbl default (text) default (inherited) default (inherited) 1
**COBOL* default (undefined) binary default (inherited) default (inherited) 2

Mapping data sets and partitioned data set members

A data set mapping associates the lowest level qualifier in each MVS data set to a file name extension that
is used for the related workstation-based file in your subprojects. One mapping, for example, associates
the z/OS-based qualifier COBOL with the workstation-based file extension .cbl.
The Developer for z/OS product provides a set of default mappings, but you can create more mappings.
To add a data set mapping:
1. Open the z/OS File System Mapping view.
This view displays all remote z/OS systems and the data set mappings that are defined on them. When
there are multiple definitions for a data set or member name pattern, the order in which a mapping is
displayed in the table determines its priority: the higher it is on the list, the higher the priority.
2. From the System list, select the remote system that you want to modify mappings for.
3. To add a data set mapping, right-click the table and select Add Data Set Mapping.
The Add Data Set Mapping window opens.
4. To add a member mapping, right-click a data set mapping in the z/OS File System Mapping view and
select Add Member Mapping.
The Add Member Mapping window opens.
5. Specify a string in the Mapping criterion field.
Data sets and members with names that match this string are included in the mapping.
• Use ** as a wildcard for matching one or more data set name segments or qualifiers:
– **COBOL matches <any high-level qualifier>.<any middle qualifier>.COBOL. These sample data
set names match this mapping:
- [Link]
- [Link]
- [Link]
- [Link]

Setting up an Eclipse development environment 97

 – **ERROR** matches <any high-level qualifier>.ERROR.<any low-level qualifier>. These sample
data set names match this mapping:
- [Link]
- [Link]
- [Link]
• Use * as a wildcard for matching within a data set name segment or qualifier. For example,
USER**COB* matches the following names:
– [Link]
– [Link]
– [Link]
• You can also use a period as a delimiter in a mapping:
– USER.*.TEST matches [Link], but not [Link]
– USER.**TEST matches [Link], [Link], and [Link].
• Use ? as a wildcard for any single character within a member name. Take members A0, A00, and A00
as example. The wildcard pattern A?? matches member A00, but other two members A0 and A000
are not matched. In this case, this wildcard is only effective for Member Mapping criterion.
For more examples of wildcard patterns and matching data set names, see Table 8 on page 98.
6. In the Workstation file extension group, click Default or click Other and type the file name extension
that you want to associate with the data set matching string.
7. Use the remaining fields to choose a file transfer type and local and remote code pages.
For more information about other file mapping options, see the related topics.
8. Click OK.
The new mapping is displayed in the table. Member mappings are added as children of the data set
mapping that you selected before you click Add Member Mapping. You can sort this table by any of
the headings that are shown in the view (such as Mapping Criterion, Workstation File Extension, and
Transfer Mode). To sort the table, click a table heading.
9. Optional: You can override these system-wide mappings by defining mappings for specific data sets or
members:
a) Right-click the data set or member in the Remote Systems view and click Properties.
b) Click Mapping in the list on the left.
The Mapping pane opens on the right. This pane is similar to the Add Data Set Mapping window.
c) Leave the option to inherit values selected for each of the values you want to cascade from a higher
level.
The following table provides further examples of wildcard patterns and the strings that match and do not
match them.

Table 8. Examples of wildcard patterns in data set mappings. Wildcard patterns are listed across the top
of the table, and sample data set names are listed down the first column of the table. The remaining
cells indicate whether the sample data set name and the wildcard pattern match.
Wildcard Patterns
Data set KENYA**C KENYA**C KENYA.** KENYA.**. KENYA.*C KENYA.*.C KENYA.*.*.
names OBOL OBOL* COBOL COBOL OBOL OBOL COBOL
[Link] Match Match Match Do not Match Do not Do not
BOL match match match
KENYA.A.C Match Match Match Match Do not Match Do not
OBOL match match

98 Developer for z/OS: Setting up an Eclipse Development Environment

 Table 8. Examples of wildcard patterns in data set mappings. Wildcard patterns are listed across the top
of the table, and sample data set names are listed down the first column of the table. The remaining
cells indicate whether the sample data set name and the wildcard pattern match. (continued)
Wildcard Patterns
Data set KENYA**C KENYA**C KENYA.** KENYA.**. KENYA.*C KENYA.*.C KENYA.*.*.
names OBOL OBOL* COBOL COBOL OBOL OBOL COBOL
KENYA.A.B Match Match Match Match Do not Do not Match
.COBOL match match
[Link] Match Match Match Do not Match Do not Do not
OBOL match match match
KENYA.A.X Match Match Match Do not Do not Do not Do not
YCOBOL match match match match
[Link] Do not Match Do not Do not Do not Do not Do not
OBOLY match match match match match match

File encoding, code page conversion, and inheritance

When you copy a file between a remote system and the workstation, the file is converted to a code page
appropriate to its destination. File code pages are inherited from the system or folder that contains them.

File system default encoding

You can determine the default file encoding on a local or remote file system by setting a property in the
Remote Systems view. Two options are available:
Default from remote system
The default file encoding is inherited from the local or remote system.
Other
You can select the default file encoding from a list of available choices. Developer for z/OS uses
the International Components for Unicode (ICU) for file encoding. You can learn more about ICU at
International Components for Unicode.
To choose a default file encoding for a local or remote system:
1. If you are connected to the remote system, disconnect. You can change the default file encoding for a
remote system only when you are disconnected.
2. In the Remote Systems view, select a local or remote system.
3. Right-click and select Properties. The Properties window opens.
4. In the categories list, click Host.
5. Choose one of the file encoding options, and then click OK.

Code page conversion

Developer for z/OS uses remote-to-local file mapping to determine how file encodings are converted
between local and remote code pages during file transfers. For more information about remote-to-local
file mapping, see “Remote-to-local file mapping” on page 94.

Code page inheritance

When you transfer a file between a local and remote file system, the file inherits the code page setting
from the destination container. This inheritance sometimes results in a file encoding that is different from
or incompatible with the original file encoding. To ensure correct file encoding during a file transfer, make
sure that the code page for the destination container is set correctly.
To set the code page for a file or container:

Setting up an Eclipse development environment 99

 1. Select the file or container. To set the code page for the MVS Files subsystem of a z/OS connection, for
example, select MVS Files.
2. Right-click and select Properties.
3. From the category list, select Code Pages.
4. Select host and local code pages from the list.

Supported host code pages

These host code pages are supported. The default value is IBM-037 (mixed-case English).

IBM-037 IBM-273 IBM-277 IBM-278

IBM-280 IBM-284 IBM-285 IBM-297
IBM-420 IBM-424 IBM-425 IBM-500
IBM-803 IBM-870 IBM-871 IBM-875
IBM-930 IBM-933 IBM-935 IBM-937
IBM-939 IBM-1026 IBM-1047 IBM-1140
IBM-1141 IBM-1142 IBM-1143 IBM-1144
IBM-1145 IBM-1146 IBM-1147 IBM-1148
IBM-1149 IBM-1364 UTF-8 UTF-16
UTF16BE UTF-16LE

Specifying an alternative logical NOT symbol

You can define an alternative logical NOT symbol in a file mapping definition. The alternative logical NOT
symbol specifies the character that maps to X'5F' on the remote system.
By default, alternative logical NOT symbols are supported for PL/I files only. To enable alternative logical
NOT symbols for COBOL files, you can set a preference on the MVS Files preference page. For more
information about this preference, see the related topics.
The standard logical NOT symbol is ¬, which corresponds to EBCDIC code point X'5F'. If you cannot type
this symbol on your workstation because your keyboard does not contain the ¬ character, then you can
define an alternative NOT symbol, such as the exclamation point (!) or caret symbol (^). If you configure
an alternative NOT symbol such as ! or ^, you must ensure that the symbol you configure is not present in
another area of the file such as within a literal or a comment.
You can specify an alternative symbol in a file mapping definition. This action causes the alternative
symbol to map to EBCDIC code point X'5F' on the remote system. It also causes the standard NOT symbol
to no longer map to X'5F' unless you specify it as the logical NOT symbol in the mapping definition. You
can specify only one alternative logical NOT symbol. If you define the tilde character (~) as the logical NOT
symbol in a file mapping definition, for example, then the tilde character, rather than the NOT symbol ¬, is
mapped to the logical NOT operator X'5F'.
Specifying an inappropriate alternative logical NOT symbol can produce error CRRZI0487E when you edit
a file. When you specify an alternative NOT symbol, be careful to choose a character that is not already
present in your source file. For example, if your remote source file contains one or more tilde characters
(EBCDIC X'A1'), and you define the tilde character as the logical NOT symbol in a file mapping definition,
then all X'A1' code points might be changed to X'5F'. To prevent this situation, the CRRZI0487E message
is displayed, and the file is opened in browse mode so that you cannot edit it.
Preprocessors: When you run a preprocessor against a PL/I source file, the product translates the
preprocessed file into the UTF-8 code page, which is an ASCII-character code page. If the source file is
encoded in EBCDIC and it contains the EBCDIC character ¬ (X'5F'), then that character is translated to
the ASCII character ¬ (X'C2AC'). Because the ASCII character for the PL/I NOT symbol is ^ (X'5E'), the

100 Developer for z/OS: Setting up an Eclipse Development Environment

preprocessor does not recognize ¬ and returns an error message. To solve this issue define an alternative
NOT symbol by selecting Other and specifying ^. This definition results in the EBCDIC character ¬ (X'5F')
being correctly translated to ^ X'5E' in UTF-8. Any changes to the file are correctly translated back to ¬ on
the remote system.
Note: Any alternative NOT symbol that you define must not be a double-byte character. The PL/I language
requires that the NOT symbol be a single-byte character.
You can set an alternative logical not symbol on the Properties page of a data set, on the Properties page
of the MVS Files subsystem, or in the Edit Data Set Mapping or Add Data Set Mapping windows.
• From the Properties page of a data set:
a) In the Remote Systems view, select a data set or partitioned data set member and select
Properties.
b) Select Mapping from the list of property categories.
c) In the PL/I logical NOT symbol or Logical NOT symbol group box, click Other and type the
alternative symbol in the field.
• From the Properties page of the MVS Files subsystem:
a) In the Remote Systems view, select MVS Files and then select Properties.
b) Select Code Pages from the list of property categories.
c) In the PL/I logical NOT symbol or Logical NOT symbol field, type an alternative symbol.
• From the Edit Data Set Mapping or Add Data Set Mapping windows:
a) In the z/OS File System Mapping view, select a PL/I or COBOL mapping.
b) From the menu, select Edit or to create a mapping, select Add Data Set Mapping.
The Edit Data Set Mapping or Add Data Set Mapping window opens.
c) In the PL/I logical NOT symbol or Logical NOT symbol group box, click Other and type the
alternative symbol in the field.

Setting up an Eclipse development environment 101

102 Developer for z/OS: Setting up an Eclipse Development Environment
Documentation notices
© International Business Machines Corporation 1992, 2024.

This information was developed for products and services offered in the US. This material might be
available from IBM in other languages. However, you may be required to own a copy of the product or
product version in that language in order to access it.
IBM may not offer the products, services, or features discussed in this document in other countries.
Consult your local IBM representative for information on the products and services currently available in
your area. Any reference to an IBM product, program, or service is not intended to state or imply that
only that IBM product, program, or service may be used. Any functionally equivalent product, program, or
service that does not infringe any IBM intellectual property right may be used instead. However, it is the
user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter described in this
document. The furnishing of this document does not grant you any license to these patents. You can
send license inquiries, in writing, to ipemail@[Link].
INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS"
WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A
PARTICULAR PURPOSE. Some jurisdictions do not allow disclaimer of express or implied warranties in
certain transactions, therefore, this statement may not apply to you.
This information could include technical inaccuracies or typographical errors. Changes are periodically
made to the information herein; these changes will be incorporated in new editions of the publication.
IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this
publication at any time without notice.
Any references in this information to non-IBM websites are provided for convenience only and do not in
any manner serve as an endorsement of those websites. The materials at those websites are not part of
the materials for this IBM product and use of those websites is at your own risk.
IBM may use or distribute any of the information you provide in any way it believes appropriate without
incurring any obligation to you.
Licensees of this program who wish to have information about it for the purpose of enabling: (i)
the exchange of information between independently created programs and other programs (including
this one) and (ii) the mutual use of the information which has been exchanged, should contact
ipemail@[Link].
Such information may be available, subject to appropriate terms and conditions, including in some cases,
payment of a fee.
The licensed program described in this document and all licensed material available for it are provided by
IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any
equivalent agreement between us.
Any performance data and client examples cited are presented for illustrative purposes only. Actual
performance results may vary depending on specific configurations and operating conditions.
Information concerning non-IBM products was obtained from the suppliers of those products, their
published announcements or other publicly available sources. IBM has not tested those products and
cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM
products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of
those products.
Statements regarding IBM's future direction or intent are subject to change or withdrawal without notice,
and represent goals and objectives only. Such statements should not be relied upon when making
purchasing decisions.

© Copyright IBM Corp. 1992, 2024 103

 This information contains examples of data and reports used in daily business operations. To illustrate
them as completely as possible, the examples include the names of individuals, companies, brands, and
products. All of these names are fictitious and any similarity to the names and addresses used by actual
people or business enterprises is entirely coincidental.
COPYRIGHT LICENSE:
This information contains sample application programs in source language, which illustrate programming
techniques on various operating platforms. You may copy, modify, and distribute these sample programs
in any form without payment to IBM, for the purposes of developing, using, marketing or distributing
application programs conforming to the application programming interface for the operating platform
for which the sample programs are written. These examples have not been thoroughly tested under
all conditions. IBM, therefore, cannot guarantee or imply reliability, serviceability, or function of these
programs. The sample programs are provided "AS IS", without warranty of any kind. IBM shall not be
liable for any damages arising out of your use of the sample programs.
Each copy or any portion of these sample programs or any derivative work must include a copyright notice
as follows:

© (your company name) (year).

Portions of this code are derived from IBM Corp. Sample Programs.
© International Business Machines Corporation _enter the year or years_.

Trademarks
IBM, the IBM logo, and [Link] are trademarks or registered trademarks of International Business
Machines Corporation, registered in many jurisdictions worldwide. Other product and service names
might be trademarks of IBM or other companies. A current list of IBM trademarks is available at
"Copyright and trademark information" at [Link]/legal/[Link].

Terms and conditions for product documentation

Permissions for the use of these publications are granted subject to the following terms and conditions.

Applicability
These terms and conditions are in addition to any terms of use for the IBM website.

Personal use
You may reproduce these publications for your personal, noncommercial use provided that all proprietary
notices are preserved. You may not distribute, display or make derivative work of these publications, or
any portion thereof, without the express consent of IBM.

Commercial use
You may reproduce, distribute and display these publications solely within your enterprise provided
that all proprietary notices are preserved. You may not make derivative works of these publications, or
reproduce, distribute or display these publications or any portion thereof outside your enterprise, without
the express consent of IBM.

Rights
Except as expressly granted in this permission, no other permissions, licenses or rights are granted, either
express or implied, to the publications or any information, data, software or other intellectual property
contained therein.

104 Developer for z/OS: Setting up an Eclipse Development Environment

IBM reserves the right to withdraw the permissions granted herein whenever, in its discretion, the use
of the publications is detrimental to its interest or, as determined by IBM, the above instructions are not
being properly followed.
You may not download, export or re-export this information except in full compliance with all applicable
laws and regulations, including all United States export laws and regulations.
IBM MAKES NO GUARANTEE ABOUT THE CONTENT OF THESE PUBLICATIONS. THE PUBLICATIONS
ARE PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT,
AND FITNESS FOR A PARTICULAR PURPOSE.

Documentation notices 105

106 Developer for z/OS: Setting up an Eclipse Development Environment
Security considerations
This topic highlights some of the security limitations that you might encounter with this application. To
help ensure the security of your installation, customize your security settings and set up user access
controls.

Enabling security during the installation process

Security configuration for Developer for z/OS is addressed in Security definitions. More details on all
security aspects can be found in Security considerations.
Security considerations for Developer for z/OS:
• Installing Developer for z/OS results in a basic configuration with default settings for a basic, secure
setup. Extra configuration tasks, such as configuring SSL, allow for tighter controls. This information is
covered in detail in Security considerations.
Note: Security is not fully enabled during the installation process and must be enabled during
customization after installation is complete. The customization of some security-related aspects must
be completed for the product to work and for certain security features to be enabled. This limitation
applies to silent installations.
• Security for Developer for z/OS on the host is configured through a combination of Developer for z/OS
configuration files and RACF commands (or other similar security products).
• Developer for z/OS does not provide a login option when the Developer for z/OS host is used as an LDAP
client that accesses a customer-specific LDAP server to get group membership information that is used
to enforce wanted client behavior. LDAP logon information can be provided in a configuration file when
the Developer for z/OS host is used as an LDAP client that accesses public certificate revocation lists
(CRLs).
• Security for Developer for z/OS database authentication is enabled through RACF commands.
• For information about setting up SSL and installing a custom certificate, see these topics in the IBM
Explorer for z/OS documentation: (Optional) [Link], the RSE encrypted communication, RSE -
[Link], and Setting up encrypted communication and X.509 authentication.
• For information about enabling security between the client and server or web client and server, see
Connection flow.
• To configure the security settings of other applications that communicate with Developer for z/OS (Db2
Connect, Debug Tool, Fault Analyzer, File Manager), use the security configuration options available in
those products.
• To verify that you correctly configured the security settings, see Verify the security settings.
• More information:
– With the host connection in Enterprise Service Tools, you can set up a terminal session with a remote
z/OS system. You can configure the session to use SSL, client authentication, and host authentication.
You can use the IBM Key Management tool iKeyman to create a key database file, to create or request
certificates, and to import and export certificates.
Note: Developer for z/OS also uses REXEC, or the more secure SSH, to compile UNIX System Services
projects. For more information, see z/OS UNIX subprojects.

Enabling secure communication between multiple applications

For integrated products, Developer for z/OS provides security for the communications between the
products through the Developer for z/OS communication configuration by using Developer for z/OS tools.
The communication is host only, so there is no encryption.

© Copyright IBM Corp. 1992, 2024 107

 To handle user access controls between products in Developer for z/OS, the receiving application (for
example, JMON) requires authentication, which is done by the calling application (RSE) on the user’s
behalf. Where possible (for example, JMON or CARMA), Developer for z/OS binds to the loopback stack
only, which can be reached only from the same system.
For single-sign on, the user authenticates with RSE. RSE then does authentications on the user’s behalf
for other servers. While the user stays within Developer for z/OS, it all looks like one server, but this
situation is not true for other servers. Users must manually authenticate for other servers outside of
Developer for z/OS.

Ports, protocols, and services

Developer for z/OS internal processes, tasks, or services do not require a fixed user ID. You can create
your own user ID for these processes, tasks, or services, and associate the user ID with them by using
RACF commands. For more information about what ports, protocols, and services Developer for z/OS
uses, see Planning and TCP/IP considerations.
Before you can connect to a remote system from the Developer for z/OS client, you must define
a connection for the remote system and specify connection properties. For more information about
connecting to a remote system and the ports that are used for a connection, see Creating a connection to
a z/OS system.

Customizing your security settings

Customizing your security settings is covered in Security considerations. For more information about
setting and changing passwords, and client certificate authentication, see these topics:
• Connecting to a remote system
• Changing your password
• Creating a connection by using client certificate authentication
• Setting preferences for client certificate authentication
Note: Developer for z/OS uses generated PassTickets and does not store passwords on the host. The
Remote Connection Emulator (RCE) stores SSL-related passwords in the Eclipse Secure Storage. For more
information, see Secure storage in the Eclipse documentation. Clients mask password fields with ***, and
a password that is provided by a client during logon is always transmitted in a masked format, even for
SSL encrypted communication.
To enable multiple levels of security, and determine the implications of each, see the various chapters
about security in the host configuration documentation. Each chapter addresses a specific aspect of
security configuration.
Developer for z/OS relies on the options that are offered by TCP/IP to set up notifications of security
breaches or attempts.
Note: Information about login attempts is stored in the Developer for z/OS server logs, and in various
other places (for example, server log, user logs, audit log, syslog).

Multi-Factor Authentication
Developer for z/OS relies on IBM Explorer for z/OS for multi-factor authentication (MFA) support. For
information about configuring MFA in IBM Explorer for z/OS, see Using Multi-Factor Authentication.

Setting up user roles and access

RACF commands are used for the following purposes:
• Create and delete users and set their access levels.
• Create groups and assign them privileges.
• Establish password rules for users (such as no reuse, minimum length, or character requirements).

108 Developer for z/OS: Setting up an Eclipse Development Environment

• Setup superuser IDs or IDs with special security privileges.
For more information about RACF, see the Security Server RACF Security Administrator's Guide,
SA23-2289.

Privacy policy considerations

This software offering does not use cookies or other technologies to collect personally identifiable
information.

Security considerations 109

110 Developer for z/OS: Setting up an Eclipse Development Environment
IBM®

Product Number: 5755-A05

5724-T07