FAQ PascalConsultez toutes les FAQ

Cette erreur survient quand la mémoire vive n'est pas suffisante pour permettre la compilation du programme.

Solutions

• Essayez d'augmenter la mémoire disponible en modifiant CONFIG.SYS ou CONFIG.NT : diminuez le nombre de tampons fichiers (SET FILES et SET BUFFERS), chargez un minimum de résidents.
• Si vous utilisez TURBO.EXE, optez pour TPX.EXE, plus performant et moins gourmand en mémoire.
• Compilez sur disque et non en mémoire (Compile --> Destination sur Disk, sur TURBO.EXE).
• Forcez l'édition de liens sur disque et non en mémoire (Options --> Linker --> Link buffer sur Disk).
• Quittez l'EDI et utilisez le compilateur en ligne de commande TPC.EXE.
• En désespoir de cause, divisez votre source en plus petites unités et compilez-les individuellement.
  

Le compilateur attend un identificateur : cette erreur survient typiquement lorsque vous essayez de redéclarer un mot réservé.

Vous utilisez un identificateur non déclaré ou bien déclaré dans un autre bloc.

Vous déclarez deux fois le même identificateur. Par exemple, vous essayez de donner à une procédure le même nom qu'une variable déclarée.

La cause d'une erreur de syntaxe peut avoir une foule d'origines : vous utilisez des caractères accentués dans les identificateurs, vous oubliez d'encadrer une chaîne de caractères par des apostrophes, etc., etc.

Il y a une erreur dans la syntaxe d'une constante de type réel.

Exemples de syntaxes correctes :

1
2
3
4
  
Const r1 : Real = 0.14; 
      r2 : Double = 15; 
	  r3 : Real = 3.7E-36;

Il y a une erreur dans la syntaxe d'une constante de type entier.
Cette erreur survient typiquement lorsque vous déclarez un réel sans décimale, dont la valeur dépasse les intervalles de valeurs des entiers. Dans ce cas, il faut rajouter une décimale nulle :

1
2
3
  
Const r1 : Real = 12345678910;    { Erreur de compilation } 
      r2 : Real = 12345678910.0;  { Correct }

Une constante de type chaîne de caractères fait plus d'une ligne.
Vous avez probablement oublié l'apostrophe qui termine la chaîne...

