PL/I

(George Radin, IBM, 1964)

 

PL/I(Programming Language 1) je rozsiahly, komplexný blokovo štruktúrovaný jazyk vyvinutý firmou IBM a prvýkrát uvoľnený v roku 1964 v spojení s vplyvnou líniou počítačov 360.

PL/I mal byť všestranným jazykom pre sálové počítačové systémy a vývoj aplikácii. Preto mal veľkú množinu vlastností.

 

PL/I bol prevažne použitý IBM komunitou, a v skorých 80tich rokoch obsahoval PL/I nasledovné vlastnosti:

 

·        funkcie a procedúry

·        veľké množstvo numerických dátových typov

·        polia a záznamy

·        plnú množinu riadiacich štruktúr, vrátane rekurzie

·        znakové reťazce a manipuláciu s nimi

·        COBOL-style obrázkové formáty

·        stream, record, and formátovane I/O prostriedky

·        bitové reťazce

·        všeobecný

·        prerušenia (spôsob ošetrenia chýb)

·        dynamický správa pamäte

·        multi-tasking a asynchrónne udalosti

 

Programovací jazyk PL/1 je jazykom vyššej úrovne, avšak štúdium tohto jazyka poskytuje základy pre programovanie v jazyku nižšej úrovne (napríklad v asembleri).

 

IBM vynaložilo množstvo námahy vývojom optimálneho kompilátora pre PL/1. Množstvo výskumu na optimalizácii kompilátora pre tento jazyka bolo urobené na prelome 60tich a  70tich rokoch.

 

Budúcnosť PL/I vyzerala ružovo v roku, 1965 keď si team vybral tento jazyk, ako jazyk  Multics systému spolu s myšlienkou naprogramovania operačného systému vo vyššom programovacom jazyku. Dátové modely, procedurálne modely, dátové typy a run-time architektúra Multics-u boli navrhnuté podľa tých v PL/I, a všetky systémové API boli dané v PL/I. Použitie iných programovacích jazykov na systémové programovanie bolo zamietnuté. Rokmi boli niektoré kritické subsystémy prepracované do assemblera kvôli optimalizácií. Implementácia Multics PL/I (Bob Freiburghouse and Barry Wolman, vedúci architekti) obsahovala preukázateľne vynikajúcu implementáciu záznamov.

 

Dnes sú k dispozícií komerčné kompilátory pre IBM sálové počítače, PC bežiace na WindowsNT a OS/2, a aj pre niektoré UNIXové pracovné stanice. Žiadne free PL/1 kompilátory nie sú momentálne k dispozícií. ( aj keď jedného času bola podmnožina kompilátorov s názvom PL/C zadarmo)

 

Zaujímavosti:

PL/1 bol pokusom skombinovať najlepšie vlastnosti Algolu (programová štruktúra, sémantika), Fortranu(výpočty), a Cobolu (dátové štruktúry, I/O) do jedného nového, všestranného jazyka. Výsledkom bol veľmi komplexný jazyk, ale taký, ktorý ponúkal použitie najväčšiemu množstvu  účelov. Akokoľvek, komplexnosť jazyka a výsledná komplexnosť kompilátorov a ich diagnostiky spravila z písania a debugovania PL/1 kódu ťažkú vec pre mnohých užívateľov.

 

PL/1 bol vyvinutý v čase diernych štítkov, ale syntax jazyka je len nepatrne poškvrnená pravidlami stĺpcovo špecifického formátovania. Novšie verzie PL/1 sa zbavili tejto zastaralej vlastnosti diernych štítkov.

 

PL/C bol vyvinutý na Cornell University a tvoril podmnožinou PL/1. Hlavnou príčinou bolo, že kompilátor IBM/PL1 bol veľmi veľký a pomalý pre nasadenie pre študentov na programovanie. PL/C bol vyvíjaný a používaný na mnohých univerzitách.

 

 

Linky:

PL/I, jeho výber pre Multics a popis jednotlivých verzií.

http://www.multicians.org/pl1.html

FAQ PL/1, prehľad najnovších verzií

http://www.faqs.org/faqs/computer-lang/pli-faq/

Demo, Visual Age for PL/I for windows.

ftp://ftp.software.ibm.com/ps/products/pli/demos/ 
 
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Examples:

 

HELLO: PROCEDURE OPTIONS (MAIN);

 

  PUT SKIP LIST('HELLO WORLD!');

 

END HELLO;

 

 

