Re: Question about PARMDD

2017-02-28 Thread Paul Gilmartin
On Mon, 27 Feb 2017 14:54:49 -0500, John Eells wrote:

>Paul Gilmartin wrote:
>
>>>
>> You're suggesting that a transcript or summary of those discussions
>> is available.  Can you cite?  Thanks.
>>
>
>
>I suggested neither one, so I am a bit puzzled about how you inferred
>that.  What I wrote was, "In fact, there was a protracted discussion
>right here in IBM-MAIN about how we should implement this support, well
>in advance of its actual appearance, led by the designer. I am
>reasonably confident that you can find in that discussion why it was
>done as it was, if you care to look."
> 
My apologies.  I overlooked the reference to IBM-MAIN.

>The IBM-MAIN archives are searchable, here:
>https://listserv.ua.edu/archives/ibm-main.html
>
>If you are sufficiently interested, you can find the discussion.
>
The archives are a pretty big target, given the decades of discussion of
PARM length, here and elsewnere.  I'll rely on memory

I recall a general wish for a longer PARM, no mention of anything like
PARMDD until IBM unveiled it.

IIRC, there some feeling that for very long PARMs command files are
a better approach.  Alas, some utilities don't support command files
ahd may require PARM strings longer that 100 characters.  Command
files are more practical with (recent) JCL enhancements:
o JCLLIB
o DD DATA SYMBOLS=...
o Instream data sets are no longer limited to LRECL=80
o Instream data sets may now appear in PROCs

(Yes, those facilities also apply to PARMDD.)

There was considerable concern that long PARMs might be passed to
programs not prepared for them, resulting in unexpected and undesirable
results.  The LONGPARM program object attribute is a good solution for
this.  But why is it enforced only on APF-authorized programs?  Unauthorized
programs might be similarly unprepared for PARM>100 bytes.  Granted,
for unauthorized programs there's no threat to system integrity, only to
application integrity, but that still matters.  Simply, LONGPARM should
be recognized alike for any program invoked as a job step task, whether
authorized on not.

And I'm looking at the "BPX.EXECMVSAPF.program_name FACILITY class
profile".  Why does this even exist?  Having two dissimilar ways to
achieve similar functions tends to confuse system administrators.
The LONGPARM attribute is preferable because:
o It can be set by the program owner who may lack authority to
  define RACF profile classes.
o It distinguishes between similar program_names residing in
  different libraries.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-28 Thread Charles Mills
Oh man, that brings back some memories. Check out Figure 3 on page 25 of the 
1970 manual!

Interesting -- the example of a possible PARM= value ('P1,123,MT5') has not 
changed between that manual and 
https://www.ibm.com/support/knowledgecenter/SSLTBW_2.2.0/com.ibm.zos.v2r2.ieab600/iea3b6_Syntax89.htm
 Ditto for the first three examples on 
https://www.ibm.com/support/knowledgecenter/SSLTBW_2.2.0/com.ibm.zos.v2r2.ieab600/iea3b6_Examples_of_the_PARM_parameter.htm
 

*Accounting* information is limited to 142 characters -- perhaps that is what 
@Clark is recalling.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Tom Marchant
Sent: Tuesday, February 28, 2017 4:34 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

On Mon, 27 Feb 2017 22:20:07 -0400, Clark Morris wrote:

>When did it change to 100?

Some time between 1967 and 1970.

See page 85 of
http://bitsavers.trailing-edge.com/pdf/ibm/360/os/R19_Jun70/GC28-6704-0_JCL_Reference_Rel_19_Jun70.pdf
for OS/360, dated June, 1970


PARM=value
value
consists of up to 100 characters of information or options that the system is 
to pass to the processing program.


See also page 18 of the fifth edition of the OS/360 JCL manual, dated March, 
1967, where the limit is specified as 40 characters.

http://bitsavers.trailing-edge.com/pdf/ibm/360/os/R01-08/C28-6539-4_OS_JCL_Mar67.pdf

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-28 Thread Elardus Engelbrecht
Tom Marchant wrote:

>Some time between 1967 and 1970.

I think the limits of 40 or 100 characters were based on a quick way (without 
using tapes or extra punch cards) to give shortish parameters to a program 
using puch cards. Or so it was told to me by an oldie years ago.


About "Reference of the PARM field":

Then (from bitsavers):

"The exact location and format of control information passed to a processing 
program are described under the topic titled "Program Management" in section 1 
of the publication IBM System/360 Operating System: Supervisor and Data 
Management Services.

Today (from my bookmanager):

"For details on the format of the passed information and its retrieval, see 
z/OS MVS Programming: Assembler Services Guide."

Amazing how they worded same things then and now.


>See page 85 of 
>http://bitsavers.trailing-edge.com/pdf/ibm/360/os/R19_Jun70/GC28-6704-0_JCL_Reference_Rel_19_Jun70.pdf

Amazing those bitsavers place which I read now and then just for amusement. I 
have a look at that book.

Same familiar monospaced fonts. Same two columns per page. Same weird spacing 
of words. Pages left blank intentionally. ;-)


I also looked at the 'Programmers name' and am amazed that it is still 20 chars 
long!
I tried out a job with 21 chars and got a JCL error with this nice message in 
upper and lower case!
'HASP110 value of programmer name is too long'


Good to see those ancient manuscripts. I (re-)discovered ancient terms like 
SUL, BISAM and QISAM and such animals. 

Do you think I should fill in 'READER'S COMMENTS'? H? ;-D

Thanks, Tom for discovering this little gem! ;-)

Groete / Greetings
Elardus Engelbrecht

SUL - type of LABEL which I never ever used at all.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-28 Thread Tom Marchant
On Mon, 27 Feb 2017 22:20:07 -0400, Clark Morris wrote:

>When did it change to 100?

Some time between 1967 and 1970.

See page 85 of 
http://bitsavers.trailing-edge.com/pdf/ibm/360/os/R19_Jun70/GC28-6704-0_JCL_Reference_Rel_19_Jun70.pdf
for OS/360, dated June, 1970


PARM=value 
value
consists of up to 100 characters of information or options 
that the system is to pass to the processing program.


See also page 18 of the fifth edition of the OS/360 JCL manual, dated 
March, 1967, where the limit is specified as 40 characters.

http://bitsavers.trailing-edge.com/pdf/ibm/360/os/R01-08/C28-6539-4_OS_JCL_Mar67.pdf

-- 
Tom Marchant

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Charles Mills
Just out of curiosity, looking at "MVS JCL" for MVS/SP from Dec. 1984 on
archive.org. It is a combined Guide and Reference, FWIW. 

Says Length: The entire information passed must not exceed 100 characters.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Charles Mills
Sent: Monday, February 27, 2017 6:50 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

100 forever.

No harm in maxing at 144.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Clark Morris
Sent: Monday, February 27, 2017 6:20 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

[Default] On 27 Feb 2017 07:44:46 -0800, in bit.listserv.ibm-main
bill.wood...@gmail.com (Bill Woodger) wrote:

>On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
>> No. IBM chose not to break thousands upon thousands of programs that 
>> were
perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not
sufficient.
>> 
>
>Unless you change the JCL to use PARMDD on the EXEC instead of PARM on 
>the
EXEC, nothing changes.
>
>If you make that change for no purpose, and then the program is doing
something which relies on there being 100 bytes of data as a maximum
implicitly, then you may have a problem. But how is that IBM's fault? No-one
forced the JCL change.

