Turbo Pascal MSX – Lezione 4

da | Nov 20, 2023 | Programmazione, Turbo Pascal | 0 commenti

MSX Turbo Pascal Rubrica a cura di Stefano Roperto (parte 4)

Lezione 4

Set di istruzioni

Le parole riservate sono parte integrante di Turbo Pascal. Non possono essere ridefinite, né usate come identificatori o nomi di variabili. Il Turbo Pascal è sostanzialmente il linguaggio Pascal standard rivisitato da Borland inc. Le parole riservate precedute dal simbolo * non sono parte del linguaggio Pascal standard e indicano le estensioni del linguaggio implementate da Borland per la gestione della memoria, per il meccanismo di Overlay, per la gestione delle stringhe e per l’inserimento di istruzioni  assembler direttamente nel codice

*external     Nil             *shl          and          file          not               *shr           Array     forward     *overlay
*string         begin         for           of             then        case             function    or           type           const
goto            packed      to            div           *inline      Procedure    until          do          if                 program
var              downto      in            record       while      else               label        repeat    with            end
mod            set            *xor

Oltre alle parole riservate, il Turbo Pascal fornisce un certo numero di identificatori, procedure, funzioni, costanti, tipi predefiniti e variabili. Di seguito l’elenco completo di tutti gli elementi del linguaggio. La maggior parte di questi non sono difficili da comprendere, in ogni caso li vedremo tutti proseguendo nel corso. Alcuni di questi elementi sono relativi ai file come per esempio BlockRead o SeekEof, altri servono per la manipolazione delle stringhe come per esempio Lenght o Concat, altri ancora come GetMem o MemAvail per la getione della memoria. Inoltre come si vede, sono definiti qui i tipi standard come integer, byte o char e alcune costanti come Pi che vale 3,14…

Addr                                  Delay                                  Length                           Real
ArcTan                              Delete                                 Ln                                  Release
Assign                               EOF                                    Lo                                  Rename
Aux                                   EOLN                                  LowVideo                       Reset
AuxInptr                            Erase                                  Lst                                  Rewrite
AuxOutPtr                         Execute                              LstOutPtr                        Round
BlockRead                        Exit                                     Mark                               Seek
BlockWrite                        Exp                                     MaxInt                             Sin
Boolean                            False                                  Mem                                SizeOf
BufLen                              FilePos                              MemAvail                         SeekEof
Byte                                  FileSize                              MemW                             SeekEoln
Chain                                FillChar                              Move                                Sqr
Char                                  Flush                                 New                                  Sqrt
Chr                                    Frac                                   NormVideo                       Str
Close                                GetMem                             Odd                                  Succ
ClrEOL                              GotoXY                              Ord                                   Swap
ClrScr                                Halt                                    Output                             Text
Con                                   HeapPtr                              Pi                                    Trm
ConInPtr                           Hi                                        Port                                 True
ConOutPtr                        IOresult                               PortW                              Trunc
Concat                              Input                                   Pos                                  UpCase
ConstPtr                           InsLine                                Pred                                 Usr
Copy                                 Insert                                   Ptr                                   UsrInptr
Cos                                   Int                                        Random                          UsrOutPtr
CrtExit                              Integer                                  Randomize                     Val
CrtInit                               Kbd                                       Read                               Write
DelLine                            KeyPressed                          ReadLn                            WriteLn

Come si vede la dotazione di procedure e funzioni utili alla programmazione è sufficientemente ampia, ma rimane sempre valido il fatto che è possibile ampliare ulteriormente il linguaggio definendo le proprie routines che possono essere salvate in file esterni da utilizzare, poi, nei propri programmi. Andiamo dunque a vedere nel dettaglio la struttura di un programma Turbo Pascal e quando le incontreremo negli esempi, la sintassi delle istruzioni del linguaggio.

Come abbiamo accennato nel secondo capitolo, il Turbo Pascal ha una struttura molto ordinata. Ogni programma è suddiviso in sezioni precise e in ognuna di queste sezioni si utilizzano costrutti precisi. Vediamoli nel dettaglio:

  1. intestazione del programma. Ogni programma in Pascal inizia con l’intestazione

               Program NomeDelProgramma(parametri);
               Program CalcoloProbabilità(input,output);
               Program Sparatutto(score,lives);

