Re: Question about PARMDD
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
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
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
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
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
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
[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
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
@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
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
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
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
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
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
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
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
">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
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
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
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
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
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
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
[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
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
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
[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
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
[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
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
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
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
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
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
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
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
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
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
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