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++)
• __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))

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
• BCCOSX.EXE, le compilateur C++ pour macOS
• BCCIOSARM.EXE, le compilateur C++ pour le périphérique iOS 32 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