I parametri non sono obbligatori ma rispecchiano la sintassi del pascal standard.

  1. Dichiarazioni
    1. Dichiarazione di etichette o Label
    2. Dichiarazione di costanti o Const
    3. Dichiarazione di tipi o Type
    4. Dichiarazione di variabili o Var
    5. Dichiarazione di procedure e funzioni o Procedure e Function

 

Vediamo ora nel dettaglio la sezione dichiarativa.

Le etichette o label si utilizzano nei salti incondizionati ovvero con l’istruzione GOTO (che in realtà in un linguaggio strutturato ha poco senso).  Dopo la parola chiave Label si indicano le etichette separate da una virgola e concluse da un punto e virgola, ovviamente anche nelle label, dovrebbe valere la regola di utilizzare nomi significativi a beneficio della leggibilità del codice.

Label Uscita, 10, Aexuoi, 1addf,etichetta;

Nel programma, poi si inserisce l’etichetta nel punto desiderato seguita dai due punti:

program usoetichette;
label     Uscita;
var x,y:integer;
begin
for x:=1 to 10
begin
y:=y+x;
if (y<100) goto Uscita;
end;
end;
uscita: writeln(y);
end.

L’istruzione goto nel ciclo for fa uscire il programma dal ciclo secondo la condizione prima che questo arrivi alla fine. Per inciso, il turbo Pascal fornisce l’istruzione Exit che fa la stessa cosa in maniera più elegante.

 Le Costanti si definiscono utilizzando la parola chiave Const si utilizzano per definire valori costanti, ovvero che non cambiano mai nel corso del programma e il valore assegnato ne indica il tipo allo stesso modo in cui abbiamo visto nel capitolo 3 del corso. Potrebbero sembrare uguali alle variabili, ma in realtà vi sono differenze significative. Per esempio, una variabile definita all’interno di una procedura o di una funzione, non è visibile (utilizzabile) al di fuori della funzione o procedura nella quale è dichiarata, inoltre una costante non può essere modificata per cui è più sicura di una variabile, ma vediamo qualche esempio:

const
tasso = 3.56;                    {questa è una costante di tipo real}
unità = ‘Metro’;                 {questa è di tipo stringa}
indirizzo =$F5;                 {questa è un integer espresso in esadecimale}

l’utilizzo in un programma dovrebbe essere chiaro:
 
program usocostanti;
const    coefficiente = 3.5;
var
x:integer;
y:real;
begin
for x:=1 to 10
begin
y:=y+x*coefficiente;
writeln(y);
end;
end.

Se nelle specifiche del software, dovrebbe cambiare il coefficiente, basta cambiare il valore della costante, senza cercarne ogni occorrenza all’interno del programma. L’ambiente Turbo Pascal, fornisce alcune costanti predefinite tra le quali

Pi                         {il cui valore è 3.1415926536E+00}
Maxint                 {il cui valore è 32767}
False                   {il cui valore è il valore boolean per falso}
True                    {il cui valore è il valore boolean per vero}

Da notare che nella definizione che ne fa il compilatore  False < True.