When did it change to 100?  I always tested for 144 as a maximum or whatever
I was expecting going back to MVT.

--
For IBM-MAIN subscribe / signoff / archive access instructions, send email
to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Charles Mills
100 forever.

No harm in maxing at 144.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Clark Morris
Sent: Monday, February 27, 2017 6:20 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

[Default] On 27 Feb 2017 07:44:46 -0800, in bit.listserv.ibm-main
bill.wood...@gmail.com (Bill Woodger) wrote:

>On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
>> No. IBM chose not to break thousands upon thousands of programs that were
perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not
sufficient.
>> 
>
>Unless you change the JCL to use PARMDD on the EXEC instead of PARM on the
EXEC, nothing changes.
>
>If you make that change for no purpose, and then the program is doing
something which relies on there being 100 bytes of data as a maximum
implicitly, then you may have a problem. But how is that IBM's fault? No-one
forced the JCL change.

When did it change to 100?  I always tested for 144 as a maximum or whatever
I was expecting going back to MVT.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Clark Morris
[Default] On 27 Feb 2017 07:44:46 -0800, in bit.listserv.ibm-main
bill.wood...@gmail.com (Bill Woodger) wrote:

>On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
>> No. IBM chose not to break thousands upon thousands of programs that were 
>> perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not 
>> sufficient.
>> 
>
>Unless you change the JCL to use PARMDD on the EXEC instead of PARM on the 
>EXEC, nothing changes.
>
>If you make that change for no purpose, and then the program is doing 
>something which relies on there being 100 bytes of data as a maximum 
>implicitly, then you may have a problem. But how is that IBM's fault? No-one 
>forced the JCL change.

When did it change to 100?  I always tested for 144 as a maximum or
whatever I was expecting going back to MVT.

Clark Morris
>
>If you don't change the JCL, the program expecting a maximum of 100 bytes and 
>never needing any more than that will work as designed for the next... well, 
>forever.
>
>Have you got an example from one of the thousands and thousands of breaks 
>caused?
>
>--
>For IBM-MAIN subscribe / signoff / archive access instructions,
>send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread John Eells

Paul Gilmartin wrote:




You're suggesting that a transcript or summary of those discussions
is available.  Can you cite?  Thanks.




I suggested neither one, so I am a bit puzzled about how you inferred 
that.  What I wrote was, "In fact, there was a protracted discussion 
right here in IBM-MAIN about how we should implement this support, well 
in advance of its actual appearance, led by the designer. I am 
reasonably confident that you can find in that discussion why it was 
done as it was, if you care to look."


The IBM-MAIN archives are searchable, here: 
https://listserv.ua.edu/archives/ibm-main.html


If you are sufficiently interested, you can find the discussion.

--
John Eells
IBM Poughkeepsie
ee...@us.ibm.com

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Charles Mills
@Gil points out to me off-list that PARMDD can be longer than 100 per the 
message I was replying to but not PARM=.

Well then, yes, that is consistent with what I was saying. Had I designed it I 
would have just made PARM= longer than 100 subject to a binder-set bit.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Charles Mills
Sent: Monday, February 27, 2017 10:10 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

Well that was my recollection but looking at

https://www.ibm.com/support/knowledgecenter/SSLTBW_2.2.0/com.ibm.zos.v2r2.ieab600/iea3b6_Syntax89.htm
 

It says

Length: The length of the subparameters passed must not exceed 100 characters:

So I thought I imagined the below.

Charles

-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Paul Gilmartin
Sent: Monday, February 27, 2017 9:42 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

On Mon, 27 Feb 2017 09:18:04 -0800, Charles Mills wrote:

>Admittedly poor technique, but a program allocates a 100-byte buffer. 
>It moves the parm info into that buffer using an executed MVC or an 
>MVCL without first verifying that the length is no more than 100.
>Conceivably a security exposure: many exposures start with buffer overrun.
>
>What I think I would have done if I had designed the enhancement was 
>had a linkedit bit similar to AC(1) that said "this program is good 
>with JCL parms over 100 bytes." Admittedly not perfect: what if the 
>jobstep program calls another program that processed the JCL PARM= info.
>
z/OS MVS Program Management: User's Guide and Reference Version 2 Release 2
SA23-1393-01

Chapter 6. Binder options reference
Binder options
LONGPARM: Long parameter option
The LONGPARM option indicates whether the program supports a parameter 
longer
than 100 bytes. This applies mainly to programs that are invoked using a 
JCL EXEC
statement or a z/OS UNIX EXECMVS callable service. LONGPARM or LONGPARM=YES
specifies that the program can accept a parameter string of more than 100 
bytes.
In this case, an appropriate directory entry bit will be turned on. The 
system checks
for this attribute only when the program is being invoked with a parameter 
string of
more than 100 bytes and the program is APF authorized. In this case, if the 
LONGPARM 
attribute is not set on, the system fails the invocation.

>This is a philosophy issue and not a detailed design issue, but I think 
>we are over-obsessed with compatibility. I understand why we are, I 
>remember the FS debacle, and I still feel that way. You can't make an 
>omelet without breaking eggs. I think the obsession with compatibility 
>sometimes holds the platform back, or makes enhancement unnecessarily 
>complex. I recognize the validity of other opinions.

They anticipated your concern.  It has always been the caller's responsibility 
either to validate the PARM or to ensure that the called program does so.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Charles Mills
Well that was my recollection but looking at

https://www.ibm.com/support/knowledgecenter/SSLTBW_2.2.0/com.ibm.zos.v2r2.ieab600/iea3b6_Syntax89.htm
 

It says

Length: The length of the subparameters passed must not exceed 100 characters:

So I thought I imagined the below.

Charles

-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Paul Gilmartin
Sent: Monday, February 27, 2017 9:42 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

On Mon, 27 Feb 2017 09:18:04 -0800, Charles Mills wrote:

>Admittedly poor technique, but a program allocates a 100-byte buffer. 
>It moves the parm info into that buffer using an executed MVC or an 
>MVCL without first verifying that the length is no more than 100. 
>Conceivably a security exposure: many exposures start with buffer overrun.
>
>What I think I would have done if I had designed the enhancement was 
>had a linkedit bit similar to AC(1) that said "this program is good 
>with JCL parms over 100 bytes." Admittedly not perfect: what if the 
>jobstep program calls another program that processed the JCL PARM= info.
>
z/OS MVS Program Management: User's Guide and Reference Version 2 Release 2
SA23-1393-01

Chapter 6. Binder options reference
Binder options
LONGPARM: Long parameter option
The LONGPARM option indicates whether the program supports a parameter 
longer
than 100 bytes. This applies mainly to programs that are invoked using a 
JCL EXEC
statement or a z/OS UNIX EXECMVS callable service. LONGPARM or LONGPARM=YES
specifies that the program can accept a parameter string of more than 100 
bytes.
In this case, an appropriate directory entry bit will be turned on. The 
system checks
for this attribute only when the program is being invoked with a parameter 
string of
more than 100 bytes and the program is APF authorized. In this case, if the 
LONGPARM 
attribute is not set on, the system fails the invocation.

