PL/I Language Support

PL/I Language Support enhances the PL/I programming experience on your IDE. The extension leverages the language server protocol to provide syntax highlighting and coloring, and diagnostic features for PL/I code, compiler options, and include files. PL/I Language Support is available as a VS Code extension, and on an interactive playground (development and main branches).

PL/I Language Support recognizes files with the extension .pli and .pl1 as PL/I files.

This extension is a part of the Zowe open-source project, hosted by the Open Mainframe Project. To contribute and report issues, visit our Git repository.

This extension is part of the Code4z experience

PL/I Language Support is part of the Code4z experience from Broadcom, which offers a modern experience for mainframe application developers. To get started with Code4z, check out our foundational extension pack.

Address Software Requirements

There are no client or server-side prerequisites for PL/I Language Support.

Integrate with Zowe Explorer

Integrate PL/I Language Support with Zowe Explorer to retrieve your PL/I source code stored on mainframe data sets. PL/I Language Support and Zowe Explorer are both available as part of the Code4z Foundation pack.

Language Support Features

PL/I Language Support provides the following PL/I syntax awareness features:

Syntax and Semantic Check for Code

This feature checks for mistakes and errors in PL/I code, including compiler options. The syntax check feature reviews the whole content of the code and suggests fixes, and the semantic analysis highlights incorrect names of variables and include files.

The syntax check feature also validates built-in functions, pseudovariables, and subroutines which must be explicitly declared.

Syntax Highlighting

The extension enables syntax highlighting for PL/I code.

Syntax Coloring

Contrasting colors are used in displayed code for ease of identifying and distinguishing keywords, variables, type functions, compiler options, paragraphs, and sections.

Outline View and Breadcrumbs

The extension enables outline view and the breadcrumbs navigation bar at the top of the edit window, which show the structure of elements within the program and allow easy navigation between them.

Code Snippets

Before you write your PL/I code from scratch, search the snippet library for useful templates.

Press F1 to open the command palette.
Run the command Snippets: Insert PL/I Snippet.
Select the snippet that you want to insert.

You can also insert a code snippet by typing the name of the snippet in your code and clicking on the autocomplete text.

Preprocessor Support

PL/I Preprocessors process source code before compilation. They support complex logic, variable manipulation, and string processing to generate optimized or customized code. All PL/I Core Preprocessors are supported by PL/I Language Support.

Include File Support

The PL/I Language Support extension supports include files used in your source code as long as they are stored locally in an /inc folder in your workspace, or in another folder which you specify in a processor group. Files with the extensions .inc and .mac or with no extension are recognised by default as PL/I include files. If your include files use other extensions, specify them in a processor group.

The %INCLUDE statement is supported by default, variations on it such as ++INCLUDE must be specified as compiler options in a processor group.

The Find All References and Go To Definition functionalities are extended to work for occurrences of include file names, variables and paragraphs in the main PL/I file.

Find All References identifies all occurrences of variables and paragraphs from include files in the code.
Go To Definition enables you to right-click on any variable or paragraph to reveal a definition of the element. If the definition is in an include file, or the name of an include file, the include file opens.

Animated gif showing the Go To Definition functionality on a PL/I include file and a variable defined in that file

CICS and SQL Built-In Variable Support

The PL/I Language Support extension supports the built-in variables for CICS, SQLCA and SQLDA. Hover over a built-in variable to display its definition.

Type Function Support

The PL/I Language Support extension supports all PL/I type functions. Hover over a type function to display its definition.

Configure Processor Groups

Configure processor groups to link specific programs with compiler options, folders that contain include files, and non-standard include file extensions. You define processor groups in a proc_grps.json file and associate processor groups with programs in a pgm_conf.json file. You can use a wildcard in the pgm_conf.json file to create a global processor group. Create both of these files in a /.pliplugin folder in your workspace root.

The proc_grps.json file is formatted as an array of JSON elements, with one JSON per processor group. Each processor group can contain the following elements:

"name": (string)
- Specify a name for the processor group.
(Optional) "libs": (array)
- Specify local folders that contain include files. Folders can be relative paths to the workspace root, or absolute paths to any local folder.
- Include members by adding ddnames, such as adding mylibs/a.b.c, where a.b.c(member) is a file in the mylibs folder.
(Optional) "include-extensions": (array)
- Specify file extensions that you use for the include files in programs linked with this processor groups.
(Optional) "compiler-options": (array)
- Specify compiler directives that you want to apply to the programs linked with this processor group.

Example Program Configuration File

The program configuration file, pgm_conf.json, links programs to processor groups. The program configuration file has the following format:

{
    "pgms": [
        { "program": "PROGRAM1", "pgroup": "GROUP1" },
        { "program": "PROGRAM2", "pgroup": "GROUP2" },
    ]
}

Each element contains the following parameters:

"program": (string)
- Specify a program name. This field can be wildcarded.
"pgroup": (string)
- Specify the name of a procecssor group that is defined in proc_grps.json.

Example Processor Group Configuration

Using the example pgm_conf.json file in the section above, the following proc_grps.json example enables the following:

Include files from local folder /lib1, with the extensions ".cpy" and ".copy" are used with PROGRAM1.
The INCAFTER(PROCESS(FWKMACRO)) compiler option is enabled for PROGRAM1.
Include files from local folders /lib2 and /lib3 are used with PROGRAM2.

{
  "pgroups": [
    {
      "name": "GROUP1",
      "compiler-options": ["INCAFTER(PROCESS(FWKMACRO))"],
      "libs": [
        "lib1"
      ],
      "include-extensions": [
        ".cpy", ".copy"
      ],
      "member-name-validation": true
    },
    {
      "name": "GROUP2",
      "libs": [
        "lib2",
        "lib3"
      ]
    }
  ]
}

Dynamic Include File Resolution

You can use the VS Code Quick Fix feature to dynamically resolve include files that are stored in a subfolder of your workspace. For this feature to work correctly, your proc_grps.json file must be present in the correct location your workspace.

Hover over an unresolved include file name.
Select Quick Fix...
Select the option Add folder to INCLUDE...
The folder is added to the "libs" array in your proc_grps.json file in order to resolve the include file.