Options non prises en charge par les compilateurs C++ améliorés par Clang

Remonter à Compilateurs C++ améliorés par Clang

Les compilateurs C++ améliorés par Clang ne prennent pas en charge les options et les fonctionnalités suivantes de BCC32 :

• Fonctionnalités BCC32 qui ne sont pas prises en charge par les compilateurs C++ améliorés par Clang
• Options BCC32 qui ne sont pas prises en charge par les compilateurs C++ améliorés par Clang
• Options des avertissements BCC32 qui ne sont pas prises en charge par les compilateurs C++ améliorés par Clang

Fonctionnalités BCC32 qui ne sont pas prises en charge par les compilateurs C++ améliorés par Clang

• Codeguard
• Modes de compatibilité bcc (voir Extensions de mots clés C++Builder et Compatibilité du compilateur C++)
• Attributs C++11 deprecated, final (C++), et noreturn (voir Solution pour les attributs C++0x deprecated et final (compilateurs C++ basés sur Clang))
• export (C++)
• fastmath.h
• __RTTI
• typeof, __typeof, __typeof__
• #pragma samecodeseg FUNC [, FUNC ...]
• #pragma hdrignore (obsolète)
• __fortran et _fortran
• cdecl (utiliser __cdecl)
• pascal (utiliser __pascal)
• __abs__(EXPR) (valeur intrinsèque absolue)
• __int__(N) (instruction d'interruption système .N.)
• __alloca__(SIZE) (alloca intrinsèque)
• __strcmp__(ADDR, ADDR) (strcmp intrinsèque)
• __strcpy__(ADDR, ADDR) (strcpy intrinsèque)
• __memset__(ADDR, INT, SIZE (memset intrinsèque)
• __thread (utilisez __declspec(thread))

Remarque: Cette fonctionnalité est disponible uniquement avec le compilateur bcc32 classique, et pas avec le compilateur amélioré par Clang moderne.

Options BCC32 qui ne sont pas prises en charges par les compilateurs C++ améliorés par Clang

• -savemem N
• -3 et -4 (générer du code pour 80386, 80486, 80586 et 80686)
• -5 (générer des instructions Pentium)
• -6 (générer des instructions pour Pentium Pro)
• -AF (utiliser les mots clés et extensions SUN Forte)
• -AG (utiliser les mots-clés et les extensions GNU)
• -AK (utiliser les mots clés et extensions Kernighan and Ritchie (K&R))
• -AU (utiliser les mots clés et extensions UNIX System V)
• -Ax (réserver les mots clés pour les futures extensions C++-0x)
• -B (compiler en .ASM (-S), puis assembler en .OBJ)
• -C (activer les commentaires incrustés)
• -H (générer et utiliser les en-têtes précompilés)
• -H= (définir le nom du fichier à utiliser pour les en-têtes précompilés)
• -Hc (utiliser l'en-tête précompilé en cache (doit être utilisé avec -H ou -H=FILE))
• -He (activer les en-têtes précompilés avec les fichiers de type externe)
• -Hh (arrêter la pré-compilation après le fichier en-tête)
• -HrFILE=FILE (remplacer le nom d'en-tête)
• -Hs (activer les en-têtes précompilés en mémoire cache intelligente)
• -Hp (imprimer les en-têtes comme ils sont inclus)
• -Hu (utiliser mais ne pas générer d'en-têtes précompilés)
• -J (options de génération de templates)
• -Jgd (générer des définitions pour toutes les instances de templates et fusionner les doublons)
• -Jgi (imprimer toutes les instanciations requises, avec la syntaxe C++)
• -Jgx (générer des références externes pour toutes les instances de templates)
• -Jqs (générer des références externes pour toutes les instances de templates)
• -Nd (les macros obtiennent la valeur "1" par défaut (-DX => -DX=1))
• -NmFILE (emplacement du catalogue de messages)
• -Nt (Support GNU __typeof(SYM))
• -Nv (autoriser void& comme type valide)
• -O (optimiser les sauts ; les sous-options pour '-O' peuvent être combinées en une seule option (-XA -XB => -XAB))
• -Ob (élimination de mémoire morte)
• -Oc (éliminer les expressions en double à l'intérieur des blocs et des fonctions basiques)
• -Oi (développer les fonctions intrinsèques communes (inline))
• -OI=NN (coût inline maximal [0=désactivé, 100=no max.])
• -Or (utiliser une variable registre)
• -Ov (permettre la réduction de force et la variable d'induction de boucle)
• -OS (permettre la planification des intructions Pentium)
• -Q (informations d'erreur du compilateur étendues)
• -R (inclure les informations du navigateur dans les fichiers .OBJ générés)
• -Rb (permettre la prise en charge des informations de navigateur (compilateur de l'EDI uniquement))
• -Rk (permettre la prise en charge des informations de navigateur (compilateur de l'EDI uniquement))
• -Rx (permettre la prise en charge des informations de navigateur (compilateur de l'EDI uniquement))
• -RF[=NAME] (chercher toutes les références [au symbole avec le nom substantypé NAME])
• -V (gestion des tables virtuelles [toujours CF_VIRT_SDEF])
• -V0 (gestion des tables virtuelles [toujours CF_VIRT_SDEF])
• -v1 (gestion des tables virtuelles [toujours CF_VIRT_SDEF])
• -VA (générer toutes les fonctions globales dans leur segment virtuel/faible propre)
• -VC (ne pas substantyper les conventions d'appel dans les symboles)
• -VF (compatibilité MFC)
• -VF3 (compatibilité MFC 3.0)
• -VF4 (compatibilité MFC 4.0)
• -VI (compatibilité d'inclusion MSC)
• -VM (compatibilité Microsoft Visual C++)
• -Va (supporter les arguments de classe de style ancien)
• -Vb (activer la compatibilité descendante avec les versions Bcc 5.8.2 et supérieures)
• -Vbc (ne pas replier ref-to-ref et autoriser les références qualifiées)
• -Vbe (autoriser la spécialisation de template explicite de style ancien)
• -Vbi (suivre les règles C89)
• -Vbn (autoriser l'appel d'une fonction membre non-const ou non-volatile pour un objet const ou volatile)
• -Vbo (utiliser les anciennes règles de résolution de surcharge (anciennes règles Borland))
• -Vbr (autoriser la liaison de références non-const (anciennes règles Borland))
• -Vbs (traiter les littéraux chaîne en tant que non-const)
• -Vbt (utiliser les anciennes règles de type pour les opérateurs ternaires (anciennes règles Borland))
• -Vbu (utiliser les anciennes règles pour 'using' dans les templates (anciennes règles Borland))
• -Vbv (anciennes règles de référence rvalue)
• -Vbx (permettre la spécialisation de template explicite en tant que fonction membre)
• -Vc (supporter les déplacements de constructeurs)
• -Vd (utiliser les anciennes règles de portée de l'instruction for C++)
• -Ve (classe de base vide de longueur zéro)
• [[Compatibilité du compilateur C++|-Vg (désactiver le scanner de digraphes lexicaux)
• -Vi (substantypage d'inclusion <> d'ancien style (inclusions de style 8.3))
• -Vl (utiliser l'ancienne disposition de classe Borland)
• -Vm (options de pointeur membre)
• -Vmd (utiliser la plus petite représentation possible pour les pointeurs membre)
• -Vmm (supporter l'héritage multiple pour les pointeurs membre)
• -Vmp (honorer la précision déclarée des pointeurs membre)
• -Vms (supporter l'héritage unique pour les pointeurs membre)
• -Vmv (ne pas placer de restrictions sur l'endroit où les pointeurs membre peuvent pointer)
• -Vn (activer les nouveaux noms d'opérateurs : and, or, and_eq, bitand, etc.)
• -Vo (définir (presque) tous les indicateurs de compatibilité ; utilisé avec l'ancien code)
• -Vp (pousser 'this' en premier, comme en Pascal)
• -Vr (inverser l'ordre des constantes multicaractères)
• -Vs (gestion des tables virtuelles (toujours CF_VIRT_SDEF))
• -Vt (placer le pointeur de table virtuelle devant la disposition d'objet)
• -Vv (utiliser des pointeurs de base virtuelle 'slow')
• -Vw (émettre le code natif au lieu de Unicode pour les caractères multi-octets)
• -Vx (fonctions de membres de classes vides de longueur zéro (les membres vides n'occupent pas d'espace))
• -X (désactiber la sortie d'autodépendance du compilateur)
• -Zd[=FILE] (afficher les définitions globales sous forme de spécifications DocBook)
• -Zn (désactiver et/ou ne pas définir les builtins CodeGear ; clang: -f[no-]builtin -- reconnaître les fonctions intégrées)
• -Zf (activer les fonctionnalités futures masquées)
• -Zr (dans l'EDI, inverser la liste d'inclusion ; dans le compilateur en ligne de commande, elle est ignorée)
• -Zx (sortir les définitions globales vers un fichier XML)
• -Zx=FILE (émettre seulement les types/declarations dans FILE)
• -Zxf[=FILE] (passer les membres type de base)
• -Zxf[=FILE] (émettre les macros)
• -Zxp[=FILE] (émettre la position fichier et ligne)
• -ff (virgule flottante rapide ON)
• -fp (corriger le défaut Pentium FDIV (cible IX86 seulement) ; msvc: /Qlfdiv)
• -fq (utiliser l'instruction de comparaison en virgule flottante silencieuse (FUCOMP) ON (cible IX86 seulement))
• -g (arrêter la compilation groupée après n avertissements (par défaut = 255))
• -i (définir la longueur d'identifiant signifiant maximale (par défaut = 250))
• -iN (définir la longueur d'identificateur significative maximale sur N)
• -k (générer les cadres de pile standard)
• -mm (ignorer les fichiers en-tête système au moment de générer les informations de dépendance)
• -p (utiliser la convention d'appel Pascal)
• -pm (les fonctions dépourvues d'une convention d'appel explicite doivent utiliser __msfastcall)
• -s (utiliser le lieur lent (Win32 seulement))
• -u (générer des tirets bas sur les noms de symbole)
• -v4 (générer des informations de débogage compatibles CodeView4)
• -vg (basculer le profileur (générer les appels de profilage) ; clang: -p -- Activer le profilage des fonctions)
• -vp (profilage de style paradox)
• -vG (activer toutes les options de surveillance du code ; gcc: -fstack-check; clang: -fcatch-undefined-behavior)
• -vG- (désactiver toutes les options de surveillance du code)
• -vG. (restaurer les valeurs par défaut de la surveillance du code)
• -vGc (surveiller l'accès du pointeur inline)
• -vGd (surveiller les accès aux données globales et pile)
• -vGt (vérifier le pointeur "this" sur l'entrée de fonction membre)
• -vG0 (surveillance du code niveau 0)
• -vG1 (surveillance du code niveau 1)
• -vG2 (surveillance du code niveau 2)
• -vG3 (surveillance du code niveau 3)
• -vu (Ne pas préfixer les symboles exportés par soulignement)
• -xd (activer le nettoyage des destructeurs)
• -xdg (utiliser le compteur de destructeurs globaux (!PC_MAPPED_EXCEPTIONS))
• -xds (pas de nettoyage des destructeurs DLL/MT (!PC_MAPPED_EXCEPTIONS))
• -xf (activer les prologues d'exceptions rapides)
• -xp (activer les informations d'emplacement des exceptions (déclencher les informations de position))
• -xs (activer les épilogues d'exceptions lentes (utiliser les appels fn))
• -xv (masquer les variables d'exception)
• -y (numéros de lignes source dans l'objet)
• -zCNAME (définir le nom codeseg (Windows seulement))
• -zPNAME (définir le nom codegrp (Windows seulement))
• -zANAME (définir le nom codeclass (Windows seulement))
• -zRNAME (définir le nom dataseg (Windows seulement))
• -zSNAME (définir le nom datagrp (Windows seulement))
• -zTNAME (définir le nom dataclass (Windows seulement))
• -zUNAME (définir le nom constseg (Windows seulement))
• -zVNAME (définir le nom constgrp (Windows seulement))
• -zWNAME (définir le nom constclass (Windows seulement))
• -zDNAME (définir le nom bssseg (Windows seulement))
• -zGNAME (définir le nom bssgrp (Windows seulement))
• -zBNAME (définir le nom bssclass (Windows seulement))

Options des avertissements BCC32 qui ne sont pas prises en charge par les compilateurs C++ améliorés par Clang

• -wamb (W8000)
• -wamp (W8001)
• -wasc (W8002)
• -wasm (W8003)
• -waus (W8004)
• -wali (W8086)
• -watr (W8100)
• -watr (W8110)
• -wadt (W8134)
• -wbbf (W8005)
• -wbei (W8006)
• -wbig (W8007)
• -wbex (W8120)
• -wbcx (W8126)
• -wccc (W8008)
• -wcln (W8009)
• -wcom (W8010)
• -wcpt (W8011)
• -wcsu (W8012)
• -wcod (W8093)
• -wcni (W8108)
• -wdef (W8013)
• -wdig (W8014)
• -wdpu (W8015)
• -wdsz (W8016)
• -wdup (W8017)
• -wdep (W8106)
• -wdtp (W8109)
• -wdpr (W8111)
• -wdex (W8112)
• -wdlx (W8127)
• -wdim (W8128)
• -wdgu (W8129)
• -wdiu (W8130)
• -wdin (W8131)
• -wdns (W8139. Prise en charge de declspec '%s' non implémentée)
• -weas (W8018)
• -weff (W8019)
• -wext (W8020)
• -wexc (W8101)
• -weoi (W8125)
• -whch (W8021)
• -whid (W8022)
• -wias (W8023)
• -wibc (W8024)
• -will (W8025)
• -winl (W8026)
• -winl (W8027)
• -wifr (W8085)
• -wimp (W8102)
• -wiex (W8113)
• -winc (W8115)
• -wiip (W8118)
• -wiac (W8121)
• -wind (W8132)
• -witl (W8136)
• -wlin (W8028)
• -wlvc (W8029)
• -wlvc (W8030. Temporaire utilisé pour le paramètre '%s' dans un appel à '%s')
• -wlvc (W8031)
• -wlvc (W8032)
• -wmpc (W8033)
• -wmpd (W8034)
• -wmsg (W8035)
• -wmes (W8095)
• -wmcs (W8096)
• -wmcc (W8098)
• -wmls (W8104)
• -wmnc (W8105)
• -wmal (W8119)
• -wmtx (W8122)
• -wnak (W8036)
• -wncf (W8037)
• -wnci (W8038)
• -wncl (W8039)
• -wnfd (W8040)
• -wngu (W8041)
• -wnin (W8042)
• -wnma (W8043)
• -wnmu (W8044)
• -wnod (W8045)
• -wnop (W8046)
• -wnsf (W8047)
• -wnst (W8048)
• -wntd (W8049)
• -wnto (W8050)
• -wnvf (W8051)
• -wnpp (W8083)
• -wntn (W8107)
• -wnrm (W8124)
• -wobi (W8052)
• -wobs (W8053)
• -wofp (W8054)
• -wosh (W8055)
• -wovf (W8056)
• -wonr (W8097)
• -wpar (W8057)
• -wpch (W8058)
• -wpck (W8059)
• -wpia (W8060)
• -wpin (W8061)
• -wpow (W8062)
• -wpre (W8063)
• -wpro (W8064)
• -wpro (W8065)
• -wprc (W8084)
• -wpcm (W8094)
• -wpsb (W8099)
• -wptl (W8103)
• -wpnf (W8123)
• -wpun (W8135)
• -wpns (W8138. #pragma '%s' n'est pas pris en charge sur cette plate-forme)
• -wrch (W8066)
• -wret (W8067)
• -wrng (W8068)
• -wrpt (W8069)
• -wrvl (W8070)
• -wrlo (W8116)
• -wsig (W8071)
• -wspa (W8072)
• -wstu (W8073)
• -wstv (W8074)
• -wsus (W8075)
• -wstl (W8087)
• -wstl (W8089)
• -wstl (W8090)
• -wstl (W8091)
• -wstl (W8092)
• -wsmx (W8133)
• -wtai (W8076)
• -wtes (W8077)
• -wthr (W8078)
• -wtlb (W8137)
• -wucp (W8079)
• -wuse (W8080)
• -wucn (W8114)
• -wvoi (W8081)
• -wxxx (W8117)
• -wzdi (W8082)

Voir aussi

• BCC32.EXE, le compilateur C++ 32 bits en ligne de commande
• BCC64.EXE, le compilateur C++ Windows 64 bits
• BCCIOSARM64.EXE, le compilateur C++ pour le périphérique iOS 64 bits
• BCCAARM.EXE, le compilateur C++ pour Android
• Options de projet prises en charge par les compilateurs C++ améliorés par Clang
• Options de ligne de commande des en-têtes précompilés pour les compilateurs C++ améliorés par Clang
• Erreurs et avertissements des compilateurs C++ améliorés par Clang