>This is a philosophy issue and not a detailed design issue, but I think 
>we are over-obsessed with compatibility. I understand why we are, I 
>remember the FS debacle, and I still feel that way. You can't make an 
>omelet without breaking eggs. I think the obsession with compatibility 
>sometimes holds the platform back, or makes enhancement unnecessarily 
>complex. I recognize the validity of other opinions.

They anticipated your concern.  It has always been the caller's responsibility 
either to validate the PARM or to ensure that the called program does so.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions, send email to 
lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Paul Gilmartin
On Mon, 27 Feb 2017 06:47:14 -0500, John Eells wrote:

>Paul Gilmartin wrote:
>
>>  http://i2.kym-cdn.com/photos/images/original/000/475/756/7ab.jpg
>>
>> ... what the users wanted was a PARM on the EXEC statement longer than 100 
>> bytes.
>> Somehow, IBM couldn't understand.
>
>
>We certainly *did* understand. We further understand that there were
>sound reasons why that was not done. In fact, there was a protracted
>discussion right here in IBM-MAIN about how we should implement this
>support, well in advance of its actual appearance, led by the designer.
>I am reasonably confident that you can find in that discussion why it
>was done as it was, if you care to look.
> 
You're suggesting that a transcript or summary of those discussions
is available.  Can you cite?  Thanks.

Those discussions were protracted.  Two or three decades ago a colleague,
not then an IBM employee, was party to an RFE for longer PARM.  IBM
rebutted him with an alternative similar to PARMDD.  I suspect implementation
was deferred until DD DATA,SYMBOLS= and in-stream data sets in
PROCs became available.

I try to envision a rationale.  If a longer PARM is cumbersome for internal
operations, it could be cached in a spool file, but transparently to the user.

Otherwise, compatibility is not preserved.  A program that follows (non-GUPI?)
control blocks to find PARM is broken alike by PARMDD or by restructuring
control blocks to relieve the 100-character constraint.

in: SA23-1385-03 z/OS MVS JCL Reference

Chapter 16. EXEC statement
PARMDD parameter
Record length requirements
... Fixed record length data sets and in-stream data sets are examined to 
determine
if their records contain sequence numbers.  ...

So, apparently, variable record length in-stream data sets are processed for
sequence numbers.  Other variable record length data sets are not.

Why?  This is puzzling.  I'll submit an RCF.

Thanks again,
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Paul Gilmartin
On Mon, 27 Feb 2017 16:27:51 +, Windt, W.K.F. van der (Fred) wrote:

>But how would support for a longer parameter possibly break an existing 
>program? The program is passed the address of a binary half word (the length 
>of the content of the parm) followed by that content. Even if a much longer 
>parm was supported nothing would change for a program that is currently 
>invoked with a certain parameter.
>
>The program would probably break if somebody passes a 1000 character parameter 
>to a program that expects only 8 characters. But it would probably break as 
>well if you pass such a program a 9 character parameter.
>  
And such a program is likewise broken whether the 1000 character PARM were 
passed
by EXEC PARM=... or by PARMDD.

And it has always been possible to ATTACH a program with a parameter of up to
65535 characters with a 16-bit length field.  I have successfully passed a 65535
character parameter to an IBM program that way.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Paul Gilmartin
On Mon, 27 Feb 2017 09:18:04 -0800, Charles Mills wrote:

>Admittedly poor technique, but a program allocates a 100-byte buffer. It
>moves the parm info into that buffer using an executed MVC or an MVCL
>without first verifying that the length is no more than 100. Conceivably a
>security exposure: many exposures start with buffer overrun.
>
>What I think I would have done if I had designed the enhancement was had a
>linkedit bit similar to AC(1) that said "this program is good with JCL parms
>over 100 bytes." Admittedly not perfect: what if the jobstep program calls
>another program that processed the JCL PARM= info.
>
z/OS MVS Program Management: User's Guide
and Reference
Version 2 Release 2
SA23-1393-01

Chapter 6. Binder options reference
Binder options
LONGPARM: Long parameter option
The LONGPARM option indicates whether the program supports a parameter 
longer
than 100 bytes. This applies mainly to programs that are invoked using a 
JCL EXEC
statement or a z/OS UNIX EXECMVS callable service. LONGPARM or LONGPARM=YES
specifies that the program can accept a parameter string of more than 100 
bytes.
In this case, an appropriate directory entry bit will be turned on. The 
system checks
for this attribute only when the program is being invoked with a parameter 
string of
more than 100 bytes and the program is APF authorized. In this case, if the 
LONGPARM 
attribute is not set on, the system fails the invocation.

>This is a philosophy issue and not a detailed design issue, but I think we
>are over-obsessed with compatibility. I understand why we are, I remember
>the FS debacle, and I still feel that way. You can't make an omelet without
>breaking eggs. I think the obsession with compatibility sometimes holds the
>platform back, or makes enhancement unnecessarily complex. I recognize the
>validity of other opinions.

They anticipated your concern.  It has always been the caller's responsibility
either to validate the PARM or to ensure that the called program does so.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Charles Mills
Admittedly poor technique, but a program allocates a 100-byte buffer. It
moves the parm info into that buffer using an executed MVC or an MVCL
without first verifying that the length is no more than 100. Conceivably a
security exposure: many exposures start with buffer overrun. 

What I think I would have done if I had designed the enhancement was had a
linkedit bit similar to AC(1) that said "this program is good with JCL parms
over 100 bytes." Admittedly not perfect: what if the jobstep program calls
another program that processed the JCL PARM= info. 

This is a philosophy issue and not a detailed design issue, but I think we
are over-obsessed with compatibility. I understand why we are, I remember
the FS debacle, and I still feel that way. You can't make an omelet without
breaking eggs. I think the obsession with compatibility sometimes holds the
platform back, or makes enhancement unnecessarily complex. I recognize the
validity of other opinions.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Windt, W.K.F. van der (Fred)
Sent: Monday, February 27, 2017 8:28 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

But how would support for a longer parameter possibly break an existing
program? The program is passed the address of a binary half word (the length
of the content of the parm) followed by that content. Even if a much longer
parm was supported nothing would change for a program that is currently
invoked with a certain parameter.

The program would probably break if somebody passes a 1000 character
parameter to a program that expects only 8 characters. But it would probably
break as well if you pass such a program a 9 character parameter.

Fred!

Sent from my new iPad

