Langage de programmation - MPW Pascal

Les instructions

Les instructions sont constituées d'expressions combinées à certains mots réservés. Les instructions décrivent des algorithmes et sont exécutables. Ils effectuent le travail réel du programme Pascal, en effectuant des tâches telles que donner une valeur à une variable ou fournir une exécution conditionnelle d'autres instructions.

Le MPW Pascal a 13 instructions :

Ces instructions sont discutées dans cette page.

Instructions d'affectation

L'instruction d'affectation définit la valeur d'une variable. Le symbole := peut être lu comme "fixer à". La déclaration est écrite :

La référence de variable du côté gauche identifie une variable de n'importe quel type à l'exception d'un type de fichier. Pour la plupart des variables, il s'agit simplement d'un nom d'identification, mais dans quatre cas, il s'agit d'un nom suivi d'une qualification :

Si la variable est un élément de chaîne de caractères, elle est identifiée par le nom de chaîne de caractères suivi du numéro d'index de l'élément entre parenthèses.
Si la variable est un élément de tableau, elle est identifiée par le nom du tableau suivi d'une ou plusieurs valeurs d'index (une pour chaque dimension du tableau) entourées de crochets et séparées par des virgules.
Si la variable est un champ d'enregistrement, son nom doit être précédé du nom de l'enregistrement le contenant et d'un point (sauf si l'instruction d'affectation est entourée d'une instruction WITH).
Si la variable est une variable dynamique, elle est identifiée par le nom de son pointeur suivi d'un caret.

Lorsque vous écrivez des associations, gardez ces règles à l'esprit :

Une variable de type Real peut être définie sur la valeur d'un autre type Real, un Integer ou un LongInt, un type de sous-gamme entière ou une expression donnant des résultats entiers ou réels.
Une variable LongInt peut être définie sur la valeur d'un Integer, d'un type de sous-intervalle entière ou d'une expression donnant des résultats entiers. Il peut être défini sur la valeur d'un autre LongInt ou sur une expression donnant des résultats LongInt, à condition que la valeur réelle ne dépasse pas sa taille déclarée.
Une variable Boolean peut être définie sur la valeur d'un autre Boolean ou sur une expression donnant un résultat booléen.
Une variable Char peut être définie sur la valeur d'un autre Char, d'un type de sous-intervalle Char ou d'un élément chaîne de caractères.
Une variable scalaire de type sous-intervalle peut être définie sur la valeur d'un autre scalaire (ou d'une expression donnant des résultats scalaires) du type hôte, à condition que la valeur réelle se situe dans l'intervalle déclarée.
Une variable scalaire définie par l'utilisateur peut être définie sur n'importe laquelle des valeurs nommées dans sa déclaration.
Une variable chaîne de caractères peut être définie sur la valeur d'une autre chaîne de caractères, à condition que sa longueur réelle ne dépasse pas la taille déclarée de la variable.
Une variable d'ensemble peut prendre la valeur d'une autre variable d'ensemble ou d'un constructeur d'ensemble, à condition qu'ils aient le même type de base.
Une variable de tableau entier ou une variable d'enregistrement peut être définie sur la valeur d'un autre tableau entier ou d'une variable d'enregistrement de type compatible avec l'affectation.
Une variable de type tableau de caractères compacté unidimensionnel peut être définie sur la valeur d'une constante chaîne de caractères (mais pas d'une variable chaîne de caractères), à condition que sa plage d'index soit la même que la longueur de la chaîne de caractères.
Les éléments de tableau (y compris les éléments qui sont des tableaux) et les champs d'enregistrement (y compris les champs étant des enregistrements) agissent dans les affectations comme des variables ordinaires de leurs types déclarés.

Voici quelques exemples d'énoncés d'affectation :



x:=y+z;

p:=(1<=i) AND (i<100);

i:=Sqr(k)-(i*j);

hue1:=[blue,succ(c)];

Instructions composées

Lors de l'écriture de programmes Pascal, vous devez souvent traiter plusieurs instructions comme si elles n'en formaient qu'une seule, par exemple lorsqu'elles sont toutes exécutées par une seule instruction de contrôle. Pour ce faire, vous utilisez l'instruction composée.

