PL/I Language Support

https://github.com/zowe/zowe-pli-language-support
Admin
PL/I Language Support is a VS Code extension that enhances the PL/I programming experience by...
Tokens:181,340
Snippets:768
Trust Score:9.8
Update:9 months ago
Show doc for...
Tokens:
Raw
### PL/I: Handle DESTINATION Input Validation and Setup

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

Validates the DESTINATION input (COM) for length and allowed characters before calling SETUPL. Returns an error code (16) if validation fails, otherwise proceeds with the setup.

```PL/I
ACT(10): /*  DESTINATION  */
    IF LENGTH(COM) = 0 | LENGTH(COM) > 8 | VERIFY(COM,ALPHANUM) > 0
       THEN RETURN(16);
       ELSE CALL SETUPL(88,1,COM);
    RETURN(0);
```

--------------------------------

### PL/I Procedure Declaration Example

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/ZOWE_IJ_COMPILE_OPTIONS.txt

A basic PL/I procedure declaration for a program named 'X$' with the 'MAIN' option, indicating it's an entry point for execution. This is a standard way to start a PL/I program on z/OS.

```PL/I
CALC: PROCEDURE(X$) OPTIONS (MAIN);
```

--------------------------------

### Install Dependencies with pnpm

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/README.md

Installs project dependencies using the pnpm package manager. Ensure Node.js and pnpm are installed before running this command.

```shell
pnpm install
```

--------------------------------

### Preprocessor Instruction Generation Example

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/preprocessor/README.md

This example demonstrates how a PL/I preprocessor declaration statement is converted into a sequence of instructions for the preprocessor's virtual machine. It shows the input PL/I code and the resulting machine instructions.

```plaintext
%dcl A fixed;

//will generate the following instructions

PUSH []
SET A
ACTIVATE A RESCAN
```

--------------------------------

### PL/I: File Initialization and Main Process

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PTASK38.txt

Initializes the program by opening necessary files (VSR404, REP3800, SYSPRINT) and printing a start message. It then proceeds to read the first record from the VSAM file VSR404 and checks if the file is empty.

```PL/I
PUT SKIP LIST('PTASK38 STARTED ')   ;
 OPEN FILE(VSR404)                  ;
 OPEN FILE(REP3800)                  ;
 OPEN FILE(SYSPRINT)                 ;
 READ FILE (VSR404) INTO (R404_RECORD) ;  
 IF EOF_VSAM                              
 THEN DO                             ;
   PUT LIST('VSAM FILE VSR404 IS EMPTY') SKIP ;
   FLAG_VSAM = '1'                   ;
 END                                 ;
```

--------------------------------

### PL/I Example Program Translation (With Preprocessor)

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/preprocessor/README.md

This example demonstrates the translation of a PL/I program that utilizes preprocessor statements for variable declaration and assignment. It showcases preprocessor directives like %dcl and %A = 'B'.

```plain
%dcl A char;
%A = 'B';
dcl A%C fixed bin(31);
```

--------------------------------

### Run PL/I Playground Locally with pnpm

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/playground/README.md

Starts a local development server to preview the PL/I playground. This command is used after building the project to test it locally.

```shell
pnpm preview
```

--------------------------------

### Start PL/I Playground Client (TypeScript)

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/playground/index.html

This snippet demonstrates how to import and initiate the client for the PL/I Playground. It relies on a local module './src/app.ts' to manage the client's lifecycle. This is typically used to bootstrap the playground environment.

```typescript
import { startClient } from "./src/app.ts";
startClient();
```

--------------------------------

### PL/I: Handle DDNAME Input Validation and Setup

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

Validates the DDNAME input (COM) for length and allowed characters before calling the SETUPL routine. Returns an error code (16) if validation fails, otherwise proceeds with the setup.

```PL/I
ACT(3):  /*  DDNAME  */
   ACT(4):
      IF LENGTH(COM) = 0 | LENGTH(COM) > 8 | VERIFY(COM,ALPHANUM || '@#$') 
              > 0 | VERIFY(SUBSTR(COM,1,1),ALPHA || '@#$') > 0
          THEN RETURN(16);
          ELSE CALL SETUPL(1,1,COM);
          RETURN(0);
```

--------------------------------

### PL/I Example Program Translation (No Preprocessor)

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/preprocessor/README.md

This example shows the translation of a simple PL/I program without preprocessor statements. It includes variable declaration and a HALT instruction.

```plain
 dcl A fixed bin(31);
```

--------------------------------

### PL/I GET Instruction

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/preprocessor/README.md

The GET instruction retrieves the value of a specified variable and pushes it onto the stack. It is used for data retrieval and manipulation.

```plain
GET <VARNAME>;
```

--------------------------------

### PL/I Workspace Setup with .pliplugin Configuration

Source: https://context7.com/zowe/zowe-pli-language-support/llms.txt

Illustrates the directory structure and configuration files for setting up a PL/I development workspace using the `.pliplugin` folder. This includes `pgm_conf.json` for program-to-processor group mapping and `proc_grps.json` for defining processor group settings like compiler options and library paths.

```text
my-pli-project/
├── .pliplugin/
│   ├── pgm_conf.json      # Program to processor group mapping
│   └── proc_grps.json     # Processor group definitions
├── src/
│   ├── MAINPROG.pli       # Main program
│   └── UTILITY.pli        # Utility procedures
├── inc/
│   ├── COPYBOOK.inc       # Include files
│   └── MACROS.inc
└── lib/
    └── COMMON.cpy         # Copybooks

```