> On 27 Feb 2017, at 08:54, Allan Staller <allan.stal...@hcl.com> wrote:
> 
> ">No. IBM chose **not to break** thousands upon thousands of programs that
were perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not
sufficient."
> 
> 
> 
> My reply was to Gil who was complaining about IBM's implementation of
PARMDD (it should have been). The "not to break" is a good thing.
> Gil seems to think that breaking existing programs by introducing
incompatable function is OK to do. I disagree.
> 
> I am in support of the path IBM chose.
> 
> -Original Message-
> From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] 
> On Behalf Of Bill Woodger
> Sent: Monday, February 27, 2017 9:46 AM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: Question about PARMDD
> 
>> On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
>> No. IBM chose not to break thousands upon thousands of programs that were
perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not
sufficient.
>> 
> 
> Unless you change the JCL to use PARMDD on the EXEC instead of PARM on the
EXEC, nothing changes.
> 
> If you make that change for no purpose, and then the program is doing
something which relies on there being 100 bytes of data as a maximum
implicitly, then you may have a problem. But how is that IBM's fault? No-one
forced the JCL change.
> 
> If you don't change the JCL, the program expecting a maximum of 100 bytes
and never needing any more than that will work as designed for the next...
well, forever.
> 
> Have you got an example from one of the thousands and thousands of breaks
caused?
> 
> --
> For IBM-MAIN subscribe / signoff / archive access instructions, send 
> email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
> 
> 
> ::DISCLAIMER::
> --
> --
> 
> 
> The contents of this e-mail and any attachment(s) are confidential and
intended for the named recipient(s) only.
> E-mail transmission is not guaranteed to be secure or error-free as 
> information could be intercepted, corrupted, lost, destroyed, arrive 
> late or incomplete, or may contain viruses in transmission. The e mail and
its contents (with or without referred errors) shall therefore not attach
any liability on the originator or HCL or its affiliates.
> Views or opinions, if any, presented in this email are solely those of 
> the author and may not necessarily reflect the views or opinions of 
> HCL or its affiliates. Any form of reproduction, dissemination, 
> copying, disclosure, modification, distribution and / or publication of
this message without the prior written consent of authorized representative
of HCL

Re: Question about PARMDD

2017-02-27 Thread Bill Woodger
Sorry, Allan, one of those occasions when reading all of the words prior to 
jumping is good...

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Windt, W.K.F. van der (Fred)
But how would support for a longer parameter possibly break an existing 
program? The program is passed the address of a binary half word (the length of 
the content of the parm) followed by that content. Even if a much longer parm 
was supported nothing would change for a program that is currently invoked with 
a certain parameter.

The program would probably break if somebody passes a 1000 character parameter 
to a program that expects only 8 characters. But it would probably break as 
well if you pass such a program a 9 character parameter.

Fred!

Sent from my new iPad

> On 27 Feb 2017, at 08:54, Allan Staller <allan.stal...@hcl.com> wrote:
>
> ">No. IBM chose **not to break** thousands upon thousands of programs that 
> were perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not 
>> sufficient."
>
>
>
> My reply was to Gil who was complaining about IBM's implementation of PARMDD 
> (it should have been). The "not to break" is a good thing.
> Gil seems to think that breaking existing programs by introducing 
> incompatable function is OK to do. I disagree.
>
> I am in support of the path IBM chose.
>
> -Original Message-
> From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On 
> Behalf Of Bill Woodger
> Sent: Monday, February 27, 2017 9:46 AM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: Question about PARMDD
>
>> On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
>> No. IBM chose not to break thousands upon thousands of programs that were 
>> perfectly happy with 100 byte parm fields, provided via JCL.
>> They added a new mechanism for those program, where 100 bytes was not 
>> sufficient.
>>
>
> Unless you change the JCL to use PARMDD on the EXEC instead of PARM on the 
> EXEC, nothing changes.
>
> If you make that change for no purpose, and then the program is doing 
> something which relies on there being 100 bytes of data as a maximum 
> implicitly, then you may have a problem. But how is that IBM's fault? No-one 
> forced the JCL change.
>
> If you don't change the JCL, the program expecting a maximum of 100 bytes and 
> never needing any more than that will work as designed for the next... well, 
> forever.
>
> Have you got an example from one of the thousands and thousands of breaks 
> caused?
>
> --
> For IBM-MAIN subscribe / signoff / archive access instructions, send email to 
> lists...@listserv.ua.edu with the message: INFO IBM-MAIN
>
>
> ::DISCLAIMER::
> 
>
> The contents of this e-mail and any attachment(s) are confidential and 
> intended for the named recipient(s) only.
> E-mail transmission is not guaranteed to be secure or error-free as 
> information could be intercepted, corrupted,
> lost, destroyed, arrive late or incomplete, or may contain viruses in 
> transmission. The e mail and its contents
> (with or without referred errors) shall therefore not attach any liability on 
> the originator or HCL or its affiliates.
> Views or opinions, if any, presented in this email are solely those of the 
> author and may not necessarily reflect the
> views or opinions of HCL or its affiliates. Any form of reproduction, 
> dissemination, copying, disclosure, modification,
> distribution and / or publication of this message without the prior written 
> consent of authorized representative of
> HCL is strictly prohibited. If you have received this email in error please 
> delete it and notify the sender immediately.
> Before opening any email and/or attachments, please check them for viruses 
> and other defects.
>
> 
>
>
> --
> For IBM-MAIN subscribe / signoff / archive access instructions,
> send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


ATTENTION:
The information in this e-mail is confidential and only meant for the intended 
recipient. If you are not the intended recipient, don't use or disclose it in 
any way. Please let the sender know and delete the message immediately.
--

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Allan Staller
">No. IBM chose **not to break** thousands upon thousands of programs that were 
perfectly happy with 100 byte parm fields, provided via JCL.
> They added a new mechanism for those program, where 100 bytes was not 
> sufficient."



My reply was to Gil who was complaining about IBM's implementation of PARMDD 
(it should have been). The "not to break" is a good thing.
Gil seems to think that breaking existing programs by introducing incompatable 
function is OK to do. I disagree.

I am in support of the path IBM chose.

-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Bill Woodger
Sent: Monday, February 27, 2017 9:46 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
> No. IBM chose not to break thousands upon thousands of programs that were 
> perfectly happy with 100 byte parm fields, provided via JCL.
> They added a new mechanism for those program, where 100 bytes was not 
> sufficient.
> 

Unless you change the JCL to use PARMDD on the EXEC instead of PARM on the 
EXEC, nothing changes.

If you make that change for no purpose, and then the program is doing something 
which relies on there being 100 bytes of data as a maximum implicitly, then you 
may have a problem. But how is that IBM's fault? No-one forced the JCL change.

If you don't change the JCL, the program expecting a maximum of 100 bytes and 
never needing any more than that will work as designed for the next... well, 
forever.

Have you got an example from one of the thousands and thousands of breaks 
caused?

--
For IBM-MAIN subscribe / signoff / archive access instructions, send email to 
lists...@listserv.ua.edu with the message: INFO IBM-MAIN


::DISCLAIMER::


The contents of this e-mail and any attachment(s) are confidential and intended 
for the named recipient(s) only.
E-mail transmission is not guaranteed to be secure or error-free as information 
could be intercepted, corrupted,
lost, destroyed, arrive late or incomplete, or may contain viruses in 
transmission. The e mail and its contents
(with or without referred errors) shall therefore not attach any liability on 
the originator or HCL or its affiliates.
Views or opinions, if any, presented in this email are solely those of the 
author and may not necessarily reflect the
views or opinions of HCL or its affiliates. Any form of reproduction, 
dissemination, copying, disclosure, modification,
distribution and / or publication of this message without the prior written 
consent of authorized representative of
HCL is strictly prohibited. If you have received this email in error please 
delete it and notify the sender immediately.
Before opening any email and/or attachments, please check them for viruses and 
other defects.




--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Bill Woodger
On Monday, 27 February 2017 15:00:03 UTC+1, Allan Staller  wrote:
> No. IBM chose not to break thousands upon thousands of programs that were 
> perfectly happy with 100 byte parm fields, provided via JCL.
> They added a new mechanism for those program, where 100 bytes was not 
> sufficient.
> 

