Misplaced Pages

#124875

79-656: Early projects using PL/S were the batch utility, IEHMOVE , and the Time Sharing Option of MVT , TSO. By the 1970s, IBM was rewriting its flagship operating system in PL/S. Although users frequently asked IBM to release PL/S for their use, IBM refused, saying that the product was proprietary. Their concern was that open PL/S would give competitors, Amdahl , Itel (National Advanced Systems), Storage Technology Corporation , Trilogy Systems , Magnuson Computer Systems , Fujitsu , Hitachi , and other PCM vendors

158-739: A Roman numeral "I"). The first definition appeared in April 1964. IBM took NPL as a starting point and completed the design to a level that the first compiler could be written: the NPL definition was incomplete in scope and in detail. Control of the PL/I language was vested initially in the New York Programming Center and later at the IBM UK Laboratory at Hursley . The SHARE and GUIDE user groups were involved in extending

237-420: A PDS member containing control cards or a temporary data-set, if you wish. Example of using SYSIN files would be something like this: or this: IEBCOMPR compares records in sequential or partitioned data sets . The IEBCOMPR utility is used to compare two sequential or partitioned datasets . This data set comparison is performed at the logical record level. Therefore, IEBCOMPR is commonly used to verify that

316-555: A VSAM key-sequenced data set and copy an ISAM data set into it. IEBPTPCH ("PrinT and PunCH") prints or punches records from a sequential or partitioned dataset. PL/I PL/I ( Programming Language One , pronounced / p iː ɛ l w ʌ n / and sometimes written PL/1 ) is a procedural , imperative computer programming language initially developed by IBM . It is designed for scientific, engineering, business and system programming. It has been in continuous use by academic, commercial and industrial organizations since it

395-462: A backup copy of a data set is correct (exact match to the original). During processing, IEBCOMPR compares each record from each data set, one by one. If the records are unequal, IEBCOMPR lists the following information in the SYSOUT: When comparing sequential data sets, IEBCOMPR considers the data sets equal if the following conditions are met: For partitioned data sets , IEBCOMPR considers

474-603: A common level of PL/I language and aimed to replace the PL/I F compiler. The checkout compiler is a rewrite of PL/I F in BSL, IBM's PL/I-like proprietary implementation language (later PL/S ). The performance objectives set for the compilers are shown in an IBM presentation to the BCS. The compilers had to produce identical results – the Checkout Compiler is used to debug programs that would then be submitted to

553-542: A competitive advantage. However, even though they refused to make available a compiler, they shipped the PL/S source code to large parts of the OS to customers, many of whom thus became familiar with reading it. Closed PL/S meant that only IBM could easily modify and enhance the operating system. PL/S was succeeded by PL/S II, PL/S III and PL/AS (Programming Language/Advanced Systems), and then PL/X (Programming Language/Cross Systems). PL/DS (Programming Language/Distributed Systems)

632-494: A compiler backend named the VAX Code Generator (VCG) created by a team led by Dave Cutler . The front end was designed by Robert Freiburghouse, and was ported to VAX/VMS from Multics . It runs on VMS on VAX and Alpha , and on Tru64 . During the 1990s, Digital sold the compiler to UniPrise Systems , who later sold it to a company named Kednos. Kednos marketed the compiler as Kednos PL/I until October 2016 when

711-484: A condition prefix enabling or disabling a computational condition – e.g. (NOSIZE) ). Entry and label names may be single identifiers or identifiers followed by a subscript list of constants (as in L(12,2):A=0; ). A sequence of statements becomes a group when preceded by a DO statement and followed by an END statement. Groups may include nested groups and begin blocks. The IF statement specifies

790-474: A distinctive concise and readable syntax. Many principles and capabilities combined to give the language its character and were important in meeting the language's goals: The language is designed to provide sufficient facilities to be able to satisfy the needs of all programmers, regardless of what problems the language is being applied to. The summary is extracted from the ANSI PL/I Standard and

869-596: A group or a single statement as the THEN part and the ELSE part (see the sample program). The group is the unit of iteration. The begin block ( BEGIN; stmt-list END; ) may contain declarations for names and internal procedures local to the block. A procedure starts with a PROCEDURE statement and is terminated syntactically by an END statement. The body of a procedure is a sequence of blocks, groups, and statements and contains declarations for names and procedures local to

SECTION 10

#1732780878125

