Compiler switches: -$ (defaults are shown below)

  A8  Aligned record fields
  B-  Full boolean Evaluation
  C+  Evaluate assertions at runtime
  D+  Debug information
  E-  Unknown
  F-  Force far procedure calls on | off.
  G+  Use imported data references
  H+  Use long strings by default
  I+  I/O checking
  J-  Writeable structured consts
  K-  Use smart callbacks.
  L+  Local debug symbols
  M-  Runtime type info
  N+  Numeric coprocessor support and floating point types
  O+  Optimization
  P+  Open string params
  Q-  Integer overflow checking
  R-  Range checking
  S-  Generate stack-overflow checking code
  T-  Typed @ operator
  U-  Pentium(tm)-safe divide
  V+  Strict var-strings
  W-  Generate stack frames
  X+  Extended syntax
  Y+  Symbol reference info
  Z1  Minimum size of enum types


 -----------------------------------------------------------------------------

$A[+|-|1|2|4|8]
 Align data on word boundaries.
  The $A compiler directive determines whether Delphi aligns data, or whether
  it packs the data into the smallest space.
  Note: In older versions of Delphi, this option could be checked on or off.
  Choosing 1 is the equivalent of off and 8 is the equivalent of on.
  
  * En mode {$A1} ou {$A-}, les champs ne sont jamais alignés. Tous les
   enregistrements et structures classe sont packed.
  * En mode {$A2}, les champs des types enregistrement déclarés sans le
   modificateur packed et les champs des structures classe sont alignés sur
   les frontières des mots.
  * En mode {$A4}, les champs des types enregistrement déclarés sans le
   modificateur packed et les champs des structures classe sont alignés sur
   les frontières des doubles mots.
  * En mode {$A8} ou {$A+}, les champs des types enregistrement déclarés sans
   le modificateur packed et les champs des structures classe sont alignés sur
   les frontières des quadruples mots.
  
  Quel que soit le mode de la directive $A, les variables et constantes
  typées sont toujours alignées pour un accès optimal. En mode {$A8},
  l'exécution est plus rapide.


$B[+|-]
 Short circuit boolean expression evaluation
  The $B compiler directive tells Delphi whether to continue a multi argument
  boolean expression evaluation when the result is known before evaluation
  completes. 


$C[+|-]
 Evaluate assertions at runtime
  La directive $C active ou désactive la génération de code pour les
  assertions dans un fichier source Delphi. {$C+} est la valeur par défaut.
  Comme les assertions ne sont pas habituellement utilisées au moment de la
  compilation des versions commercialisées d'un produit, les directives de
  compilation désactivant la génération de code pour les assertions sont
  fournies. {$C-} désactivera les assertions.


$D[+|-]
 Generate debugger information, on for Debug, off for Release.
  The $D compiler directive determines whether Delphi builds debug
  information for the application.
  By default, Delphi builds the information, which provides the line number
  when a program abnormally terminates.
  The overheads for keeping $D on are minimal.


$F[+|-]
 Force far procedure calls on | off.


$G[+|-]
  Use imported data references (delphi doc)
 or
  Generate 80286 code (Windows protected mode).


$H[+|-]
 Treat string types as AnsiString or ShortString
  The $H compiler directive determines whether Delphi treats the string type
  as an AnsiString when on (default) or ShortString when off.
  The default recognises that the general use of string types is to hold data
  that is likely to be longer than 255 characters (ShortString capacity).

  L'état {$H-} est surtout pratique pour utiliser du code écrit pour des
  versions précédentes de Delphi qui utilisaient par défaut le type chaîne
  courte. Vous pouvez localement surcharger la signification des définitions
  des types chaînes pour assurer la génération de chaînes courtes. Vous
  pouvez aussi changer les déclarations des types chaînes courtes en
  string[255] ou ShortString, qui ne sont pas ambigus et sont indépendants
  du paramètre $H.


$I[+|-]
 IO errors generate exceptions.
  Controls whether exceptions are thrown when an IO error occurs.
  {$I+} default generates the EInOutError exception when an IO error occurs.
  {$I-} does not generate an exception. Instead, it is the responsiblity of
  the program to check the IO operation by using the IOResult routine.


