Examples of assembler code.

This page contains the following sample programs:

Traditional assembler programs:
- Static glue module
- Dynamic VSAM I/O module
Assembler programs that make use of Bixoft's eXtended Assembly macro's:

Remark 1:
All samples on this page are no more than examples, and are in no way guaranteed to be free of errors or omissions. You may use (parts of) these code-samples, but it remains in all aspects your own responsibility to test your programs.

Remark 2:
All comments in the code samples are in english. Comments in your sources can of course be in any language you choose. We recommend that you use the language most commonly used in your firm. The same holds of course for all other kinds of documentation as well.

Static glue module.

In order to build a miniature DataBase Manager (DBMS) we employed the following premises:

Split the logic into a static module with minimal functionality and a dynamic part that will effect the translation between logical and physical record lay-outs For each logical record lay-out the dynamic module may support several versions.
The version of a logical record lay-out to be used will be determined by the entry-point - there will be 1 entry-point in the static module for each logical record lay-out (view in SQL terminology).
The static part will be linked into each calling load module, and will determine the version number of each logical record lay-out. Thus, whenever an application is to start using a newer version of a logical record lay-out, a newer version of the static module will have to be linked with it.
Inverting this logic implies that whenever the physical structure of the database (the underlying physical datasets) is being changed, the applications need not be changed at all. They may continue their operation with the existing version of the static module, receiving from the dynamic module the logical records with the associated lay-out version number.
The static module will be called with a single parameter. This parameter has the following lay-out:
- CL2 function code
- CL1 return code
- CL15 key value for random access
- CLnnn content of the logical record
The static module adds a second parameter. This parameter contains the following fields:
- AL4 pointer to working storage of the dynamic module
- CL2 version number of the logical record lay-out
- CL8 logical record selectors
The following codes have been defined for the function code field:
- RS - Read Sequential
- RR - Read Random (by key)
- WS - reWrite Sequential
- WR - reWrite Random (by key)
- SK - Skip to specified key
- SN - Skip to specified key, then read Next record
- IR - Insert Random (by key)
- DR - Delete Random (by key)
- SI - open for Sequential Input
- RI - open for Random Input
- SU - open for Sequential Update
- RU - open for Random Update
- WN - reWrite current record, then read Next
- DN - Delete current record, then read Next
- SD - create a Snap-Dump
The following codes have been defined for the returncode field:
- 0 - everything ok
- 1 - record not found (random processing) or end-of-file (sequential processing)
- 2 - warning, problem solved, see joblog for details
- 3 - programming error in application, see joblog for details
- 4 - error during processing, see joblog for error encountered.
  Processing probably cannot continue.
- 5 - fatal error during processing, see joblog for error encountered.
  Further processing is impossible.

View source code of program BXAIO .

Dynamic VSAM I/O module.

For a short description of the design please refer to the topic above: static glue module.

View source code of program BXAIO00.

Dummy program in amode 24.

This program issues a message to show that it was invoked correctly. The program runs in amode 24, and has no useful function. This program was written to test the GLUE macro and it can be used as a sample or skeleton program.

View source code of program BXALOWPG.

Overview of control blocks.

This program has no run-time function. It is used to generate overviews of fields in control blocks and to check that no conflicts are created in the naming of fields.

The control blocks to be generated can be selected by changing the value of the assembly-variabele &SELECT.

View source code of program BXAMAPS.

Check the value of a JCL-variable.

This program checks the value of a JCL-variable.

The check to be performed is to be supplied in the PARM-field of the EXEC-statement.
The syntax is as follows:

operand 1
operator (EQ or NE)
operand 2

The program ends with a return code 0 (check evaluates as true) or 4 (check false). Other steps in the job can be executed or skipped depending upon these return codes.

The following example shows how program BXATEST can be used in a JCL proc:

//BXAASM   PROC MEMB=,PROJ=,LVL=
//*
//TEST     EXEC PGM=BXATEST,PARM='&LVL EQ T'
//PROD     EXEC PGM=BXATEST,PARM='&LVL EQ P'
//*
//* Invoke assembler, using default parms for TEST
//*
//         IF   (TEST.RC = 0) THEN
//ASMT     EXEC PGM=ASMA90,PARM=(OBJECT,NODECK,TERM,
//             'SYSPARM(SRLIST,DBG,OPT)')
//SYSLIB   DD   DSN=SYS1.MACLIB,DISP=SHR
//         DD   DSN=SYS1.MODGEN,DISP=SHR
//         DD   DSN=BIXOFT.ASMPLUS&LVL..MACLIB,DISP=SHR
//         DD   DSN=BIXOFT.ASMPLUSP.MACLIB,DISP=SHR
//         DD   DSN=BIXOFT.&PROJ.&LVL..MACLIB,DISP=SHR
//         DD   DSN=BIXOFT.&PROJ.P.MACLIB,DISP=SHR
//...      Other DD-statements
//         ENDIF
//*
//* Invoke assembler, using default parms for PROD
//*
//         IF   (PROD.RC = 0) THEN
//ASMP     EXEC PGM=ASMA90,PARM=(OBJECT,NODECK,TERM,
//             'SYSPARM(SRLIST,NODBG,OPT)')
//SYSLIB   DD   DSN=SYS1.MACLIB,DISP=SHR
//         DD   DSN=SYS1.MODGEN,DISP=SHR
//         DD   DSN=BIXOFT.ASMPLUS&LVL..MACLIB,DISP=SHR
//         DD   DSN=BIXOFT.&PROJ.&LVL..MACLIB,DISP=SHR
//...      Other DD-statements
//         ENDIF
//*
//         PEND

View source code of program BXATEST.

Copy a dataset or a member.

This program will copy a member from a PDS concatenation or a physical sequential dataset concatenation.

Input:
- JCL-parm specifying 'MEMBER=memname' or 'DATSET=PS'
- INPUT dd-statement giving the input dataset(s)
Output:
- OUTPUT dd-statement specifying the dataset to be created

For MEMBER=memname the INPUT concatenation of PDS'es will be searched for the specified member, which will then be copied to OUTPUT.
For DATSET=PS the INPUT concatenation of physical sequential files will be copied to OUTPUT.

IEBCOPY does more, but needs control cards for its input, which cannot be substituted from JCL variables.
IEHLIST will also copy datasets, but it also lists all records, filling up the spool.

The following example shows how program BXACOPY can be used in a JCL proc:

//BXAASM   PROC MEMB=,PROJ=,LVL=
//*
//* Copy source member to be used
//*
//COPY     EXEC PGM=BXACOPY,PARM='MEMBER=&MEMB'
//INPUT    DD   DSN=BIXOFT.&PROJ.&LVL..ASM,DISP=SHR
//         DD   DSN=BIXOFT.&PROJ.P.ASM,DISP=SHR
//OUTPUT   DD   SPACE=(TRK,(10,10,1),RLSE),DISP=(NEW,PASS,DELETE),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920),
//             DSN=&&ASM(&MEMB)
//*
//...      other steps
//         PEND

View source code of program BXACOPY.

Unload a library.

This program unloads all members of a PDS into a single IEBUPDTE-job which can be used to reload the library anywhere else.
The program accepts a parameter, which specifies the step-name for the IEBUPDTE-job to be generated.

The advantage of using the IEBUPDTE format is that the source code can be browsed or edited under DOS, Windows and Unix as well.

The example below shows how BXAUNLD can be invoked.

//BXAUNLD  EXEC PGM=BXAUNLD,PARM='GOODIES'
//SYSUT1   DD   DSN=BIXOFT.GOODIES.ASM,DISP=OLD
//SYSUT2   DD   DSN=BIXOFT.GOODIES.UNLOAD,DISP=(NEW,CATLG,CATLG),
//             SPACE=(TRK,(10,10),RLSE),UNIT=3390,VOL=SER=TEMP00,
//             DCB=(LRECL=80,BLKSIZE=27920,RECFM=FB)

View source code of program BXAUNLD.

Remarks? Questions? More information? Select the topic of your choice or e-mail us with your questions.

Traditional Assembler examples:

Example of a Static glue module.
Example of a Dynamic VSAM I/O module.

Bixoft's eXtended Assembly examples:

Example of a dummy program.
Example of an overview of control block fields.
Example of a check of a JCL variable.
Example of a copy (dataset or member) program.
Example of an unload library program.

Topics available
Symposium: extending the life cycle of legacy applications
Bixoft Homepage	What's new?
Introduction / Sitemap	Why assembler
Courses	Sample code snippets
Counselling	Sample programs
Consultancy	Macro Library
Maintenance	Public License Proposal
Design	Network
3GL-migrations	HLASM Experts
Pre-compilers	Books & sites
Bottlenecks	Reviews
	Profile A.F. Kornelis

This site is a member of WebRing. You are invited to browse the list of mainframe-loving sites.		Dinos are not dead. They are alive and well and living in data centers all around you. They speak in tongues and work strange magics with computers. Beware the dino! And just in case you're waiting for the final demise of these dino's: remember that dinos ruled the world for 155-million years!
Dinos and other anachronisms [ Join Now \| Ring Hub \| Random \| << Prev \| Next >> ]