```json
// .pliplugin/proc_grps.json
{
  "pgroups": [
    {
      "name": "production",
      "compiler-options": ["MARGINS(2,72)", "AGGREGATE"],
      "libs": ["inc", "lib"],
      "include-extensions": [".inc", ".cpy", ".pli"],
      "member-name-validation": true
    }
  ]
}

```

```json
// .pliplugin/pgm_conf.json
{
  "pgms": [
    { "program": "src/*.pli", "pgroup": "production" }
  ]
}

```

--------------------------------

### PL/I Structured Declaration Example

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/linking/README.md

Demonstrates how structured declarations in PL/I define hierarchical symbols. It shows the declaration syntax and the resulting `QualifiedSyntaxNode` structure used internally by the linker.

```pli
DCL 1 A,
      2 B,
        3 K,
        3 G,
      2 C,
        3 K;
```

```text
K -> B -> A
G -> B -> A
B -> A
K -> C -> A
C -> A
A
```

--------------------------------

### PL/I Environment Setup for FABLE

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

This PL/I snippet shows environment setup logic, likely for a system named FABLE. It decrements a counter S99TUPL# and sets a flag S99FLAG1 to a specific value (8192). This type of code is typically used for managing system states or resource allocation before executing other operations.

```PL/I
S99TUPL# = S99TUPL# - 1;
         S99FLAG1 = 8192;
         RETURN(0);
```

--------------------------------

### VS Code Extension Activation for PL/I

Source: https://context7.com/zowe/zowe-pli-language-support/llms.txt

This TypeScript code snippet demonstrates the activation of the PL/I VS Code extension. It initializes a file system provider, settings manager, and starts the language server client. The extension is configured to activate for PL/I language files.

```typescript
import * as vscode from "vscode";
import { LanguageClient, TransportKind } from "vscode-languageclient/node.js";

// Extension activation - called when VS Code loads the extension
export function activate(context: vscode.ExtensionContext): void {
  // Register builtin file system provider
  BuiltinFileSystemProvider.register(context);

  // Initialize settings manager
  const settings = Settings.getInstance();

  // Start the language server client
  const client = startLanguageClient(context);

  // Watch .pliplugin folder for configuration changes
  const workspaceFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
  if (workspaceFolder) {
    watchPlipluginFolder(client, workspaceFolder, context);
  }
}

function startLanguageClient(context: vscode.ExtensionContext): LanguageClient {
  const serverModule = context.asAbsolutePath("out/language/main.cjs");

  const serverOptions = {
    run: { module: serverModule, transport: TransportKind.ipc },
    debug: { module: serverModule, transport: TransportKind.ipc }
  };

  const clientOptions = {
    documentSelector: [{ scheme: "*", language: "pli" }]
  };

  const client = new LanguageClient("pli", "PL/I", serverOptions, clientOptions);
  client.start();
  return client;
}
```

--------------------------------

### PL/I: Handle ACT(5) - Dummy Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

Implements the dummy action for ACT(5) by calling SETUPL with specific parameters and returning 0. This routine is part of the Zowe PL/I language support.

```PL/I
48.1    1 ACT(5):  /*  DUMMY  */                                                  00480005
49.1         CALL SETUPL(36,0,'');                                                00490000
50.1         RETURN(0);                                                           00500000
```

--------------------------------

### SETUPL Procedure for Tuple Initialization in PL/I

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

The SETUPL procedure in PL/I is responsible for initializing elements of a tuple structure. It takes a key, a numeric value, and a character string as input and assigns them to specific elements within the S99TUPL array, effectively setting up parameters for subsequent operations.

```PL/I
SETUPL: PROCEDURE(KY,##,PR) REORDER;
DECLARE
  KY                 FIXED BIN(15,0),
  ##                 FIXED BIN(15,0),
  PR                 CHAR(*) VARYING;
S99TUPL(S99TUPL#) = ADDR(KEY(S99TUPL#));
KEY(S99TUPL#)  = KY;
#(S99TUPL#)    = ##;
PARM(S99TUPL#) = PR;
END SETUPL;
```

--------------------------------

### PL/I: Handle CCHAR parameter with character and string processing

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/BATCH.txt

This PL/I code snippet handles the CCHAR (character) parameter. It uses SELECT statements to process the input VALUE. It can assign the VALUE directly to CCHAR, or if the value starts with a single or double quote, it uses GET STRING to extract the character. It also includes a check for hexadecimal characters using ^HEXIN. Invalid conditions result in a return code of 99.

```PL/I
240.0           WHEN(21) SELECT(L);  /* CCHAR */                                   02420009
      241.0                    WHEN(0) RC=99;
      242.0                    WHEN(1) CCHAR=VALUE;
      243.0                    OTHERWISE SELECT(SUBSTR(VALUE,1,1));                      02450009
      244.0                              WHEN('''') GET STRING(VALUE) LIST(CCHAR);       02460009
      245.0                              WHEN('
```

--------------------------------

### PL/I: Handle SYSOUT Action with Conditional SETUPL Call

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

Handles the 'SYSOUT' action, conditionally calling SETUPL based on whether the COM variable is empty. If empty, it calls SETUPL with an empty string; otherwise, it passes the COM value.