Le corps de chaque procédure, fonction et programme principal Pascal est constitué d'une seule instruction composée. Pour créer une seule instruction composée à partir d'une séquence d'instructions, faites précéder la séquence par BEGIN et terminez-la par END, en séparant les instructions internes par des points-virgules.

La flèche revenant sur le point-virgule indique que de nombreuses instructions peuvent être placées entre BEGIN et END, aussi longtemps qu'elles sont séparées par des points-virgules.

Vous pouvez imbriquer n'importe quel nombre d'instructions BEGIN ... END. Dans n'importe quel bloc, le compilateur associera le dernier BEGIN au premier END, l'avant-dernier BEGIN au deuxième END, et ainsi de suite. Si vous avez écrit plus de BEGIN que de END, le compilateur s'arrêtera et affichera un message d'erreur.

Voici un exemple d'instruction composée :



BEGIN

 z:=x;

 x:=y;

 y:=z;

END

Instructions de procédure

Une procédure est appelée en écrivant son identifiant dans le texte source, suivi de sa liste de paramètres réelle (si elle en a une) entre parenthèses. Les paramètres d'une liste de paramètres sont séparés par des virgules.

L'identificateur doit être le même que l'identificateur utilisé dans la déclaration de procédure ou de fonction.

La liste de paramètres dans un appel de procédure ou de fonction contient le même nombre de paramètres formels que ceux répertoriés dans la déclaration de procédure ou de fonction. Ceux de la déclaration sont appelés paramètres formels; ceux de l'instruction appelante, les paramètres réels (ou source). Les valeurs des paramètres réels sont censées être transmises aux paramètres formels dans le cadre de l'appel.

L'ordre et le nombre de paramètres réels dans l'appel doivent correspondre à l'ordre et au nombre de paramètres formels dans la déclaration. Chaque paramètre réel doit avoir le même type que le paramètre formel correspondant, avec ces exceptions :

Les types de sous-intervalle sont équivalents à leurs types de base.
Un paramètre formel de type LongInt acceptera un paramètre Real de type Integer.
Les paramètres formels précédés de univ acceptent tout paramètre réel occupant le même espace en mémoire. Pour une discussion complète sur univ.

De plus, les paramètres actuelles spécifiés dans tout appel de procédure ou de fonction doivent suivre ces règles :

Les paramètres variables actuelles doivent être des variables. Contrairement aux paramètres de valeur, les paramètres de variable ne peuvent pas être des constantes, des expressions ou des éléments de variables compactés.
La valeur de n'importe quelle variable de chaîne de caractères actuelle peut être transmise à n'importe quel paramètre de chaîne de variable formelle, quelle que soit sa longueur. Cependant, si la longueur maximale déclarée du paramètre formel est plus longue que la longueur maximale déclarée du paramètre actuel, vous obtiendrez une erreur du compilateur. Vous pouvez éviter le problème en suspendant la vérification des plages avec la directive du compilateur $R-.
Si la valeur d'un paramètre actuel dépasse l'intervalle d'un paramètre formel (par exemple, parce que le paramètre formel est un type de sous-intervalle), vous obtiendrez une erreur d'exécution à moins que vous n'ayez suspendu la vérification de l'intervalle avec la directive du compilateur $R-.

Voici quelques exemples d'instructions de procédure :



printheading;

transpose(a, n, m);

bisect(fct, -1.0, +1.0, x);

Instructions de répétition

Pascal propose trois manières d'exécuter la même section de programme de manière répétée : le processus appelé bouclage. Mais Pascal configure les routines de boucle et de sortie pour vous; il suffit de lui indiquer les conditions de répétition. Les instructions de répétition sont les suivantes :