948-456: A joint effort of ECMA TC/10 and ANSI X3J1. A subset of the GY33-6003 document was offered to the joint effort by IBM and became the base document for standardization. The major features omitted from the base document were multitasking and the attributes for program optimization (e.g. NORMAL and ABNORMAL ). Proposals to change the base document were voted upon by both committees. In

1027-445: A limited subset of the PL/I language in addition to BASIC and a remote job entry facility. PL/C , a dialect for teaching, a compiler developed at Cornell University , had the unusual capability of never failing to compile any program through the use of extensive automatic correction of many syntax errors and by converting any remaining syntax errors to output statements. The language was almost all of PL/I as implemented by IBM. PL/C

1106-789: A long-time contributor to computer research and development (e.g., JOSS , the Rand tablet , WYLBUR ) and was an early pioneer in the definition and development of “packet switching” network technology ( Baran ).  Rand was also one of the early nodes on the Arpanet , the Defense Department’s precursor to the Internet . Rand’s interest in PL/S derived from extensive modifications that the Computation Center had made to IBM’s MVT operating system , including modifications to improve

1185-754: A major attempt to speed up PL/I code to compete with Fortran object code, PL/I F Release 5 does substantial program optimization of DO-loops facilitated by the REORDER option on procedures. A version of PL/I F was released on the TSS/360 timesharing operating system for the System/360 Model 67 , adapted at the IBM Mohansic Lab. The IBM La Gaude Lab in France developed "Language Conversion Programs" to convert Fortran, Cobol, and Algol programs to

1264-484: A number of schools built their own subsets of PL/I and their own interactive support. Examples are: In the 1960s and early 1970s, Allen-Babcock implemented the Remote Users of Shared Hardware (RUSH) time sharing system for an IBM System/360 Model 50 with custom microcode and subsequently implemented IBM's CPS , an interactive time-sharing system for OS/360 aimed at teaching computer science basics, offered

1343-435: A sequential dataset, or creates a partitioned dataset. Some of the tasks that IEBGENER can perform include the following: An example of an IEBGENER program to copy one dataset to another: For straight copy tasks, the sort program can often do these faster than IEBGENER. Thus many mainframe shops make use of an option that automatically routes such tasks to the sort ICEGENER program instead of IEBGENER. On some systems it

1422-475: A single pass over the partially-compiled program, usually held in memory. Aspects of the language were still being designed as PL/I F was implemented, so some were omitted until later releases. PL/I RECORD I/O was shipped with PL/I F Release 2. The list processing functions  – Based Variables, Pointers, Areas and Offsets and LOCATE-mode I/O  – were first shipped in Release 4. In

1501-540: A user. These programs are usually invoked via Job Control Language (JCL). They tend to use common JCL DD identifiers (in the OS, now z/OS operating systems) for their data sets: IDCAMS ("Access Method Services") generates and modifies Virtual Storage Access Method (VSAM) and Non-VSAM datasets. IDCAMS was introduced along with VSAM in OS/VS ; the "Access Method" reference derives from the initial "VSAM replaces all other access methods" mindset of OS/VS. IDCAMS probably has

1580-544: Is English-like and suited for describing complex data formats with a wide set of functions available to verify and manipulate them. In the 1950s and early 1960s, business and scientific users programmed for different computer hardware using different programming languages. Business users were moving from Autocoders via COMTRAN to COBOL , while scientific users programmed in Fortran , ALGOL , GEORGE , and others. The IBM System/360 (announced in 1964 and delivered in 1966)

1659-451: Is couched as a formal definition using a "PL/I Machine" to specify the semantics. It was the first programming language standard to be written as a semi-formal definition. A "PL/I General-Purpose Subset" ("Subset-G") standard was issued by ANSI in 1981 and a revision published in 1987. The General Purpose subset was widely adopted as the kernel for PL/I implementations. PL/I was first implemented by IBM, at its Hursley Laboratories in

SECTION 20

#1732780878125

1738-529: Is credited with ensuring PL/I had the CHARACTER data type. The language was first specified in detail in the manual "PL/I Language Specifications. C28-6571", written in New York in 1965, and superseded by "PL/I Language Specifications. GY33-6003", written by Hursley in 1967. IBM continued to develop PL/I in the late sixties and early seventies, publishing it in the GY33-6003 manual. These manuals were used by