La definizione dei tipi o Type è una caratteristica importante nella programmazione in Pascal, permette infatti di definire tipi complessi, partendo dai tipi primitivi (char, integer, real. Nella sezione Type si dichiarano variabili alle quali viene assegnato un tipo, inoltre diversi tipi di dato sono forniti dal compilatore oltre ai tipi standard. Vediamo alcuni esempi:

Type
Numero = integer;
nome = string[50];
EnumDay = (lun, mar, mer, gio, ven, sab, dom);
Successivamente, nella sezione di dichiarazione delle variabili possiamo utilizzare i tipi definiti qui allo stesso modo in cui utilizziamo i tipi standard, in questo modo:

Var
Ordinale:Numero;
persona:nome;
GiorniDellaSettimana:EnumDay;
e utilizzarli nel programma.

Infine eccoci alla definizione dei sottoprogrammi, che abbiamo già introdotto in precedenza, Procedure e Function. La definizione di una procedura o di una funzione segue esattamente lo stesso modello del programma, le uniche differenze sono le seguenti, al posto della parola program si utilizza la parola procedure o function e all’interno della procedura troveranno posto le sezioni label, const, type, var, procedure e function. Questa, come già detto è una caratteristica molto importante perché permette di dividere il programma in parti più piccole, ovvero di scomporre il problema in problemi più piccoli e con l’opportunità di poter passare e ottenere come risultati dei parametri. Ma analizziamo nel dettaglio le differenze tra una funzione e una procedura e vediamo da vicino la loro definizione e il loro utilizzo in un programma.

Una procedura, come detto si definisce tramite la parola procedure. Per esempio:

procedure AggiornaPosizioneSprite(modello : byte, CoordX, CoordY:integer)
label…
const…
type…
var…
procedure…
function… {Si! Una procedura, cosi come una funzione può definire al proprio interno altre procedure e funzioni}
 
begin
istruzioni che variano;
i valori di X e Y;
dello sprite;
numero modello;
end;

Nel programma principale poi si utilizzerà la procedura, come se fosse una normale istruzione del programma:

program game;
label…
const
nemico=10;
giocatore = 1;
palla=3;
type…
var
sprite:byte
X,Y : integer


Begin


{calcola in qualche modo i valori di posizione dello sprite}
X:=espressione;
Y:=espressione;
{e li aggiorna}
Sprite:=nemico; {qui si utilizza il valore di una costante}
AggiornaPosizioneSprite(sprite,X,Y);
{calcola in qualche modo i valori di posizione dello sprite}
X:=espressione;
Y:=espressione;
{e li aggiorna}
Sprite:=palla;
AggiornaPosizioneSprite(sprite,X,Y);


Resto del programma;
end.

Si capisce immediatamente come suddividere il programma in parti più piccole renda più efficace la programmazione la procedura può essere chiamata in ogni punto del programma con i parametri relativi all’azione che dobbiamo compiere. Ovviamente essendo una procedura, cosi come una funzione, un programma a se stante che compie una sola zione semplice, è compito del programmatore validare i dati in ingresso al fine di evitare errori durante l’ esecuzione del programma. Questo è importante soprattutto per le funzioni. Le funzioni si dichiarano come le procedure, con la differenza che restituiscono un valore nel nome ad esempio una funzione che converte gradi celsius in gradi kelvin avrebbe la seguente struttura:
function Celsius2Kelvin(gradi:real):real
{anche qui si possono dichiarare costanti, tipi, variabili, procedure, funzioni}
Const
Coeff = 273.15;
begin
Celsius2Kelvin:=gradi+coeff;
end;
la differenza tra una procedura e una funzione, dunque è che la procedura prende in input dei parametri e compie un’azione, mentre la funzione restituisce sempre un valore e deve essere parte di un’espressione, per esempio

temperatura := Celsius2Kelvin(15);
k:=5+(Celsius2Kelvin * 15)-(2*4+4) mod 15;
scrivere
Celsius2Kelvin(15)
senza che il valore venga utilizzato in un’espressione o in una istruzione di assegnamento, provocherà un errore.
Dunque una procedura è una porzione di programma che compie un’azione, mentre una funzione è una porzione di programma che restituisce un valore di un determinato tipo.

Dalla prossima lezione in avanti, cominceremo ad approfondire il linguaggio. Le fondamenta le abbiamo gettate, ora andremo un po’ più spediti, con qualche esempio un po’ più complesso cosi da introdurre gli argomenti nuovi, direttamente programmando.

 

0 commenti

Invia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Turbo Pascal MSX – Lezione 7

Turbo Pascal MSX – Lezione 7

I FILES (parte 1) Turbo Pascal fornisce un completo set di istruzione per la gestione dei file. Il tipo FILE è rappresentato da una sequenza di oggetti dello stesso tipo, la dimensione di  un file non è determinata dal tipo, ma viene fornito un puntatore che si sposta...

Turbo Pascal MSX – lezione 3

MSX Turbo Pascal Rubrica a cura di Stefano Roperto (parte 3) Capitolo 3 Il tipo di dati definisce l’insieme di valori che una variabile può assumere. I tipi di dati più complessi che possono essere definiti dal programmatore, derivano tutti dai tipi standard. I tipi...

Turbo Pascal MSX – lezione 2

MSX Turbo Pascal Rubrica a cura di Stefano Roperto (parte 2) Capitolo 2 Introduzione al linguaggio Turbo Pascal Vedremo ora come è strutturato un programma in Turbo Pascal. Non è necessario comprendere tutto in questo momento, stiamo solo vedendo la struttura tipica...

it_ITIT_IT