Finished the Pascal text for Brazilian Portuguese.

Added some extra details about loops and if/else blocks

(modified pascal-pt.html.markdown)

pt-br/pascal-pt.html.markdown

@@ -6,8 +6,8 @@ contributors:
 ---
 
 
->Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. 
+>Pascal é uma linguagem de programação estruturada, que recebeu este nome em homenagem ao matemático e físico Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth,tendo em mente encorajar o uso de código estruturado. 
-source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language))
+fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa%C3%A7%C3%A3o))
 
 
 
@@ -22,102 +22,105 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um
 }
 
 //cabeçalho do programa
-program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra.
+PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra.
 
-const
+CONST
     {
         aqui você declara valores constantes
     }
-type
+TYPE
     {
         aqui você declara tipos não nativos
     }
-var
+VAR
     {
         aqui você declara variáveis
     }
 
 //programa de fato
-begin
+BEGIN
     {
         aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos
+		blocos de código começam com BEGIN e terminam com END (como as chaves em C)
     }
-end. //o "end" no final do programa requer um ponto final.
+END. //o "end" no final do programa requer um ponto final.
 ```
 
 ```pascal
 //formas de declarar uma variável
-var a:integer;
+VAR a:INTEGER;
-var b:integer;
+VAR b:INTEGER;
 
-var 
+VAR 
-    a : integer;
+    a : INTEGER;
-    b : integer;
+    b : INTEGER;
 
-var a,b : integer;
+VAR a,b : INTEGER;
 ```
 
 ```pascal
-program Learn_More;
+PROGRAM Learn_More;
 //agora, mais sobre tipos de dados e operações
 
-const
+CONST
     PI = 3.141592654;
     GNU = 'GNU''s Not Unix';
         // a convenção é usar caixa alta para constantes
         // constantes têm valores fixos que só podem ser alterados antes da compilação
         // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string)
 
-type
+TYPE
-    ch_array : array [0..255] of char;
+    vet_char : array [0..255] of CHAR;
-        // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres
+        // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres
-    md_array : array of array of integer;
+    vet_multd : array of array of INTEGER;
         // vetores de vetores são vetores multidimensionais
         // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica)
-        // vetores do tipo md_array são de duas dimensões
+        // vetores do tipo vet_multd são de duas dimensões
 
 //declarando variáveis
-var
+VAR
-    int, c, d  : integer;
+    int, c, d  : INTEGER;
            // três variáveis que guardam valores inteiros
            // inteiros têm 16 bits (vão de -32768 a 32767)
-    r    : real;
+    r    : REAL;
            // uma variável que guarda um valor real
            // reais vão de 3.4E-38 a 3.4E38
-    bool : boolean;
+    bool : BOOLEAN;
            // uma variável que guarda um valor booleano (verdadeiro ou falso)
-    ch   : char;
+    ch   : CHAR;
            // uma variável que guarda um caractere
            // caracteres têm 8 bits 
-    str  : string;
+    str  : STRING;
            // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores
            // string é um vetor de caracteres com tamanho padrão de 255 elementos
-    s    : string[50];
+    s    : STRING[50];
            // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória
-    my_str: ch_array;
+    my_str: vet_char;
            // aqui, uma variável de um tipo personalizado declarado acima
-    my_2d : md_array;
+    my_2d : vet_multd;
            // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados
 
+// outros tipos de dados (pascal é uma linguagem fortemente tipada)
+
     // tipos adicionais de inteiros
-    b    : byte;     // faixa [0..255]
+    b    : BYTE;     // faixa [0..255]
-    shi  : shortint; // faixa [-128..127]
+    shi  : SHORTINT; // faixa [-128..127]
-    smi  : smallint; // faixa [-32,768..32,767] (inteiro padrão)
+    smi  : SMALLINT; // faixa [-32,768..32,767] (inteiro padrão)
-    w    : word;     // faixa [0..65,535]
+    w    : WORD;     // faixa [0..65,535]
-    li   : longint;  // faixa [-2,147,483,648..2,147,483,647]
+    li   : LONGINT;  // faixa [-2,147,483,648..2,147,483,647]
-    lw   : longword; // faixa [0..4,294,967,295]
+    lw   : LONGWORD; // faixa [0..4,294,967,295]
-    c    : cardinal; // longword
+    c    : CARDINAL; // longword
-    i64  : int64;    // faixa [-9223372036854775808..9223372036854775807]
+    i64  : INT64;    // faixa [-9223372036854775808..9223372036854775807]
-    qw   : qword;    // faixa [0..18,446,744,073,709,551,615]
+    qw   : QWORD;    // faixa [0..18,446,744,073,709,551,615]
 
     // tipos adicionais de reais
-    rr   : real;     // faixa depende da plataforma (8 bits, 16 bits, etc)
+    rr   : REAL;     // faixa depende da plataforma (8 bits, 16 bits, etc)
-    rs   : single;   // faixa [1.5E-45..3.4E38]
+    rs   : SINGLE;   // faixa [1.5E-45..3.4E38]
-    rd   : double;   // faixa [5.0E-324 .. 1.7E308]
+    rd   : DOUBLE;   // faixa [5.0E-324 .. 1.7E308]
-    re   : extended; // faixa [1.9E-4932..1.1E4932]
+    re   : EXTENDED; // faixa [1.9E-4932..1.1E4932]
-    rc   : comp;     // faixa [-2E64+1 .. 2E63-1]
+    rc   : COMP;     // faixa [-2E64+1 .. 2E63-1]
 
-Begin
+BEGIN
     int := 1;// usa-se := para atribuir valores a variáveis
     r   := 3.14; 
     ch  := 'a';
@@ -128,13 +131,13 @@ Begin
     //aritmética
     int := 1 + 1; // int deixa de ser 1 e passa a ser 2
     int := int + 1; // int = 2 + 1 = 3;
-    int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora")
+    int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora")
-    int := 3 div 2; //int = 1
+    int := 3 DIV 2; //int = 1
-    int := 1 div 2; //int = 0
+    int := 1 DIV 2; //int = 0
 
-    bool := true or false; // bool = true
+    bool := true OR false; // bool = true
-    bool := false and true; // bool = false
+    bool := false AND true; // bool = false
-    bool := true xor true; // bool = false
+    bool := true XOR true; // bool = false
 
     r := 3 / 2; // usa-se a "/" para divisões entre inteiros
     r := int; // um real pode receber um valor inteiro (mas não o contrário)
@@ -144,65 +147,75 @@ Begin
 
     my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez)
 
-    setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 
+    // LAÇOS
-    for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes)
+	WHILE (ch != 'a') DO
-        for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa
+		BEGIN
+			writeln('ch é diferente de a');
+			IF (ch = 'c') THEN
+				writeln('ch é igual a c');
+		END;
+	
+	SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 
+    FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes)
+        FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa
         my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...]
 	
-End.
+
+END.
 ```
 
 ```pascal
-program Functional_Programming;
+PROGRAM programacao_com_funcoes;
 
-Var
+VAR
-    i, dummy : integer;
+    i, inutil : INTEGER;
 
 { OBS: diferença entre procedimento e função
 	função: realiza operações e retorna valor
 	procedimento: só realiza operações
 } 
 //declarando e descrevendo uma função
-function fatorial_recursiva(const a: integer) : integer;
+FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER;
 { calcula a! recursivamente }
 
 // pode-se declarar variáveis locais para funções e procedimentos
 // exemplo:
-// Var
+// VAR
-//    local_a : integer;
+//    local_a : INTEGER;
 
-Begin
+BEGIN
-    If a >= 1 Then
+	// obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila)
+    IF a >= 1 THEN
     // o valor de retorno é atribuído como se a função fosse uma variável
         fatorial_recursiva := a * fatorial_recursiva(a-1)
-    Else
+    ELSE
         fatorial_recursiva := 1;
-End; // o END de funções e procedimentos recebe ponto e vírgula
+END; // o END de funções e procedimentos recebe ponto e vírgula
 
 //declarando e descrevendo um procedimento 
-procedure salvainteiro(var i : integer; dummy : integer);
+PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER);
 { recebe entrada do usuário e salva na variável i
   passagem de valor:
 	por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa
-	por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas
+	por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas
 }
 
-Begin
+BEGIN
-    write('Insira um inteiro: '); //escreve sem quebrar linha
+    WRITE('Insira um inteiro: '); //escreve sem quebrar linha
-    readln(i); //lê i com quebra de linha
+    READLN(i); //lê i com quebra de linha
-    dummy := 4; // dummy não terá seu valor alterado fora do procedimento. 
+    inutil := 4; // inutil não terá seu valor alterado fora do procedimento. 
-End;
+END;
 
-Begin // programa principal
+BEGIN // programa principal
-    dummy := 3;
+    inutil := 3;
-    salvainteiro(i, dummy);
+    salvainteiro(i, inutil);
 
 	// escrevendo i! 
-    writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita
+    WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita
 
-    // escrevendo o valor de dummy
+    // escrevendo o valor de inutil
-    writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro
+    WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro
-End.
+END.
 
 ```