```PL/I
ACT(9): /*  SYSOUT  */
    IF LENGTH(COM) = 0
       THEN DO;
         CALL SETUPL(24,0,'');
         RETURN(0);
       END;
    ELSE;
    CALL SETUPL(24,1,COM);
    RETURN(0);
```

--------------------------------

### PL/I: Handle HOLD Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

Executes the 'HOLD' action by calling SETUPL with specific parameters and an empty string. This likely enables a hold function for a dataset or resource.

```PL/I
ACT(11): /*  HOLD  */
    CALL SETUPL(89,0,'');
    RETURN(0);
```

--------------------------------

### PL/I Initialization Routine for Date, Time, and Parameters

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/MACROS.txt

An initialization routine written in PL/I that formats the current date and time, and processes command-line parameters. It demonstrates basic string manipulation for date/time formatting and conditional logic for parameter handling.

```PL/I
INITIALIZE:BEGIN;
     TODAY=
        SUBSTR(DATE,3,2)||'/'||SUBSTR(DATE,5)||'/'||SUBSTR(DATE,1);
     NOW=SUBSTR(TIME,1,2)||'.'||SUBSTR(TIME,3,2)||'.'||
         SUBSTR(TIME,5,2);
     IF LENGTH(PARM) > 0  THEN CALL OPTIONS(PARM);  /*RESOLVE PARM*/

  /* CALL  WHOAMI(PROFILE_AREA)*/              /* EXTERNAL CALL   */
  /* IF SUBSTR(JOBNAME,1,3) ^= 'HB2' THEN RETURN; /*  <========   */

     IF TEST & Q(1) THEN PUT SKIP DATA(Q);
     IF DTS THEN PUT SKIP EDIT
```

--------------------------------

### Parse PL/I Code and Detect Statement Boundaries

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/FORM01.txt

This snippet iterates through PL/I source code lines to detect statement start and end points. It identifies lines ending with a semicolon and marks them as statement ends, subsequently marking the next line as a statement start. It also handles cases where a statement start might be an empty line.

```PL/I
      291.0       do i = 1 to hbound(sourceU,1)-1;
          if rightmostNB(Uline) = ';' then
          do;
             properties.stmt_end(i)     = '1';
             properties.stmt_start(i+1) = '1';
          end;
          if properties.stmt_start(i) = '1' then
          do;
             /* make sure stmt-start is correct       */
             /* (comments blanked out at this point)  */
             if Uline = '' then
             do;
                properties.stmt_end(i)     = '0';
                properties.stmt_start(i+1) = '1';
             end;
             /* pick out statement keyword            */
             else call firstkw(i);
          end;
       end;
```

--------------------------------

### PL/I: Handle Tracks Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

This PL/I code handles the 'TRACKS' action. It directly calls the SETUPL routine with parameters (7, 0, ''). This action does not appear to have input validation.

```PL/I
- ACT(18): /*  TRACKS  */
        CALL SETUPL(7,0,'');
        RETURN(0);
```

--------------------------------

### PL/I: Handle KEEP Action with UNSPEC

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

Sets specific bits in the UNSPEC variable for the 'KEEP' action and then calls SETUPL. This action likely prepares for keeping a dataset or resource.

```PL/I
ACT(5): /*  KEEP  */
    UNSPEC(TMP) = '0000000000000001'B || '00001000'B;
 0 ACT5A:
    CALL SETUPL(5,1,TMP);
    RETURN(0);
```

--------------------------------

### PL/I: Handle Directory Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

This PL/I code handles the 'DIRECTORY' action. It checks if the COM string is empty or contains non-digit characters. If invalid, it returns 16; otherwise, it calls SETUPL with specific parameters.

```PL/I
- ACT(20): /*  DIRECTORY  */
        IF LENGTH(COM) = 0 | VERIFY(COM,DIG) > 0 
           THEN RETURN(16);
        ELSE CALL SETUPL(12,1,NUM(COM,3));
        RETURN(0);
```

--------------------------------

### PL/I: Get Macro Dataset Name using SVC99

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/MACROS.txt

This PL/I procedure, GET_MACRO_DSN, retrieves the dataset name for macros. It uses the SVC99 system call to get information about the 'MACROS' DD statement. It handles potential errors and sets the DSNAME variable.

```PL/I
GET_MACRO_DSN:PROC;
 IF ^FIRST_TIME THEN RETURN;
 FIRST_TIME = FALSE;
 CALL SVC99(WORK,'INFO',INFORMATION,'DD=MACROS   ;');
 RTNCODE = PLIRETV;
 DSNAME = DSN;
 IF TEST & Q(146) THEN SIGNAL CONDITION(DYNALOC);
 IF DD_NAME ^= LOW(8) THEN DO;
 OPEN FILE(MACROS);
 DD.DDN = 'MACROS';
 CALL DDINFO(DD);
 MRECFM = RECFM;
 CLOSE FILE(MACROS);
 CALL SVC99(WORK,'UNALLOC','DD=MACROS UNALLOC;');
 END;
 RTNCODE = PLIRETV;
 IF TEST & Q(142) THEN SIGNAL CONDITION(DYNALOC);
 END;
```

--------------------------------

### Parse Keywords and Initialize Tuple in PL/I

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

This PL/I code snippet demonstrates parsing keywords using the SCANNER function and initializing a tuple. It checks the return code of the scanner and conditionally increments a tuple counter and calls the SETUPL procedure. It also prepares for a SVC99 call to manage system resources.