Unless you change the JCL to use PARMDD on the EXEC instead of PARM on the 
EXEC, nothing changes.

If you make that change for no purpose, and then the program is doing something 
which relies on there being 100 bytes of data as a maximum implicitly, then you 
may have a problem. But how is that IBM's fault? No-one forced the JCL change.

If you don't change the JCL, the program expecting a maximum of 100 bytes and 
never needing any more than that will work as designed for the next... well, 
forever.

Have you got an example from one of the thousands and thousands of breaks 
caused?

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread Allan Staller
No. IBM chose not to break thousands upon thousands of programs that were 
perfectly happy with 100 byte parm fields, provided via JCL.
They added a new mechanism for those program, where 100 bytes was not 
sufficient.


On Wed, 22 Feb 2017 11:16:33 -0600, Juergen Kehr wrote:
>
>since a while we're using the new PARMDD keyword for our DB2 subsystems.
>
http://i2.kym-cdn.com/photos/images/original/000/475/756/7ab.jpg

... what the users wanted was a PARM on the EXEC statement longer than 100 
bytes.
Somehow, IBM couldn't understand.



::DISCLAIMER::


The contents of this e-mail and any attachment(s) are confidential and intended 
for the named recipient(s) only.
E-mail transmission is not guaranteed to be secure or error-free as information 
could be intercepted, corrupted,
lost, destroyed, arrive late or incomplete, or may contain viruses in 
transmission. The e mail and its contents
(with or without referred errors) shall therefore not attach any liability on 
the originator or HCL or its affiliates.
Views or opinions, if any, presented in this email are solely those of the 
author and may not necessarily reflect the
views or opinions of HCL or its affiliates. Any form of reproduction, 
dissemination, copying, disclosure, modification,
distribution and / or publication of this message without the prior written 
consent of authorized representative of
HCL is strictly prohibited. If you have received this email in error please 
delete it and notify the sender immediately.
Before opening any email and/or attachments, please check them for viruses and 
other defects.




--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-27 Thread John Eells

Paul Gilmartin wrote:

On Wed, 22 Feb 2017 11:16:33 -0600, Juergen Kehr wrote:


since a while we're using the new PARMDD keyword for our DB2 subsystems.


 http://i2.kym-cdn.com/photos/images/original/000/475/756/7ab.jpg

... what the users wanted was a PARM on the EXEC statement longer than 100 
bytes.
Somehow, IBM couldn't understand.



We certainly *did* understand. We further understand that there were 
sound reasons why that was not done. In fact, there was a protracted 
discussion right here in IBM-MAIN about how we should implement this 
support, well in advance of its actual appearance, led by the designer. 
I am reasonably confident that you can find in that discussion why it 
was done as it was, if you care to look.


--
John Eells
IBM Poughkeepsie
ee...@us.ibm.com

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-25 Thread Paul Gilmartin
On Wed, 22 Feb 2017 11:16:33 -0600, Juergen Kehr wrote:
>
>since a while we're using the new PARMDD keyword for our DB2 subsystems.
>
http://i2.kym-cdn.com/photos/images/original/000/475/756/7ab.jpg

... what the users wanted was a PARM on the EXEC statement longer than 100 
bytes.
Somehow, IBM couldn't understand.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-24 Thread Bill Woodger
The exact possibilities for the content of a PARM in a JCL deck depend on an 
interaction between "JCL" and the data the parm represents, (as David W Noon 
was keen to impress in the other thread on this).

What happens for PARM-in-JCL need not happen for PARM-in-PARMDD. PARMDD did not 
exist previously, you have to change the JCL significantly to use it, PARMDD 
data contains no elements of JCL, nothing relating to JCL directly (unless you 
count the symbol-substitution and & compression) and "does some other 
stuff", stripping what it (it being the PARMDD processing) thinks is a line 
number.

Taking your original example and putting it in PARMDD would not work, because 
the program using the PARM data would not understand the extra information.

Taking Charles' example and removing the comments and putting it in PARMDD 
would not work, because some of the PARM formatting in that example is to allow 
for the presence of the comments (those apostrophes).

Taking any PARM which has required extra formatting because the data of the 
PARM conflicted with JCL's understanding of how a line is formed and putting it 
unchanged into PARMDD would not work, because those extra bits of formatting 
for the JCL are still there, and now part of the data, which the program using 
the PARM data will not understand.

PARM is data. You can "embed" a comment in the JCL, but it is embedded in the 
JCL, not the data (in your example the commas have a dual role, they are data, 
and the JCL-processor sees them as JCL).

PARM is data. Sometimes the data requires encapsulation so that the 
JCL-processor understands.

PARMDD is data. There is no requirement or capability for de-encapsulating JCL 
that in an original PARM existed only to enforce a distinction between the data 
and the JCL.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Paul Gilmartin
On Thu, 23 Feb 2017 22:12:00 -0400, Clark Morris wrote:
>
Just read carefully.  JCL Ref.; EXEC Statement; PARMDD paramter says ...

>The knowledge center says the processing strips out blanks and
>sequence numbers.  I am not certain as to where a sequence number
>would be in format V or VB data sets or Unix files.  ...
>
Data set requirements
z/OS UNIX System Services files also provide the appearance of
a physical sequential (PS) data set and are supported.

Record length requirements
... Fixed record length data sets and in-stream data sets are examined to
determine if their records contain sequence numbers.

This would seem to include RECFM=V in-stream data sets.  But is an RCF
in order?

If sequence numbers exist, they are assumed to consist of eight contiguous 
numeric characters
occupying the last eight bytes of the input record. 

Including the last eight characters of each record of RECFM=V in-stream data 
sets?

Parameter string requirements
The parameter string that is passed to the job step program is formed by a 
simple concatenation
of each input record, up to a maximum of 32760 bytes. Blank records and 
trailing blanks on each
record are ignored during the concatenation process.

Note that says *trailing* blanks, not leading nor interior blanks.

>that goes into excruciating detail as to how this works?  The JCL
>reference doesn't.  You can use symbols and system symbols if the parm
>data is instream.  I agree with your example and suspect the only way
>to tell for sure is to run tests which I can't do without a system.
>
There are other rules, described elsewhere, about stretching or compressing
sequences of blanks during symbol substitution.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Clark Morris
[Default] On 23 Feb 2017 12:59:08 -0800, in bit.listserv.ibm-main
bill.wood...@gmail.com (Bill Woodger) wrote:

>I don't think so either. There is documentation of the possibility of symbol 
>substitution, but nothing about placement of commas, nothing about 
>continuation symbols, and a piece about embedded blanks being possible. 
>Particularly this latter could be affected by the embedding of comments in 
>such a way.
>
>For the processing of the PARMDD data set(s), explicit documentation of the 
>processing of comments (if it is done) would be required.
>
>As far as I can tell, if you want to put PARM='LUMP', you could have:
>
>Dataset 1: L followed by blanks
>Dataset 2: U followed by blanks
>Dataset 3: M followed by blanks
>Dataset 4: P folowed by blanks
>
>How would you tell, if that is possible, where a comment was? There's no 
>specified requirement to "break" at a specific column on on a comma, as one 
>long "string" of up to 32760 characters are created.