1817-535: Is not known. The phase names of this PL/S compiler were the same as the corresponding phase names of IBM's PL/I Optimizer compiler, with the initial "I" (IBM) in each phase name being replaced by an initial "J" (Japan). All IBM copyright notices (source and object) within the modules were deleted to hide their true origin and ownership. IEHMOVE This article discusses support programs included in or available for OS/360 and successors . IBM categorizes some of these programs as utilities and others as service aids;

1896-572: Is possible to send email from a batch job by directing the output to the " SMTP " external writer . On such systems, the technique is as follows: It is also possible to attach files while sending the email from Mainframe. IEBIMAGE manipulates several types of definitions (AKA images ) for the IBM 3211 printer, IBM 3800 laser printing subsystem and the IBM 4248 printer. Common uses are for forms control buffers ( FCB s), character arrangement tables, character definitions and images of forms to be printed on

1975-542: Is specified, the entire namelist must be enclosed in parentheses. When coded with TYPE=POSITION, STEPNAME specifies the first job step to be placed in the output data set. Job steps preceding this step are not copied to the output data set. When coded with TYPE=INCLUDE or TYPE=EXCLUDE, STEPNAME specifies the names of job steps that are to be included in or excluded from the operation. For example, STEPNAME=(STEPA,STEPF-STEPL,STEPZ) indicates that job steps STEPA, STEPF through STEPL, and STEPZ are to be included in or excluded from

2054-437: Is terminated by a semi-colon. The maximum length of a statement is implementation defined. A comment may appear anywhere in a program where a space is permitted and is preceded by the characters forward slash, asterisk and is terminated by the characters asterisk, forward slash (i.e. /* This is a comment. */ ). Statements may have a label-prefix introducing an entry name ( ENTRY and PROCEDURE statements) or label name, and

2133-519: Is to contain a JOB statement and all job steps belonging to the job except those steps specified in the STEPNAME parameter. STEPNAME=(namelist) specifies the names of the job steps that you want to process. namelist can be a single job step name, a list of step names separated by commas, or a sequential range of steps separated by a hyphen (for example, STEPA-STEPE). Any combination of these may be used in one namelist. If more than one step name

2212-684: The Picture-for-arithmetic type is encoded within the picture-specification . The mode is specified separately, with the picture specification applied to both the real and the imaginary parts. Values are computed by expressions written using a specific set of operations and builtin functions, most of which may be applied to aggregates as well as to single values, together with user-defined procedures which, likewise, may operate on and return aggregate as well as single values. The assignment statement assigns values to one or more variables. There are no reserved words in PL/I. A statement

2291-553: The MVS operating system were used. RL/S is fully compatible with IBM’s PL/S II language.  This was assured by parsing many thousands of lines of IBM written PL/S code taken from the MVS distribution files.  The assembler language code produced by the Rand RL/S compiler is not identical to the code produced by IBM’s PL/S compiler, but it is functionally equivalent. Rand has been

2370-618: The Multics group and other early implementers. The first compiler was delivered in 1966. The Standard for PL/I was approved in 1976. The goals for PL/I evolved during the early development of the language. Competitiveness with COBOL's record handling and report writing was required. The language's scope of usefulness grew to include system programming and event-driven programming . Additional goals for PL/I were: To achieve these goals, PL/I borrowed ideas from contemporary languages while adding substantial new capabilities and casting it with

2449-690: The PL/I preprocessor are not in the Standard but are supported in the PL/I F compiler and some other implementations are discussed in the Language evolution section.) Names may be declared to represent data of the following types, either as single values, or as aggregates in the form of arrays, with a lower-bound and upper-bound per dimension, or structures (comprising nested structure, array and scalar variables): The arithmetic type comprises these attributes: The base, scale, precision and scale factor of

IBM PL/S - Misplaced Pages Continue