```PL/I
BIT(1) INIT('1'B);
RCC = SCANNER(S99VFR1,CBUF,KWORDS);
IF RCC ^= 0
   THEN RETURN;
ELSE S99TUPL# = S99TUPL# + 1;
CALL SETUPL(7,0,'');
X80PTR = ADDR(S99TUPL(S99TUPL#));
X80 = '10000000'B;
S99RC = SVC99(S99VERB);
S99ERR = S99ERROR;
S99INF = S99INFO;
%INCLUDE (SETUPL);
%INCLUDE (S99VFR1);
```

--------------------------------

### PL/I: Copy PDS Member using SVC99 and DDINFO

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/MACROS.txt

This PL/I code snippet demonstrates copying a PDS member. It uses SVC99 to get information about the 'PDSCOPY' DD statement, opens the file, calls DDINFO to get dataset details, closes the file, and then unallocates the DD. It also includes logic for determining the output file format.

```PL/I
CALL SVC99(WORK,'INFO',INFORMATION,'DD=PDSCOPY  ;');
 IF TEST & Q(138) THEN SIGNAL CONDITION(DYNALOC);
 IF DD_NAME ^= LOW(8) THEN DO;
 COPY = TRUE;
 OPEN FILE(PDSCOPY);
 DD.DDN = 'PDSCOPY';
 CALL DDINFO(DD);
 CLOSE FILE(PDSCOPY);
 OUTFILE = DSN;
 CALL SVC99(WORK,'UNALLOC','DD=PDSCOPY UNALLOC;');
 RTNCODE = PLIRETV;
 IF RECFM = 'U' & BLKSIZE = 6233 THEN WYLFMT =1B;
 END;
 ELSE COPY = FALSE;
```

--------------------------------

### PL/I: ELSE CALL SETUPL statement

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

A PL/I code snippet demonstrating an ELSE clause that calls the SETUPL procedure with specific arguments. This is part of Zowe's PL/I language support.

```PL/I
46.1         ELSE CALL SETUPL(1,1,COM);                                           00460000
```

--------------------------------

### PL/I: Handle NOHOLD Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99FREE.txt

Executes the 'NOHOLD' action by calling SETUPL with specific parameters and an empty string. This likely disables a hold function for a dataset or resource.

```PL/I
ACT(12): /*  NOHOLD  */
    CALL SETUPL(10,0,'');
    RETURN(0);
```

--------------------------------

### PL/I Compiler Options

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/CALC.txt

Specifies the compiler options used for the PL/I source code. This includes the installation and command-line options for the compiler.

```PL/I
SOURCE,RULES(LAXDCL)
```

--------------------------------

### PL/I Help Message Display

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/CALC.txt

Displays a help message for the CALC procedure when the input starts with '?'. It outlines the supported mathematical operations and how to format results.

```PL/I
IF SUBSTR(X$,1,1) = '?' THEN DO;
  DISPLAY('CALC WILL PERFORM THE FOLLOWING OPERATIONS:    ');
  DISPLAY(' X + Y                                         ');
  DISPLAY(' X - Y                                         ');
  DISPLAY(' X * Y                                         ');
  DISPLAY(' X / Y                                         ');
  DISPLAY(' X MO Y (MODULUS OF X BY Y)                    ');
  DISPLAY(' X ** Y (X TO THE POWER Y)                     ');
  DISPLAY(' X SQ ( SQUARE ROOT)                           ');
  DISPLAY(' X SI ( SIN OF X IN DEGREES)                   ');
  DISPLAY(' X CO ( COS OF X IN DEGREES)                   ');
  DISPLAY(' X TA ( TAN OF X IN DEGREES)                   ');
  DISPLAY('                                               ');
  DISPLAY(' RESULT TYPED. IF ARGUMENT X IS PRECEEDED BY   ');
  DISPLAY(' THE LETTER X, I.E. CALC X3 * 4, THE RESULT    ');
  DISPLAY(' WILL BE AN INTEGER IN THE RETURN CODE.        ');
  GOTO EXIT;
  END;
```

--------------------------------

### PL/I Factorized Declaration Example

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/linking/README.md

Shows how factorized declarations in PL/I, which group multiple names under a single declaration, are unrolled into individual declarations by the linker. This simplifies the internal representation.

```pli
DCL 1 A,
      2 (B, C, D),
         3 E;
```

```pli
  DCL 1 A,
        2 B,
        2 C,
        2 D,
          3 E;
```

--------------------------------

### PL/I: Handle Block Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

This PL/I code handles the 'BLOCK' action. It checks if the COM string is empty or contains non-digit characters. If invalid, it returns 16; otherwise, it calls SETUPL with specific parameters.

```PL/I
ACT(17): /*  BLOCK  */
        IF LENGTH(COM) = 0 | VERIFY(COM,DIG) > 0 
           THEN RETURN(16);
        ELSE CALL SETUPL(9,1,NUM(COM,3));
        RETURN(0);
```

--------------------------------

### Dynamic SQL Query Preparation and Execution in PL/I

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PLI0001.txt

The DYNSQL procedure demonstrates dynamic SQL query preparation using the SQLDA. It reads a table name from input, constructs a SELECT statement, and prepares it for execution. The GETLEN auxiliary procedure determines the appropriate display length for different SQL data types. This snippet includes the preparation of the SQL statement and the declaration of related structures.

