Mostrar código-fonte de PL/I

{{Info/Linguagem de computador
|nome            =PL/I
|logotipo        =
|ano             =1964
|criador         =[[IBM]] e o comitê de desenvolvimento de linguagens de programação SHARE
|tipagem         =procedural, imperativa, estruturada
|compiladores    =
|dialetos        =
|influenciada_por=[[COBOL]], [[Fortran]], [[ALGOL]]
|influenciou     =SP/k, [[B (linguagem de programação)|B]], [[REXX]], AS/400 Linguagem controle
|wikibooks       =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ência]]s, [[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.

Sua principal função é o processamento/manipulação de dados; suporta recursão e alocação dinâmica.<ref>{{citar livro|último =Sturm |primeiro =Eberhard |título=The New PL/I |publicado=Vieweg+Teubner |ano=2009 |isbn=978-3-8348-0726-7}}</ref>

== 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 ===
<pre>
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
</pre>

=== Operadores de comparação ===
<pre>
=	Igual

^=	diferente

>	maior

>=	maior ou igual

<	menor

<=	menor ou igual
</pre>

=== COMANDO "SELECT" ===
<pre>
SELECT (<campo>);
  WHEN (<valor> ou <condição>) --<comando>--;
  ...
  WHEN (<valor> ou <condição>) --<comando>--;
  OTHERWISE --<comando>--;
END;
</pre>

=== COMANDO "IF" ===
<pre>
IF --<condição>-- THEN --<comando>--;
                 ELSE --<comando>--;
</pre>

=== COMANDO "WHILE" ===
<pre>
DO WHILE (--CONDICAO--);
  --COMANDOS--;
END;
</pre>

== 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:
<pre>
IF IF = THEN THEN THEN = ELSE; ELSE ELSE = IF;
</pre>

== Exemplos de código ==
=== Procura por uma string ===
<pre>
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;
</pre>

=== Hello World ===
<pre>
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;
</pre>

=== N-Primeiros Números Perfeitos ===
<pre>
 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;
</pre>

=== Bubble Sort ===
<pre>
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;
</pre>

{{Referências}}

== Ligações externas ==
* {{Link||2=http://teampli.net/ |3=The PL/I Language}}
* {{Link||2=http://www.softpanorama.org/Lang/pl1.shtml |3=PL/1 Programming Language}}
* {{Link||2=http://members.dodo.com.au/~robin51/resource.htm |3=PL/I RESOURCES PAGE}}
* {{Link||2=http://members.dodo.com.au/~robin51/pli_faq.htm |3=PL/i FREQUENTLY-ASKED QUESTIONS}}
* {{Link||2=http://pl1gcc.sourceforge.net |3=PL1GCC project in SourceForge}}

{{Linguagens de programação}}

{{DEFAULTSORT:Pl/I}}
[[Categoria:Linguagens de programação]]
[[Categoria:Linguagens de programação procedurais]]
[[Categoria:IBM]]
[[Categoria:Linguagens de programação criadas na década de 1960]]