2528-527: The ANSI PL/I General-Purpose Subset Standard. A PL/I program consists of a set of procedures, each of which is written as a sequence of statements. The %INCLUDE construct is used to include text from other sources during program translation. All of the statement types are summarized here in groupings which give an overview of the language (the Standard uses this organization). (Features such as multi-tasking and

2607-458: The IBM scientific users group, to propose these extensions to Fortran. Given the constraints of Fortran, they were unable to do this and embarked on the design of a new programming language based loosely on ALGOL labeled NPL . This acronym conflicted with that of the UK's National Physical Laboratory and was replaced briefly by MPPL (MultiPurpose Programming Language) and, in 1965, with PL/I (with

2686-479: The Optimizer. Given that the compilers had entirely different designs and were handling the full PL/I language this goal was challenging: it was achieved. IBM introduced new attributes and syntax including BUILTIN , case statements ( SELECT / WHEN / OTHERWISE ), loop controls ( ITERATE and LEAVE ) and null argument lists to disambiguate, e.g., DATE () . The PL/I optimizing compiler took over from

2765-432: The PL/I F compiler and was IBM's workhorse compiler from the 1970s to the 1990s. Like PL/I F, it is a multiple pass compiler with a 44 kilobyte design point, but it is an entirely new design. Unlike the F compiler, it has to perform compile time evaluation of constant expressions using the run-time library, reducing the maximum memory for a compiler phase to 28 kilobytes. A second-time around design, it succeeded in eliminating

2844-469: The PL/I F level of PL/I. The PL/I D compiler, using 16 kilobytes of memory, was developed by IBM Germany for the DOS/360 low end operating system. It implements a subset of the PL/I language requiring all strings and arrays to have fixed extents, thus simplifying the run-time environment. Reflecting the underlying operating system, it lacks dynamic storage allocation and the controlled storage class. It

2923-658: The United Kingdom, as part of the development of System/360 . The first production PL/I compiler was the PL/I F compiler for the OS/360 Operating System, built by John Nash's team at Hursley in the UK: the runtime library team was managed by I.M. (Nobby) Clarke. The PL/I F compiler was written entirely in System/360 assembly language. Release 1 shipped in 1966. OS/360 is a real-memory environment and

3002-644: The University of New South Wales, PLUM by Marvin Victor Zelkowitz at the University of Maryland., and PLUTO from the University of Toronto. In a major revamp of PL/I, IBM Santa Teresa in California launched an entirely new compiler in 1992. The initial shipment was for OS/2 and included most ANSI-G features and many new PL/I features. Subsequent releases provided additional platforms ( MVS , VM , OS/390 , AIX and Windows ), but as of 2021,

3081-526: The University of Toronto produced the SP/k compilers which supported a sequence of subsets of PL/I called SP/1, SP/2, SP/3, ..., SP/8 for teaching programming. Programs that ran without errors under the SP/k compilers produced the same results under other contemporary PL/I compilers such as IBM's PL/I F compiler, IBM's checkout compiler or Cornell University's PL/C compiler. Other examples are PL0 by P. Grouse at

3160-499: The annoyances of PL/I F such as cascading diagnostics. It was written in S/360 Macro Assembler by a team, led by Tony Burbridge, most of whom had worked on PL/I F. Macros were defined to automate common compiler services and to shield the compiler writers from the task of managing real-mode storage, allowing the compiler to be moved easily to other memory models. The gamut of program optimization techniques developed for

3239-410: The boundaries are not always consistent or obvious. Many, but not all, of these programs match the types in utility software . The following lists describe programs associated with OS/360 and successors . No DOS , TPF or VM utilities are included. Many of these programs were designed by IBM users, through the group SHARE , and then modified or extended by IBM from versions originally written by

IBM PL/S - Misplaced Pages Continue

3318-706: The code into 28 kb sections, IBM Poughkeepsie was finally ready to ship virtual memory support in OS/360). It supported the batch programming environments and, under TSO and CMS, it could be run interactively. This compiler went through many versions covering all mainframe operating systems including the operating systems of the Japanese plug-compatible machines (PCMs). The compiler has been superseded by "IBM PL/I for OS/2, AIX, Linux, z/OS" below. The PL/I checkout compiler, (colloquially "The Checker") announced in August 1970

3397-416: The company ceased trading. In the late 1960s and early 1970s, many US and Canadian universities were establishing time-sharing services on campus and needed conversational compiler/interpreters for use in teaching science, mathematics, engineering, and computer science. Dartmouth was developing BASIC , but PL/I was a popular choice, as it was concise and easy to teach. As the IBM offerings were unsuitable,

3476-514: The compiler publicly.  Rand, however, continued to use the RL/S language and compiler internally for many projects. A fully compliant PL/S compiler was "developed" by Fujitsu Ltd in the late-1970s, adapting IBM's PL/I Optimizer compiler source code as its starting point. This PL/S compiler was used internally by Fujitsu, and also by Fujitsu's external affiliates. Whether or not IBM was aware of this unlicensed use of its licensed intellectual property