```PL/I
DCL STATEMENT CHAR(255) VARYING;
DCL STR CHAR(80);

GET EDIT(STR)(A(80));

STATEMENT = 'SELECT * FROM ' || STR;

/*$*$*
EXEC SQL PREPARE STATEMENT FROM :STATEMENT
$*$*/*
DO;
DCL
  1 SQLPLIST4 UNALIGNED
   ,2 SQLPLLEN     FIXED BIN(15) INIT(64)
   ,2 SQLFLAGS     FIXED BIN(15) INIT('4000'XN)
   ,2 SQLCTYPE     FIXED BIN(15) INIT(35)
   ,2 SQLPROGN     CHAR(8) INIT('PLI0001')
   ,2 SQLTIMES     CHAR(8)
        INIT('1BE259C6_08AFFE2C'X)
   ,2 SQLSECTN     FIXED BIN(15) INIT(1)
   ,2 SQLCODEP     POINTER
   ,2 SQLVPARMP    POINTER
   ,2 SQLAPARMP    POINTER
   ,2 SQLCCSID     FIXED BIN(16) UNSIGNED INIT( 1047)
   ,2 SQLSTYPE     FIXED BIN(15) INIT(14)
   ,2 SQLSTNUM     FIXED BIN(32) UNSIGNED INIT(95)
   ,2 SQLFLGS2     FIXED BIN(15) INIT('0000'XN)
   ,2 SQLRESRV     CHAR(18) INIT('00'X)
   ,2 SQLPVARS
     ,3 SQLPVDAID  CHAR(8)
     ,3 SQLPVDABC  FIXED BIN(31)
     ,3 SQLPVN     FIXED BIN(15)
     ,3 SQLPVD     FIXED BIN(15)
     ,3 SQLPVELT(2)
END;
```

```PL/I
GETLEN: PROC;
SELECT (SQLVAR(I).SQLTYPE);
   WHEN (500,501) /* SMALLINT */
      LEN = 6;
   WHEN (496,497) /* INTEGER */
      LEN = 11;
   WHEN (480,481) /* FLOAT */
      IF SQLVAR(I).SQLLEN = 4 THEN
         LEN = 8; ELSE /* SQLVAR(I).SQLLEN = 8 */
         LEN = 18;
   WHEN (384,385,388,389,392,393,452,453,448,449,456,457)
   /* TIME, DATE, TIMESTAMP, CHAR, VARCHAR */
      LEN = SQLVAR(I).SQLLEN;
   OTHERWISE LEN = 4;
END;
IF LEN < 4 THEN LEN = 4;

END GETLEN;
```

--------------------------------

### PL/I IF-THEN-ELSE Translation

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/preprocessor/README.md

This example shows the translation of a PL/I IF-THEN-ELSE structure with preprocessor directives. It includes conditional assignment and variable activation, followed by a program segment that uses the assigned variable.

```plain
 %IF 1 %THEN
    %A = 123;
%ELSE
    %A = 456;
%ACTIVATE A;
dcl X fixed;
X = A;
```

--------------------------------

### PL/I: Handle Destination Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

This PL/I code handles the 'DESTINATION' action. It validates the COM string for length (<= 8) and alphanumeric characters. If invalid, it returns 16; otherwise, it calls SETUPL with the COM string.

```PL/I
- ACT(21): /*  DESTINATION  */
        IF LENGTH(COM) = 0 | LENGTH(COM) > 8 | VERIFY(COM,ALPHANUM) > 0 
           THEN RETURN(16);
        ELSE CALL SETUPL(88,1,COM);
        RETURN(0);
```

--------------------------------

### Initialize and Call DSNHLI with SQLDA (PL/I)

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PLI0001.txt

This snippet demonstrates how to initialize and populate an SQLDA structure, then call the DSNHLI interface to interact with a database. It includes setting various SQLDA fields like SQLPVTYPE, SQLPVLEN, and SQLPVADDR, and checks the SQLCODE for success.

