Open main menu
Home
Random
Recent changes
Special pages
Community portal
Preferences
About Wikipedia
Disclaimers
Incubator escapee wiki
Search
User menu
Talk
Dark mode
Contributions
Create account
Log in
Editing
PL/I
(section)
Warning:
You are not logged in. Your IP address will be publicly visible if you make any edits. If you
log in
or
create an account
, your edits will be attributed to your username, along with other benefits.
Anti-spam check. Do
not
fill this in!
==Implementations== {{See also|List of compilers#PL/I_compilers}} ===IBM PL/I F and D compilers=== PL/I was first implemented by IBM, at its [[Hursley Laboratories]] in 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.<ref name=Krasun>{{cite web|last1=Krasun|first1=Andy|title=The first 35+ years of Hursley software 1958-1993 with some hardware asides, a personal account|url=https://apsg.bcs.org/materials/presentations/20061026krasun.pdf|access-date=May 5, 2020}}</ref> Release 1 shipped in 1966. OS/360 is a real-memory environment and 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 a single pass over the partially-compiled program, usually held in memory.<ref>{{cite book|url=http://www.bitsavers.org/pdf/ibm/360/pli/Y28-6800-1_PL1(F)_PLM_Sep66.pdf|title=IBM System/360 Operating System PL/I (F) Compiler Program Logic Manual|id=Y28-6800-1|date=December 1966|publisher=IBM|at=Section 2: Compiler Phases}}</ref> 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<ref>These were designed in 1966 for an early Optimizing compiler, written in PL/I and to be bootstrapped starting with the PL/I F compiler</ref>{{snd}} Based Variables, Pointers, Areas and Offsets and [[LOCATE-mode I/O]]{{snd}} were first shipped in Release 4. In 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"<ref>There were many delays in shipping these, so a common PL/I joke at the time was that [[Charles de Gaulle|Gen de Gaulle]] forbade La Gaude from shipping them until the [[Concorde]] had its first flight</ref> to convert Fortran, Cobol, and Algol programs to 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.<ref>{{cite book|url=http://www.bitsavers.org/pdf/ibm/360/pli/C28-8202-0_PLIsubsetRM_1967.pdf|title=IBM System/360 PL/I Subset Reference Manual|id=C28-8202-0|date=1967|publisher=IBM}}</ref> It was shipped within a year of PL/I F. ===Multics PL/I and derivatives=== 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 programming language|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 (cryptographer)|Robert Morris]], and others.<ref name="MulticsPL1"/> Initially, it was developed using the [[TMG (language)|TMG]] compiler-compiler.<ref>{{cite web |editor=Tom Van Vleck |editor-link=Tom Van Vleck |url=https://multicians.org/pl1.html#EPL |title=The Choice of PL/I |website=Multicians.org}}</ref> The influential Multics PL/I compiler<ref name="MulticsPL1">{{cite web|url=http://www.multicians.org/pl1-raf.html|title=The Multics PL/1 Compiler|author=R. A. Frieburghouse|website=Multicians.org}}</ref> [sic "PL/1"] 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.<ref>{{cite book|publisher=[[Honeywell]]|title=Series 60 (Level 66)/6000 PL/I Reference Manual|id=Order No. DE05|year=1976}}</ref> ===IBM PL/I optimizing and checkout compilers=== The PL/I Optimizer and Checkout compilers produced in Hursley support a common level of PL/I language<ref name="gc33-0009-4">{{cite book|url=http://www.bitsavers.org/pdf/ibm/360/pli/GC33-0009-4_PLI_Checkout_And_Opt_Compiler_Lang_Ref_Oct76.pdf|title=OS PL/I Checkout and Optimizing Compilers: Language Reference Manual|id=GC33-0009-04|date=October 1976|publisher=IBM}}</ref> 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]]).<ref name=Krasun /> The performance objectives set for the compilers are shown in an IBM presentation to the BCS.<ref name=Krasun /> The compilers had to produce identical results{{snd}} the Checkout Compiler is used to debug programs that would then be submitted to 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 {{tt|BUILTIN}}, case statements ({{tt|SELECT}}/{{tt|WHEN}}/{{tt|OTHERWISE}}), loop controls ({{tt|ITERATE}} and {{tt|LEAVE}}) and null argument lists to disambiguate, e.g., <code>DATE'''()'''</code>. The PL/I optimizing compiler took over from 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 the annoyances of PL/I F such as cascading diagnostics.<ref name=CasD/> 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 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,<ref name=OptPLI.1971/> and the first virtual memory IBM operating systems [[OS/VS1]], [[MVS]], and [[VM/CMS]]. (The developers were unaware that while they were shoehorning 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|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,<ref>{{cite journal|title=A Conversational Compiler for Full PL/I|author=R. N. Cuff|journal=[[The Computer Journal]]|date=May 1972|volume=15|issue=2|pages=99β104|doi=10.1093/comjnl/15.2.99|doi-access=free}}</ref><ref>{{cite journal|title=The design of a checkout compiler|author=B. L. Marks|journal=[[IBM Systems Journal]]|volume=12|issue=3|pages=315β327|date=1973|doi=10.1147/sj.123.0315}}</ref> (colloquially "The Checker") announced in August 1970 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 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 was withdrawn (in the 1990s?) ===DEC PL/I=== 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.<ref>{{cite web|url=https://bitsavers.org/pdf/dec/vax/lang/pl1/AE-J971B-TE_VAX-11_PLI_1.0_SPD_198010.pdf|title=VAX-11 PL/I, version 1.0|date=October 1980|publisher=Digital|access-date=2023-10-31}}</ref><ref>''Uniprise PL/I for UNIX Reference Manual,'' Uniprise Systems, Inc., Irvine, California, 1995, p. xxi.</ref> It originally used a compiler backend named the VAX Code Generator (VCG) created by a team led by [[Dave Cutler]].<ref>{{cite newsgroup|url=http://compgroups.net/comp.os.vms/re-dave-cutler-and-vms-2/514577|archive-url=https://web.archive.org/web/20210614015421/https://compgroups.net/comp.os.vms/re-dave-cutler-and-vms-2/514577|url-status=usurped|archive-date=June 14, 2021|title=RE: Dave Cutler and VMS #2|date=2004-05-21|author=Tom Linden|newsgroup=comp.os.vms|access-date=2021-02-26}}</ref> The front end was designed by Robert Freiburghouse, and was ported to [[VAX/VMS]] from [[Multics]].<ref>{{cite interview |last1=Cutler|first1=Dave|subject-link=Dave Cutler|interviewer=Grant Saviers|title=Dave Cutler Oral History|url=https://www.youtube.com/watch?v=29RkHH-psrY |archive-url=https://ghostarchive.org/varchive/youtube/20211211/29RkHH-psrY |archive-date=2021-12-11 |url-status=live|publisher=Computer History Museum|date=2016-02-25|website=youtube.com|access-date=2021-02-26}}{{cbignore}}</ref> It runs on VMS on [[VAX]] and [[DEC Alpha|Alpha]], and on [[Tru64]]. During the 1990s, Digital sold the compiler to [[UniPrise Systems]], who later sold it to a company named Kednos.<ref>{{cite newsgroup|url=https://comp.answers.narkive.com/t33zEl7i/pl-i-frequently-asked-questions-faq|title=PL/I Frequently Asked Questions (FAQ)|author=Robin Vowels|date=2010-04-01|newsgroup=comp.answers}}</ref> Kednos marketed the compiler as Kednos PL/I until October 2016 when the company ceased trading.<ref name="kednos">{{cite web|archive-url=https://web.archive.org/web/20210314190741/https://www.kednos.com/|archive-date=2021-03-14|url=https://www.kednos.com/|title=Kednos PL/I for OpenVMS and Tru64|date=2016-11-02|access-date=2021-03-30|website=kednos.com}}</ref> ===Teaching subset compilers=== 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 College|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,<ref>{{cite web|url=http://plg.uwaterloo.ca/~holt/papers/fatal_disease.html|title=Teaching the Fatal Disease (or) Introductory Computer Programming Using PL/I|author=Richard C. Holt|date=November 5, 1972|access-date=May 30, 2010|archive-url=https://web.archive.org/web/20110415025435/http://plg.uwaterloo.ca/~holt/papers/fatal_disease.html|archive-date=April 15, 2011|url-status=live}}</ref> 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 '''[[Conversational Programming System|CPS]]''', an interactive time-sharing system for [[OS/360]] aimed at teaching computer science basics, offered 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.<ref>Department of Computer Science, ''User's Guide to PL/C - The Cornell Compiler for PL/I,'' Cornell University, Ithaca, 1977.</ref> PL/C was a very fast compiler. '''{{visible anchor|SL/1}}''' (Student Language/1, Student Language/One or Subset Language/1)<ref>{{cite web |url=http://teampli.net/plifamily.html#sli |title=SL/1 (Student Language/One)}}</ref><ref>{{cite web |url=http://www.bobspixels.com/kaibab.org/bob/ibm1130.htm |title=The IBM 1130 |website=BobsPixels.com}}</ref> 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<ref>''PLAGO/360 User's Manual,'' Polytechnic Institute of Brooklyn.</ref> and focused on good diagnostic error messages and fast compilation times. The Computer Systems Research Group of 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.<ref>J. N. P. Hume and R. C. Holt, ''Structured Programming using PL/I and SP/k,'' Reston, Reston, 1975.</ref> Other examples are '''PL0''' by P. Grouse at the University of New South Wales, '''PLUM''' by [[Marvin Victor Zelkowitz]] at the University of Maryland.,<ref>[[Marvin Victor Zelkowitz]], ''PL/I Programming with PLUM,'' 2nd Ed., Paladin House, Geneva (Ill.), 1978.</ref> and '''PLUTO''' from the University of Toronto. ===IBM PL/I for OS/2, AIX, Linux, z/OS=== 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.<ref name="pli-for-os2-acm">{{cite journal|title=PL/I for OS/2|author=Robin A. Vowels|journal=ACM SIGPLAN Notices|volume=31|issue=3|date=March 1996|pages=22β27|doi=10.1145/227717.227724|publisher=[[Association for Computing Machinery]]|s2cid=24441291|doi-access=free}}</ref> Subsequent releases provided additional platforms ([[MVS]], [[VM (operating system)|VM]], [[OS/390]], [[IBM AIX|AIX]] and [[Microsoft Windows|Windows]]), but as of 2021, the only supported platforms are [[z/OS]] and AIX.<ref>{{cite web |title=IBM PL/I Compiler Family |website=[[IBM]] |url=https://www.ibm.com/products/pli-compiler-family |access-date=5 July 2021}}</ref> 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 is a compatible super-set of the PL/I Standard and of the earlier IBM compilers. Major topics added to PL/I were: * New attributes for better support of user-defined data types β the <code>DEFINE ALIAS</code>, <code>ORDINAL</code>, and <code>DEFINE STRUCTURE</code> statement to introduce user-defined types, the <code>HANDLE</code> locator data type, the <code>TYPE</code> data type itself, the <code>UNION</code> data type, and built-in functions for manipulating the new types. * Additional data types and attributes corresponding to common PC data types (e.g., <code>UNSIGNED</code>, <code>VARYINGZ</code>). * Improvements in readability of programs β often rendering implied usages explicit (e.g., <code>BYVALUE</code> attribute for parameters) * Additional structured programming constructs. * Interrupt handling additions. * Compile time preprocessor extended to offer almost all PL/I string handling features and to interface with the Application Development Environment The latest series of PL/I compilers for z/OS, called Enterprise PL/I for z/OS, leverage code generation for the latest z/Architecture processors (z14, z13, zEC12, zBC12, z196, z114) via the use of ARCHLVL parm control passed during compilation, and was the second High level language supported by z/OS Language Environment to do so (XL C/C++ being the first, and Enterprise COBOL v5 the last.) ====Data types==== {{tt|ORDINAL}} is a new computational data type. The ordinal facilities are like those in [[Pascal (programming language)|Pascal]], e.g., {{code|DEFINE ORDINAL Colour (red, yellow, green, blue, violet);}} but in addition the name and internal values are accessible via built-in functions. Built-in functions provide access to an ordinal value's predecessor and successor. The {{tt|DEFINE}}-statement (see below) allows additional {{tt|TYPE}}s to be declared composed from PL/I's built-in attributes. The <code>HANDLE(data structure)</code> locator data type is similar to the {{tt|POINTER}} data type, but strongly typed to bind only to a particular data structure. The <code>=></code> operator is used to select a data structure using a handle. The {{tt|UNION}} attribute (equivalent to {{tt|CELL}} in early PL/I specifications) permits several scalar variables, arrays, or structures to share the same storage in a unit that occupies the amount of storage needed for the largest alternative. ====Competitiveness on PC and with C==== These attributes were added: * The string attributes <code>VARYINGZ</code> (for zero-terminated character strings), <code>HEXADEC</code>, <code>WIDECHAR</code>, and <code>GRAPHIC</code>. * The optional arithmetic attributes <code>UNSIGNED</code> and <code>SIGNED</code>, <code>BIGENDIAN</code> and <code>LITTLEENDIAN</code>. <code>UNSIGNED</code> necessitated the <code>UPTHRU</code> and <code>DOWNTHRU</code> option on iterative groups enabling a counter-controlled loop to be executed without exceeding the limit value (also essential for <code>ORDINAL</code>s and good for documenting loops). * The <code>DATE(pattern)</code> attribute for controlling date representations and additions to bring time and date to best current practice. New functions for manipulating dates include{{snd}} <code>DAYS</code> and <code>DAYSTODATE</code> for converting between dates and number of days, and a general <code>DATETIME</code> function for changing date formats. New string-handling functions were added{{snd}} to centre text, to edit using a picture format, and to trim blanks or selected characters from the head or tail of text, <code>VERIFYR</code> to <code>VERIFY</code> from the right. and <code>SEARCH</code> and <code>TALLY</code> functions. Compound assignment operators a la C e.g., <code>+=</code>, <code>&=</code>, <code>-=</code>, <code>||=</code> were added. <code>A+=1</code> is equivalent to <code>A=A+1</code>. Additional parameter [[Data descriptor|descriptors]] and attributes were added for omitted arguments and variable length argument lists. ====Program readability β making intentions explicit==== The {{tt|VALUE}} attribute declares an identifier as a constant (derived from a specific literal value or restricted expression). Parameters can have the {{tt|BYADDR}} (pass by address) or {{tt|BYVALUE}} (pass by value) attributes. The {{tt|ASSIGNABLE}} and {{tt|NONASSIGNABLE}} attributes prevent unintended assignments. <code>DO FOREVER;</code> obviates the need for the contrived construct {{code|DO WHILE ( '1'B );|rexx}}. The {{tt|DEFINE}}-statement introduces user-specified names (e.g., {{tt|INTEGER}}) for combinations of built-in attributes (e.g., <code>FIXED BINARY(31,0)</code>). Thus <code>DEFINE ALIAS INTEGER FIXED BINARY(31.0)</code> creates the {{tt|TYPE}} name {{tt|INTEGER}} as an alias for the set of built-in attributes FIXED BINARY(31.0). <code>DEFINE STRUCTURE</code> applies to structures and their members; it provides a {{tt|TYPE}} name for a set of structure attributes and corresponding substructure member declarations for use in a structure declaration (a generalisation of the {{tt|LIKE}} attribute). ====Structured programming additions==== A {{tt|LEAVE}} statement to exit a loop, and an {{tt|ITERATE}} to continue with the next iteration of a loop. {{tt|UPTHRU}} and {{tt|DOWNTHRU}} options on iterative groups. The package construct consisting of a set of procedures and declarations for use as a unit. Variables declared outside of the procedures are local to the package, and can use {{tt|STATIC}}, {{tt|BASED}} or {{tt|CONTROLLED}} storage. Procedure names used in the package also are local, but can be made external by means of the {{tt|EXPORTS}} option of the {{tt|PACKAGE}}-statement. ====Interrupt handling==== The {{tt|RESIGNAL}}-statement executed in an ON-unit terminates execution of the ON-unit, and raises the condition again in the procedure that called the current one (thus passing control to the corresponding ON-unit for that procedure). The {{tt|INVALIDOP}} condition handles invalid operation codes detected by the PC processor, as well as illegal arithmetic operations such as subtraction of two infinite values. The {{tt|ANYCONDITION}} condition is provided to intercept conditions for which no specific ON-unit has been provided in the current procedure. The {{tt|STORAGE}} condition is raised when an {{tt|ALLOCATE}} statement is unable to obtain sufficient storage. ===Other mainframe and minicomputer compilers=== A number of vendors produced compilers to compete with IBM PL/I F or Optimizing compiler on mainframes and minicomputers in the 1970s. In the 1980s the target was usually the emerging ANSI-G subset. * In 1974 [[Burroughs Corporation]] announced PL/I for the B6700 and B7700.<ref>Burroughs Corporation, ''B 6700/B 7700: PL/I Language Reference Manual,'' Reference 5001530, Detroit, 1977.</ref> * [[UNIVAC]] released a UNIVAC PL/I,<ref>Sperry-Univac Computer Systems, ''Sperry-Univac 1100 Series PL/I Programmer Reference,'' Reference UP-8277, 1976.</ref> and in the 1970s also used a variant of PL/I, PL/I PLUS, for system programming. * From 1978 [[Data General]] provided PL/I on its [[Data General Eclipse|Eclipse]] and [[Data General Eclipse|Eclipse MV]] platforms running the [[Data General AOS|AOS]], [[AOS/VS]] & [[AOS/VS II]] operating systems.<ref>Data General Corporation, ''AOS PL/I Reference Manual,'' Order No. 093-000204, c. 1978.</ref> A number of operating system utility programs were written in the language. * Paul Abrahams of NYU's Courant Institute of Mathematical Sciences wrote CIMS PL/I in 1972 in PL/I, bootstrapping via PL/I F. It supported "about 70%" of PL/I compiling to the CDC 6600<ref>{{cite conference |last1=Abrahams |first1=Paul W. |title=The CIMS PL/I compiler |conference=1979 SIGPLAN symposium on Compiler construction |pages=107β116 |doi=10.1145/800229.806960 |isbn=0-89791-002-8 |doi-access=free}}</ref> * [[Control Data Corporation|CDC]] delivered an optimizing subset PL/I compiler for Cyber 70, 170 and 6000 series.<ref>Control Data Corporation, ''PL/I Reference Manual,'' 1978, Publication No. 60388100A.</ref> * Fujitsu delivered a PL/I compiler equivalent to the PL/I Optimizer. * Stratus Technologies PL/I is an ANSI G implementation for the [[Stratus VOS|VOS]] operating system.<ref>{{cite book|title=OpenVOS PL/I Language Manual (R009)|publisher=[[Stratus Computer|Stratus Computer, Inc.]]|location=[[Marlboro, Massachusetts]]|year=1995|url=http://stratadoc.stratus.com/vos/19.0.0/r009-05/index.html?context=r009-05&file=ch1r009-05.html|at=OpenVOS PL/I}}</ref> * [[IBM Series/1]] PL/I<ref name=S1PliIntro>{{cite book |title=IBM Series/1 PL/I Introduction Program Numbers 5719-PL1 5719-PL3 |id=GC34-0084-0 |date=February 1977 |edition=1st |url=http://bitsavers.org/pdf/ibm/series1/GC34-0084-0_PL_I_Introduction_Feb77.pdf |publisher=IBM }} </ref><ref>{{cite book |title=IBM Series/1 PL/I: Language Reference Manual |id=GC34-0085-0 |publisher =IBM }} </ref> is an extended subset of ANSI Programming Language PL/I (ANSI X3.53-1976) for the IBM Series/1 Realtime Programming System. ===PL/I compilers for Microsoft .NET=== * In 2011, Raincode designed a full legacy compiler for the [[Microsoft .NET]] and [[.NET Core]] platforms, named The Raincode PL/I compiler. ===PL/I compilers for personal computers and Unix=== * {{anchor|PL/I-80|PL/I-86}}In the 1970s and 1980s [[Digital Research]] sold a PL/I compiler for [[CP/M]] (PL/I-80), [[CP/M-86]] (PL/I-86) and Personal Computers with [[DOS]]<!-- PLI-86 -->.<ref name="norton-chronicles">{{cite magazine|title=The Norton chronicles|author=Peter Norton|author-link=Peter Norton|magazine=[[PC Magazine]]|date=May 15, 1984|url=http://members.dodo.com.au/~robin51/norton.htm|access-date=January 25, 2010|archive-date=July 6, 2011|archive-url=https://web.archive.org/web/20110706103943/http://members.dodo.com.au/~robin51/norton.htm|url-status=dead}}</ref> It was based on Subset G of PL/I<ref name="norton-chronicles"/> and was written in [[PL/M]]. * [[Micro Focus]] implemented Open PL/I for Windows<ref>{{cite web|url=https://www.microfocus.com/media/brochure/whats-new-in-studio-and-server_tcm6-8231.pdf|title=What's New in Studio and Server Enterprise Edition 6.0 Service Pack 2 - Wrap Pack 1|page=1|website=[[Micro Focus]]|archive-url=https://web.archive.org/web/20171107025457/https://www.microfocus.com/media/brochure/whats-new-in-studio-and-server_tcm6-8231.pdf|archive-date=November 7, 2017|url-status=dead}}</ref> and UNIX/Linux systems,<ref>{{cite web|url=http://documentation.microfocus.com/help/topic/com.microfocus.eclipse.infocenter.studee60ux/GUID-D3FC9AD2-25B7-47E6-8011-B67644AE987D.html?cp=3_15_0_2_0_0_0|title=Enterprise > Micro Focus Studio Enterprise Edition for UNIX > Welcome > Product Information > Installing Studio Enterprise Edition for UNIX > System Requirements|website=Micro Focus|access-date=2017-11-05|archive-url=https://web.archive.org/web/20171107014253/http://documentation.microfocus.com/help/topic/com.microfocus.eclipse.infocenter.studee60ux/GUID-D3FC9AD2-25B7-47E6-8011-B67644AE987D.html?cp=3_15_0_2_0_0_0|archive-date=2017-11-07|url-status=dead}}</ref> which they acquired from Liant. * IBM delivered PL/I for [[OS/2]]<ref name="pli-for-os2-acm"/> in 1994, and PL/I for AIX in 1995.<ref name="pli-for-aix">{{cite web |title=IBM PL/I Set for AIX Version 1 |date=19 September 1995 |url=https://www-01.ibm.com/common/ssi/ShowDoc.wss?docURL=/common/ssi/rep_ca/4/897/ENUS295-394/index.html&lang=en&request_locale=en |access-date=13 May 2019}}</ref> * Iron Spring PL/I for [[OS/2]] and later [[Linux]] was introduced in 2007.<ref>{{cite web|url=http://www.iron-spring.com/prog_guide.html|title=Iron Spring PL/I Compiler - Programming Guide|date=2020-09-15|access-date=2021-02-26|website=ironspring.com}}</ref> * [[GNU Compiler Collection|GCC]] (pl1gcc) front end;<ref>{{cite web|url=https://gcc.gnu.org/frontends.html|title=Programming Languages Supported by GCC|access-date=2014-06-23|publisher=GNU Project|archive-date=January 18, 2023|archive-url=https://web.archive.org/web/20230118185814/https://gcc.gnu.org/frontends.html|url-status=live}}</ref> the project's last release was in September 2007.<ref>{{cite web |url=https://pl1gcc.sourceforge.net |title=PL/I front-end for GNU Compiler Collection}}</ref>
Edit summary
(Briefly describe your changes)
By publishing changes, you agree to the
Terms of Use
, and you irrevocably agree to release your contribution under the
CC BY-SA 4.0 License
and the
GFDL
. You agree that a hyperlink or URL is sufficient attribution under the Creative Commons license.
Cancel
Editing help
(opens in new window)