Votre code source (principal ou source d'une unité) s'interrompt avant le end final.
Vous avez probablement oublié des end; dans votre code source. Vérifiez bien que chaque begin et chaque case possèdent bien leur propre end;.

Votre ligne est trop longue : Turbo Pascal ne peut compiler que des lignes d'un maximum de 127 caractères. Au-delà, vous devez scinder votre ligne en plusieurs lignes. Le compilateur sait très bien gérer des instructions sur plusieurs lignes, à supposer que vous ne coupiez pas des instructions en deux (beg et in) et que vous ne coupiez pas de constante chaîne.

Vous avez déclaré un identificateur sans type.

Cette erreur vient en fait du système : le nombre maximal de fichiers ouverts est atteint.
Pour y remédier, augmentez la valeur du paramètre FILES= dans le fichier CONFIG.SYS ou CONFIG.NT.

Cette erreur provient d'un nom de fichier ou de chemin d'accès inexistant. Vous essayez probablement de créer une application EXE dans un répertoire qui n'existe pas ! Vérifiez donc dans Options --> Directories... que tous les répertoires définis correspondent à des répertoires existants.

EXE and TPU directories peut éventuellement être laissé vide : les fichiers .EXE et .TPU seront alors écrits dans le répertoire en cours (que l'on peut modifier avec File --> Change dir).

Le compilateur n'a pas réussi à trouver une unité.
Très souvent, cela est dû à une mauvaise définition des répertoires dans les options de Turbo Pascal. Vérifiez donc dans Options --> Directories... que tous les répertoires sont corrects.

Vous avez bien entendu deviné : le disque est plein et il n'y a plus moyen d'enregistrer de fichier et même de compiler, si le compilateur et/ou l'éditeur de liens utilisent le disque.

Cette erreur peut avoir plusieurs causes :

• le compilateur rencontre une directive de compilation inconnue (qui peut, par exemple, provenir de l'importation de code d'un autre compilateur) ;
• vous insérez une directive de compilation globale au milieu du source (par exemple, une directive {$M}) ;
• le contenu d'un commentaire commence malencontreusement par le caractère $.

Votre projet, dans sa globalité, contient trop de fichiers (fichiers sources, fichiers include).
Si vous avez beaucoup de fichiers include, essayez de les rassembler. Vous pouvez également tenter cette astuce : donnez à vos fichiers des noms très courts.

Dans la déclaration d'un type pointeur, le type référencé n'est déclaré nulle part.

Exemple :

1
2
  
Type pEnreg = ^Enreg;

Un identificateur utilisé ne correspond pas à une variable déclarée.

Le nom de type commence par un symbole illégal.

La taille d'une structure (tableau ou enregistrement) ne peut dépasser 65 520 octets (par exemple, un tableau d'entiers (Integer) ne peut comporter que 65 520 / 2 soit 32 760 entiers). Des astuces existent pour allouer des structures plus larges en passant par la mémoire dynamique.

La taille du type de base d'un ensemble ne peut dépasser un octet :

1
2
3
  
Var s1 : Set of Word;   { Erreur de compilation } 
    s2 : Set of Byte;   { OK }

1
2
if i in [1..350] then   { Erreur de compilation } 
if i in [1..255] then   { OK }

On ne peut déclarer de type File of File ou File of Object.

La taille d'une chaîne de caractères de type String ne peut dépasser 255 caractères.

Voici peut-être l'erreur de compilation la plus fréquente : une variable ou une expression d'un type non attendu par le compilateur.
Il y a une foule de raisons possibles :

• affectation à une variable d'une variable ou expression d'un autre type ;
• passage à une procédure ou fonction d'un paramètre d'un type invalide ;
• utilisation comme indice d'un tableau d'une variable d'un type non attendu par le compilateur ;
• etc.

Le type d'un sous-intervalle doit être scalaire.

C'est tout simple : cette erreur de compilation est déclenchée lorsque la borne inférieure d'un intervalle est supérieure à la borne supérieure.

Le compilateur attend un type scalaire à l'emplacement de l'erreur. Vous faites peut-être référence à un pointeur, un réel ou un type structuré.

Le compilateur attend une constante de type entier.

Le compilateur attend une constante et non, par exemple, le résultat d'une expression.

Le compilateur attend uniquement une constante numérique.

Le compilateur attend un identificateur de type pointeur.

Une fonction ne peut retourner qu'un type simple ou un pointeur ou une chaîne de caractères (string). Pour retourner, par exemple, un type structuré, il faut passer celui-ci comme variable par adresse.

Exemple qui génère l'erreur 34 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
Program Stock; 
  
Type tArticle = Record 
                  Num : Integer; 
                  Nom : String[25]; 
                end; 
     tTab = Array [1..20] of tArticle; 
  
Var Stock : tTab; 
    i : Integer; 
  
Function NouvelArticle : tArticle;   { <-- Erreur de compilation 34 } 
Begin 
  Write('Entrez le n°  : '); ReadLn(NouvelArticle.Num); 
  Write('Entrez le nom : '); ReadLn(NouvelArticle.Nom); 
End; 
  
Begin 
  for i := 1 to 20 do 
    Stock[i] := NouvelArticle; 
End.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
Program Stock; 
  
Type tArticle = Record 
                  Num : Integer; 
                  Nom : String[25]; 
                end; 
     tTab = Array [1..20] of tArticle; 
  
Var Stock : tTab; 
    i : Integer; 
  
Procedure NouvelArticle (var Article : tArticle); 
Begin 
  Write('Entrez le n°  : '); ReadLn(Article.Num); 
  Write('Entrez le nom : '); ReadLn(Article.Nom); 
End; 
  
Begin 
  for i := 1 to 20 do 
    NouvelArticle(Stock[i]); 
End.

L'instruction goto attend un label, pas un identificateur de procédure, fonction ou variable.
Utilisez le lien ci-dessous pour voir les détails de l'utilisation des labels.

Le compilateur attend un begin. Cette erreur peut avoir de multiples causes. Typiquement, le compilateur attend le begin du programme principal parce qu'il y a un end en trop dans la déclaration des procédures et fonctions.

Le compilateur attend un end. Revoyez la structure de vos blocs conditionnels ou l'imbrication de procédures et fonctions.

Le compilateur attend une expression de type entier.

Le compilateur attend une expression de type scalaire.

Le compilateur attend une expression de type booléen.
Généralement, cette erreur vient d'un if sur une expression ou une fonction non booléenne.

Vous utilisez une opération sur des variables ou constantes d'un type incompatible avec celle-ci.
Par exemple, l'opérateur div utilisé avec des réels ou l'opérateur / utilisé avec des entiers, une soustraction de caractères, etc.

Cette erreur indique généralement qu'une expression est incomplète : soit il manque l'opérateur, soit il manque un opérande.

Cette erreur est déclenchée lorsque l'on essaye d'affecter une valeur à une variable de type fichier ou à une fonction, en dehors du corps de la fonction.

L'identificateur pointé par l'erreur ne correspond pas à un champ d'enregistrement.

La taille d'un fichier .OBJ ne peut dépasser 64 Kb.

Dans un fichier .OBJ destiné à être lié à l'exécutable final, il n'y a aucune procédure ou fonction déclarée PUBLIC qui correspond à l'identificateur.

Le fichier .OBJ que vous tentez de lier à votre programme n'est peut-être pas au format 16 bits.

Votre module (programme principal ou unité) est trop gros. Il faut le scinder en plusieurs unités.

Votre programme a déclaré trop de variables et constantes. Vous devez nécessairement réduire cette quantité soit en supprimant certaines variables, soit en utilisant la mémoire dynamique pour les grosses structures (tableaux, enregistrements). Un programme ne peut contenir qu'au maximum 65 520 octets de données, y compris les variables déclarées dans la partie interface des unités.

Il manque tout simplement le mot réservé do avec une des instructions suivantes :

• while {expression} do
• with {enregistrement} do
• for {compteur} do
  

Cette erreur est générée lors de l'ajout d'un fichier .OBJ à votre programme. Voici les causes possibles :

• une procédure ou fonction déclarée PUBLIC dans le code objet n'est pas déclarée comme external dans le programme Pascal ;
• il y a plus d'une directive PUBLIC pour un seul et unique identificateur dans le code objet ;
• une directive PUBLIC concerne un identificateur qui n'est pas situé dans le segment CODE (ou CSeg).

Cette erreur est générée lors de l'ajout d'un fichier .OBJ à votre programme. Voici les causes possibles :

• dans le code objet, il est fait référence à un identificateur inexistant dans le source Pascal (du moins, qui n'est déclaré ni dans le module d'appel, ni dans une des unités utilisées par le programme ;
• il est fait référence à une variable absolute dans le source Pascal ;
• il est fait référence à une routine inline.

Cette erreur est générée lors de l'ajout d'un fichier .OBJ à votre programme : on ne peut référencer que 256 identificateurs EXTRN maximum.

Il manque le petit of dans une instruction case of :

1
2
3
4
5
  
case Reponse of 
  'O' : ... 
  'N' : ... 
end;

Dans la syntaxe d'une unité, toutes les déclarations de types, variables, constantes, procédures, fonctions publiques doivent se trouver dans une partie interface.
Voici la structure générale d'une unité :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
  
Unit MyUnit; 
  
Interface 
  { Unités éventuellement utilisées } 
  Uses ... 
  
  { Constantes, types et variables PUBLICS } 
  Const ... 
  Type ... 
  Var ... 
  
  { En-tête des procédures et fonctions PUBLIQUES } 
  Procedure Proc1; 
  Procedure Proc2; 
  
Implementation 
  { Unités éventuellement utilisées } 
  Uses ... 
  
  { Constantes, types et variables PRIVES } 
  Const ... 
  Type ... 
  Var ... 
  
  { Procédures et fonctions PRIVEES } 
  Procedure Proc3; 
  Begin 
    { ... } 
  End;   
  
  { Corps des procédures et fonctions PUBLIQUES } 
  Procedure Proc1; 
  Begin 
    { ... } 
  End; 
  Procedure Proc2; 
  Begin 
    { ... } 
  End; 
  
Begin   { Uniquement si du code d'initialisation doit être exécuté } 
  { Code d'initialisation éventuel } 
End.

Cette erreur est générée lors de l'ajout d'un fichier .OBJ à votre programme. Voici les causes possibles :

• vous avez déclaré une variable initialisée dans le segment DATA : c'est interdit et il faut toujours utiliser ? dans les déclarations (voir l'exemple 1 ci-dessous) ;
• une instruction fait référence à un symbole qui ne se trouve pas dans les segments CODE ou DATA ;
• dans une instruction, vous ajoutez un déplacement à un identificateur de procédure ou fonction référencé par la directive EXTRN (voir l'exemple 2 ci-dessous).

1
2
3
4
5
6
7
8
9
10
 
DATA      SEGMENT   WORD   PUBLIC 
 
          ; Variable initialisée : INCORRECT 
		  NbCases   dw     100           
		   
		  ; Voici ce qui est CORRECT : 
		  NbCases   dw     ?           
 
DATA      ENDS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
CODE      SEGMENT   WORD   PUBLIC 
 
          ASSUME    CS:CODE,DS:DATA 
          EXTRN     Traitement : NEAR   ; Routine implémentée dans le source Pascal 
 
          PUBLIC    Recherche 
 
Recherche PROC      FAR 
          ... 
          ; Ajout d'un déplacement à l'identificateur déclaré EXTRN : INCORRECT 
		  call      Traitement+8 
          ... 
Recherche ENDP 
 
CODE      ENDS

Il manque le then dans une instruction if then (else) :

1
2
3
4
5
6
  
if Reponse = 'O' 
   then 
     ... 
   else 
     ...

Il manque le to ou le downto dans une instruction for :

1
2
3
4
5
6
7
8
9
10
  
for i := 1 to 10 do 
  begin 
    ... 
  end; 
  
for i := 5 downto 1 do 
  begin 
    ... 
  end;

Voici les deux causes possibles à cette erreur :

• vous avez probablement déclaré une fonction ou procédure dans la partie interface d'une unité sans écrire son code dans la partie implémentation ;
• vous avez déclaré une procédure ou fonction avec la directive [B]forward[/B, mais avez omis de l'implémenter dans la suite du code.

Cette erreur est déclenchée par un transtypage invalide :

• soit les deux types n'ont pas la même taille ;
• soit vous vous trouvez dans un cas où le transtypage ne peut s'appliquer à une expression.

Dans une division, le diviseur a la valeur 0.

Il s'agit bien ici d'une erreur de compilation et non d'exécution ! Prenons deux exemples :

1
2
3
4
5
6
7
8
9
10
11
  
Program Divise; 
  
Const b = 0; 
  
Var a : Integer; 
  
Begin 
  a := 4; 
  WriteLn(a div b);   { Erreur de compilation 62 } 
End;

1
2
3
4
5
6
7
8
9
10
  
Program Divise; 
  
Var a, b : Integer; 
  
Begin 
  a := 4; 
  b := 0; 
  WriteLn(a div b);   { Pas d'erreur de compilation mais erreur d'exécution 200 } 
End;

Certaines procédures et fonctions adaptées aux fichiers binaires ne peuvent être utilisées sur des fichiers texte et vice-versa.
Cette erreur de compilation sera déclenchée, par exemple, si vous essayez d'utiliser Seek sur un fichier texte ou WriteLn sur un fichier binaire.

Vous tentez d'utiliser Write/WriteLn ou Read/ReadLn avec un type de variable complexe, autre qu'un entier, un réel, un booléen, un caractère ou une chaîne de caractères.
Si, par exemple, vous voulez afficher le contenu d'un tableau, il faut utiliser Write avec chaque élément du tableau (Write(A[1])), et non avec le tableau en entier (Write(A)).

Le compilateur attend une variable de type pointeur, probablement comme paramètre d'une routine telle que New, GetMem, Dispose ou FreeMem.

Le compilateur attend une variable de type chaîne de caractères.

Le compilateur attend un type chaîne de caractères comme résultat d'une expression.

Deux unités se référencent mutuellement au travers de leurs clauses uses de leur partie interface, ce que le compilateur ne sait pas gérer (quelle unité compiler en premier ?). Pour résoudre le problème, il faut déplacer au moins une clause uses dans la partie implementation pour supprimer la référence circulaire.

Une unité ne possède pas un nom de fichier correspondant à son intitulé. Ainsi, si une unité s'appelle Unit1, alors elle devra être enregistrée dans le fichier UNIT1.PAS. Si le nom de l'unité dépasse 8 caractères, par exemple UniteNumero1, alors le nom de fichier doit être tronqué à 8 caractères, par exemple UNITEN~1.PAS.

Cette erreur se produira également si vous renommez un fichier .TPU : son nom de fichier sera changé, mais pas son nom interne. Pour renommer une unité, il faut idéalement la recompiler.

Vous avez modifié une unité dont se sert une unité plus ancienne. Dans ce cas, reconstruisez le projet avec Compiler --> Build.

Il ne s'agit pas réellement d'une erreur dans le source puisqu'en fait, cette erreur provient d'un débordement de la pile interne du compilateur. Votre code comporte trop de niveaux d'instructions imbriquées.
Une solution peut être de créer une procédure ou fonction indépendante, contenant le ou les dernier(s) niveau(x) d'instructions imbriquées.

Un fichier .TPU provient d'une autre version de Turbo Pascal. Si vous possédez le source de cette unité, il vous suffit de le recompiler. Par contre, si vous ne le possédez pas, le problème est difficilement soluble, car il n'existe aucun utilitaire permettant de convertir un fichier TPU d'une version à une autre.
Si vous souhaitez déterminer la version d'un fichier TPU, c'est très simple : avec n'importe quel éditeur, regardez les 4 premiers caractères du fichier :

Cette erreur de compilation est la petite sœur de l'erreur 55 : il manque le mot-clé Implementation. Turbo Pascal ne tolère pas que le code d'une procédure ou fonction soit implémenté dans la partie Interface d'une unité.
Voyez le lien ci-dessous pour la syntaxe complète d'une unité.

Vous utilisez un type de constante incompatible avec le sélecteur d'une expression case of.
Exemple :

1
2
3
4
5
6
7
8
9
  
Const c = 2.2;    { Constante réelle... } 
Var i : Integer;  { ... mais sélecteur entier } 
  
  case i of 
    ... 
    c : { Erreur 74 } 
    ... 
s  end;

Le compilateur attend une variable de type enregistrement (record) ou objet (object).

Le compilateur détecte une constante qui déborde du domaine de validité :

• d'un indice de tableau ;
• d'une variable ;
• d'un paramètre de procédure ou fonction.

Le compilateur attend une variable de type fichier (file).

Le compilateur attend une expression de type pointeur (pointer).

Le compilateur attend une expression de type entier (integer) ou réel (real).

Une instruction goto référence un label situé hors du bloc de code courant.
Utilisez le lien ci-dessous pour voir les détails de l'utilisation des labels.

Dans un même bloc d'instructions, il ne peut bien sûr y avoir deux fois le même label.

Le compilateur rencontre un label qui n'a pas été déclaré par une directive label.

L'argument @ n'est autorisé que pour exprimer l'adresse d'une variable, constante typée, procédure ou fonction.

Le mot réservé Unit est absent.
Voyez le lien ci-dessous pour la syntaxe complète d'une unité.

Cette erreur est un classique parmi les classiques : il manque un point-virgule à la fin d'une instruction ! La seule exception à cette règle est la dernière instruction qui précède un end.

Dans la déclaration d'une variable ou d'une constante typée, la spécification de type doit bien sûr être précédée d'un deux-points :

1
2
3
  
Var i : Integer; 
Const p : Pointer = Nil;

Il y a plusieurs causes possibles à cette erreur de compilation, mais une qui revient régulièrement est un nombre insuffisant de paramètres passés à une procédure ou fonction.

Le compilateur attend l'ouverture d'une parenthèse. Parmi les quelques causes possibles, la plus courante est l'appel d'une procédure ou fonction sans aucun paramètre alors qu'elle en nécessite.

Erreur de distraction : une parenthèse ouverte n'a pas été refermée.

Dans une déclaration de type, il ne faut pas utiliser les deux-points (comme dans la déclaration d'une variable ou constante typée), mais bien le signe =.
Même chose dans la déclaration d'une constante non typée.

1
2
3
4
5
6
  
Type Enreg = Record 
               Numero : Integer; 
               Article : String; 
               Prix : Real; 
            end;

1
2
  
Const NbLignesEcran = 25;

Le compilateur attend une instruction d'affectation.

Il manque un crochet, soit pour indiquer un indice de tableau, soit pour définir un ensemble.
Notez que le crochet est équivalent à (., qui est une syntaxe très rarement utilisée :

1
2
3
  
Type Tab1 = Array [0..9] of Byte;					 
     Tab2 = Array (.0..9.) of Byte;   { Syntaxe correcte ! }

Dans la définition d'un indice de tableau ou d'un ensemble, il manque le crochet de fermeture.
Notez que le crochet est équivalent à .), qui est une syntaxe très rarement utilisée.

Il manque un point. Généralement, cette erreur provient d'un problème de statement : il y a un end; de trop dans votre code, de sorte que le compilateur prend le end; suivant pour le end final de votre programme ou unité.

Pour définir un intervalle de valeurs, il faut utiliser deux points :

1
2
3
4
  
case Caractere of					 
  'A'..'Z','a'..'z' : ... 
end;

Vous avez déclaré trop de variables (chaque élément d'un tableau compte pour une variable). Tentez de réduire ce nombre, soit en supprimant des variables, soit en utilisant la mémoire dynamique.

La variable de contrôle de l'instruction for doit absolument être déclarée dans le même sous-programme que l'instruction.

Le compilateur attend une variable de type entier.

Dans la partie déclarations, une constante typée ne peut pas être de type file ni procedure ni function.

Vous affectez à un tableau de caractères une constante chaîne dont la longueur ne correspond pas.

Vous déclarez une constante typée de type enregistrement ou objet ; lors de l'affectation, vous devez absolument respecter l'ordre des champs.

Le compilateur attend une constante de type chaîne de caractères.

Le compilateur attend une variable de type entier ou réel.

Le compilateur attend une variable de type scalaire.

La directive inline permet d'inclure directement du code machine dans le source Pascal. Les opérateurs < et > permettent de fixer la taille des opérandes dans les instructions :

• < provoque l'inclusion uniquement de l'octet de poids faible d'un mot ;
• > force la génération d'une opérande 16 bits.
  

Le compilateur attend une expression de type caractère.

Votre programme est trop volumineux pour l'éditeur de liens de Turbo Pascal. En effet, la table des adresses relocatables ne peut dépasser 64 Kb.

Le résultat d'une opération déborde du domaine de valeurs d'un entier (LongInt). La solution peut être de travailler avec des réels.

La procédure Break provoque la sortie immédiate d'une boucle for, while ou repeat. La procédure Continue, elle, met fin à l'itération en cours et déclenche l'itération suivante d'une boucle for, while ou repeat.
L'erreur de compilation 109 signifie qu'une de ces deux procédures est utilisée hors d'une boucle.

Vous avez demandé au compilateur d'inclure les informations de débogage dans le code. Malheureusement, le nombre de symboles et le nombre de lignes de code (exclus les lignes vides, begin et end) ne peuvent dépasser 65536. L'erreur 110 signifie que ce nombre est dépassé.
Une solution peut être de désactiver l'inclusion des informations de débogage dans certaines unités dont vous êtes sûr(e) du code.

Dans une instruction case of, vous utilisez une constante de type entier qui déborde de l'intervalle de valeurs [-32768..32767].

Une des erreurs de compilation les plus courantes. Vous avez oublié un begin ou un end quelque part !
En soignant l'indentation de votre code, vous deviez repérer assez facilement à quel endroit la directive est manquante.

Turbo Pascal permet d'écrire ses propres procédures d'interruption (voir le lien ci-dessous). Celles-ci sont destinées à être appelées par le système et non directement par le programme.

Votre programme utilise des opérations sur les nombres réels. Il faut activer le coprocesseur arithmétique. Pour ce faire, allez dans Options --> Compiler, puis dans le cadre Numeric processing, cochez 8087/80287 et Emulation.

Lorsque votre programme déclenche une erreur d'exécution, l'adresse de l'instruction qui a déclenché cette erreur est donnée (Segment:Offset). Vous pouvez effectuer une recherche de cette adresse dans l'éditeur de Turbo Pascal, par le menu Search --> Find error. Si l'éditeur ne trouve pas l'instruction correspondante, c'est vraisemblablement que celle-ci se trouve dans un module externe.

Vous spécifiez au compilateur qu'il doit inclure un fichier source à l'intérieur d'un bloc d'instructions. Il est impératif que toutes les instructions d'un bloc (compris entre begin et end) soient situées dans un seul et unique fichier source.

Vous utilisez le mot-clé inherited :

• en dehors d'une méthode d'objet ;
• dans une méthode d'un objet qui n'a pas d'ancêtre.

Cette erreur classique peut avoir des causes multiples :

• vous indicez une variable qui n'est pas de type tableau ou chaîne de caractères ;
• vous spécifiez un champ d'enregistrement qui n'existe pas (sûrement une faute de frappe) ;
• vous déréférencez une variable qui n'est pas de type pointeur.

Vous essayez vraisemblablement d'utiliser le résultat d'une fonction de type pointeur sans le déréférencer.

Vous avez déclaré trop de procédures, fonctions et types. Vous pouvez tenter de réduire ceux-ci, ou bien de désactiver partiellement le débogage dans Options --> Compiler, dans le cadre Debugging, décochez Local symbols.

Un bloc d'instructions (compris entre begin et end) ne peut dépasser 24 Kb, ce qui est déjà énorme. Structurez davantage votre code en procédures ou fonctions.

Un paramètre de type fichier ne peut être transmis à une procédure ou fonction que par adresse.
La raison est que la structure interne du type fichier doit absolument rester cohérente ; on ne peut donc travailler temporairement sur une copie locale, puisque l'état des différents pointeurs et buffers ne serait pas répercuté dans le programme appelant.

Le compilateur a atteint sa limite interne de mémoire pour les symboles de compilation conditionnelle. Essayez d'utiliser des noms d'identificateurs plus courts.

Le compilateur rencontre une directive de compilation conditionnelle {$ELSE} ou {$ENDIF} qui ne correspond à aucune directive {$IFxxx}.

Le compilateur ne trouve pas de directive {$ENDIF} qui mette fin à un bloc défini par une directive {$IFxxx}.

Il est possible de définir des symboles de compilation conditionnelle directement dans les options de compilation, via le menu Options --> Compiler --> Conditional defines.
Les symboles définis à cet endroit doivent être séparés par des espaces, virgules ou points-virgules.
L'erreur 130 indique qu'il y a des caractères illégaux dans un ou plusieurs noms de symboles.

Cette erreur est un grand classique. Elle signifie que l'en-tête d'une procédure ou fonction située dans la partie implementation d'une unité ne correspond pas à la déclaration faite dans la partie interface.
Il peut s'agir aussi d'une différence d'en-tête entre une procédure ou fonction déclarée forward et son implémentation effective plus loin dans le source.

Cette erreur signifie que le compilateur est incapable d'évaluer une expression constante.
En effet, une expression constante ne peut utiliser de variable ou constante typée, ni d'opérateur @, ni de fonction hormis la liste suivante : Chr, Hi, Lo, Ord, Pred, Succ, Abs, Odd, Trunc, Round, Ptr, Swap, Length, SizeOf.

Exemple d'expression erronée :

1
2
3
  
Const Angle = 60; 
      Sinus = Sin(Angle);   { Erreur de compilation 133 }

Dans une expression, il manque vraisemblablement un opérateur.

Il y a une erreur dans les paramètres de format passés à la procédure FormatStr de l'unité Drivers.

Vous faites référence indirectement à une variable qui n'est pas connue dans le module courant. Par exemple, une variable absolute dont la variable de base se trouve dans un autre module.

Vous essayez d'effectuer une opération qui n'accepte pas de variables de type structuré.

Le débogueur intégré ne trouve pas l'unité System dans le fichier TURBO.TPL. Sans doute avez-vous isolé l'unité System à l'aide de l'utilitaire TPUMover ; dans ce cas, effectuez l'opération inverse.

Le débogueur intégré ne peut accéder aux variables du programme en dehors de l'exécution de celui-ci.

Une opération sur des réels produit un débordement ou une division par zéro.
Vous pouvez peut-être choisir un type réel permettant de stocker de plus grandes ou de plus petites valeurs, comme les types Double ou Extended.

Pour compiler des overlays, il faut sélectionner Disk comme destination, via le menu Compile --> Destination.

La fonction Assigned teste si la valeur d'un pointeur ou d'une variable de type procedure ou function est différente de Nil.
L'erreur 142 signifie simplement que le paramètre passé à Assigned est d'un autre type.

On ne peut affecter à une variable de type procedure ou function que l'adresse d'une procédure ou fonction far (directive de compilation {$F+}). De plus, il ne peut s'agir d'une routine inline ni d'une interruption.
Il se peut aussi que l'erreur 143 provienne du fait que vous utilisez une variable de type procedure ou function dans une expression.

Pour compiler une unité comme overlay, il faut spécifier la directive de compilation {$O+}.

Votre source comporte trop de niveaux d'imbrication ! Turbo Pascal ne supporte pas plus de 128 niveaux par bloc de code et 512 niveaux sur le total du programme.

C'est le compilateur lui-même qui rencontre une erreur d'écriture de fichier.
Une raison courante est que vous compilez votre source avec comme destination Disk (menu Compile --> Destination) et que l'exécutable créé lors d'une compilation précédente est toujours en cours d'exécution.

Le compilateur attend une variable de type objet.

Les déclarations de type objet ne peuvent pas se faire dans une procédure ou fonction.

Dans une déclaration de type objet, vous avez oublié de spécifier le mot-clé virtual pour une méthode virtuelle.

Dans l'implémentation des méthodes d'un objet, vous avez probablement fait une erreur dans le nom d'une méthode, qui ne correspond donc à aucun nom de méthode dans la déclaration de type.
Il est également possible que vous fassiez référence à une méthode inexistante d'un objet ancêtre.

Un constructeur d'objet ne peut être une méthode virtuelle.

Le compilateur attend un nom de constructeur d'objet. Lorsque vous allouez dynamiquement un objet (à l'aide de la fonction New), vous essayez d'exécuter directement une méthode qui n'est pas le constructeur.

Exemple d'appel correct du constructeur

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
Type pObjetPerso = ^tObjetPerso; 
     tObjetPerso = Object 
                     Constructor INIT; 
                     ... 
                   end; 
  
Var MonObjet : pObjetPerso; 
  
Begin 
  { Allocation de l'objet et exécution du constructeur } 
  MonObjet := New(pObjetPerso,INIT); 
  ... 
End.

Le compilateur attend un nom de destructeur d'objet. Lorsque vous désallouez (à l'aide de Dispose) un objet dynamiquement alloué, vous essayez d'exécuter directement une méthode qui n'est pas le destructeur.

Exemple d'appel correct du destructeur

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  
Type pObjetPerso = ^tObjetPerso; 
     tObjetPerso = Object 
                     Constructor INIT; 
                     ... 
                     Destructor DONE; 
                   end; 
  
Var MonObjet : pObjetPerso; 
  
Begin 
  { Allocation de l'objet et exécution du constructeur } 
  MonObjet := New(pObjetPerso,INIT); 
  ... 
  { Exécution du destructeur et désallocation de l'objet } 
  Dispose(MonObjet,DONE); 
End.

La procédure Fail force la désallocation immédiate d'un objet, s'il y a erreur lors de sa construction. Cette procédure ne peut être appelée que dans un constructeur d'objet.

Il y a une erreur de syntaxe dans un bloc de code Assembleur. En substance, une instruction reçoit un nombre erroné d'opérandes, un ou plusieurs opérandes incompatibles ou encore les opérandes ne sont pas dans le bon ordre.
La syntaxe attendue par le compilateur est celle de TASM.

Dans un bloc de code Assembleur, le compilateur attend un opérande de type mémoire.
Il est possible que vous ayez omis d'encadrer un adressage indirect basé et/ou indexé avec des crochets, par exemple :

1
2
 
mov ax,[bp+si]

Dans un bloc de code Assembleur, vous spécifiez un opérande qui est la somme (ou la soustraction) de deux adresses relogeables. Une adresse relogeable est une variable, une constante typée, une procédure, une fonction ou un label.

1
2
3
 
mov ax,variable + constante_non_typee 
mov ax,constante_non_typee + constante_non_typee

1
2
 
mov ax,variable + variable

Dans un bloc de code Assembleur, vous spécifiez un adressage basé-indexé incorrect.

1
2
3
4
5
 
mov ax,[bx+si] 
mov ax,[bx+di] 
mov ax,[bp+si] 
mov ax,[bp+di]

Dans un bloc de code Assembleur, vous utilisez des instructions non supportées par le processeur 8086/8088 sans avoir spécifié l'option de compilation {$G+}.

Dans un bloc de code Assembleur, vous utilisez comme opérande une adresse inatteignable :

• une procédure ou fonction standard ;
• Mem, MemW, MemL, Port, PortW ;
• une constante non typée ;
• une routine inline ;
• le résultat par défaut d'une fonction (Result), hors de la fonction.
  

Il y a une erreur à l'assemblage d'un bloc de code Assembleur.
Typiquement, un saut court (short jump) ne peut atteindre le label spécifié comme opérande. Le label ne peut en effet être distant de plus de 128 octets de l'instruction en cours.
Si l'erreur est déclenchée par un saut conditionnel (je, jnb, etc.), vous pouvez éventuellement faire un saut intermédiaire vers une instruction de saut long (jmp). De même, si l'erreur provient d'une instruction loop, vous pouvez essayer de remplacer celle-ci par un test du registre cx suivi d'un jmp.

Un bloc de code Assembleur doit toujours débuter par la directive asm.

Dans une déclaration de type objet, vous spécifiez le même index à deux méthodes dynamiques. Il est possible que l'index soit déjà utilisé par une méthode de l'objet ancêtre de votre objet.

Votre programme (Turbo Pascal for Windows) utilise deux ressources qui ont le même identificateur.

Vous compilez une DLL et :

• soit deux routines exportées ont le même index ;
• soit l'index d'une routine sort de l'intervalle [1..32767].

Lorsque vous compilez une DLL, vous ne pouvez spécifier dans la section Exports que des procédures et des fonctions.

Lorsque vous compilez une DLL, vous devez spécifier la directive export pour exporter une procédure ou une fonction. L'erreur 167 signifie que le compilateur a trouvé dans la section Exports une routine qui n'a pas été déclarée avec cette directive.

Dans votre DLL, deux routines portent le même nom d'export.

L'en-tête de l'exécutable dépasse la taille maximale de 64 Kb.
Il se peut que vous importiez ou exportiez des routines par leur nom d'export : essayez de remplacer ce nom par l'index. De même, si votre programme (Windows) contient des ressources avec des identificateurs littéraux, remplacez ceux-ci par des identificateurs numériques.

Votre programme (compilé pour les plateformes DPMI ou Windows) comporte plus de 254 segments.
Vous pouvez augmenter la taille par défaut (16384) de segment de code à l'aide de la directive de compilation {$S xxx}.