```PL/I
DCL  1 SQLPLIST4 UNALIGNED,
     2 SQLPVTYPE  FIXED BIN(15),
     2 SQLPVLEN   FIXED BIN(15),
     2 SQLPVADDR  POINTER,
     2 SQLPVIND   POINTER,
     2 SQLPVNAME,
     3 SQLPVNAMELEN FIXED BIN(15),
     3 * UNION,
     4 SQLPVNAMEDAT CHAR(30),
     4 *,
     5 SQLPVNAMER0 FIXED BIN(31),
     5 SQLPVNAMER1 FIXED BIN(15),
     5 SQLPVNAMER2 FIXED BIN(15),
     5 SQLPVNAMER3 CHAR(22);
SQLPLIST4.SQLPVARS.SQLPVTYPE(1) = 452;
SQLPLIST4.SQLPVARS.SQLPVLEN(1) = 0;
SQLPLIST4.SQLPVARS.SQLPVADDR(1) = SYSNULL();
SQLPLIST4.SQLPVARS.SQLPVNAMELEN(1) = 0;
SQLPLIST4.SQLPVARS.SQLPVTYPE(2) = 448;
SQLPLIST4.SQLPVARS.SQLPVLEN(2) = 255;
SQLPLIST4.SQLPVARS.SQLPVADDR(2) = ADDR(STATEMENT);
SQLPLIST4.SQLPVARS.SQLPVIND(2) = SYSNULL();
SQLPLIST4.SQLPVARS.SQLPVNAMELEN(2) = 0;
SQLPLIST4.SQLPVARS.SQLSQLDAID = 'SQLDA  ' || '08'X;
SQLPLIST4.SQLPVARS.SQLPVDABC = 104;
SQLPLIST4.SQLPVARS.SQLPVN = 2;
SQLPLIST4.SQLPVARS.SQLPVD = 2;
SQLPLIST4.SQLVPARMP = ADDR(SQLPLIST4.SQLPVARS.SQLPVDAID);
SQLPLIST4.SQLAPARMP = SYSNULL();
SQLPLIST4.SQLCODEP = ADDR(SQLCA);
CALL DSNHLI(SQLPLIST4);
IF SQLCODE < 0 THEN DO;
   CALL SQLMSGP;
   STOP;
END;
SQLSIZE = 0; ALLOCATE SQLDA;

/*$*$*$
EXEC SQL DESCRIBE STATEMENT INTO :SQLDA
$*$*$*/
DO;
DCL
  1 SQLPLIST5 UNALIGNED
   ,2 SQLPLLEN     FIXED BIN(15) INIT(64)
   ,2 SQLFLAGS     FIXED BIN(15) INIT('0400'XN)
   ,2 SQLCTYPE     FIXED BIN(15) INIT(40)
   ,2 SQLPROGN     CHAR(8) INIT('PLI0001')
   ,2 SQLTIMES     CHAR(8)
        INIT('1BE259C6_08AFFE2C'X)
   ,2 SQLSECTN     FIXED BIN(15) INIT(1)
   ,2 SQLCODEP     POINTER
   ,2 SQLVPARMP    POINTER
   ,2 SQLAPARMP    POINTER
   ,2 SQLCCSID     FIXED BIN(16) UNSIGNED INIT( 1047)
   ,2 SQLSTYPE     FIXED BIN(15) INIT(17)
   ,2 SQLSTNUM     FIXED BIN(32) UNSIGNED INIT(109)
   ,2 SQLFLGS2     FIXED BIN(15) INIT('0000'XN)
   ,2 SQLRESRV     CHAR(18) INIT('00'X)
   ;
SQLPLIST5.SQLAPARMP = ADDR(SQLDA);
SQLPLIST5.SQLVPARMP = SYSNULL();
SQLPLIST5.SQLCODEP = ADDR(SQLCA);
CALL DSNHLI(SQLPLIST5);
END;
IF SQLCODE < 0 THEN DO;
   CALL SQLMSGP;
   STOP;
END;
SQLSIZE = SQLD; FREE SQLDA; ALLOCATE SQLDA;

/*$*$*$
EXEC SQL DESCRIBE STATEMENT INTO :SQLDA
$*$*$*/
DO;
DCL
  1 SQLPLIST6 UNALIGNED
   ,2 SQLPLLEN     FIXED BIN(15) INIT(64)
   ,2 SQLFLAGS     FIXED BIN(15) INIT('0400'XN)
   ,2 SQLCTYPE     FIXED BIN(15) INIT(40)
   ,2 SQLPROGN     CHAR(8) INIT('PLI0001')
   ,2 SQLTIMES     CHAR(8)
        INIT('1BE259C6_08AFFE2C'X)
   ,2 SQLSECTN     FIXED BIN(15) INIT(1)
   ,2 SQLCODEP     POINTER
   ,2 SQLVPARMP    POINTER
   ,2 SQLAPARMP    POINTER
   ;
END;
```

--------------------------------

### Process Message Buffer (PL/I)

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/RXGIM.txt

The SETMSGS procedure is designed to process a message buffer. It initializes a message counter and checks if the MSGBUFF pointer is valid. The provided snippet is incomplete but indicates the start of a loop to process messages.

```PL/I
SETMSGS: PROCEDURE;
       DCL CURMSG POINTER;
       DCL TEXTPTR POINTER;
       DCL MSGTEXT CHAR(256) BASED(TEXTPTR);
       DCL CNTMSG BIN FIXED(31); /* Message count */
       DCL RESULT BIN FIXED(31);
       CNTMSG = 0;
       IF MSGBUFF ^= SYSNULL
       THEN DO;
         CURMSG = MSGBUFF;
```

--------------------------------

### PL/I: Handle Cylinders Action

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

This PL/I code handles the 'CYLINDERS' action. It directly calls the SETUPL routine with parameters (8, 0, ''). This action does not appear to have input validation.

```PL/I
- ACT(19): /*  CYLINDERS  */
        CALL SETUPL(8,0,'');
        RETURN(0);
```

--------------------------------

### PL/I Wildcard Declaration Example

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/packages/language/src/linking/README.md

Illustrates the use of wildcard declarations (`*`) in PL/I for creating anonymous groupings within structures. It shows how wildcard declarations affect symbol accessibility and how fully qualified references take precedence.

```pli
DCL 1 A,
      2 *, /* Wildcard used to anonymously group the following members */
        3 B CHAR(8) VALUE("B");
PUT(A.B);
```

```pli
DCL 1 A,
       2 *, /* Anonymous group */
         3 B CHAR(8) VALUE("B"), /* First 'B', effectively part of A */
       2 B CHAR(8) VALUE("B2"); /* Second 'B', directly part of A */
PUT(A.B);
```

--------------------------------

### PL/I CICS Preprocessor Options Configuration

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PTASK34.txt

Specifies the CICS preprocessor options used during the compilation of a PL/I program. These options control how the CICS statements are translated. The example shows options like DEBUG, EDF, and SP.

