Were there "higher level programming" macro packages for the IBM Macro Assembler?

Question

The IBM/360 Macro Assembly language was quite powerful, allowing non-trivial compile-time string manipulation.

Did macro packages exist which would facilitate programming at a (slightly) higher level, like writing expressions in an infix form, allowing a form of structured programming, standardizing subroutine calling conventions, accessing bit-fields conveniently, etc?

---

The reason I'm asking it that one of the BESM-6 assembly languages was a syntax-level port of the IBM/360 assembler, including the macro language, e.g.

 macro
 mnop &a,&b,&c,&d,&e,&f,&g,&h
 aif (&a eq '').x
 gbla &cnt  global arith. variable
 mnote * comment &cnt
&cnt seta &cnt+1 
 nop &a
 mnop &b,&c,&d,&e,&f,&g,&h
.x anop
 mend
 MNOP  FIRST,SECOND,THIRD,FOURTH

expands to

 0001  0001        MACRO
 0002  0002        MNOP  &A,&B,&C,&D,&E,&F,&G,&H
 0003  0003        AIF   (&A EQ ’’).X
 0004  0004        GBLA  &CNT GLOBAL ARITH. VARIABLE
 0005  0005        MNOTE * COMMENT &CNT
 0006  0006 &CNT   SETA  &CNT+1
 0007  0007        NOP   &A
 0008  0008        MNOP  &B,&C,&D,&E,&F,&G,&H
 0009  0009 .X     ANOP
 0010  0010        MEND
 0011  0011        MNOP  FIRST,SECOND,THIRD,FOURTH
 0012  0005 * COMMENT 0
 0013 +0007+       NOP   FIRST
 0014  0005 * COMMENT 1
 0015 +0007+       NOP   SECOND
 0016  0005 * COMMENT 2
 0017 +0007+       NOP   THIRD
 0018  0005 * COMMENT 3
 0019 +0007+       NOP   FOURTH

But the precompiled macro package for "higher-level" programming (likely also ported from IBM/360 with the appropriate architecture-dependent modifications) is missing.

Here's a few examples of using the macros from the package:

RЕG (М1 = 1,М2 = 2,М3 = 3,М4 = 4,М5 = 5)
КТ1 ВINDА (А(PAGE1)+KMD+М14)
FКТ3 SТRIТ (NCMD,0,0,8),(NARCH,0,40,8),(SND,0,16,8)
ЕХРR (FNM = $) FILE NAME
ЕХРR (SND = (OWNER,ADDR)) SENDER
ЕХРR (NUMREQ = (OWNER,REQ)) REQUEST NUMBER
IFА (QUEUE),Z=DISCRD NO REQUEST

Searching the web for the most distinctive macro names BINDA and STRIT doesn't help.

If a macro package with those or similar macros existed for the IBM/360 Macro Assembler, getting access to its source code would be of great help.

Answer 1

There is a group of macros called Concept 14, that was written by an IBM Federal Systems employee named Marvin Kessler. They ran on IFOX00 (the F assembler) and were used as the basis for the HLASMTK SPM.

A former co-worker of mine, Paul Scott, provides them in IEBUPDTE format. He also has a scan of the documentation; unfortunately it is missing a page.

I believe they have also made it into the Hercules and z390 worlds.

Answer 2

The IBM/360 Macro Assembly language was quite powerful, allowing non-trivial compile-time string manipulation.

Well, reducing it to "string manipulation" might fall short, as there is no similarity to the usual string manipulation languages. It's a rather full figured imperative programming language. Programs get executed when 'assembled'. It provides typed global and local variables (bool, integer, string), arrays (depending on assembler version) and more.

Did macro packages exist which would facilitate programming at a (slightly) higher level,

Not just 'slightly' higher.

like writing expressions in an infix form, allowing a form of structured programming, standardizing subroutine calling conventions, accessing bit-fields conveniently, etc?

For structured programming (which ofc includes calling conventions and data structures) this has already be kind of answered in a question about stacks on stackless machines:

How was C ported to architectures that had no hardware stack?

---

Example of a dummy program, calling a function and checking the result, copied from the answer:

    @ENTR TYPE=M,NAME=MAIN  ** Main programm, execution starts here
    ...
    @PASS NAME=FUBAR,PLIST=(FCB,RECORD)
    @IF   NE
    LTR   R15,R15         * Return Code Not Zero?
    @THEN
    @EXIT RC=#UNSATISFIED * Finish Program with Return Code UNSATISFIED
    @BEND
    ...
    @EXIT RC=#HAPPYENDING * Finish Program with Return Code HAPPYENDING
    @END


    @ENTR TYPE=L,NAME=FUBAR,PLIST=(FCB,RECORD)  * Function FUBAR, called by MAIN
    ...
    (do whatever needed with FCB and RECORD)
    ...
    @EXIT RC=0            * Finish Function with Return Code Zero
    @END

---

While the mentioned COLUMBUS Assembler (*1) package was AFAIK a Siemens specific development, it was 100% F-Assembler macro code. In addition to the macro library there were as well listing formatters that turned a straight assembler listing into an intended or Nassi/Shneiderman listings.

Besides that, projects/companies of course did build macro packages to enable easy handling of more complex issues. Plus, of course, every OS did supply macros for whatever services they had as well.

---

getting access to its source code would be of great help

Well, I do still have somewhere a tape with several versions (we did modify it quite a lot from its original version). In addition I did port it a long time ago to ORCA/M for the Apple II. Just, finding either may take some time.

Then again, building such a lib for structured programming is, with F-Assembler (or better) macros or higher/compatible, a mostly trivial task of building a parsing stack to check syntax and generate labels. Drop me a note, if you like some hints.

---

D/E/F-Assembler (and its macro language) was published short after the /360 was introduced with F being the 'full' version, but also coming with a huge RAM requirement of 64 KiB :)) So this is most likely the base for your package.

---

*1 - The same package was available for COBOL, just then code generation was done by a preprocessor.