• Commercial applications
• Engineering/scientific applications
• and more

Step 1: Prepare your files

• Create a new PL/I  module residing in a HFS file
• Copy an existing PL/I module that resides in a PDS (Partitioned Dataset) to an HFS file
• Reference an existing PL/I module that resides in a PDS via an external link

*process display(std);

 plimain: proc options(main);
   declare s character (100) varying;

   display("Hello World!");
  
   put skip list ('Your input:');
   get list (s);
   put skip list (s);
 end;

pli -qlp=64 -qlimits=extname=31 my.pli -o my.prog

echo "MY STDIN" | ./my.prog

Hello World!
Your input:
MY STDIN

cp -X "//'HLQ.PDS(PLI)'" my.prog

ln -e  "//'HLQ.PDS(PLI)'" my.prog

export STEPLIB=HLQ.PDS:$STEPLIB

Step 2: Create a Node.js application to invoke the PL/I module

const { spawn } = require('child_process');
const pli = spawn('./my.prog');

pli.stdout.on('data', (data) => {
  console.log(`PL/I stdout: ${data}`);
});

pli.stderr.on('data', (data) => {
  console.error(`PL/I stderr: ${data}`);
});

pli.on('close', (code) => {
  console.log(`PL/I process exited with code ${code}`);
});

pli.stdin.write("My STDIN\n");

node index.js

PL/I stdout: HELLO WORLD

My STDIN

PL/I process exited with code 0

Create a Native Node.js Module that calls PL/I functions

Step 1: Start a New Project

mkdir my-pli-native-module
cd my-pli-native-module

Use npm to create a Node.js package as follows:

npm init --yes

{
  "name": "my-pli-native-module",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Step 2: Set up the Native Node.js Module

npm install node-addon-api bindings

{
  "targets": [
    {
      "target_name": "plibinding",
      "sources": [ "plibinding.cc" ],
      "include_dirs": [
        "<!@(node -p \"require('node-addon-api').include\")"
      ],
      'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
    }
  ]
}

#include <ctype.h>
#include <napi.h>

extern "C" int __getPLIData();

Napi::Number getPLIData(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  _ae_thread_swapmode(__AE_EBCDIC_MODE); // Switch to EBCDIC mode before entering PL/I
  int data = __getPLIData();
  _ae_thread_swapmode(__AE_ASCII_MODE);  // Switch back to ASCII mode after exiting PL/I
  return Napi::Number::New(env, data);
}

Napi::Object Init(Napi::Env env, Napi::Object exports) {
  Napi::String name = Napi::String::New(env, "getPLIData");
  Napi::Function function = Napi::Function::New(env, getPLIData);
  exports.Set(name, function);
  return exports;
}

NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

*process display(std);

 __getPLIData: proc ext("__getPLIData")
   returns(fixed bin(63) byvalue);
   return(10);
 end;

{
"targets": [
   {
     "target_name": "plibinding",
     "include_dirs": [
        "<!@(node -p \"require('node-addon-api').include\")"
     ],
     "sources": [ "plibinding.cc", "num.pli" ],
     "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
   }
]
}

pli -qlp=64 -qlimits=extname=31 num.pli -c num.o

{
  "targets": [
    {
      "target_name": "plibinding",
      "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")"
      ],
      "sources": [ "plibinding.cc" ],
      "libraries": [ "../num.o" ],
      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
    }
  ]
}

Step 3: Build and test the Native Node.js Module

npm install

const plibinding = require('bindings')('plibinding');

console.log(plibinding.getPLIData());

node index.js

10

Leverage COBOL Programs in Node.js

Step 1: Prepare your files

• Create and compile a COBOL program residing in HFS
• Copy an existing COBOL program that resides in a PDS (Partitioned Dataset) to an HFS file
• Reference an existing COBOL program that resides in a PDS

Create and compile a COBOL program residing in HFS

       IDENTIFICATION DIVISION.
       PROGRAM-ID.
           COBPROG.
       ENVIRONMENT DIVISION.
       DATA DIVISION.
       PROCEDURE DIVISION.
           DISPLAY "HELLO WORLD".
           STOP RUN.

cob2 my.cob -o my.prog

./my.prog

HELLO WORLD

Copy an existing COBOL program that resides in a PDS (Partitioned Dataset) to an HFS file

cp -X "//'HLQ.PDS(COBOL)'" my.prog 

Reference an existing COBOL program that resides in a PDS

ln -e  "//'HLQ.PDS(COBOL)'" my.prog

export STEPLIB=HLQ.PDS:$STEPLIB

Step 2: Create the Node.js program to invoke the COBOL module

const { spawn } = require('child_process');
const cobol = spawn('./my.prog');

cobol.stdout.on('data', (data) => {
  console.log(`COBOL stdout: ${data}`);
});

cobol.stderr.on('data', (data) => {
  console.error(`COBOL stderr: ${data}`);
});

cobol.on('close', (code) => {
  console.log(`COBOL process exited with code ${code}`);
});

node index.js

COBOL stdout: HELLO WORLD

COBOL process exited with code 0

More information

• For additional resources on IBM Open Enterprise SDK for Node.js:
  • IBM Open Enterprise SDK for Node.js product page
  • IBM Open Enterprise SDK for Node.js documentation
• For additional resources on PL/I:
  • IBM Enterprise PL/I for z/OS product page
  • IBM Enterprise PL/I for z/OS documentation
• For additional resources on COBOL:
  • IBM Enterprise COBOL for z/OS product page
  • IBM Enterprise COBOL for z/OS documentation