```plaintext
0 Command: PP(CICS("SP")),SOURCE
0 Install:
15655-PL6  IBM(R) Enterprise PL/I for z/OS  PTASK34: PROC OPTIONS(MAIN) REORDER ;               2024.05.10 23:35:28   Page     2
- CICS (Built:20220315) Preprocessor Options Used
0   CICS
0   DEBUG
0   EDF
0   SP
0   NATLANG(EN)
0   NOSYSEIB
0   NOFEPI
0   NOCPSM
0   LENGTH
```

--------------------------------

### PL/I Conditional Logic and Variable Initialization

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/PDUMVS.txt

Demonstrates setting default values for variables like LINESIZE, ECHO, and window dimensions based on conditions. It also includes initialization of translation tables and command-related variables.

```PL/I
456.0                 IF TT='3270' THEN RC3270=IO3270(' ',0);
      457.0                 END;
      458.0              LS=LNSZ;
      459.0              END;
      460.0              ELSE DO;
      461.0                   LS=120;  /* DEFAULT BATCH LINESIZE IS 120 */
      462.0                   ECHO='1'B;  /* ECHO INPUT COMMANDS IN BATCH MODE */
      463.0                   END;
      464.0           IF LS>=120 THEN #W=8; ELSE #W=4;
      465.0           #B=#W*4;
      466.0           #H=#B*2;
      467.0           ALLOCATE DUMPLINE;
      468.0           ALLOCATE HEX64;
      469.0           ALLOCATE LINE32;
      470.0           ALLOCATE PREVINFO;
      471.0           TRTAB1=(256)'.';
      472.0           SUBSTR(TRTAB1,65,1)=' ';
      473.0           SUBSTR(TRTAB1,75,7)='?.<(+|&';
      474.0           SUBSTR(TRTAB1,91,8)='!$*);^-/';
      475.0           SUBSTR(TRTAB1,108,5)=',%_>?';
      476.0           SUBSTR(TRTAB1,123,6)=':#@''="';
      477.0           SUBSTR(TRTAB1,130,9)=SUBSTR(LOWER,1,9);
      478.0           SUBSTR(TRTAB1,146,9)=SUBSTR(LOWER,10,9);
      479.0           SUBSTR(TRTAB1,163,8)=SUBSTR(LOWER,19,8);
      480.0           SUBSTR(TRTAB1,194,9)=SUBSTR(UPPER,1,9);
      481.0           SUBSTR(TRTAB1,210,9)=SUBSTR(UPPER,10,9);
      482.0           SUBSTR(TRTAB1,227,8)=SUBSTR(UPPER,19,8);
      483.0           SUBSTR(TRTAB1,241,10)=NUM;
      484.0           TRTAB2=TRANSLATE(TRTAB1,' ','.');
      485.0           SUBSTR(TRTAB2,76,1)='.';
      486.0           FC='';  /* INDICATE NO PREVIOUS FIND COMMAND */
      487.0           FROM=1; TO=0;  /* DEFAULT "FROM" AND "TO" VALUES */
      488.0           C#=1;  /* DEFAULT "COMPRESS" VALUE */
      489.0           DYNALDDN='';  /*  INDICATE NO PREVIOUS SUCCESSFUL
      490.0                                   DYNAMIC ALLOCATION  */
      491.0           CALL PUTMSG(TODAY()||'    '||TIMEX());
```

--------------------------------

### Find Next Non-Blank Character in PL/I

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/MACROS.txt

The NEXT_CHAR procedure finds the next non-blank character in a character string. It starts searching from the current pointer and skips over any blank characters. It returns the index of the first non-blank character found.

```PL/I
NEXT_CHAR:PROC(CURRENT_POINTER,CMD)/*.........*/RETURNS(FIXED BIN);
      /* FIND THE NEXT NON-BLANK CHARACTER                             */
      DCL CURRENT_POINTER FIXED BIN, CMD(*) CHAR;
      IF CMD(CURRENT_POINTER) ^= ' '
         THEN CURRENT_POINTER = CURRENT_POINTER + 1;
      DO N = CURRENT_POINTER TO LL WHILE(CMD(N) = ' ');END;
      RETURN(N);
END NEXT_CHAR;
```

--------------------------------

### GIMAPI Interface Declaration and Initialization

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/RXGIM.txt

Declares the external GIMAPI entry point and initializes REXX environment variables and pointers. This includes fetching necessary REXX functions and setting up the environment block pointer.