3555-506: The compiler was designed for systems with as little as 64 kilobytes of real storage – F being 64 kB in S/360 parlance. To fit a large compiler into the 44 kilobytes of memory available on a 64-kilobyte machine, the compiler consists of a control phase and a large number of compiler phases (approaching 100). The phases are brought into memory from disk, one at a time, to handle particular language features and aspects of compilation. Each phase makes

3634-417: The contemporary IBM Fortran H compiler were deployed: the Optimizer equaled Fortran execution speeds in the hands of good programmers. Announced with IBM S/370 in 1970, it shipped first for the DOS/360 operating system in August 1971, and shortly afterward for OS/360, and the first virtual memory IBM operating systems OS/VS1 , MVS , and VM/CMS . (The developers were unaware that while they were shoehorning

3713-500: The control statements, for example replacing a name field by random alphabetic text. The contents of each field may be varied for each record, for example by rotating the characters in an alphanumeric field left or right for each subsequent record. Example: IEBEDIT selectively copies portions of JCL. An example of an IEBEDIT program: In this example, data set xxxxx.yyyyy.zzzzz should contain job(s) (which should include steps named STEP5, STEP10, and STEP15). This IEBEDIT routine copies

3792-517: The copy operation, and rename or replace members. Some of the tasks that IEBCOPY can perform include the following: For the IEBCOPY utility , the required job control statements for a copy are as follows: The MYDD1 and MYDD2 DD statements are names chosen by the user for the partitioned input and output data sets, respectively; The defaults are SYSUT1 and SYSUT2. You can use any valid DDNAME for these two DD statements. These DDNAMEs are specified in

3871-446: The data sets equal if the following conditions are met: If ten unequal comparisons are encountered during processing, IECOMPR terminates with the appropriate message. Note: IEBCOMPR is not a very flexible or user-friendly compare program. It can't restrict the comparison to only certain columns, it can't ignore differences in white space, it doesn't tell you where in the record the difference occurs, and it halts after 10 differences. On

3950-490: The event that the committees disagreed, the chairs, initially Michael Marcotty of General Motors and C.A.R. Hoare representing ICL had to resolve the disagreement. In addition to IBM, Honeywell , CDC , Data General , Digital Equipment Corporation , Prime Computer , Burroughs , RCA , and Univac served on X3J1 along with major users Eastman Kodak , MITRE , Union Carbide , Bell Laboratories , and various government and university representatives. Further development of

4029-485: The final code then compiled by RL/S. The Rand RL/S language and compiler were publicly announced in August, 1976, at a Share meeting where numerous copies of the RL/S Language Reference Manual were distributed to attendees.  IBM quickly responded claiming the language was “proprietary”.  While Rand admitted no wrong doing in developing RL/S, Rand management agreed not to distribute

SECTION 50

#1732780878125

4108-580: The generated assembler level were easily obsoleted when IBM modified the PL/S source code and distributed re-generated assembler code. This was particularly true of modifications to PL/S generated data structures.  Rand, therefore, decided to develop its own version of a PL/S compiler to meet both operational objectives and contractual commitments. The RL/S compiler was initially written in PL/I and later converted to RL/S to improve performance. With few restrictions, RL/S programs could be developed using IBM’s PL/I compiler for preprocessing and debugging, with

4187-485: The language and had a role in IBM's process for controlling the language through their PL/I Projects. The experience of defining such a large language showed the need for a formal definition of PL/I. A project was set up in 1967 in IBM Laboratory Vienna to make an unambiguous and complete specification. This led in turn to one of the first large scale Formal Methods for development, VDM . Fred Brooks

4266-482: The language occurred in the standards bodies, with continuing improvements in structured programming and internal consistency, and with the omission of the more obscure or contentious features. As language development neared an end, X3J1/TC10 realized that there were a number of problems with a document written in English text. Discussion of a single item might appear in multiple places which might or might not agree. It

4345-415: The most functionality of all the utility programs, performing many functions, for both VSAM and non-VSAM files. The following example illustrates the use of IDCAMS to copy a dataset to disk. The dataset has 80-byte records, and the system will choose the block size for the output: In the example above, SYSIN control cards are coming from an in-stream file, but you can instead point to any sequential file or

4424-494: The need for operators to stop the printer and change paper. IEBISAM unloads, loads, copies and prints ISAM datasets. Extracted from IBM manual SC26-7414-08 z/OS DFSMSdfp Utilities: The IEBISAM program is no longer distributed. Starting in z/OS V1R7, ISAM data sets can no longer be processed (created, opened, copied or dumped). ISAM data sets that are still in use must be converted to VSAM key-sequenced data sets. Prior to z/OS V1R7, you could use access method services to allocate

4503-704: The only supported platforms are z/OS and AIX. IBM continued to add functions to make PL/I fully competitive with other languages (particularly C and C++) in areas where it had been overtaken. The corresponding "IBM Language Environment" supports inter-operation of PL/I programs with Database and Transaction systems, and with programs written in C, C++, and COBOL, the compiler supports all the data types needed for intercommunication with these languages. The PL/I design principles were retained and withstood this major extension, comprising several new data types, new statements and statement options, new exception conditions, and new organisations of program source. The resulting language

4582-455: The operating system with the intent of porting the hypervisor and other modifications to MVS. As is well documented , IBM, however, refused to provide its PL/S compiler to customers, claiming it was a significant competitive advantage.  Not having the compiler meant that neither competitors nor customers could modify the MVS code at the PL/S source level, and could only modify the generated assembler code.  However, modifications made at

4661-470: The operation. If STEPNAME is omitted, the entire input job whose name is specified on the EDIT statement is copied. If no job name is specified, the first job encountered is processed. NOPRINT specifies that the message data set is not to include a listing of the output data set. Default: The resultant output is listed in the message data set. See here for more info: [1] IEBGENER copies records from

4740-510: The other hand, it is fast, and it is present on all IBM mainframes. So it is very useful when an exact match is expected, such as comparing load modules that have not been reblocked, or checking that a copy worked properly. For comparisons of programs or reports, the ISPF SuperC (ISRSUPC) compare program is often used instead. IEBCOPY copies, compresses and merges partitioned data sets . It can also select or exclude specified members during

4819-408: The output along with the text, for company logos to be printed on the page, or just to print 'graybar' pages (alternating gray & white horizontal backgrounds, to match the previous greenbar paper ). With this utility, many different forms or logos could be stored as images, and printed when needed, all using the same standard blank paper, thus eliminating the need to stock many preprinted forms, and

SECTION 60

#1732780878125

4898-418: The output is to consist of a JOB statement, the job step specified in the STEPNAME parameter, and all steps that follow that job step. All job steps preceding the specified step are omitted from the operation. POSITION is the default. INCLUDE specifies that the output data set is to contain a JOB statement and all job steps specified in the STEPNAME parameter. EXCLUDE specifies that the output data set

4977-440: The output. Default: If START is omitted and only one EDIT statement is provided, the first job encountered in the input data set is processed. If START is omitted from an EDIT statement other than the first statement, processing continues with the next JOB statement found in the input data set. TYPE={POSITION|INCLUDE|EXCLUDE} specifies the contents of the output data set. These values can be coded: POSITION specifies that

5056-459: The performance of the Arpanet on its IBM 360 computer.  Because MVT did not process network interrupts quickly enough to handle the Arpanet traffic, a “ hypervisor ” was developed to allow Arpanet interrupts to be handled by specially written code while all other interrupts were handled by MVT.  When the MVS operating system was announced by IBM, Rand volunteered as an early “beta” site for

5135-499: The procedure or EXTERNAL to the procedure. An ON-unit is a single statement or block of statements written to be executed when one or more of these conditions occur: a computational condition , or an Input/Output condition, or one of the conditions: A declaration of an identifier may contain one or more of the following attributes (but they need to be mutually consistent): Current compilers from Micro Focus , and particularly that from IBM implement many extensions over

5214-504: The selected steps of the job onto the SYSUT2 output file (in this example, the internal reader). The syntax of the EDIT statement is: START=jobname specifies the name of the input job to which the EDIT statement applies. Each EDIT statement must apply to a separate job. If START is specified without TYPE and STEPNAME, the JOB statement and all job steps for the specified job are included in

5293-603: The standardized version of the language. The IBM extensions are summarised in the Implementation sub-section for the compiler later. Although there are some extensions common to these compilers the lack of a current standard means that compatibility is not guaranteed. Language standardization began in April 1966 in Europe with ECMA TC10. In 1969 ANSI established a "Composite Language Development Committee", nicknamed "Kludge", later renamed X3J1 PL/I. Standardization became

5372-428: The target address and a description of the referenced item, thus permitting "bad" pointer use to be diagnosed. In a conversational environment when an error is detected, control is passed to the user who can inspect any variables, introduce debugging statements and edit the source program. Over time the debugging capability of mainframe programming environments developed most of the functions offered by this compiler and it

5451-444: The utility control statements to tell IEBCOPY the name of the input and output data sets. You only need one DD statement for a PDS to be compressed. IEBDG ('Data Generator') creates test datasets consisting of patterned data. Control statements define the fields of the records to be created, including position, length, format, and initialization to be performed. IEBDG can use an existing dataset as input and change fields as specified in

5530-633: Was a closely related language used to develop the DPPX operating system, and PL/DS II was a port of the S/370 architecture for the DPPX/370 port. As the market for computers and software shifted away from IBM mainframes and MVS, IBM recanted and has offered the current versions of PL/S to select customers (ISVs through the Developer Partner program.) The Rand RL/S compiler for IBM’s PL/S language

5609-583: Was a very fast compiler. SL/1 (Student Language/1, Student Language/One or Subset Language/1) was a PL/I subset, initially available late 1960s, that ran interpretively on the IBM 1130 ; instructional use was its strong point. PLAGO , created at the Polytechnic Institute of Brooklyn , used a simplified subset of the PL/I language and focused on good diagnostic error messages and fast compilation times. The Computer Systems Research Group of

5688-400: Was designed as a common machine architecture for both groups of users, superseding all existing IBM architectures. Similarly, IBM wanted a single programming language for all users. It hoped that Fortran could be extended to include the features needed by commercial programmers. In October 1963 a committee was formed composed originally of three IBMers from New York and three members of SHARE ,

5767-509: Was designed to speed and improve the debugging of PL/I programs. The team was led by Brian Marks. The three-pass design cut the time to compile a program to 25% of that taken by the F Compiler. It can be run from an interactive terminal, converting PL/I programs into an internal format, "H-text". This format is interpreted by the Checkout compiler at run-time, detecting virtually all types of errors. Pointers are represented in 16 bytes, containing

5846-717: Was developed in the early 1970s by the Computation Center of the Rand Corporation in Santa Monica, CA.  It was implemented using the XPL compiler generator system by a team of three Rand programmers ( R. Lawrence Clark, James S. Reiley , and the team leader David J. Smith ).  The Rand RL/S compiler was developed independently of and without any assistance from IBM.  Only publicly available, non-copyrighted PL/S documentation and PL/S source and generated assembler code examples from IBM distributed source files for

5925-572: Was developed using the TMG compiler-compiler. The influential Multics PL/I compiler was the source of compiler technology used by a number of manufacturers and software groups. EPL was a system programming language and a dialect of PL/I that had some capabilities absent in the original PL/I. The Honeywell PL/I compiler (for Series 60) is an implementation of the full ANSI X3J1 standard. The PL/I Optimizer and Checkout compilers produced in Hursley support

6004-429: Was difficult to determine if there were omissions as well as inconsistencies. Consequently, David Beech (IBM), Robert Freiburghouse (Honeywell), Milton Barber (CDC), M. Donald MacLaren ( Argonne National Laboratory ), Craig Franklin (Data General), Lois Frampton (Digital Equipment Corporation), and editor, D.J. Andrews of IBM undertook to rewrite the entire document, each producing one or more complete chapters. The standard

6083-417: Was introduced in the 1960s. The PL/1 ANSI standard, X3.53-1976, was published in 1976. PL/I's main domains are data processing , numerical computation , scientific computing , and system programming . It supports recursion , structured programming , linked data structure handling, fixed-point , floating-point , complex , character string handling, and bit string handling. The language syntax

6162-409: Was shipped within a year of PL/I F. Compilers were implemented by several groups in the early 1960s. The Multics project at MIT , one of the first to develop an operating system in a high-level language , used Early PL/I (EPL), a subset dialect of PL/I, as their implementation language in 1964. EPL was developed at Bell Labs and MIT by Douglas McIlroy , Robert Morris , and others. Initially, it

6241-483: Was withdrawn (in the 1990s?) Perhaps the most commercially successful implementation aside from IBM's was Digital Equipment Corporation's VAX-11 PL/I, later known as VAX PL/I, then DEC PL/I. The implementation is "a strict superset of the ANSI X3.4-1981 PL/I General Purpose Subset and provides most of the features of the new ANSI X3.74-1987 PL/I General Purpose Subset", and was first released in 1980. It originally used

#124875