L'instruction FOR FOR ... DO exécute la même section de programme un nombre de fois donné. Le nombre d'exécutions peut être constant ou peut être déterminé par le résultat d'un calcul scalaire.
L'instruction WHILE WHILE ... DO exécute la même section de programme de manière répétée tant qu'une expression booléenne donnée est vraie. Il évalue le contrôle booléen avant chaque passage, y compris le premier instant ; par conséquent, il peut contourner complètement la section du programme.
L'instruction REPEAT REPEAT ... UNTIL exécute également la même section de programme de manière répétée tant qu'une expression booléenne donnée est vraie. Mais il évalue le contrôle booléen après chaque passage ; par conséquent, il exécute la section du programme au moins une fois.

Les instructions FOR

L'instruction FOR nécessite une variable locale de type scalaire préalablement déclarée. Il incrémente ou décrémente à plusieurs reprises la valeur de la variable, exécutant à chaque fois une section de votre programme. Vous définissez les valeurs scalaires de début et de fin (pouvant être constantes ou calculées) et si l'instruction FOR doit compter vers le haut ou vers le bas.

La variable de contrôle est le nom d'une variable scalaire : Integer, Char, Boolean, sous-intervalle ou définie par l'utilisateur. Il ne peut pas s'agir d'un élément de tableau ou de chaîne de caractères, d'un champ d'enregistrement ou d'une variable dynamique. Il doit être déclaré dans le bloc contenant l'instruction FOR. L'instruction FOR lui donne une valeur avant chaque passage dans la section du programme qu'elle contrôle. A noter que la valeur de cette variable est accessible dans la section contrôlée.

Les expressions de valeur initiale et finale doivent avoir le même type scalaire que la variable. Il peut s'agir de simples constantes ou variables, ou d'expressions complexes contenant des opérateurs et des fonctions.

Vous écrivez TO ou DOWNTO, selon que l'ordinanalité de la valeur de la deuxième expression est supérieure ou inférieure à l'ordinanalité de la valeur de la première expression. L'instruction contrôlée par l'instruction FOR peut être une autre instruction unique (telle qu'une affectation ou un appel de procédure) ou une instruction composée contenant de nombreuses autres instructions.

Respectez ces règles et mises en garde lorsque vous rédigez une instruction FOR :

La variable de contrôle doit être une : variable simple à portée locale.
Si la variable de contrôle est un type de sous-intervalle ou un scalaire défini par l'utilisateur, elle doit être capable d'accepter les valeurs initiales et limites ainsi que toutes les valeurs avec une ordonnée entre les deux.
N'essayez pas de modifier la valeur de la variable de contrôle à partir de l'instruction FOR ; cela peut avoir des résultats imprévisibles.
N'incluez la variable de contrôle dans aucune des xpressions de limite.
Une fois l'instruction FOR terminée, la valeur de la variable de contrôle peut ne plus être spécifiée.
Les expressions limites sont évaluées une seule fois, avant le premier passage. Les modifier depuis l'instruction FOR ne modifiera pas son comportement.
Si les expressions limites ont la même valeur, l'instruction FOR exécutera son instruction contrôlée une fois.
Si les valeurs limites sont inversées (limite grande inférieure à limite petite), l'instruction FOR sera ignorée.

Voici quelques exemples d'instructions FOR :



For i:=2 To 63 do If a[i]>max Then max:=a[i];

For i:=1 To n do For j:= 1 TO n do Begin

 x:=0;

 For k:=1 To n do x:=x+m1[i,k]*m2[k,j];

 m[i,j]:=x;

End;

FOR c:=red To blue do q(c);

Instructions WHILE

L'instruction WHILE évalue une expression booléenne puis exécute une instruction si l'expression est vraie. Il répète l'exécution, en évaluant l'expression avant chaque passage, jusqu'à ce que l'expression devienne fausse. L'instruction WHILE s'écrit comme suit :

L'expression de contrôle doit être de type booléen; il est généralement formé d'opérateurs relationnels et logiques.

L'instruction contrôlée par WHILE ... DO peut être soit une instruction unique, soit une construction composée BEGIN ... END contenant d'autres instructions.

Voici quelques exemples d'instructions WHILE :



While a[i]<>x do i:=i+1;

While i>0 do Begin

 If odd(i) Then z:=z*x;

 i:=i div 2;

 x:=Sqr(x)

End;

While not Eof(f) do Begin

 process(f^);

 get(f);

End;

Instructions REPEAT

L'instruction REPEAT se comporte de manière similaire à l'instruction WHILE, mais elle évalue son expression booléenne après avoir exécuté les instructions qu'elle contrôle. Il est écrit ainsi :

REPEAT et UNTIL créent leur propre composé à partir des instructions qu'ils contrôlent ; vous n'avez pas besoin d'utiliser BEGIN et END.

L'expression de contrôle doit être de type Boolean ; il est généralement formé d'opérateurs relationnels et logiques.

Remarque : avec WHILE et REPEAT, veillez à ce que les instructions de programme qu'elles contrôlent incluent des moyens pratiques pour modifier l'expression, ou pour s'échapper au moyen d'une instruction GOTO ou Leave ou d'un appel Exit. Sinon, votre programme ne pourra jamais se terminer.

Voici quelques exemples d'instructions REPEAT :



REPEAT

 k:=i MOD j;

 i:=j;

 j:=k

UNTIL j=0;

REPEAT

 process(f^);

 get(f)

UNTIL Eof(f);

Contrôle de boucle : une comparaison

Les trois instructions de répétition présentent chacune des avantages et des inconvénients spécifiques dans une situation de programmation donnée. En voici quelques uns.

L'instruction FOR garde automatiquement une trace de la répétition qu'elle exécute, en modifiant la valeur de sa variable de contrôle à la fin de chaque passe. Ainsi, vous pouvez utiliser la valeur de contrôle pour modifier ce que fait votre programme à chaque fois. Par exemple, la valeur de contrôle peut amener la section répétée à :

Sélectionnez un élément différent dans un tableau à chaque fois en changeant le numéro d'index.
Appele une procédure différente à chaque fois en servant de valeur de sélecteur pour l'instruction CASE (décrite ci-dessous)
Effectue un calcul différent à chaque fois en devenant un facteur dans une expression

L'instruction FOR est cependant quelque peu rigide. Vous pouvez modifier son nombre de répétitions uniquement en le terminant par une instruction GOTO ou Leave.

Les instructions WHILE et REPEAT permettent un meilleur contrôle des conditions dans lesquelles elles arrêtent de s'exécuter. La principale différence entre eux est que l'instruction WHILE n'a pas besoin d'être exécutée du tout, alors que l'instruction REPEAT s'exécute au moins une fois. Ainsi, l'instruction WHILE est plus utile lorsque la condition contrôlant son exécution a déjà été satisfaite ; l'instruction REPEAT est particulièrement utile lorsque la condition ne peut être satisfaite qu'en exécutant l'instruction.

L'instruction WHILE doit également être utilisée dans les cas où son exécution dans de mauvaises conditions pourrait être préjudiciable, car elle évalue son contrôle avant chaque passage.

Expressions conditionnelles

Le Pascal propose à votre programme deux manières de choisir ce qu'il doit faire ensuite : le processus parfois appelé branchement :

L'instruction IF ... THEN ... ELSE évalue une expression booléenne et exécute une instruction contrôlée uniquement si elle est vraie. Il peut également être écrit pour exécuter une deuxième instruction si l'expression est fausse.
L'instruction CASE ... OF ... OTHERWISE exécute une instruction à partir d'une liste, en fonction de la valeur d'une expression de contrôle scalaire.

Instructions IF

L'instruction IF exécute une seule instruction contrôlée (qui peut être une construction composée BEGIN ... END) si une expression booléenne est vraie. Vous pouvez ajouter une partie ELSE facultative à la fin qui exécute une autre instruction (éventuellement composée) si elle est fausse :

L'expression de contrôle entre IF et THEN doit être de type booléen ; il est généralement formé d'opérateurs relationnels et logiques.

L'une ou les deux instructions contrôlées peuvent être des instructions uniques ou des constructions composées BEGIN ... END contenant d'autres instructions. Le seul endroit où vous devez mettre un point-virgule dans une instruction IF est dans une construction composée BEGIN ... END.

Lors de l'exécution d'une instruction IF, Pascal effectue ces étapes :

Il évalue l'expression booléenne.
Si sa valeur est vraie, Pascal exécute l'instruction suivant THEN et quitte l'instruction IF.
Si sa valeur est fausse et qu'il y a une instruction après ELSE, Pascal l'exécute ; sinon, il quitte les instructions IF.

Voici quelques exemples d'instructions IF :



If x<l.5 Then z:=x+y Else z:=1.5;

If p1<>NIL Then p1:=p1^.father;

Instructions IF imbriquées

Dans toute instruction IF, l'instruction suivant le mot ELSE peut également être une instruction IF et contenir sa propre clause ELSE. Ainsi, une instruction IF peut être écrite pour entreprendre différentes actions pour chacune de plusieurs conditions mutuellement exclusives.

Pascal évaluera les expressions booléennes uniquement jusqu'à ce qu'une vraie soit trouvée. Vous obtenez une vitesse d'exécution maximale si vous donnez la priorité aux conditions les plus probables.

L'instruction suivant le mot THEN peut également être une instruction IF imbriquée, mais cela peut créer une confusion dans le texte source. S'il devient difficile de savoir lequel ELSE correspond à quel THEN ; clarifiez la situation en utilisant une construction composée BEGIN ... END ou une indentation appropriée.

Instructions CASE

L'instruction CASE vous permet d'écrire une liste d'instructions alternatives à exécuter, en associant à chacune une constante scalaire. Lors de l'exécution de l'instruction CASE, Pascal évalue une expression scalaire de contrôle; si sa valeur correspond à l'une des constantes, Pascal exécute l'instruction correspondante. Vous pouvez ajouter une partie facultative OTHERWISE à la fin qui exécute une instruction supplémentaire si rien n'a été sélectionné dans la liste. L'instruction CASE suit cette syntaxe :

Les clauses présentées dans le diagramme ont le format suivant :

L'expression de contrôle peut avoir n'importe quel type scalaire : integer, char, boolean, sous-intervalle ou défini par l'utilisateur. Il doit être capable de renvoyer la valeur de n'importe laquelle des constantes de la clause CASE.

Les expressions constantes de la clause CASE doivent avoir le même type scalaire que l'expression de contrôle.

N'importe laquelle des instructions contrôlées dans la clause CASE ou l'instruction par défaut suivant OTHERWISE peut être des instructions simples ou des constructions composées BEGIN ... END contenant d'autres instructions.

Voici deux exemples d'instructions CASE :



Case operator of

 plus:x:=x+y;

 minus:x:=x-y;

 times:x:=x*y;

End;

Case i of

 1:x:=Sin(x);

 2:x:=Cos(x);

 3,4,5:x:=Exp(x);

 Otherwise x:=Ln(x);

End;

Instructions de contrôle

Les trois instructions de répétition et les deux instructions conditionnelles décrites dans cette page, ainsi que les affectations et les appels de procédure, sont suffisamment flexibles pour gérer presque tous les travaux de programmation. Parfois, cependant, vous pouvez encourager une situation exigeant un transfert immédiat ou une suspension de l'exécution du programme. Pour ces cas, Pascal propose cinq outils supplémentaires :

L'instruction GOTO, transférant le contrôle directement d'une instruction de programme à une autre.
L'instruction Cycle, forçant une réitération immédiate d'une boucle d'instruction de répétition.
L'instruction Leave, annulant immédiatement une boucle d'instruction de répétition.
La procédure Exit, terminant toute procédure, fonction ou programme entier.
La procédure Halt, arrêtant immédiatement l'exécution du programme.

Les instructions GOTO, Cycle et Leave sont décrites ci-dessous.

Instructions i

L'instruction GOTO transfère l'exécution du programme au début de toute instruction se trouvant dans la même procédure, fonction ou programme principal. Avant de pouvoir utiliser une instruction GOTO, vous devez effectuer deux choses :

Déclarez une étiquette pour chaque destination GOTO de votre programme. Chaque étiquette est un nombre de un à quatre chiffres. La déclaration d'étiquette se compose du mot réservé LABEL, suivi d'un ou plusieurs numéros d'étiquette séparés par des virgules.
Écrivez l'une des étiquettes de destination déclarées, suivie de deux points, devant l'instruction constituant la destination de chaque instruction GOTO.

L'instruction GOTO s'écrit :

L'entier non signé est l'étiquette de destination ; il ne doit pas dépasser quatre chiffres décimaux.

Deux autres précautions s'appliquent aux instructions GOTO :

La destination de toute instruction GOTO doit être le début d'une instruction.
Passer à une instruction se trouvant dans la structure d'une autre instruction (sauf avec une instruction composée formant un bloc de programme) peut avoir des effets indéfinis, bien que le compilateur n'indique pas d'erreur.

Ainsi, chaque destination GOTO doit être le début d'une instruction se trouvant au niveau supérieur d'imbrication dans un bloc de programme.

Voici un exemple illustrant l'utilisation d'une instruction GOTO :



BEGIN

 1234:Write('Donnez-moi un nombre : ');

 ReadLn(n);

 IF n=0 THEN GOTO 1234

END

Instructions Cycle

L'instruction Cycle transmet le contrôle du programme à la fin de la partie en boucle de la plus petite instruction WHILE, REPEAT ou FOR l'entourant. C'est similaire à l'instruction continue du langage de programmation C.

Voici un exemple illustrant l'utilisation d'une instruction cycle. Elle appelle la procédure f pour toutes les valeurs positives de a[i] :



For i:=1 To n do Begin

 If a[il<=0 Then Cycle;

 f(a[i])

End

Remarque : Le mot Cycle n'est pas un mot réservé. Si vous le redéfinissez, vous ne pouvez pas utiliser les instructions Cycle dans le cadre de votre définition.

Instructions Leave

L'instruction Leave termine la plus petite instruction WHILE, REPEAT ou FOR la contenant, en passant le contrôle à l'instruction suivante. Cela ressemble à l'instruction break en C.

Voici un exemple illustrant l'utilisation d'une instruction Leave ; dans celui-ci, l'instruction WHILE se termine lorsque la première valeur x d'un [i] est trouvée :



While i<63 do Begin

 If a[i]=x Then Leave;

 i:=i+1

End

Remarque : Le mot Leave n'est pas un mot réservé. Si vous le redéfinissez, vous ne pouvez pas utiliser les instructions Leave dans le cadre de votre définition.

Instructions WITH

L'instruction WITH ... DO fournit un moyen par lequel les champs des enregistrements spécifiés peuvent être référencés en utilisant uniquement leurs identificateurs de champ. Il a la syntaxe suivante :

N'importe quel nombre d'identificateurs de variables d'enregistrement, y compris ceux d'enregistrements étant des champs d'autres enregistrements, peuvent être répertoriés entre WITH et DO. La déclaration :



WITH v1, v2, v3 DO s;

est équivalent au groupe d'instructions WITH :



WITH v1 DO

 WITH v2 DO

  WITH v3 DO s;

Les règles suivantes régissent l'utilisation de WITH ... DO :

Lorsque vous répertoriez un enregistrement étant un champ d'un autre enregistrement, vous devez soit répertorier l'enregistrement contenant plus tôt, soit répertorier ce champ sous une forme explicite.
Les instructions WITH peuvent être imbriquées. Les variables d'enregistrement "ouvertes" par n'importe quelle instruction WITH restent ouvertes dans les instructions imbriquées.
Lorsque les champs de variables d'enregistrement différentes portent le même nom, WITH accède au champ de ce nom dans le dernier enregistrement répertorié, y compris les listes redondantes dans les instructions imbriquées. L'identité des noms de champs ne provoque pas d'erreur du compilateur.
Où un identificateur de champ d'enregistrement est le même qu'une variable ou un autre identificateur déclaré à l'extérieur, l'enregistrement, WITH accède au champ.
Dans une instruction WITH, les champs peuvent toujours être identifiés explicitement, même si leurs variables d'enregistrement sont répertoriées. Cette fonctionnalité peut être utilisée pour résoudre l'ambiguïté des noms de champs identiques.
Lorsqu'il est utilisé avec des variables d'enregistrement variantes, WITH accède aux identificateurs de leurs champs de balise et de tous les champs variantes.

Voici un exemple d'instruction WITH :



With Date do If Month=12 Then Begin

 Month:=1;

 Year:=Year+1

End

 Else 

Month:=Month+1;

Instruction NULL

Les instructions NULL sont des instructions ne contenant rien. Cela signifie simplement que chaque fois que la syntaxe Pascal appelle une instruction, vous pouvez l'omettre. Cela signifie également que lorsqu'un programme contient un point-virgule inutile, le compilateur Pascal considère que le point-virgule sépare une instruction NULL d'une autre instruction. Le résultat est deux déclarations alors que vous n'en prévoyez qu'une. La plupart du temps, cela est inoffensif, mais cela provoque parfois une erreur lorsqu'une seule instruction est autorisée.

PARTAGER CETTE PAGE SUR

Dernière mise à jour : Vendredi, le 28 juin 2024

	ABAP/4
	Ada
	Assembleur
	Assembly & bytecode
	ASP (Active Server Pages)
	Basic
	C
	C++
	C# (C Sharp)
	Cobol
	ColdFusion
	Fortran
	HTML
	Java
	JavaScript
	LISP
	Logo
	LotusScript
	Oberon
	Pascal
	Perl
	PHP
	PL/1
	Prolog
	Python
	Rebol
	REXX
	Ruby
	SAS
	NoSQL
	SQL
	Swift
	X++ (Axapta)

	Assembleur 370
	Assembleur 1802
	Assembleur 4004
	Assembleur 6502
	Assembleur 6800
	Assembleur 68000
	Assembleur 8080 et 8085
	Assembleur 8089
	Assembleur 80x86
	Assembleur AGC4
	Assembleur ARM
	Assembleur DPS 8000
	Assembleur i860
	Assembleur Itanium
	Assembleur MIPS
	Assembleur PDP-11
	Assembleur PowerPC
	Assembleur RISC-V
	Assembleur SPARC
	Assembleur SuperH
	Assembleur UNIVAC I
	Assembleur VAX
	Assembleur Z80
	Assembleur Z8000
	Assembleur z/Architecture

	CIL
	Jasmin
	LLVM
	MSIL
	Parrot
	P-Code (PCode)
	SWEET16

	ASP 1.0
	ASP 2.0
	ASP 3.0
	ASP.NET

	ABasiC (Amiga)
	Adam SmartBASIC
	Altair BASIC
	AmigaBASIC (Amiga)
	AMOS Basic (Amiga)
	Atari Basic (Atari 400, 600 XL, 800, 800XL)
	Basic Apple II (Integer BASIC/APPLESOFT)
	Basic Commodore 64 (CBM-BASIC)
	Basic Commodore 128 (BASIC 7.0)
	Basic Commodore VIC-20 (CBM-BASIC 2.0)
	Basic Coco 1 (Color Basic)
	Basic Coco 2 (Extended Color Basic)
	Basic Coco 3 (Extended Color Basic 2.0)
	BASICA (PC DOS)
	Basic Pro
	BBC BASIC
	Blitz BASIC (Amiga)
	DarkBASIC
	Dartmouth BASIC
	GFA-Basic (Atari ST/Amiga)
	GWBASIC (MS-DOS)
	Liberty BASIC
	Locomotive BASIC (Amstrad CPC)
	MSX-Basic
	Omikron Basic (Atari ST)
	Oric Extended Basic
	Power Basic
	Quick Basic/QBasic (MS-DOS)
	Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
	ST BASIC (Atari ST)
	Turbo Basic
	Vintage BASIC
	VBScript
	Visual Basic (VB)
	Visual Basic .NET (VB .NET)
	Visual Basic pour DOS
	Yabasic

Section courante

A propos

Section administrative du site