$J[+|-]
 Writeable structured consts
  Enable this for backward compatibility with Delphi 1.0 on Windows. When
  enabled, the compiler allows assignments to typed constants. Corresponds
  to {$J}.
  
  La directive $J contrôle si les constantes typées peuvent être modifiées
  ou non. En mode {$J+}, les constantes typées peuvent être modifiées et sont
  essentiellement des variables initialisées. En mode {$J-}, les constantes
  typées sont réellement constantes et toute tentative de modification d'une
  constante typée provoque l'émission d'une erreur par le compilateur.

  Dans les premières versions de Delphi et de Borland Pascal, les constantes
  typées pouvaient toujours être modifiées, ce qui correspond au mode {$J+}.
  L'ancien code source utilisant des constantes typées affectables doit être
  compilé en mode {$J+}, mais pour les nouvelles applications, il est
  conseillé d'initialiser les variables et de compiler votre code en
  mode {$J-}.


$K[+|-]
 Use smart callbacks.


$L[+|-]
 Generate local symbol information for debugging, on for Debug, off for Release.
  The $L compiler directive determines whether Delphi saves local symbols
  when building debug information for the application.
  By default, Delphi builds the routine, variable and line number
  information, but this can be dsiabled by setting $L off.
  The overheads for keeping $L on are minimal.


$M[+|-]
 Runtime type info
  La directive $M contrôle la génération d'informations de type accessibles
  à l'exécution (RTTI). Lorsqu'une classe est déclarée en mode {$M+}, le
  compilateur génère des informations de type pour les champs, les méthodes
  et les propriétés déclarées dans les sections published de cette classe.

  Une application utilise directement l'indicateur $M de compilation très
  rarement, si ce n'est jamais.


$M[minStackSize, maxStackSize]
 Tailles d'allocation mémoire
  La directive $M spécifie les paramètres d'allocation mémoire d'une pile
  d'application. 'minStackSize' doit être un entier compris entre 1 024 et
  2 147 483 647, et spécifie la taille minimum d'une pile d'application.
  maxStackSize doit être un entier compris entre 'minStackSize' et
  2 147 483 647 spécifiant la taille maximum d'une pile d'application.

  S'il n'y a pas assez de mémoire disponible pour satisfaire les besoins
  minimum de pile d'une application, Windows émettra une erreur lors du
  démarrage de l'application.
  Une pile d'application ne peut jamais dépasser la taille de pile maximum.
  Une telle tentative provoque une exception EStackOverflow.


$N[+|-]
 Numeric coprocessor support and floating point types : Single, Double,
  Extended, and Comp.


$O[+|-]
 Optimization
  The $O compiler directive determines whether Delphi compiles the current
  application with code optimization. Code optimization makes for slightly
  more efficient code operation, and size.

  Delphi does this in a way that preserves the logical integrity of the code,
  but which can confuse during debugging. This is especially true when Delphi
  creates no code for what it sees as redundant lines, such as variable
  assignment where the variable is then not used.


$P[+|-]
 Open String parameters
  Allow string variables of varying sizes to be passed to the same procedure
  or function. 
  
  La directive $P n'a de signification que pour du code compilé en mode {$H-}
  et assure une compatibilité descendante avec les premières versions de
  Delphi et de Borland Pascal. $P contrôle la signification des paramètres
  variables déclarés en utilisant le mot réservé string en étant à l'état
  {$H-}.

  * En mode {$P-}, les paramètres variables déclarés à l'aide du mot clé
   string sont des paramètres variables normaux.
  * En mode {$P+} il s'agit de paramètres chaînes ouverts.

  Quel que soit le positionnement de la directive $P, il est toujours possible
  d'utiliser l'identificateur openstring pour déclarer des paramètres chaînes
  ouverts.


$Q[+|-]
 Integer overflow checking
  The $Q compiler directive determines whether Delphi should add code to
  check for integer and enum operation value overflows.
  This is set off by default, meaning that a bad integer or enum operation
  will pass unnoticed, revealing itself in a difficult to debug part of the
  code.
  It is recommended to switch on OverFlowChecks in order to detect overflows
  before they cause problems. This will result in the raising of an exception,
  allowing code testing to correctlt identify the point of failure.


$R[+|-]
 Range checking
  This is set off (-) by default, meaning that a bad array access will pass
  unnoticed, revealing itself in a difficult to debug part of the code.
  It is recommended to switch on $R in order to detect array bound problems.
  This will result in the raising of an exception, allowing code testing to
  correctlt identify the point of failure.


