Module Learn Pascal du Texas Instruments TI 74 Basicalc

Cet article est paru originellement dans le n° 10 de la Gazette des Pocketicaires du forum MySilicium. La Gazette des Pockiticaires est une revue traitant des calculatrices et ordinateurs de poches des années 70 et 80 mais pas que. Apparemment c'est la seule revue de ce genre au monde .... et même sûrement de tout l'Univers voire du multivers.

La plupart des pockets parlent Basic, un plus petit nombre parle aussi le C voire un Assembler. Mais combien parlent le Pascal ?

A vrai dire. Deux à ma connaissance. Le Casio PB 2000c et le TI 74 muni de son module « Learn Pascal » (‘Apprends le Pascal’ pour ceux qui ne maîtrisent pas la langue de l’inspecteur Barnaby).Ah le Pascal ! Non pas l’ancien billet de 500 FRF (environ 75 Euros  pour les djeun’s qui n’auraient pas connu le Franc Français) mais un langage de programmation créé par Niklaus Wirth dans les années 70. Ce langage a été mon langage de prédilection pendant des années avec ses déclinaisons qu’ont été le Turbo Pascal puis Delphi. Je l'ai connu au milieu des années 80 grâce au Turbo Pascal (version étudiants) sous CP/M qui tournait sur l'Amstrad CPC 6128 de mon petit frère. Je trouvais le Pascal à la fois simple à apprendre (il a été conçu pour être un langage d’enseignement), élégant et puissant ; ce qui n’était pas l’avis de tout le monde.

En effet, durant les années 80 une guéguerre opposait les partisans du Pascal à ceux du langage C. Désormais on sait que c’est C qui a gagné avec ses évolutions qu'ont été C++ et C# voire PHP mais à l’époque ce n’était pas aussi évident. Les détracteurs du Pascal disaient que le langage C permettait d’écrire des programmes plus performants car il était plus proche du langage machine et les partisans rétorquaient que le langage C avait été écrit pour un système qui était basé sur l’architecture d’un microprocesseur bien spécifique et par conséquent sur d’autres systèmes, comme les architectures Intel, il n’était pas plus proche de la machine qu’une implémentation d’un Pascal et que donc tout dépendait de la façon dont le compilateur avait été écrit. Car les programmes écrits dans ces langages, contrairement à la plupart des Basic de l’époque, étaient compilés pour produire un exécutable autonome et non pas interprétés au moment de l’exécution.

La boîte contient le module, le guide utilisateur, le manuel de référence, un overlay et son guide de références rapide. Le tout est en Anglais. Une fois le module inséré dans la machine, le langage Pascal est lancé via la commande RUN « PASCAL ». S’il y a un programme Basic en mémoire le module demande s’il faut l’effacer ou pas.  Il vaut mieux répondre Y parce que sinon … et bien ... pas de Pascal. A partir de ce moment et tant que la commande BYE n’aura pas été exécutée le TI 74 démarrera directement sur le Pascal si le module est présent et n’acceptera plus la saisie d’un programme en Basic si le module est absent. C’est fromage ou dessert. Tenez-vous le pour dit !

Le module date de 1985

Le Pascal présent dans le module est un sous-ensemble du Pascal UCSD (Université de Californie et San Diego) très en vogue à la fin des années 70 et au début des années 80 notamment sur Apple II.

