PL/I

PL/I (alternativamente PL/1, lê-se pê-ele-um) significa Programming Language One e é uma linguagem de programação desenvolvida pela IBM em meados de 1960. A previsão da IBM era que a linguagem fosse utilizada em ciências, inteligência artificial e negócios. Por um período de tempo foi a principal linguagem ensinada na Universidade de Michigan Dearborn. Entretanto, a popularidade declinou nos anos recentes, devido à introdução de línguagens de programação mais modernas voltadas para o ambiente Mainframe.

PL/I
Surgido em	1964
Criado por	IBM e o comitê de desenvolvimento de linguagens de programação SHARE
Estilo de tipagem	procedural, imperativa, estruturada
Influenciada por	COBOL, Fortran, ALGOL
Influenciou	SP/k, B, REXX, AS/400 Linguagem controle

Sua principal função é o processamento/manipulação de dados; suporta recursão e alocação dinâmica.^[1]

Principais características

• Linguagem de programação imperativa e estruturada, de controle e recursividade do ALGOL 60
• Fortemente tipada
• Subprogramas e E/S formatadas do FORTRAN
• Manipulação de arquivos e registros do COBOL
• Alocação dinâmica de memória e estruturas encadeadas do LISP
• Operações de arrays do APL

Contribuições de PL/I para futuras linguagens

• Tratamento de interrupção - execução de procedimentos específicos quando uma condição excepcional ocorre
• Multitarefa - especificação de tarefas que podem ser executadas concorrentemente

Sintaxe do comando PL/I

<instrução> ;

• Qualquer comando / comentário PL/I deverão ser codificados entre as colunas 2 a 72
• O término de qualquer comando PL/I é identificado por ponto e vírgula (;)
• Um comando PL/I poderá ser codificado em uma ou mais linhas
• Não há posição nem caracter para indicar a continuação de um comando PL/I
• O comentário em PL/I deverá estar codificado entre os caracteres "/*" (abre comentário) e os caracteres "*/" (fecha comentário)
• O comentário PL/I poderá ser condificado em qualquer ponto do fonte e poderá ser de uma ou mais linhas
• Não existem palavras reservadas no PL/I
• O ponto decimal no PL/I é sempre o ponto (.)

Estrutura padrão

LABEL:     PROC OPTIONS (MAIN) ;         Identificação do programa
    DECLARE    arquivos ,                    Declaração de variáveis
               campos ,
               PICTUREs de edição ,
               tabelas ,
               estruturas ,
               inicializações ,
               redefinições ,
               funções (BUILT-IN) ,
               rotinas externas;
    ON CONDITIONS ;                          Tratamento de condições
    COMANDOS ;                               Comandos / Instruções
      movimentações ;
      expressões ;
      concatenação ;
      condições ;
      LOOPs ;
      manipulação de arquivos ;
      manipulação de banco de dados ;
      chamadas de rotinas internas;
      chamadas de rotinas externas;
    COMANDOS ;
    ROT-LABEL: PROC ;                        Identificação da
                                             Sub-rotina interna
    END ROT-LABEL ;                          Finalização da
                                             Sub-rotina interna
    END LABEL ;                              Finalização do programa

Operadores de comparação

=	Igual

^=	diferente

>	maior

>=	maior ou igual

<	menor

<=	menor ou igual

COMANDO "SELECT"

SELECT (<campo>);
  WHEN (<valor> ou <condição>) --<comando>--;
  ...
  WHEN (<valor> ou <condição>) --<comando>--;
  OTHERWISE --<comando>--;
END;

COMANDO "IF"

IF --<condição>-- THEN --<comando>--;
                 ELSE --<comando>--;

COMANDO "WHILE"

DO WHILE (--CONDICAO--);
  --COMANDOS--;
END;

Nome de variáveis

O compilador PL/I permite usar variáveis que são consideradas "reservadas" em outras linguagens (como IF, ELSE, THEN,etc) e usa o mesmo símbolo('=') para verificar a igualdade e atribuição. Por exemplo:

IF IF = THEN THEN THEN = ELSE; ELSE ELSE = IF;

Exemplos de código

Procura por uma string

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;

Hello World

HELLO:   PROCEDURE OPTIONS (MAIN);

             /* A PROGRAM TO OUTPUT HELLO WORLD */
             FLAG = 0;

LOOP:     DO WHILE (FLAG = 0);
             PUT SKIP LIST('HELLO WORLD!');
          END;

END HELLO;

N-Primeiros Números Perfeitos

 program nperfeitos
 declare
 n,qtd,soma,contador,i,j: int;
 numeros: array[1..40] of int;

 begin
  display('Valor de N')
  reply(n);
  qtd=0;
  i=2;
   while qtd<n do
     begin
     soma=0;
     j=1;
     while j<i do
       begin
     if (i%j=0) then
       begin
         soma=soma+j;
       end;
     else
     j=j+1;
     endif;
     if (soma=i) then
       begin
         numeros[qtd+1]=i;
         qtd=qtd+1;
       end;
     else i=i+1;
     endif;
     for contador=1 to n do
     begin
      display(numeros[contador]);
 end;

Bubble Sort

SHELL:   PROCEDURE OPTIONS (MAIN);
         DECLARE
           ARRAY(50) FIXED BIN(15),
           (K,N) FIXED BIN(15);

         GET LIST(N);
         GET EDIT((ARRAY(K) DO K = 1 TO N));
         PUT EDIT((ARRAY(K) DO K = 1 TO N));
         CALL BUBBLE(ARRAY,N);

END BUBBLE;

BUBBLE:   PROCEDURE(ARRAY,N); /* BUBBLE SORT*/
          DECLARE (I,J) FIXED BIN(15);
          DECLARE S BIT(1);        /* SWITCH */
          DECLARE Y FIXED BIN(15); /* TEMPO */
          DO I = N-1 BY -1 TO 1;
            S = '1'B;
            DO J = 1 TO I;
              IF X(J)>X(J+1) THEN DO;
                S = '0'B;
                Y = X(J);
                X(J) = X(J+1);
                X(J+1) = Y;
                END;
              END;
            IF S THEN RETURN;
            END;
          RETURN;
          END SRT;

Referências

1. Sturm, Eberhard (2009). The New PL/I. [S.l.]: Vieweg+Teubner. ISBN 978-3-8348-0726-7