The knowledge center says the processing strips out blanks and
sequence numbers.  I am not certain as to where a sequence number
would be in format V or VB data sets or Unix files.  Is there a manual
that goes into excruciating detail as to how this works?  The JCL
reference doesn't.  You can use symbols and system symbols if the parm
data is instream.  I agree with your example and suspect the only way
to tell for sure is to run tests which I can't do without a system.

Clark Morris


>
>--
>For IBM-MAIN subscribe / signoff / archive access instructions,
>send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Bill Woodger
I don't think so either. There is documentation of the possibility of symbol 
substitution, but nothing about placement of commas, nothing about continuation 
symbols, and a piece about embedded blanks being possible. Particularly this 
latter could be affected by the embedding of comments in such a way.

For the processing of the PARMDD data set(s), explicit documentation of the 
processing of comments (if it is done) would be required.

As far as I can tell, if you want to put PARM='LUMP', you could have:

Dataset 1: L followed by blanks
Dataset 2: U followed by blanks
Dataset 3: M followed by blanks
Dataset 4: P folowed by blanks

How would you tell, if that is possible, where a comment was? There's no 
specified requirement to "break" at a specific column on on a comma, as one 
long "string" of up to 32760 characters are created.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Paul Gilmartin
On Thu, 23 Feb 2017 16:23:24 -0400, Clark Morris wrote:
>
>>It will work more or less as you expect, with no C's necessary. The
>>following is cut-and-pasted *exactly* from a working job, and the parm works
>>as expected.
>>
>>/CZAAPILD EXEC PGM=CZAAPILD,
>>//  PARM=('INST(CAM.Test.Agent)',
>>//*   'COMM(";"),MAJ(CorreLog),MIN(5),TRACE(),LEN(PREFIX)', Test
>>//'COMM(";"),MAJ(CorreLog),MIN(6),TRACE(),LEN(CZ1LEN)', VM RACF
>>//*   'COMM(";"),MAJ(IMS),MIN(1),TRACE()',IMS 01&03
>>//'PURGE(N)')
>
>That says to me that you can have comments in the records in PARMDD by
>using similar syntax.
> 
It doesn't say that to me.  Rather, I'd heed the description in:
z/OS 2.2.0
z/OS MVS
z/OS MVS JCL Reference
EXEC statement
PARMDD parameter
   Parameter string requirements

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Clark Morris
[Default] On 23 Feb 2017 06:55:00 -0800, in bit.listserv.ibm-main
charl...@mcn.org (Charles Mills) wrote:

>It will work more or less as you expect, with no C's necessary. The
>following is cut-and-pasted *exactly* from a working job, and the parm works
>as expected.
>
>/CZAAPILD EXEC PGM=CZAAPILD,
>//  PARM=('INST(CAM.Test.Agent)',
>//*   'COMM(";"),MAJ(CorreLog),MIN(5),TRACE(),LEN(PREFIX)', Test
>//'COMM(";"),MAJ(CorreLog),MIN(6),TRACE(),LEN(CZ1LEN)', VM RACF
>//*   'COMM(";"),MAJ(IMS),MIN(1),TRACE()',IMS 01&03
>//'PURGE(N)')

That says to me that you can have comments in the records in PARMDD by
using similar syntax.

Clark Morris
>
>Charles
>
>-Original Message-
>From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
>Behalf Of Clark Morris
>Sent: Thursday, February 23, 2017 6:34 AM
>To: IBM-MAIN@LISTSERV.UA.EDU
>Subject: Re: Question about PARMDD
>
>[Default] On 22 Feb 2017 14:28:53 -0800, in bit.listserv.ibm-main
>000433f07816-dmarc-requ...@listserv.ua.edu (Paul Gilmartin) wrote:
>
>
>Could someone try the following to see if it works? Assume the C for
>continuation is in column 72.
>
>//STER1 EXEC PGM=IEFBR14,PARM=(PARAM1, some comment  C
>//  PARAM2,another comment   C
>//  PARAM3)last comment
>
>After reading the entries at the Knowledge Center it has a 50/50 chance of
>working based on how I read them.  The next step would be to check a program
>(say a compiler) to see if it actually feeds the right information to it.
>
>As a retiree, I don't have access to a z system.
>
>Clark Morris
>>On Wed, 22 Feb 2017 22:10:43 +, David W Noon wrote:
>>>
>>>> This thread began with a discussion of the PARM string.  I'd like to 
>>>> think of JCL as source code, not as data.
>>>
>>>You can consider JCL as whatever you wish. The point I was making was 
>>>that the PARM string is data, not source code.
>>> 
>>The storage object pointed to by R1 is data.  The argument of the CALL 
>>macro as the programmer writes it is source code.  It's subject to 
>>symbol substitution, joining of continuation lines, etc.
>>
>>>> And I definitely think of JCL as sorely deficient in string 
>>>> manipulation operations.  It was developed a half-century ago, 
>>>> subject to severe resource constraints.
>>
>>But I think we're largely in agreement:
>>
>>>Ideally, JCL should have civilized syntax for string manipulation and 
>>>for flow control. This would include SELECT/WHEN/OTHERWISE, DO-loops.
>>>WHILE-loops as well as IF/ELSEIF/ELSE. The string manipulation would 
>>>include conditional substitution (ternary operator?) as well as 
>>>concatenation, extraction and removal of substrings, scanning 
>>>strings(*) for patterns and a whole lot more. We're basically talking 
>>>Python here, and a bit more besides.
>>>
>>>(*) I think regular expressions would send most mainframe programmers 
>>>scatty, but it would be nice to have.
>>
>>-- gil
>>
>>--
>>For IBM-MAIN subscribe / signoff / archive access instructions, send 
>>email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
>
>--
>For IBM-MAIN subscribe / signoff / archive access instructions, send email
>to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
>
>--
>For IBM-MAIN subscribe / signoff / archive access instructions,
>send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Charles Mills
It will work more or less as you expect, with no C's necessary. The
following is cut-and-pasted *exactly* from a working job, and the parm works
as expected.

/CZAAPILD EXEC PGM=CZAAPILD,
//  PARM=('INST(CAM.Test.Agent)',
//*   'COMM(";"),MAJ(CorreLog),MIN(5),TRACE(),LEN(PREFIX)', Test
//'COMM(";"),MAJ(CorreLog),MIN(6),TRACE(),LEN(CZ1LEN)', VM RACF
//*   'COMM(";"),MAJ(IMS),MIN(1),TRACE()',IMS 01&03
//'PURGE(N)')

Charles

-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Clark Morris
Sent: Thursday, February 23, 2017 6:34 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

[Default] On 22 Feb 2017 14:28:53 -0800, in bit.listserv.ibm-main
000433f07816-dmarc-requ...@listserv.ua.edu (Paul Gilmartin) wrote:


Could someone try the following to see if it works? Assume the C for
continuation is in column 72.

//STER1 EXEC PGM=IEFBR14,PARM=(PARAM1, some comment  C
//  PARAM2,another comment   C
//  PARAM3)last comment

After reading the entries at the Knowledge Center it has a 50/50 chance of
working based on how I read them.  The next step would be to check a program
(say a compiler) to see if it actually feeds the right information to it.