```PL/I
DCL GIMAPI ENTRY(CHAR(8),PTR,PTR,CHAR(3),FIXED BIN(31),
                 FIXED BIN(31),PTR) EXTERNAL OPTIONS(ASSEMBLER,INTER);

DCL (RC,CC,QC) FIXED BIN(31) INIT(0);
DCL QPARMS    PTR;
DCL MSGBUFF   PTR;
DCL QRESULT   PTR;
DCL NIL       PTR;
DCL PGMVPTR   PTR;
DCL APIVPTR   PTR;
DCL CSISTR    CHAR(44);
DCL ZONESTR   CHAR(100);
DCL ENTRYSTR  CHAR(100);
DCL SUBENTSTR CHAR(100);
DCL FILTERSTR CHAR(255);
DCL UPPERCASE CHAR(26) INIT('ABCDEFGHIJKLMNOPQRSTUVWXYZ');
DCL LOWERCASE CHAR(26) INIT('abcdefghijklmnopqrstuvwxyz');
DCL RXAPIV    CHAR(2) INIT('02');
DCL RSNCODE   BIN FIXED(31) INIT(0);
DCL RETCODE   BIN FIXED(31) INIT(0);

START:
FETCH IRXINIT;
FETCH IRXEXCOM;
FETCH GIMAPI;
CC = -1;
HLQ = STRIP(PARM);
IF HLQ = ''
THEN HLQ = 'RXGIM';

/* Get the address of ENVBLOCK */
CALL IRXINIT('FINDENVB','',NIL,NIL,0,ENVBLOCKPTR,RSNCODE,0,RETCODE,
              NIL);
IF ENVID ^= 'ENVBLOCK'
THEN DO; /* ENVBLOCK not found */
  RC = -3;
  GOTO EXIT;
  END;

NIL = SYSNULL;
SHVBLOCKPTR = ADDR(SHVBLOCK);
SHVNEXT = SYSNULL;
SHVBUFL = 255;
SHVNAMA = ADDR(RXVAR);
SHVVALA = ADDR(RXVAL);
SHVVALL = 255;
```

--------------------------------

### Find Next Delimiter in PL/I

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/MACROS.txt

The NEXT_DELIMITER procedure finds the next delimiter in a character string. It iterates through the string starting from a given pointer, looking for spaces, single quotes, or double quotes. It returns the index of the next delimiter.

```PL/I
NEXT_DELIMITER:PROC(CURRENT_POINTER,CMD)/*....*/RETURNS(FIXED BIN);
      /* DELIMITERS ARE: BLANKS OR QUOTE OR DOUBLEQUOTE                */
      DCL CURRENT_POINTER FIXED BIN, CMD(*) CHAR;
      DO N = CURRENT_POINTER+1 TO LL
         WHILE(CMD(N)^=' ' & CMD(N) ^=QUOTE);
      END;
      RETURN(N);
END NEXT_DELIMITER;
```

--------------------------------

### PL/I Procedure for File Options and Output Formatting

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/PDUMVS.txt

This PL/I procedure, 'OPTIONS', constructs and displays file-related options based on various flags and parameters. It handles dataset organization, buffer length, record format, and other attributes, formatting them into a readable string for output. Dependencies include built-in functions like LENGTH and CALL statements for external procedures like PUTMSG and HEXOUT.

```PL/I
OPTIONS: PROC;
           DCL O CHAR(100) VAR;
           DCL CIN CHAR(1) VAR;
           DCL COUT CHAR(2);
           IF OPENED THEN DO;
              O='FI('||INDD||') DSORG('||DSORG||') BUFL('||CH(BUFRL)||')';
              IF SYSXX=SYSPB|SYSXX=SYSVB THEN O=O||' BACKWARDS';
              CALL PUTMSG(O);
              END;
           IF DUMPFORMAT THEN O='DUMP;'; ELSE O='NODUMP;';
           IF PRINTKEY THEN O=O||'DKEY;'; ELSE O=O||'NODKEY;';
           IF COUNTFLAG THEN O=O||'NUM;'; ELSE O=O||'NONUM;';
           O=O||'FROM '||CH(FROM)||' TO ' ||CH(TO)||';';
           O=O||'TT '||TT||';';
           IF REF=3 THEN O=O||'NOREFLECT;';
                    ELSE O=O||'REFLECT;';
           IF AUTO THEN O=O||'AC;'; ELSE O=O||'NOAC;';
           O=O||'INT '||CH(P#)||';';
           CALL PUTMSG(O);
           IF EXPAND THEN O='EXPAND '||CH(E#)||';';
                     ELSE O='NOEXPAND'||';';
           IF COMPRESS THEN O=O||'COMPRESS '||CH(C#)||';';
                       ELSE O=O||'NOCOMPRESS'||';';
           CIN=CCHAR;
           CALL HEXOUT(CIN,COUT);
           O=O||'CCHAR "'||COUT||'";';
           CIN=ECHAR;
           CALL HEXOUT(CIN,COUT);
           O=O||'ECHAR "'||COUT||'";';
           CALL PUTMSG(O);
           IF LENGTH(FC)>0 THEN CALL PUTMSG('LAST FIND COMMAND: FIND '||FC);
           END OPTIONS;
```

--------------------------------

### PL/I EROPT Processing for Zowe

Source: https://github.com/zowe/zowe-pli-language-support/blob/development/code_samples/PDUMP/S99VAL.txt

Processes the EROPT (Error Option) parameter for Zowe. It validates that the input is a 3-character alphabetic string matching one of the predefined error options. If valid, it updates a temporary variable and calls a setup routine.

```PL/I
230.1    1 ACT(35): /*  EROPT  */
      231.1         IF LENGTH(COM) ^= 3 | VERIFY(COM,ALPHA) > 0
      232.1            THEN RETURN(16);
      233.1         ELSE;
      234.1         DO I = 1 TO 3;
      235.1            IF COM = EROPT(I)
      236.1               THEN LEAVE;
      237.1            ELSE;
      238.1         END;
      239.1         IF I = 4
      240.1            THEN RETURN(16);
      241.1         ELSE UNSPEC(TMP) = '0000000000000001'B || EROTYP(I);
      242.1         CALL SETUPL(61,1,TMP);
      243.1         RETURN(0);
```
Tokens:
Raw