Il est interprété et non pas compilé. Cela se comprend puisque qu’il y a peu de mémoire vive (7.668 octets en l'occurrence selon la fonction MEMAVAIL).
Mais même si le module est destiné à un pocket, ce n’est pas un langage au rabais. Tous les concepts du Pascal sont présents. Il y a les constantes, les types, les structures, les procédures, les fonctions, la programmation structurée (while, repeat-until, case, etc..), les variables locales, le passage de paramètres par valeur ou par référence, la récursivité, la gestion de fichiers (même si je n’en comprends pas l’utilité avec un lecteur de K7 sauf pour la sauvegarde des programmes) et même le GOTO. Dans le futur les Basic tendront vers ce modèle. Il n’y a qu’à voir le Visual Basic.

 

Une fois en mode « Pascal », le mode « calculatrice » de la TI 74 n’est plus accessible ; on est donc toujours en mode programme. Ce qui est très dommage, pour ce qui est aussi une calculatrice, car la seule manière de faire un calcul est de saisir la commande WRITE ou WRITELN ce qui est très lourd. Par exemple WRITELN(89*9) ;. Le WRITELN est l’équivalent du PRINT du Basic qui imprimerait un retour chariot et WRITE fonctionne comme WRITELN mais sans le saut de ligne.

La mémoire s’initialise avec la commande NEW ou NEW ALL, rien de nouveau sous le soleil.

Chaque ligne de programme contient 80 caractères au maximum et contrairement au Pascal sur écran mais comme avec un « vieux Basic » chaque ligne de programme doit commencer par un n° de ligne compris entre 1 et 32766. La raison en est que l’affichage n’a qu’une seule ligne. Si on veut en insérer une entre deux autres cela sera plus facile en tapant un numéro de ligne qui ira se mettre automatiquement au bon endroit.

Mais Monsieur TI a cependant bien fait les choses puisqu’il fournit la commande RENUMBER ou REN qui renumérote par défaut les lignes de 100 en 10 et comme il sait aussi que les programmeurs sont de gros fainéants il a ajouté la possibilité de numéroter automatiquement les lignes de programmes avec la commande NUM comme en Basic.

Enfin on supprime les lignes via la commande DEL. DEL 100 efface la ligne 100, DEL 100,115,125 efface les lignes 100, 115, 125 et DEL 100-200 supprime toutes les lignes comprises entre 100 et 200.

Bref, simple et efficace.

 

Autant le Basic est bordélique autant le Pascal est structuré et c’est ce qui me plaît dans ce langage. Pour peu qu’on s’en donne la peine on peut écrire des programmes clairs donc fiables.

 

La structure d’un programme Pascal est la suivante :

PROGRAM nom_programme ; LABEL déclaration des étiquettes  CONST déclaration des constantes  TYPE déclaration des types  VAR déclaration des variables du programme  Code des PROCEDURE / FUNCTION BEGIN Code du programme principal + utilisation des fonctions définies précédemment END.

En Basic une instruction doit être obligatoirement sur une seule ligne. Par exemple on pourra avoir 10 FOR I=1 TO 10 mais pas 10 FOR puis 20 I=1 et 30 TO 10. Avec le module Pascal c’est possible. Dans la pratique ça ne sert à rien puisqu’on n’a qu’une ligne d’affichage mais c’est possible ! Comme avec le langage C, le ; est le séparateur d’instructions.

 

Les étiquettes (LABEL) :

Pascal est un langage structuré qui bannit l’utilisation du GOTO responsable en Basic de la programmation spaghetti. Mais malgré tout il est présent. Il ne se fait pas sur un numéro de ligne comme en Basic (il ne faut pas exagérer !) mais sur une étiquette (LABEL) numérique de 0 à 9999 qui doit être déclarée en début de programme.

100 PROGRAM ETIQ ; 110 LABEL 1000 ; 120 VAR i :INTEGER ; 130 BEGIN 140 i := 1; 150 1000: 160 WRITE(i); 165 i := I + 1; 170 IF i < 10 THEN GOTO 1000; 180 END.

Les constantes (CONST) :

Les constantes sont des variables dont la valeur ne peut plus être modifiée ensuite. Elles peuvent être de types chaînes, réelles, entières ou booléennes.

 

Les blocs :

Pascal, comme le C, utilise des blocs pour indiquer le début et la fin d’une portion de code d’un programme, d’une procédure, d'une boucle ou d’une condition permettant d’en structurer le code. En C ce sont { pour le début et } pour la fin. En Pascal c’est BEGIN et END. Fallait y penser !

 

Les types :

Pascal est un langage typé ce qui fait que toute variable doit avoir un type. Contrairement au Basic qui ne connaît que deux ou trois types ; réel et alphanumérique voire entier, Pascal en a … une infinité ou presque. Il y a des types natifs qui n’ont pas besoin d’être définis dans un programme et des types « utilisateurs » qui doivent être déclarés avant de pouvoir être utilisés.

 

Les types natifs sont : integer (entier de -32.767 à 32.767), real (réel de -1.0E128 à 9.9999...E127), boolean (true ou false), string (chaîne de caractères par défaut de 80 caractères avec un maximum de 255), char (un seul caractère).

 

Mais on peut construire ses propres types à partir d’un seul type natif. Par exemple le type str20 qui serait un type alphanumérique contenant jusqu’à 20 caractères.

20 TYPE 30 str20 = STRING[20] ;

Mais point de type record qui est pourtant un plus du langage. C’est dommage. Pour la petite histoire le type record permet de définir des types complexes. Comme par exemple :

date = record jour : 1..31 ; mois : 1..12 ; annee : 1..2300 ; end ; personne = record nom : string ; prenom:string ; sexe : char ; date_naissance : date; end ; …. VAR papa, mamam : personne ; BEGIN maman.prenom = 'Louise' ; …. END.

Les variables et les tableaux :

Avec Pascal il y a obligation de déclarer les variables qui seront utilisées. Cela peut paraître contraignant mais c’est en fait indispensable pour sécuriser le code car l'interpréteur (ou le compilateur) contrôle que les valeurs affectées sont compatibles avec le type de la variable.

 

Les noms des variables ne se limitent pas à une seule lettre comme avec la plupart des Basic sur pocket; taux_de_tva est bien plus parlant que t. Le Sharp PC-1500 qui est une machine Basic emblématique de l’époque peut avoir des noms de variables de 2 lettres !!!

 

Contrairement aux pockets Basic qui ont généralement 26 variables numériques fixes (de A à Z) partageant ou pas leur mémoire avec les 26 variables alphanumériques fixes (de A$ à Z$) ; le module Pascal la machine est vierge au démarrage. Aucune variable fixe n’est disponible avant et après l'exécution d'un programme.

 

L’affectation d’une valeur à une variable se fait avec := et non pas avec seulement = comme en Basic. J’avoue qu’à l’époque quand je passais du Basic au Pascal et maintenant quand je passe de PHP à Delphi il m’arrive de l’oublier et de me demander pendant une dizaine de secondes quelle est la cause de cette erreur de syntaxe !

100 VAR nom_personne : STRING ; a,b :REAL ; trouve :BOOLEAN ; 110 surnom:str20; … 150 BEGIN … 160 nom_personne := ‘badaze’ ; 170 a := 3.14159 ; 180 trouve := true ; … 300 END ;

Les tableaux peuvent avoir jusqu'à 3 dimensions. Comme les autres variables ils doivent être déclarés. Il est possible de créer des types (voir plus haut) faisant référence à des tableaux.

100 VAR 110 liste_noms : ARRAY [1..100] OF STRING;     120 toto : array['a'..'f'] OF INTEGER;     130 titi : array[-10..10] OF CHAR;     140 tutu : array[1..10,1..10] OF REAL;   150 tata : array[1..2,1..10,1..10] OF CHAR;

déclare un tableau à une dimension de 100 postes dont les indices vont de 1 à 100.   déclare un tableau à une dimension de 6 postes dont les indices vont de 'a' à 'f'   déclare un tableau à une dimension de 21 postes dont les indices vont de -20 à 20   déclare un tableau à deux dimensions   déclare un tableau à trois dimensions

Ce système est bien plus puissant que ce qui se faisait sur pocket Basic à l'époque.

Les fonctions, les procédures et les variables locales :

 

Les Basic sur pockets n’ont pas ces notions. Il y a certes les «sous-programmes» (subroutines) qui permettent de factoriser du code mais par rapport au Pascal c’est un pis-aller.

 

En Basic pour pockets les variables sont globales ; c’est-à-dire qu’elles sont utilisables et modifiables dans tout le programme ce qui autorise de sacrés effets de bord si on n’y prête pas attention.

Il est néanmoins possible de simuler des variables locales en en réservant certaines dans ce but. Par exemple on dira que I, J et K ne doivent être utilisées que dans des sous-programmes. Mais d’une part, rien n’oblige le programmeur à suivre cette règle et d’autre part il suffit qu’un sous-programme en appelle un autre pour que la règle tombe à l’eau !

 

Une procédure est une fonction qui ne retourne pas de résultat, une fonction est une procédure qui en retourne un. On peut leur donner un nom parlant mais ce n’est pas une obligation. Vous pouvez toujours appeler procédures et fonctions t1, m ou k3. Pourtant montant_tva, majuscule ou euro_vers_dollar c’est tout de même plus sympa et on aurait donc tort de s'en priver.

 

Cerise sur le gâteau. On peut leur passer des paramètres de différents types. Les variables et les paramètres d’une procédure ou d’une fonction sont locaux. C’est-à-dire qu’ils n’ont d’existence et donc de valeur que dans la procédure ou la fonction. Mais le plus important et que la variable i de la fonction A n’est pas la même variable i que celle de la fonction B. Grâce à cela bye bye les effets de bords qui font perdre un temps fou en débogage.

 

Plus fort encore (si c’est possible) les paramètres peuvent être passés par valeur ou par référence. « Par valeur » on passe la valeur d’une variable au paramètre et « par référence » on passe l’adresse mémoire de la variable associée au paramètre. Dans le premier cas, quand la procédure ou la fonction se termine la valeur de la variable passé en paramètre n’a pas changé alors que dans le second elle peut être différente si le programmeur l’a prévu ainsi.

 

L’interpréteur contrôlera que types des paramètres passés sont compatibles avec ceux de la fonction ou de la procédure sans quoi il enverra une erreur. Par exemple si le paramètre avec passage « par valeur » est de type REAL on pourra lui passer une variable ou une valeur INTEGER car INTEGER est un sous ensemble de REAL mais pas l’inverse. Et si le paramètre est « par référence » alors seule une variable de même type pourra être utilisée. Cela aussi peut sembler contraignant mais que nenni puisque le code sera sécurisé en empêchant de passer des valeurs incompatibles. En effet, une variable de type INTEGER n'occupe pas le même nombre d'octets en mémoire qu'un REAL et inversement.

 

Exemple de fonction : on lui passe un montant HT et un taux de TVA de type REAL et elle retourne le montant de la TVA lui aussi de type REAL. Pour que la fonction renvoie une valeur, il est nécessaire de l'affecter à une « pseudo variable » qui a le même nom que la fonction. Dans les versions plus récentes de Pascal (à savoir Delphi), le retour de la fonction se fait (aussi) avec le mot clé result suivi de la valeur à retourner.

A noter que l'appel à une fonction (ou à une procédure) se fait en utilisant directement son nom. Pas besoin de CALL ou de GOSUB.

FUNCTION calcul_tva(hors_taxe,taux_tva :REAL) : REAL; BEGIN calcul_tva := hors_taxe * (taux_tva / 100); END; … BEGIN la_tva := calcul_tva(100,20.6); END

Exemple de procédure : on lui passe un montant HT et un taux de TVA de type REAL et le troisième paramètre contiendra le montant de la TVA lui aussi de type REAL. Les deux premiers paramètres sont passés par valeur et le troisième l’est par référence (présence du mot-clé VAR avant la déclaration de la variable). De cette manière la variable qui sera mise contiendra le montant de la TVA quand l’exécution de la procédure sera terminée.

PROCEDURE calcul_tva(hors_taxe,taux_tva :REAL; VAR montant_tva:REAL) ; BEGIN montant_tva := hors_taxe * (taux_tva / 100); END; … BEGIN la_tva := 0; calcul_tva(100,20.6,la_tva); END

Comparaison entre Basic et Pascal :

BASIC	BASIC SHARP	PASCAL
100 REM calcul factorielle 110 I = 10 120 GOSUB 1000 130 PRINT F … 1000 REM fonction factorielle 1010 F = 1 1020 FOR J=1 TO I 1030 F = F * J 1040 NEXT J 1050 RETURN	100 REM calcul factorielle 110 I = 10 120 GOSUB “FACT” 130 PRINT F … 1000 “FACT”  1010 F = 1 1020 FOR J=1 TO I 1030 F = F * J 1040 NEXT J 1050 RETURN	… 1000 FUNCTION fact(N :INTEGER) : REAL; 1010 VAR x : REAL; i : INTEGER; 1020 BEGIN 1030 x := 1; 1040 IF N > 0 THEN BEGIN 1050 FOR i:=1 TO N DO BEGIN 1060 x := x * i; 1070 END; 1080 END; 1090 fact := x; 1100 END; … 2000 BEGIN ... 2100 WRITE(fact(10)); ... 2300 END. J’ai dû mettre les lignes 1040 et 1080 car avec FACT(0) j’avais un plantage sans !!

En Pascal tout est plus beau et plus lisible. On n’a même pas à commenter le code tellement c’est clair.

 

Les conditions et branchements :

On trouve les mêmes conditions qu'en Basic (<, <=, >, >=, = et <>) et les opérateurs AND, OR. En plus il y a la condition IN qui permet de contrôler une valeur dans une liste et l'opérateur NOT qui inverse le test. A noter que les conditions sont aussi utilisées avec les boucles WHILE et REPEAT UNTIL.

 

Le if connaît le else.

100 if (a IN [1..100]) then 110 begin 120    ... 130 end ;

100 if (a < 100) then 110 begin 120    ... 130 end 140 else 150 begin 160 … 170 end ;

L'équivalent du ON GOSUB du Basic est la structure CASE qui est bien plus lisible et puissante mais qui n'a pas de valeur par défaut.

100 CASE mois OF 110    1, 3, 5, 7, 8, 10, 12 : BEGIN 120      WRITELN('Mois à 31 jours') ; 130    END ; 140    4, 6, 9, 11 : BEGIN 150      WRITELN('Mois à 30 jours') ; 160    END ; 170    2 : BEGIN 180      WRITELN('Mois à 28/29 jours') ; 190    END ; 200 END ;

100 CASE option OF 110   '1' : factorielle ; 120   '2' : gamma ; 130   '3' : sinusoidale ; 140 END ;

Enfin il y a aussi le GOTO que nous avons déjà abordé. Le GOTO est intéressant car quand je faisais mes études d’informatique un professeur nous interdisait de l’utiliser alors qu’un autre disait que dans certains cas il est très utile. Bref on devait adapter notre programmation selon qui corrigeait !

Si le GOTO est incontournable en Basic ; a-t’on le choix ? Il n’est pas nécessaire en Pascal. De fait je crois que je ne l’ai jamais utilisé hormis dans la génération automatique de code (le cours du second professeur).

 

Les boucles :

Comme le Basic, le Pascal connaît les boucles FOR-NEXT mais sous une autre forme. Il a en prime les boucles WHILE et REPEAT UNTIL (pour être honnête beaucoup de Basic de l'époque en sont aussi pourvus).

 

Le Pascal distingue deux syntaxes pour la boucle FOR. La boucle croissante s’écrit FOR i := 1 TO 10  suivi d'une seule instruction ou d'un bloc BEGIN END ; et la boucle décroissante FOR i := 10 DOWNTO 1 DO. Elle est donc moins puissante qu’en Basic car il n’y pas de STEP autre que 1 ou -1.

 

Les entrées / sorties à l'écran :

Le Pascal a été développé à une époque où l’informatique utilisait encore des cartes perforées et les entrées / sorties à l'écran sont basiques. L'entrée des données se fait grâce aux mots clés read et readln. C'est l'équivalent de l'input du Basic. read/readln permettent de lire plusieurs valeurs à la suite (exemple : read(a, b, c);). Il faut aussi noter que ces ordres permettent de lire des données à partir d'un fichier (sur K7 dans le cas de la TI 74). En fait, le clavier est considéré comme un fichier toujours ouvert !

 

Comme indiqué précédemment, les affichages se font à partir des mots clés write et writeln. Il est possible de positionner le curseur d'affichage sur un caractère avec GOTOXY. Mais comme il n'y a qu'une seule ligne, le X doit obligatoirement être égal à 0. A ma grande surprise je n'ai pas trouvé d'instruction permettant d'effacer l'écran !?!?

 

La récursivité

Le langage Pascal est un langage récursif. Késaco ? C’est la capacité qu’à une fonction à s’appeler elle-même encore et encore pour effectuer un calcul. Pour cela il faut que le système ait une pile de récursivité qui stocke les résultats intermédiaires.

 

L’exemple le plus souvent utilisé est le calcul des factorielles.

·        Par convention fact(0) = 1

·        Fact(7) = 7 x 6 x 5 x 4 x 3 x 2 x 1 = 5.040.

·        Fact(8) = 8 x 7 x 6 x 5 x 4 x 3 x 2 x 1 = 40.320.

·        Fact(8) = 8 x Fact(7) et en généralisant on obtient Fact(n) = n x Fact(n-1)

Bref la récursivité c’est la possibilité de programmer une fonction de cette manière-là ou peu s’en faut.

100 PROGRAM factorie ; 110 VAR f : integer; 120 FUNCTION fact(n :integer) : real;   130 BEGIN 140 IF n = 0 THEN fact := 1   150 ELSE fact := n * fact(n-1); 150 END; 170 BEGIN 180 {$W-} 190 WRITE(‘N=’); {$W+} 200 READ(f); 210 WRITELN(fact(f)); 220 END.

Les variables doivent être déclarées Déclaration de la fonction qui attend un entier et retourne un réel Indique le début du code de la fonction Condition de terminaison. L’affectation se fait via := et non pas par = comme en Basic Le fameux Fact(n) = n x Fact(n-1) Indique la fin du bloc fonction Indique le début du code du programme   Affiche N= à l’écran Lit la valeur saisie et l’affecte à la variable f Affiche le résultat de fact(f) Indique la fin du bloc programme

Ce code fonctionne mais seulement jusqu’à fact(5). Au-delà j’obtiens une erreur « Expression too complicated » ! Autant dire que si la récursivité est présente ; elle est anecdotique. Dommage ! Car c’est une force du langage. Pour être complet, le manuel propose une fonction factorielle récursive qui va jusqu’à fact(7). Ils sont forts chez TI.

 

Le programme ci-dessous calcule les factorielles jusqu’à fact(84) mais avouez que la version récursive est plus sexy. De plus et je ne sais pas pourquoi si n = 0 alors FOR i :=1 TO n fait planter la machine.

100 PROGRAM factorie ; 110 VAR f : integer; 120 FUNCTION fact(n :integer) : real; 121 VAR x : REAL; i : INTEGER; 122 BEGIN 123 x := 1; 124 IF n > 0 THEN BEGIN 125 FOR i:=1 TO n DO BEGIN 126 x := x * i; 147 END; 148 END; 149 fact := x; 150 END; 170 BEGIN 180 {$W-} 190 WRITE(‘N=’); {$W+} 200 READ(f); 210 WRITELN(fact(f)); 220 END.

Conclusion

Entre le Basic des pockets du début des années 80  et ce Pascal il n’y a pas photo. Peut-être que le monde informatique actuel serait différent si le Pascal avait été implémenté sur les pockets à la place du Basic. En effet si tous ceux qui ont appris à programmer dans les années 80 avaient connu d’entrée de jeu ce langage ils ne seraient pas passés aussi facilement au C bien plus puissant lui aussi que le Basic.

Le langage est tellement riche, il y a tellement de choses intéressantes à dire et que je n'ai pas dites (les chaînes de caractères, la lecture/écriture sur K7, les ensembles, l'éditeur …) qu'il faudrait beaucoup plus qu'un article pour en faire le tour. Qui sait ? Peut-être dans le prochain numéro !

Ah que je regrette de ne pas avoir connu cette machine et ce module à l'époque.