As a retiree, I don't have access to a z system.

Clark Morris
>On Wed, 22 Feb 2017 22:10:43 +, David W Noon wrote:
>>
>>> This thread began with a discussion of the PARM string.  I'd like to 
>>> think of JCL as source code, not as data.
>>
>>You can consider JCL as whatever you wish. The point I was making was 
>>that the PARM string is data, not source code.
>> 
>The storage object pointed to by R1 is data.  The argument of the CALL 
>macro as the programmer writes it is source code.  It's subject to 
>symbol substitution, joining of continuation lines, etc.
>
>>> And I definitely think of JCL as sorely deficient in string 
>>> manipulation operations.  It was developed a half-century ago, 
>>> subject to severe resource constraints.
>
>But I think we're largely in agreement:
>
>>Ideally, JCL should have civilized syntax for string manipulation and 
>>for flow control. This would include SELECT/WHEN/OTHERWISE, DO-loops.
>>WHILE-loops as well as IF/ELSEIF/ELSE. The string manipulation would 
>>include conditional substitution (ternary operator?) as well as 
>>concatenation, extraction and removal of substrings, scanning 
>>strings(*) for patterns and a whole lot more. We're basically talking 
>>Python here, and a bit more besides.
>>
>>(*) I think regular expressions would send most mainframe programmers 
>>scatty, but it would be nice to have.
>
>-- gil
>
>--
>For IBM-MAIN subscribe / signoff / archive access instructions, send 
>email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions, send email
to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-23 Thread Clark Morris
[Default] On 22 Feb 2017 14:28:53 -0800, in bit.listserv.ibm-main
000433f07816-dmarc-requ...@listserv.ua.edu (Paul Gilmartin) wrote:


Could someone try the following to see if it works? Assume the C for
continuation is in column 72.

//STER1 EXEC PGM=IEFBR14,PARM=(PARAM1, some comment  C
//  PARAM2,another comment   C
//  PARAM3)last comment

After reading the entries at the Knowledge Center it has a 50/50
chance of working based on how I read them.  The next step would be to
check a program (say a compiler) to see if it actually feeds the right
information to it.

As a retiree, I don't have access to a z system.

Clark Morris
>On Wed, 22 Feb 2017 22:10:43 +, David W Noon wrote:
>>
>>> This thread began with a discussion of the PARM string.  I'd like to think 
>>> of JCL
>>> as source code, not as data.
>>
>>You can consider JCL as whatever you wish. The point I was making was
>>that the PARM string is data, not source code.
>> 
>The storage object pointed to by R1 is data.  The argument of the CALL macro
>as the programmer writes it is source code.  It's subject to symbol 
>substitution,
>joining of continuation lines, etc.
>
>>> And I definitely think of JCL as sorely deficient
>>> in string manipulation operations.  It was developed a half-century ago,
>>> subject to severe resource constraints.
>
>But I think we're largely in agreement:
>
>>Ideally, JCL should have civilized syntax for string manipulation and
>>for flow control. This would include SELECT/WHEN/OTHERWISE, DO-loops.
>>WHILE-loops as well as IF/ELSEIF/ELSE. The string manipulation would
>>include conditional substitution (ternary operator?) as well as
>>concatenation, extraction and removal of substrings, scanning strings(*)
>>for patterns and a whole lot more. We're basically talking Python here,
>>and a bit more besides.
>>
>>(*) I think regular expressions would send most mainframe programmers
>>scatty, but it would be nice to have.
>
>-- gil
>
>--
>For IBM-MAIN subscribe / signoff / archive access instructions,
>send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Paul Gilmartin
On Wed, 22 Feb 2017 22:10:43 +, David W Noon wrote:
>
>> This thread began with a discussion of the PARM string.  I'd like to think 
>> of JCL
>> as source code, not as data.
>
>You can consider JCL as whatever you wish. The point I was making was
>that the PARM string is data, not source code.
> 
The storage object pointed to by R1 is data.  The argument of the CALL macro
as the programmer writes it is source code.  It's subject to symbol 
substitution,
joining of continuation lines, etc.

>> And I definitely think of JCL as sorely deficient
>> in string manipulation operations.  It was developed a half-century ago,
>> subject to severe resource constraints.

But I think we're largely in agreement:

>Ideally, JCL should have civilized syntax for string manipulation and
>for flow control. This would include SELECT/WHEN/OTHERWISE, DO-loops.
>WHILE-loops as well as IF/ELSEIF/ELSE. The string manipulation would
>include conditional substitution (ternary operator?) as well as
>concatenation, extraction and removal of substrings, scanning strings(*)
>for patterns and a whole lot more. We're basically talking Python here,
>and a bit more besides.
>
>(*) I think regular expressions would send most mainframe programmers
>scatty, but it would be nice to have.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread David W Noon
On Wed, 22 Feb 2017 15:05:54 -0600, Paul Gilmartin
(000433f07816-dmarc-requ...@listserv.ua.edu) wrote about "Re:
Question about PARMDD" (in
<5643810626893433.wa.paulgboulderaim@listserv.ua.edu>):

[snip]
> This thread began with a discussion of the PARM string.  I'd like to think of 
> JCL
> as source code, not as data.

You can consider JCL as whatever you wish. The point I was making was
that the PARM string is data, not source code.

> And I definitely think of JCL as sorely deficient
> in string manipulation operations.  It was developed a half-century ago,
> subject to severe resource constraints.

I first coded OS JCL under MVT more than 40 years ago. I coded DOS JCL
before that, and OS JCL is luxury in comparison. I also coded GCOS JCL
on Honeywell mainframes in the early 1980s; OS JCL is *serious luxury*
in comparison to that,

That said, I will not defend JCL's limitations. Its string handling is
largely limited to symbolic substitution using syntax taken from the
macro language of System/360 assembler. From the point of view of the
average COBOL programmer it is almost impenetrable.

Ideally, JCL should have civilized syntax for string manipulation and
for flow control. This would include SELECT/WHEN/OTHERWISE, DO-loops.
WHILE-loops as well as IF/ELSEIF/ELSE. The string manipulation would
include conditional substitution (ternary operator?) as well as
concatenation, extraction and removal of substrings, scanning strings(*)
for patterns and a whole lot more. We're basically talking Python here,
and a bit more besides.

(*) I think regular expressions would send most mainframe programmers
scatty, but it would be nice to have.
-- 
Regards,