SQUARE: PROCEDURE OPTIONS (MAIN);

 

   DECLARE I FIXED DECIMAL(5) INIT(1); 

 

   DO WHILE (I <= 10);

      PUT SKIP LIST(I**2);

      I = I + 1;

   END;

 

END SQUARE;

 

 

FINDSTRINGS: PROCEDURE OPTIONS(MAIN)

  /* READ A STRING, THEN PRINT EVERY */

  /* SUBSEQUENT LINE WITH A MATCH */

 

  DECLARE PAT VARYING CHARACTER(100),

          LINEBUF VARYING CHARACTER(100),

          (LINENO, NDFILE, IX) FIXED BINARY;

 

  NDFILE = 0; ON ENDFILE(SYSIN) NDFILE=1;

  GET EDIT(PAT) (A);

  LINENO = 1;

  DO WHILE (NDFILE=0);

    GET EDIT(LINEBUF) (A);

    IF LENGTH(LINEBUF) > 0 THEN DO;

      IX = INDEX(LINEBUF, PAT);

      IF IX > 0 THEN DO;

        PUT SKIP EDIT (LINENO,LINEBUF)(F(2),A)

      END;

    END;

    LINENO = LINENO   1;

  END;

END FINDSTRINGS;

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Hanojské veže:

 

*PROCESS langlvl(saa2) source;

*PROCESS not('ª') or('|');

*PROCESS limits(extname(31));

 

towers:proc options(main);

 

   /***************************************/

   /* Program variables                   */

   /***************************************/

   dcl tower(3, n )  ctl char(1);

 

   dcl tops(3)       fixed bin(31);

   dcl n             fixed bin(31);

   dcl nx            char(10) varying;

   dcl run_Again     char(1) varying;

   dcl jx            fixed bin(31);

   dcl moves         fixed bin(31);

   dcl alpha         char(*) value('abcdefghijklmnopqrstuvwxyz');

 

 

   /***************************************/

   /* On unit to handle non-numeric data. */

   /***************************************/

   on conversion

     begin;

       display( 'tower size must be numeric' );

       goto recover;

     end;

 

   recover:

     display( 'How big a tower do you want?') reply( nx );

 

   n = nx;

   if n < 2 then

     do;

       display( 'tower size must be at least 2' );

       goto recover;

     end;

   else;

   n = min(n,7);

 

   allocate tower;

 

   do jx = 1 to hbound(tower,2);

     tower(1,jx) = substr(alpha,jx,1);

   end;

   tops(1) = 1;

 

   tower(2,*) = '';

   tops(2) = hbound(tower,2) + 1;

 

   tower(3,*) = '';

   tops(3) = hbound(tower,2) + 1;

 

   moves = 0;

 

   call display_Towers;

 

   call Hanoi( hbound(tower,2),

               1,

               2,

               3 );

 

   put skip list( '' );

   put skip list( 'number of moves = ' || trim(char(moves)) );

 

   free tower;

 

   put skip;

   free tower;

 

   display('Do you want to specify a new tower size?')

      reply( run_Again );

 

   if run_Again = 'y' | run_Again = 'Y' then

     goto recover;

   else;

 

   /***************************************************/

   /* Use recursive algorithm to determine next move. */

   /***************************************************/

   Hanoi: proc( rings, from, using, to ) recursive;

 

     dcl ( rings, from, using, to ) fixed bin(31);

 

     if rings > 1 then

       call Hanoi( rings-1, from, to, using );

     else;

 

     tops(to) = tops(to) - 1;

     tower(to,tops(to)) = tower(from,tops(from));

     tower(from,tops(from)) = '';

     tops(from) = tops(from) + 1;

 

     moves = moves + 1;

 

     call display_Towers;

 

     if rings > 1 then

       call Hanoi( rings-1, using, from, to );

     else;

 

   end Hanoi;

 

 

   /***************************************************/

   /* Show the configuration of the 3 towers.         */

   /***************************************************/

   display_Towers: proc;

 

     dcl jx            fixed bin(31);

 

     put skip list( '' );

 

     do jx = 1 to hbound(tower,2);

       put skip list(    '   ' || tower(1,jx)

                      || '   ' || tower(2,jx)

                      || '   ' || tower(3,jx) );

     end;

 

     put skip list(    '   ' || '_'

                    || '   ' || '_'

                    || '   ' || '_' );

 

   end display_Towers;

 

 end towers;