$S[+|-]
 Generate stack-overflow checking code.


$T[+|-]
 Typed @ operator
  Type checking of pointer value the @ operator returns when applied to a
  variable reference.


$U[+|-]
 Pentium(tm)-safe divide
  Generates Delphi code that detects a faulty floating-point division
  instruction.


$V[+|-]
 Strict var-strings.
  type-checking on strings passed as variable parameters


$W[+|-]
 Generate stack frames
  Generates special prolog and epilog code for far procedures and functions
  (stack frames), on for Debug off for Release.


$X[+|-]
 Extended syntax
  Enables you to define a function call as a procedure and to ignore the
  function result. Also enables PChar support.
  
  * Treating functions as procedures
   When +, Delphi will allow a function result to be ignored - unassigned -
   thereby treating the function as if it were a procedure.
 
  * Using Result in functions
   With $X-, you must return a function value by assigning to the pseudo
   variable of the same name as the function. For example :
    function GetValue : Integer; begin   GetValue := 23; end;
 
   With $X+, you can also assign to the pseudo variable 'Result'.
 
  * Treating Char arrays as strings
   With $X+, a zero base array of Char variables can be assigned a string
   value. It can also be assigned from, as long as the array has a #0 value
   element to signify the string end.


$Y[+|-]
 Symbol reference info
  Controls generation of symbol reference information for debugging purposes,
  on for Debug off for Release. 

  La directive $Y contrôle la génération des informations de référence aux
  symboles utilisés par l'explorateur de projet, l'explorateur de code et
  l'éditeur de code. Ces informations sont présentées sous la forme de
  tableaux donnant les numéros des lignes du code source de toutes les
  déclarations et références (dans l'état {$Y+} aux identificateurs d'un
  module. Pour les unités, ces informations sont mémorisées dans le fichier
  '.dcu' avec le code objet de l'unité.
  
  Elles augmentent ainsi la taille des fichiers .dcu, mais cela n'affecte ni
  la taille, ni la vitesse d'exécution du programme exécutable.

  Lorsqu'un programme ou une unité est compilé en mode par défaut {$YD}, le
  compilateur enregistre les informations qui indiquent où est défini chaque
  identificateur. Pour la plupart des identificateurs — variables, constantes,
  classes, etc. — le compilateur enregistre l'emplacement de la déclaration.
  Pour les procédures, fonctions et méthodes, il enregistre l'emplacement de
  l'implémentation. Cela active l'examen de l'éditeur de code.

  * Lorsqu'un programme ou une unité est compilé en mode {$Y+}, le compilateur
   enregistre les informations qui indiquent où est utilisé chaque
   identificateur et où il est défini. Cela active la page Références de
   l'explorateur de projet.
  * Lorsqu'un programme ou une unité est compilé en mode {$Y-}, aucune
   information de référence de symbole n'est enregistrée. Cela désactive
   l'examen de l'éditeur de code et la page Références de l'explorateur de
   projet.

  La bascule $Y est généralement utilisée en combinaison avec les bascules $D
  et $L, qui contrôlent la génération des informations de débogage et de
  symboles locaux. La directive $Y n'a un effet que si $D et $L sont toutes
  deux activées.

  Remarque : La génération des informations de référence croisée complètes
  {$Y+} peut ralentir le cycle compilation/liaison, c'est pourquoi il vaut
  mieux ne pas l'utiliser, sauf quand vous avez besoin de la page Références
  de l'explorateur de projet.


$Z[1|2|4]
 Sets the minimum storage used to hold enumerated types.
  The $Z compiler directive sets the minimum storage size, in bytes, that
  enumerated types will take.

  This is set to 1 byte by default, thereby providing capacity for 256
  enumerations. If you exceed the current storage size, by either defining
  rather a lot of enumeration values (over 256), or, more likely, defining
  enumeration values exceeding 256, then a larger storage size is used.
  The $Z directive simply defines the minimum number of bytes to use.

  Les modes {$Z2} et {$Z4} sont intéressants pour l'interfaçage avec des
  bibliothèques C et C++, qui représentent habituellement des types énumérés
  sous la forme de mots ou de doubles mots.

  Remarque : Les directives {$Z-} et {$Z+} sont aussi supportées pour une
  compatibilité descendante avec les premières versions de Delphi et de
  Borland Pascal. Elles correspondent respectivement à {$Z1} et {$Z4}.