Dave  [RLU #314465]
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
david.w.n...@googlemail.com (David W Noon)
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

 

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Paul Gilmartin
On Wed, 22 Feb 2017 20:18:25 +, David W Noon wrote:
> ...
>Indeed, you have two character strings with a comment separating them,
>then implicitly concatenated. Neither string contains a comment.
>
>More than that, you are processing source code here, not data. The REXX
>language defines comment delimiters and the language parser takes the
>appropriate action.
>
>In contrast the PARM string, whether coded as PARM or built from PARMDD,
>is almost invariably data. There is no comment delimiter defined for
>general data, as a data stream can contain anything in the most general
>case.
> 
This thread began with a discussion of the PARM string.  I'd like to think of 
JCL
as source code, not as data.  And I definitely think of JCL as sorely deficient
in string manipulation operations.  It was developed a half-century ago,
subject to severe resource constraints.

As Greg Dyck suggests, there's little hope of finding the resource to bring JCL
up to contemporary expectations.
http://dilbert.com/strip/2017-02-22

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Charles Mills
Ditto C: char foo[] = "hello " /* talk about a cliché! */ "world";

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Paul Gilmartin
Sent: Wednesday, February 22, 2017 12:01 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Question about PARMDD

On Wed, 22 Feb 2017 19:52:26 +, David W Noon wrote:
>
>You need to remember that the PARMDD file is read in and concatenated 
>into a character string. The notion of comments inside a character 
>string is rather a strange one to me, as a programmer who has been 
>doing string parsing for decades.
> 
And yet:

572 $ rexx
say 'foo'/*comment*/'bar'
foobar

(Yes, I understand there's an implied concatenation operator there.)

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread David W Noon
On Wed, 22 Feb 2017 14:00:55 -0600, Paul Gilmartin
(000433f07816-dmarc-requ...@listserv.ua.edu) wrote about "Re:
Question about PARMDD" (in
<1294479713669226.wa.paulgboulderaim@listserv.ua.edu>):

> On Wed, 22 Feb 2017 19:52:26 +, David W Noon wrote:
>>
>> You need to remember that the PARMDD file is read in and concatenated
>> into a character string. The notion of comments inside a character
>> string is rather a strange one to me, as a programmer who has been doing
>> string parsing for decades.
>>
> And yet:
> 
> 572 $ rexx
> say 'foo'/*comment*/'bar'
> foobar
> 
> (Yes, I understand there's an implied concatenation operator there.)

Indeed, you have two character strings with a comment separating them,
then implicitly concatenated. Neither string contains a comment.

More than that, you are processing source code here, not data. The REXX
language defines comment delimiters and the language parser takes the
appropriate action.

In contrast the PARM string, whether coded as PARM or built from PARMDD,
is almost invariably data. There is no comment delimiter defined for
general data, as a data stream can contain anything in the most general
case.
-- 
Regards,

Dave  [RLU #314465]
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
david.w.n...@googlemail.com (David W Noon)
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

 

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Paul Gilmartin
On Wed, 22 Feb 2017 19:52:26 +, David W Noon wrote:
>
>You need to remember that the PARMDD file is read in and concatenated
>into a character string. The notion of comments inside a character
>string is rather a strange one to me, as a programmer who has been doing
>string parsing for decades.
> 
And yet:

572 $ rexx
say 'foo'/*comment*/'bar'
foobar

(Yes, I understand there's an implied concatenation operator there.)

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread David W Noon
On Wed, 22 Feb 2017 11:11:58 -0700, Lizette Koehler
(stars...@mindspring.com) wrote about "Re: Question about PARMDD" (in
<11166244.8506.1487787118...@elwamui-huard.atl.sa.earthlink.net>):

> There is no one standard for Parmlib members and comments.
> 
> You would need to see what the DB2 syntax is for this member.

You need to remember that the PARMDD file is read in and concatenated
into a character string. The notion of comments inside a character
string is rather a strange one to me, as a programmer who has been doing
string parsing for decades.

As an illustration, it is directly analogous to putting comments into
the PARM field:

  //STEP1 EXEC PGM=MYPROG,PARM='parm1, /* ignore this */ parm2'

This requires the application to parse the PARM string in such a manner
that the comment convention removes the comment text. The comment
convention must, of necessity, be specific to the application program:
there is no universal comment delimiter. My personal preference would be
the one used in some ALGOL 68 implementations, the cent symbol '¢'. This
would give us:

  //STEP1 EXEC PGM=MYPROG,PARM='parm1, ¢ ignore this ¢ parm2'

It's more succinct than the PL/I comment notation used above, but
anybody who has never used ALGOL 68 could find it confusing.

But the bottom line is that PARMDD is *not* processed as a PARMLIB
member, so comment lines are not applicable.
-- 
Regards,

Dave  [RLU #314465]
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
david.w.n...@googlemail.com (David W Noon)
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

 

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Paul Gilmartin
On Wed, 22 Feb 2017 11:11:58 -0700, Lizette Koehler wrote:

>There is no one standard for Parmlib members and comments.
> 
If there were, it would violate Conway's Law.

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Lizette Koehler
There is no one standard for Parmlib members and comments.

You would need to see what the DB2 syntax is for this member.

Some SYS1.PARMLIB members will take comments and some will not.  It was 
dependent on the group (DB2 in this case) that created the process.

If it is modeled on a member like SCHEDxx then you might look at SCHEDxx syntax.

If you have not done so, you might want to post on the DB2 List.  To join, go 
to IDUG.ORG

Lizette


-Original Message-
>From: Juergen Kehr 
>Sent: Feb 22, 2017 10:16 AM
>To: IBM-MAIN@LISTSERV.UA.EDU
>Subject: Question about PARMDD
>
>Hello,
>
>since a while we're using the new PARMDD keyword for our DB2 subsystems.
>
>Here an example:
>//DB31MSTR PROC   
>//IEFPROC  EXEC PGM=DSNYASCP, 
>// PARMDD=ZPARMDD,
>// DYNAMNBR=119,  
>// REGION=0K, 
>// ACCT=(6590,DB31MSTR)   
>//STEPLIB  DD DISP=SHR,DSN=LNK.DSN.SDSNEXIT.RZ 
>//BSDS1DD DISP=SHR,DSN=RZ 
>//BSDS2DD DISP=SHR,DSN=RZ 
>//ZPARMDD  DD DISP=SHR,DSN=PP.DSN.PARMLIB(DB31MSTR)  
>
>Reason for doing so is, that we now can change the DB2 ZPARMS without any 
>changes in SYS1.PROCLIB (or another PROCLIB), we have to change the 
>PP.DSN.PARMLIB instead. SYS1.PROCLIB and PP.DSN.PARMLIB may have different 
>RACF profiles, what is the case in our installation.
>
>My question now is: Is it possible to have any comments in the PARMLIB member 
>(here: DB31MSTR)?
>
>The content now is ZPARM(DSNZP310),GROUP(DSNDB3),MEMBER(DB31)
>
>Thanks in advance for any help.
>
>Kind regards
>Juergen
>

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


Re: Question about PARMDD

2017-02-22 Thread Paul Gilmartin
On Wed, 22 Feb 2017 11:16:33 -0600, Juergen Kehr wrote:
>
>My question now is: Is it possible to have any comments in the PARMLIB member 
>(here: DB31MSTR)?
>
>The content now is ZPARM(DSNZP310),GROUP(DSNDB3),MEMBER(DB31)
>
You can make it a JCLLIB member to be included as an an instream data set
with content such as:

//ZPARMDD  DD  *
// DD  *
//* Comment for ZPARM
//DD  *
ZPARM(DSNZP310),
//* Comment for GROUP
// DD  *
GROUP(DSNDB3),
//* Comment for MEMBER
// DD  *
MEMBER(DB31)

But would you want to do that!?

IIRC, there's an infuriating syntactic inconsistency in that
comments may appear between catenands, except that they're
prohibited between the first and second catenand.  Grrr!  Why!?

(Or you can add short line comments on the various "DD *".)

And, since it's instream, you can even use system symbols!

I hate JCL!

-- gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN