Turbo Pascal Forever – Statements
Antes de continuar o artigo sobre programação Pascal para plataformas old skool, primeiramente quero agradecer principalmente aos membros da comunidade nacional de MSX pelo feedback e apoio a essa série que está sendo desenvolvida e também à comunidade internacional de desenvolvedores Pascal, representados pelas novas gerações da linguagem, através do Delphi e Lazarus/FreePascal.
Below some individual thanks to community members by the support to this tutorial.
- Werner Kai, active member of the brazilian and international MSX scenary, thanks for the Pascal documentation, source code and software compilation, sent to me, specially by the HiSoft Pascal information for MSX.
- Embarcadero Development RAD Tools and Eliazer Kosciuk (Klax) on Twitter, thanks for the support to this tutorial, retwitting my Twitter messages.
Vamos ao que realmente interessa que é mão-na-massa, hands on, ….
Statements
Um Statement em sua tradução livre é definido como uma declaração mas prefiro defini-lo tecnicamente da mesma forma como faz o manual original da versão 3 do Turbo Pascal de 1983~86 e que descrevo abaixo.
Tradução do manual original da Borland
Turbo Pascal – The Ultimate Pascal Development Environment – Borland 1983~1986Um statement define a ação a ser executada pelo programa (ou sub-programa, ou sub-rotina) como uma sequencia de statements; cada uma especificando uma parte da ação.
Nesse sentido Pascal é uma linguagem de programação sequencial, ou seja, cada statement é executado sequencialmente um por vez, nunca simultâneamente. Um statement é encapsulado pelas palavras reservadas begin e end e dentro delas, statements são separadas por ponto e virgula (;).
Statements podem ser simples ou estruturados.
Claro que muita coisa mudou de lá pra cá, onde a tecnologia de hardware e a tecnologia de software evoluíram muito permitindo que tenhamos hoje um certo paralelismo, possibilitando a execução de statements simultaneamente, seja através de threads ou até mesmo paralelismo entre os diversos núcleos do processador, entretanto o conceito de execução sequencial de cada statement, em um módulo do programa, ou sub-programa, ainda é o mesmo até nas versões mais modernas de Pascal (Delphi, FreePascal, …), bem como na maioria das linguagens de alto e médio nível como Java e C.
Outro fator importante sobre os statements é que os mesmos podem ser categorizados como simples e estruturados.
Statements simples.
Entre os statements simples podemos citar o de atribuição, procedure e o statement vazio.
Segue abaixo os casos de statements simples.
Statement de atribuição.
O statement de atribuição é um simples comando de atribuição a uma variável, conforme pode ser visto no código fonte do exemplo a seguir:
nValue := 1000; { Integer assignment statement } strValue := 'This is a string assignment statement'; dValue := 10.45; { Real assignment statement } bValue := ( 1 = 2 ); { Boolean assignment statement } bEof := EOF;{ Boolean assignment statement from function EOF }
Procedure statement
Uma procedure statement tem a função de executar uma sub-rotina definida pelo usuário ou até mesmo uma sub-rotina builtin do Turbo Pascal.
WriteLn( 'This is a builtin procedure call statement' ); ClrScr; { Another builtin Turbo Pascal procedure statement } ClrEOL; { Another builtin Turbo Pascal procedure statement }
Statement vazio
Apesar de soar estranho, é possível ter um statement vazio, ou seja, que não executa nada. Segue abaixo alguns usos de statements vazios.
Begin End. { Empty block } While (True) Do; { Infinite loop } Repeat Until KeyPressed; { Wait for any key to be pressed }
Statements estruturados
Statements estruturados são construções compostas por outros statements, chamados de statements compostos, que podem ser executados em sequência, condicionalmente ou repetidamente.
Segue abaixo os statements estruturados.
Statements compostos
Um Statement composto é definido como um conjunto de outros statements simples ou compostos que estão sempre agrupados em blocos, no caso de Pascal um bloco é definido através das palavras reservadas begin e end, especificando assim que os statements serão executados na sequência em que eles foram escritos, sendo assim podemos afirmar que o próprio bloco principal de um programa em Pascal é um statement composto.
Abaixo alguns exemplos de statements compostos:
Program Test; Var bTest : Boolean; strTemp : String[255]; { Main block - In fact the main block is the major compound statement } Begin If( bTest = True ) Then Begin { This is a compound statement } strTemp := 'This is a compound statement test'; WriteLn( strTemp ); End Else { This is another compound statement } Begin strTemp := 'Another compound statement test'; WriteLn( strTemp ); End; End. { End of main block and the main compound statement }
Statements condicionais
É reconhecido que os computadores são máquinas extremamente lógicas e nada mais lógico que as linguagens de programação tenham ricos conjuntos de operações e possibilidades lógicas.
Turbo Pascal possui um conjunto moderno de statements dedicados a lógica condicional, possibilitando assim uma estruturação clara de grandes sistemas desenvolvidos na linguagem.
IF Statement
Assim como a maioria das linguagens de médio e alto nível, Pascal possui um statement dedicado a lógica condicional com duas opções de execução dependendo do resultado booleano de seu comparador.
A estrutura do statement IF é a seguinte:
IF boolean_expression THEN { Statement executed for true condition } ELSE { Statement to be executed for false condition - optional };
Onde boolean_expression é uma expressão lógica, ou booleana, a ser executada e caso a mesma tenha um resultado verdadeiro (True) o statement após o THEN será executado, caso contrário será executado o statement após o ELSE. Lembrando que o ELSE é opcional, ou seja, se o seu teste condicional não necessita executar nada para casos cuja expressão booleana testada não seja verdadeira (False), a condição do ELSE poderá ser suprimida do statement IF.
Vejamos alguns exemplos práticos de utilização do statement IF.
Program Test_IF; Var bValue1, bValue2 : Boolean; nValue : Integer; Begin bValue1 := True; bValue2 := False; nValue := 100; { If statement checking boolean values } If( bValue1 = bValue2 ) Then WriteLn( 'The boolean values are equals' ) Else WriteLn( 'The boolean values are different' ); { If statement checking integer values } If( nValue = 1000 ) Then WriteLn( 'The integer value is equal the constant value' ) Else WriteLn( 'The integer value is different of constant value' ); { If statement with only one execution condition } If( nValue = 100 ) Then WriteLn( 'The integer value is equal the constant value' ); End.
Uma observação muito importante é quanto a utilização do ; (ponto-e-virgula) no final do statement IF. Nunca devemos nos esquecer de que o ; (ponto-e-virgula) é um finalizador de statements, ou seja, deve estar presente no final de cada statement, seja simples ou composto.
No caso do IF, ele poderá estar apenas no fim do statement completo, ou seja, caso tenhamos um IF com as condição do ELSE além do THEN implementada, o ; (ponto-e-virgula) só poderá estar ao final do ELSE, uma vez que ele finaliza o statement IF nesse caso. Mas caso tenhamos apenas a condição do THEN implementada o ; (ponto-e-virgula) deverá estar após o statement seguinte ao THEN.
Abaixo alguns exemplos do uso do ; (ponto-e-virgula) finalizando o statement IF.
Program TEST_IF_2; Begin { If statement with optional ELSE } If( 1 = 2 ) Then WriteLn( 'Equals' ); If( 1 = 1 ) Then WriteLn( 'Equals' ) Else WriteLn( 'Not equals' ); End.
Outra observação é quanto ao uso combinado de um statement IF com statements compostos, como pode ser visto no exemplo abaixo.
Program TEST_IF_With_Compound_Statements; Begin If( True ) Then Begin { Start of the first compound statement } WriteLn( 'This is the first' ); WriteLn( 'compound statement' ); End Else Begin { Start of second compound statement } WriteLn( 'This is the second' ); WriteLn( 'compound statement' ); End; End.
CASE Statement
Outra estrutura condicional presente em Pascal, bem como na maioria das linguagens modernas, é o statement CASE que possibilita a comparação de uma expressão com diversas constantes de comparação, podendo ter assim especificadas diversas condições de execução de acordo com o valor da expressão de entrada.
A estrutura do statement CASE é a seguinte:
CASE expression OF constant1 : statement; constant2 : statament; . . . constantN : statament; ELSE statement { Optional }; END;
Onde expression é a expressão a ser comparada com cada constante especificada por constant1, constant2, …., constantN sendo que caso uma dessas constantes satisfaça a expressão, o statement associado à constante, após o : (dois pontos) será executado. Caso nenhuma das opções seja satisfeita, o statement após o ELSE será executado. Lembrando que assim como o ELSE do statement IF, o ELSE do statement CASE é opcional.
Abaixo temos um exemplo da utilização do CASE.
Program TEST_Case; Var nValue : Integer; Begin WriteLn( 'Digit a number between 0-3' ); Read( nValue ); Case ( nValue ) Of 0 : WriteLn( 'The number is 0' ); 1 : WriteLn( 'The number is 1' ); 2 : WriteLn( 'The number is 2' ); 3 : WriteLn( 'The number is 3' ); Else WriteLn( 'Number is not between 0-3' ); End; End.
Da mesma forma como no statement IF, podemos combinar o statement CASE com statements compostos, conforme pode ser visto no exemplo abaixo.
Program TEST_Case2; Var nValue : Integer; Begin WriteLn( 'Digit a number between 0-1' ); Read( nValue ); Case ( nValue ) Of 0 : Begin { The first compound statement in CASE statement } WriteLn( 'The number is 0' ); ReadLn; End; 1 : Begin { The second compound statement in CASE statement } WriteLn( 'The number is 1' ); ReadLn; End; End; End.
Statements de repetição.
Uma das estruturas interessantes e poderosas de Pascal são os statements de repetição que de fato são estruturas responsáveis pela execução cíclica de um ou mais statements até que uma condição booleana seja satisfeita, ou um contador tenha seu limite máximo atingido.
Em Pascal temos 3 statements de repetição distintos:
- Statement FOR;
- Statement WHILE;
- Statement REPEAT UNTIL;
Statement FOR.
O statement FOR é uma estrutura de repetição capaz de executar statements simples ou compostos por um determinado número de vezes tanto em ordem crescente quanto em ordem decrescente. É muito útil quando se conhece antecipadamente o limite máximo de repetições que se deseja executar.
A estrutura do statement FOR é a seguinte:
FOR count_variable := initial_value TO maximum_value DO execution_statement;
Onde count_variable é uma variável inteira a ser utilizada como contador e seu valor inicial será representado por initial_value, sendo incrementada em uma unidade, onde o statament representado por execution_statement será executado a cada iteração até que o limite de contagem, representado por maximum_value, seja atingido.
A segunda variação do statement FOR é a seguinte:
FOR count_variable := initial_value DOWNTO minimum_value DO execution_statement;
Sendo que a diferença entre essa última e a anterior é que ao invés de um contador crescente, temos um contador decrescente, representado pela palavra DOWNTO.
Segue abaixo alguns exemplos de repetição utilizando o statement FOR.
Program Test_Simple_FOR; Const ctMaxCount : Integer = 2000; { Maximum for loop counter } Var nCount : Integer; Begin For nCount := 0 To ctMaxCount Do { This is a simple FOR statement } WriteLn( 'Counting [', nCount, ']' ); End.
Outro exemplo do statement FOR, executando um statement composto.
Program Test_Compound_FOR; Const ctMaxCount : Integer = 2000; { Maximum for loop counter } Var nCount : Integer; Begin For nCount := 0 To ctMaxCount Do { This is a compound FOR statement } Begin WriteLn( 'Counting [' ); WriteLn( nCount ); WriteLn( ']' ); End; End.
Abaixo temos um exemplo do statement FOR com um contador decrescente.
Program Test_Decreasing_FOR; Const ctMinCount : Integer = 10; { Minimum limit for the FOR loop counter } Var nCount : Integer; Begin { This is a decreasing FOR statament } For nCount := 1000 DownTo ctMinCount Do WriteLn( 'Counting [', nCount, ']' ); End.
Statement WHILE.
Assim como o statement FOR, o statement WHILE é capaz de executar repetições de statements simples ou compostos. Entretanto a diferença primordial entre o statement FOR e o statement WHILE é que esse último é capaz de executar a repetição até que uma condição booleana seja satisfeita, podendo ser essa simples ou mais complexa.
A estrutura do statement WHILE é a seguinte:
WHILE boolean_condition DO execution_statement;
Onde boolean_condition é a condição booleana a ser satisfeita e execution_statement o statement a ser executado até que a condição boolean_condition seja satisfeita.
Vamos a alguns exemplos do uso do statement de repetição, WHILE.
Program Test_Simple_WHILE; Const ctMaxCount : Integer = 1000; Var nCount : Integer; Begin nCount := 0; { Increase the counter variable, nCount, while nCount is ‹ 1000 } While( nCount ‹ ctMaxCount ) Do nCount := nCount + 1; End.
Abaixo temos outro exemplo utilizando o statement WHILE, executando um statement composto onde a condição de parada é uma combinação booleana complexa.
Program Test_Complex_WHILE; Const ctMaxCount : Integer = 1000; Var nCount : Integer; bExit : Boolean; Begin nCount := 0; bExit := False; { This is a While with a more complex boolean checking exit } While( ( bExit = False ) And ( nCount ‹ ctMaxCount ) ) Do Begin If( nCount = 100 ) Then bExit := True; nCount := nCount + 1; End; End.
Statement REPEAT UNTIL;
Por ultimo vamos descrever o statement de repetição, REPEAT UNTIL, que assim como os statements FOR e WHILE, é capaz de executar statements simples e compostos e assim como o statement WHILE, é capaz de executar a repetição até que uma condição booleana seja satisfeita.
A grande diferença do statement REPEAT UNTIL para o WHILE é que o REPEAT UNTIL tem a checagem da condição de parada do loop executada ao fim de uma primeira iteração no loop de execução do statement, ou seja, teremos pelo menos uma execução do statement ou conjunto de statements do REPEAT UNTIL.
A estrutura do statement REPEAT UNTIL é a seguinte:
REPEAT execution_statement UNTIL boolean_condition;
Onde execution_statement é o statement ou conjunto de statements a ser executados até que a condição boolean_condition seja satisfeita.
Segue abaixo um exemplo do statement REPEAT UNTIL em ação.
Program Test_REPEAT_Until; Const ctMaxCount = 1000; Var nCount : Integer; bExit : Boolean; Begin nCount := 0; bExit := False; Repeat If( nCount = 100 ) Then bExit := True; nCount := nCount + 1; Until( ( bExit = True ) And ( nCount = ctMaxCount ) ); End.
Como podemos ver, a linguagem Pascal é rica de estruturas que facilitam e possibilitam o desenvolvimento de software de forma organizada e altamente estruturada, capacitando assim a construção de grandes sistemas escaláveis e de mais fácil manutenção.
Certamente daqui a 15 anos outro desenvolvedor poderá ler um código feito por você em Pascal e compreendê-lo com extrema facilidade devido a estrutura organizada, nativa de Pascal.
Por enquanto vou ficando por aqui deixando mais esse material para que possam se divertir até o post seguinte. 
[]‘s
PopolonY2k
Referência na internet
Embarcadero Delphi
http://www.embarcadero.com/br/products/delphi
Lazarus
http://www.lazarus.freepascal.org/
FreePascal
http://www.freepascal.org/
Embarcadero RAD Tools Dev team (Twitter)
http://twitter.com/#!/RADtools
Eliazer Kosciuk – Klax (Twitter)
http://twitter.com/#!/eliazerk
Twitter
http://twitter.com/#!/RADtools
e apesar de eu já ter dito que não irei focar em estruturas de dados, nesse caso, vou manter algo mais light no inicio….mas a pauleira começa a partir do próximo post. 
