xsdcxx - En ligne dans le Cloud

PROGRAMME:

Nom

xsdcxx - Compilateur de schéma XML W3C vers C++

SYNOPSIS

xsdcxx commander [ Options ] filet [ filet ...]
xsdcxx aider [ commander ]
xsdcxx version

DESCRIPTION

xsdcxx génère un mappage C++ spécifique au vocabulaire et typé statiquement à partir du schéma XML du W3C
définitions. La cartographie particulière à produire est sélectionnée par un commander. Chaque mappage a un
nombre de mappages spécifiques Options qui devrait apparaître, le cas échéant, après la commander. Contribution
les fichiers doivent être des définitions de schéma XML du W3C. L'ensemble exact des fichiers générés dépend
sur la cartographie et les options sélectionnées.

COMMANDES

arbre-cxx
Générez le mappage C++/Tree. Pour chaque fichier d'entrée sous la forme nom.xsd le
les fichiers C++ suivants sont générés : nom.hxx (En tête de fichier), nom.ixx (fichier en ligne,
généré uniquement si le --generate-inline option est spécifiée), nom.cxx (Source
fichier), et nom-fwd.hxx (fichier de déclaration préalable, généré uniquement si le
--générer-forward option est spécifiée).

analyseur cxx
Générez le mappage C++/Parser. Pour chaque fichier d'entrée sous la forme nom.xsd le
les fichiers C++ suivants sont générés : nom-pskel.hxx (fichier d'en-tête squelette d'analyseur),
nom-pskel.ixx (fichier en ligne squelette d'analyseur, généré uniquement si le --produire-
en ligne option est spécifiée), et nom-pskel.cxx (fichier source squelette de l'analyseur). Si
le --generate-noop-impl or --generate-print-impl l'option est spécifiée, le
Les exemples de fichiers d'implémentation supplémentaires suivants sont générés : nom-pimpl.hxx
(fichier d'en-tête d'implémentation de l'analyseur) et nom-pimpl.cxx (implémentation de l'analyseur
fichier source). Si la --generate-test-pilote option est spécifiée, l'option supplémentaire
nom-pilote.cxx le fichier du pilote de test est généré.

aider Imprimez les informations d'utilisation et quittez. Utiliser

xsdcxx aider commander

pour une aide spécifique à la commande.

version
Version imprimable et sortie.

OPTIONS

Spécifique à la commande Options, le cas échéant, doit apparaître après le commander.

commun Options
--std version
Spécifiez la norme C++ à laquelle le code généré doit se conformer. Valeurs valides
c ++ 98 (par défaut) et c ++ 11.

La norme C++ affecte divers aspects du code généré qui sont discutés
plus en détail dans diverses documentations spécifiques à la cartographie. Dans l'ensemble, lorsque C++11 est
sélectionné, le code généré repose sur la sémantique du mouvement et utilise std :: unique_ptr
au lieu d'être obsolète std ::auto_ptr.

Lorsque le mode C++11 est sélectionné, vous n'avez normalement pas besoin d'effectuer d'étapes supplémentaires
autre que d'activer C++11 dans votre compilateur C++, si nécessaire. Le compilateur XSDCXX
ajouter automatiquement les définitions de macro nécessaires aux fichiers d'en-tête générés qui
changera la bibliothèque d'exécution XSDCXX d'en-tête uniquement (libxsd) au mode C++11.
Cependant, si vous incluez l'un des en-têtes d'exécution XSDCXX directement dans votre
application (normalement, vous incluez simplement les en-têtes générés), alors vous aurez besoin
définir le XSD_CXX11 macro pour l'ensemble de votre projet.

--char-type type
Générer du code à l'aide du caractère fourni type au lieu de la valeur par défaut carboniser. Valide
les valeurs sont carboniser ainsi que wchar_t.

--char-encodage enc
Spécifiez l'encodage de caractères qui doit être utilisé dans le code généré. Valide
valeurs pour le carboniser type de caractère sont utf8 (Par défaut), iso8859-1, LCP (Xerces-C++
page de codes locale), et Customiser. Si tu passes Customiser comme valeur, vous aurez besoin
pour inclure l'en-tête d'implémentation du transcodeur pour votre encodage au début
des fichiers d'en-tête générés (voir le --hxx-prologue option).

Pour le wchar_t type de caractère la seule valeur valide est auto et l'encodage est
automatiquement sélectionné entre UTF-16 et UTF-32/UCS-4, selon le wchar_t
taille des caractères.

--rép-sortie dir
Écrire les fichiers générés dans dir au lieu du répertoire courant.

--generate-inline
Générez des fonctions simples en ligne. Cette option déclenche la création du fichier en ligne.

--generate-xml-schéma
Générer un fichier d'en-tête C++ comme si le schéma en cours de compilation définissait le schéma XML
espace de noms. Pour le mappage C++/Tree, le fichier résultant contiendra des définitions
pour tous les types intégrés de schéma XML. Pour le mappage C++/Parser, le fichier résultant
contiendra des définitions pour tous les squelettes et implémentations de l'analyseur
correspondant aux types intégrés de schéma XML.

Le fichier de schéma fourni au compilateur n'a pas besoin d'exister et est uniquement utilisé pour dériver
le nom du fichier d'en-tête résultant. Utilisez le --extern-xml-schéma Option de
inclure ce fichier dans les fichiers générés pour les autres schémas.

--extern-xml-schéma filet
Inclure un fichier d'en-tête dérivé de filet au lieu de générer le schéma XML
mappage d'espace de noms en ligne. Le fichier fourni n'a pas besoin d'exister et est uniquement utilisé pour
dérive le nom du fichier d'en-tête inclus. Utilisez le --generate-xml-schéma option
pour générer ce fichier d'en-tête.

--espace-de-noms-map xns=cns
Mapper l'espace de noms du schéma XML xns vers l'espace de noms C++ cns. Répétez cette option pour spécifier
mappage pour plusieurs espaces de noms de schéma XML. Par exemple, l'option suivante :

--espace-de-noms-map http://example.com/foo/bar=toto::bar

Cartographiera le http://example.com/foo/bar l'espace de noms XML Schema au toto :: bar C + +
espace de noms.

--espace de noms-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire l'espace de noms XML Schema
noms d'espaces de noms C++. regex est une expression régulière de type Perl sous la forme
/modèle/remplacement/. N'importe quel caractère peut être utilisé comme délimiteur au lieu de /.
Échappement du caractère délimiteur dans modèle or remplacement N'est pas pris en charge.

Toutes les expressions régulières sont poussées dans une pile avec le dernier spécifié
expression considérée en premier. La première correspondance qui réussit est utilisée. Ordinaire
les expressions sont appliquées à une chaîne sous la forme

nom de fichier namespace

Par exemple, si vous avez un fichier bonjour.xsd avec espace de nom http://example.com/hello ainsi que
vous courez xsd sur ce fichier, alors la chaîne en question sera :

bonjour.xsd. http://example.com/hello

Pour l'espace de noms XML Schema intégré, la chaîne est :

XMLSchema.xsd http://www.w3.org/2001/XMLSchema

Les trois étapes suivantes sont effectuées pour chaque expression régulière jusqu'à ce que la correspondance
est trouvé:

1. L'expression est appliquée et si le résultat est vide, l'expression suivante est
pris en considération.

2. Tout / sont remplacés par ::.

3. Le résultat est vérifié comme étant un nom de portée C++ valide (par exemple, toto :: bar). Si ce
test réussit, le résultat est utilisé comme nom d'espace de noms C++.

À titre d'exemple, l'expression suivante mappe les espaces de noms XML Schema sous la forme
http://example.com/foo/bar aux espaces de noms C++ sous la forme toto :: bar:

%.* http://example.com/(.+)%$1%

Voir également la section CITATION REGEX ET SHELL ci-dessous.

--espace de noms-regex-trace
Tracez le processus d'application des expressions régulières spécifiées avec le --espace de noms-
regex option. Utilisez cette option pour découvrir pourquoi vos expressions régulières ne fonctionnent pas
ce que vous attendiez d'eux.

--nom-réservé n[=r]
Ajouter un nom n à la liste des noms qui ne doivent pas être utilisés comme identifiants. Le nom
peut éventuellement être suivi de = et le nom de remplacement r qui devrait être utilisé
plutôt. Tous les mots-clés C++ sont déjà dans cette liste.

--include-with-parenthèses
Utilisez des crochets angulaires (<>) au lieu de guillemets ("") dans généré #comprendre directives.

--include-préfixe préfixe
Ajouter préfixe générer #comprendre chemins directifs.

Par exemple, si vous aviez l'élément d'importation suivant dans votre schéma

<importer namespace="..." schemaLocation="base.xsd"/>

et compilé ce fragment avec --include-préfixe schémas/, puis l'inclusion
directive dans le code généré serait :

#comprendre "schémas/base.hxx"

--include-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour transformer #comprendre directive
chemins. regex est une expression régulière de type Perl sous la forme /modèle/remplacement/.
N'importe quel caractère peut être utilisé comme délimiteur au lieu de /. Échappement du délimiteur
caractère modèle or remplacement N'est pas pris en charge.

Toutes les expressions régulières sont poussées dans une pile avec le dernier spécifié
expression considérée en premier. La première correspondance qui réussit est utilisée.

À titre d'exemple, l'expression suivante transforme les chemins sous la forme
schémas/foo/bar aux chemins sous la forme généré/foo/bar:

%schémas/(.+)%générés/$1%

Voir également la section CITATION REGEX ET SHELL ci-dessous.

--include-regex-trace
Tracez le processus d'application des expressions régulières spécifiées avec le --comprendre-
regex option. Utilisez cette option pour découvrir pourquoi vos expressions régulières ne fonctionnent pas
ce que vous attendiez d'eux.

--guard-préfixe préfixe
Ajouter préfixe aux gardes d'inclusion d'en-tête générés. Le préfixe est transformé en majuscule
la casse et les caractères non autorisés dans un nom de macro de préprocesseur sont remplacés par
souligne. Si cette option n'est pas spécifiée, la partie répertoire de l'entrée
fichier de schéma est utilisé comme préfixe.

--hxx-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut .hxx pour construire le nom du
En tête de fichier. Notez que ce suffixe est également utilisé pour construire des noms de fichiers d'en-tête
correspondant aux schémas inclus/importés.

--ixx-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut .ixx pour construire le nom du
fichier en ligne.

--cxx-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut .cxx pour construire le nom du
fichier source.

--fwd-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut -fwd.hxx construire le nom de
le dossier de déclaration préalable.

--hxx-expression régulière regex
Utilisez l'expression fournie pour construire le nom du fichier d'en-tête. regex est une
Expression régulière de type Perl sous la forme /modèle/remplacement/. Notez que ceci
expression est également utilisée pour construire des noms de fichiers d'en-tête correspondant à
schémas inclus/importés. Voir également la section CITATION REGEX ET SHELL ci-dessous.

--ixx-regex regex
Utilisez l'expression fournie pour construire le nom du fichier en ligne. regex est une
Expression régulière de type Perl sous la forme /modèle/remplacement/. Voir aussi la REGEX
ET SHELL CITATION section ci-dessous.

--cxx-regex regex
Utilisez l'expression fournie pour construire le nom du fichier source. regex est une
Expression régulière de type Perl sous la forme /modèle/remplacement/. Voir aussi la REGEX
ET SHELL CITATION section ci-dessous.

--fwd-regex regex
Utilisez l'expression fournie pour construire le nom du fichier de déclaration directe.
regex est une expression régulière de type Perl sous la forme /modèle/remplacement/. Voir également
la section CITATION REGEX ET SHELL ci-dessous.

--hxx-prologue texte
insérer texte au début du fichier d'en-tête.

--ixx-prologue texte
insérer texte au début du fichier en ligne.

--cxx-prologue texte
insérer texte au début du fichier source.

--fwd-prologue texte
insérer texte au début du fichier de déclaration préalable.

--prologue texte
insérer texte au début de chaque fichier généré pour lequel il n'y a pas de fichier-
prologue spécifique.

--hxx-épilogue texte
insérer texte à la fin du fichier d'en-tête.

--ixx-épilogue texte
insérer texte à la fin du fichier en ligne.

--cxx-épilogue texte
insérer texte à la fin du fichier source.

--fwd-épilogue texte
insérer texte à la fin du dossier de déclaration préalable.

--épilogue texte
insérer texte à la fin de chaque fichier généré pour lequel il n'y a pas de fichier spécifique
épilogue.

--hxx-fichier-prologue filet
Insérez le contenu de la filet au début du fichier d'en-tête.

--ixx-fichier-prologue filet
Insérez le contenu de la filet au début du fichier en ligne.

--cxx-fichier-prologue filet
Insérez le contenu de la filet au début du fichier source.

--fwd-fichier-prologue filet
Insérez le contenu de la filet au début du fichier de déclaration préalable.

--fichier-prologue filet
Insérez le contenu de la filet au début de chaque fichier généré pour lequel
il n'y a pas de fichier de prologue spécifique au fichier.

--hxx-fichier-épilogue filet
Insérez le contenu de la filet à la fin du fichier d'en-tête.

--ixx-fichier-épilogue filet
Insérez le contenu de la filet à la fin du fichier en ligne.

--cxx-fichier-épilogue filet
Insérez le contenu de la filet à la fin du fichier source.

--fwd-fichier-épilogue filet
Insérez le contenu de la filet à la fin du dossier de déclaration préalable.

--épilogue-fichier filet
Insérez le contenu de la filet à la fin de chaque fichier généré pour lequel il existe
pas de fichier épilogue spécifique au fichier.

--export-symbole symbole
insérer symbole dans les endroits où les instructions de contrôle d'exportation/importation de DLL
(__declspec(dllexport/dllimport)) sont nécessaires.

--export-xml-schéma
Exporter/importer des types dans l'espace de noms XML Schema à l'aide du symbole d'exportation fourni
les --export-symbole option. La XSD_NO_EXPORT la macro peut être utilisée pour omettre ceci
code lors de la compilation C++, ce qui peut être utile si vous souhaitez utiliser le même
code généré sur plusieurs plates-formes.

--export-maps
Exporter les cartes de prise en charge du polymorphisme à partir d'une DLL Win32 dans laquelle ce code généré est
mis. Ceci est nécessaire lorsque votre hiérarchie de types est répartie sur plusieurs DLL
sinon, chaque DLL aura son propre ensemble de cartes. Dans cette situation le
code généré pour la DLL qui contient des types de base et/ou un groupe de substitution
les têtes doivent être compilées avec cette option et le code généré pour toutes les autres DLL
doit être compilé avec --import-maps. Cette option n'est valable qu'avec
--generate-polymorpheL’ XSD_NO_EXPORT la macro peut être utilisée pour omettre ce code
lors de la compilation C++, ce qui peut être utile si vous souhaitez utiliser le même
code généré sur plusieurs plates-formes.

--import-maps
Importer des cartes de prise en charge du polymorphisme vers une DLL ou un exécutable Win32 dans lequel
le code généré est lié. Voir le --export-maps documentation des options pour plus de détails.
Cette option n'est valable qu'avec --generate-polymorpheL’ XSD_NO_EXPORT
macro peut être utilisée pour omettre ce code lors de la compilation C++, ce qui peut être utile si
vous souhaitez utiliser le même code généré sur plusieurs plates-formes.

--generate-dep
Générer faire informations de dépendance. Cette option déclenche la création du .d
fichier contenant les dépendances des fichiers générés sur le fichier de schéma principal comme
ainsi que tous les fichiers de schéma qu'il inclut/importe, de manière transitive. Cette
le fichier de dépendances est alors normalement inclus dans le fichier principal makefile à mettre en œuvre
suivi automatique des dépendances.

Notez également que la génération automatique de dépendances n'est pas prise en charge dans le fichier par
mode de saisie (--fichier-par-type). Dans ce cas, tous les fichiers générés sont produits
avec une seule invocation du compilateur et dépendent de tous les schémas. En conséquence, il est
plus facile d'établir une telle dépendance manuellement, peut-être avec l'aide du
--liste-de-fichiers* options.

--generate-dep-uniquement
Générer faire informations de dépendance uniquement.

--dep-phony
Générer de fausses cibles pour les fichiers de schéma inclus/importés, faisant dépendre chacun
sur rien. De telles règles factices fonctionnent autour faire erreurs causées par la suppression de
fichiers de schéma sans également mettre à jour le fichier de dépendance pour qu'il corresponde.

--dep-cible l'objectif
Modifiez la cible de la règle de dépendance. Par défaut, il contient tous les fichiers générés
C++ ainsi que le fichier de dépendance lui-même, sans aucun préfixe de répertoire. Si
vous avez besoin de plusieurs cibles, alors vous pouvez les spécifier comme un seul espace-
argument séparé ou vous pouvez répéter cette option plusieurs fois.

--dep-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut .d pour construire le nom du
fichier de dépendance.

--dep-regex regex
Utilisez l'expression fournie pour construire le nom du fichier de dépendances. regex is
une expression régulière de type Perl sous la forme /modèle/remplacement/. Voir aussi
REGEX ET SHELL CITATION section ci-dessous.

--disable-avertissement prévenir
Désactiver l'avertissement d'impression avec l'identifiant prévenir. Si TOUTE est spécifié pour l'identifiant d'avertissement alors
tous les avertissements sont désactivés.

--fichier-options filet
Lire les options supplémentaires de filet. Chaque option doit apparaître sur une ligne distincte
éventuellement suivi d'un espace et d'une valeur d'option. Lignes vides et lignes commençant
avec # sont ignorés. Les valeurs des options peuvent être entourées de doubles (") ou individuel (')
guillemets pour préserver les espaces blancs de début et de fin ainsi que pour spécifier des espaces vides
valeurs. Si la valeur elle-même contient des guillemets de fin ou de début, entourez-la d'un
paire de guillemets supplémentaire, par exemple '"X"'. Les cotations non-avances et non-suivantes sont
interprété comme faisant partie de la valeur de l'option.

La sémantique de fournir des options dans un fichier équivaut à fournir le même
ensemble d'options dans le même ordre sur la ligne de commande au point où le
--fichier-options L'option est spécifiée, sauf que l'échappement et les guillemets du shell sont
non requis. Vous pouvez répéter cette option pour spécifier plusieurs fichiers d'options.

--show-sloc
Affiche le nombre de lignes de code source physique générées (SLOC).

--sloc-limite num
Vérifiez que le nombre de lignes de code source physique générées (SLOC) ne
dépassent num.

--licence-propriétaire
Indiquez que le code généré est sous licence propriétaire au lieu de
la GPL.

--personnalisés-littéraux filet
Charger une chaîne XML personnalisée vers des mappages littéraux C++ à partir de filet. Ce mécanisme peut être
utile si vous utilisez un codage de caractères personnalisé et certaines des chaînes de votre
les schémas, par exemple les noms d'éléments/d'attributs ou les valeurs d'énumération, contiennent des
caractères ASCII. Dans ce cas, vous devrez fournir un mappage personnalisé vers C++
littéraux pour de telles chaînes. Le format de ce fichier est spécifié dans le personnalisé
littéraux.xsd Fichier XML Schema qui se trouve dans le répertoire de documentation.

--preserve-anonyme
Conservez les types anonymes. Par défaut, les types anonymes sont automatiquement nommés avec
noms dérivés des éléments/attributs englobants. Parce que les mappages mis en œuvre
par ce compilateur exigent que tous les types soient nommés, cette option n'est utile que si vous
voulez vous assurer que vos schémas n'ont pas de types anonymes.

--show-anonyme
Affichez les éléments et les attributs qui sont de types anonymes. Cette option ne fait que
sens avec le --preserve-anonyme option.

--regex-anonyme regex
Ajouter regex à la liste des expressions régulières utilisées pour dériver des noms pour anonymes
types à partir des attributs/éléments englobants. regex est un régulier de type Perl
expression sous la forme /modèle/remplacement/. Tout caractère peut être utilisé comme
délimiteur au lieu de /. Échappement du caractère délimiteur dans modèle or
remplacement N'est pas pris en charge.

Toutes les expressions régulières sont poussées dans une pile avec le dernier spécifié
expression considérée en premier. La première correspondance qui réussit est utilisée. Ordinaire
les expressions sont appliquées à une chaîne sous la forme

nom de fichier namespace xpath

Par exemple:

bonjour.xsd http://example.com/hello élément

bonjour.xsd http://example.com/hello type/élément

A titre d'exemple, l'expression suivante fait commencer tous les noms dérivés par
majuscules. Cela peut être utile lorsque votre convention de nommage nécessite le type
noms commençant par des majuscules :

%.* .* (.+/)*(.+)%\u$2%

Voir également la section CITATION REGEX ET SHELL ci-dessous.

--trace-regex-anonyme
Tracez le processus d'application des expressions régulières spécifiées avec le --anonyme-
regex option. Utilisez cette option pour découvrir pourquoi vos expressions régulières ne fonctionnent pas
ce que vous attendiez d'eux.

--une carte ol=nl
Mapper l'emplacement du schéma d'origine ol qui est spécifié dans le schéma XML include ou
importer des éléments vers un nouvel emplacement de schéma nl. Répétez cette option pour mapper plusieurs
emplacement du schéma. Par exemple, l'option suivante mappe le
http://example.com/foo.xsd URL vers le foo.xsd fichier local.

--une carte http://example.com/foo.xsd=foo.xsd

--location-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour mapper les emplacements de schéma qui sont
spécifiés dans le schéma XML comprennent ou importent des éléments. regex est un Perl-like
expression régulière sous la forme /modèle/remplacement/. N'importe quel caractère peut être utilisé comme
un délimiteur au lieu de /. Échappement du caractère délimiteur dans modèle or
remplacement n'est pas pris en charge. Toutes les expressions régulières sont poussées dans une pile
avec la dernière expression spécifiée considérée en premier. Le premier match réussi
est utilisé.

Par exemple, l'expression suivante mappe les emplacements d'URL sous la forme
http://example.com/foo/bar.xsd aux fichiers locaux sous la forme barre.xsd:

%http ://.+/(.+)%$1%

Voir également la section CITATION REGEX ET SHELL ci-dessous.

--location-regex-trace
Tracez le processus d'application des expressions régulières spécifiées avec le --emplacement-
regex option. Utilisez cette option pour découvrir pourquoi vos expressions régulières ne fonctionnent pas
ce que vous attendiez d'eux.

--fichier-par-type
Générez un ensemble distinct de fichiers C++ pour chaque type défini dans XML Schema. Noter
que dans ce mode il vous suffit de compiler le(s) schéma(s) racine(s) et le code sera
généré pour tous les schémas inclus et importés. Ce mode de compilation est principalement
utile lorsque certains de vos schémas ne peuvent pas être compilés séparément ou ont des cycles
dépendances qui impliquent l'héritage de type. Autres options liées à ce mode
sont: --type-file-regex, --schema-file-regex, --fichier-type-de-graisseet --liste-de-fichiers.

--type-file-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de type en fichier
noms lorsque le --fichier-par-type est spécifiée. regex est un régulier de type Perl
expression sous la forme /modèle/remplacement/. Tout caractère peut être utilisé comme
délimiteur au lieu de /. Échappement du caractère délimiteur dans modèle or
remplacement n'est pas pris en charge. Toutes les expressions régulières sont poussées dans une pile
avec la dernière expression spécifiée considérée en premier. Le premier match réussi
est utilisé. Les expressions régulières sont appliquées à une chaîne sous la forme

namespace nom-type

Par exemple, l'expression suivante mappe le type foo qui est défini dans le
http://example.com/bar espace de noms vers nom de fichier bar-foo:

%http://example.com/(.+) (.+)%$1-$2%

Voir également la section CITATION REGEX ET SHELL ci-dessous.

--type-file-regex-trace
Tracez le processus d'application des expressions régulières spécifiées avec le --type-fichier-
regex option. Utilisez cette option pour découvrir pourquoi vos expressions régulières ne fonctionnent pas
ce que vous attendiez d'eux.

--schema-file-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de fichiers de schéma
lorsque le --fichier-par-type est spécifiée. regex est un régulier de type Perl
expression sous la forme /modèle/remplacement/. Tout caractère peut être utilisé comme
délimiteur au lieu de /. Échappement du caractère délimiteur dans modèle or
remplacement n'est pas pris en charge. Toutes les expressions régulières sont poussées dans une pile
avec la dernière expression spécifiée considérée en premier. Le premier match réussi
est utilisé. Les expressions régulières sont appliquées au chemin absolu du système de fichiers d'un
schéma et le résultat, y compris la partie répertoire, le cas échéant, est utilisé pour dériver
le #comprendre chemins de directives ainsi que les chemins de fichiers C++ générés. Cette option,
avec --type-file-regex sont principalement utiles pour placer les fichiers générés dans
sous-répertoires ou pour résoudre les conflits de noms de fichiers.

Par exemple, l'expression suivante mappe les fichiers de schéma dans le truc/1.0.0/
sous-répertoire des fichiers dans le fou/ sous-répertoire. En conséquence, le #comprendre
les chemins de directives pour de tels schémas seront dans le foo/schema.hxx forme et le
les fichiers C++ générés seront placés dans le fou/ sous-répertoire:

%.*/foo/1.0.0/(.+)%foo/$1%

Voir également la section CITATION REGEX ET SHELL ci-dessous.

--schema-file-regex-trace
Tracez le processus d'application des expressions régulières spécifiées avec le --fichier-schéma-
regex option. Utilisez cette option pour découvrir pourquoi vos expressions régulières ne fonctionnent pas
ce que vous attendiez d'eux.

--fichier-type-de-graisse
Générer le code correspondant aux éléments globaux dans les fichiers de type au lieu du schéma
fichiers lorsque le --type-file-regex option est spécifiée. Cette option est principalement
utile lorsque vous essayez de minimiser la quantité de code objet lié à un
exécutable en empaquetant le code généré compilé dans une bibliothèque statique (archive).

--liste-de-fichiers filet
Écrire une liste des fichiers C++ générés dans filet. Cette option est principalement utile dans le
mode de compilation fichier par type (--fichier-par-type) pour créer une liste de C++ généré
fichiers, par exemple, en tant que fragment de makefile.

--file-list-prologue texte
insérer texte au début de la liste des fichiers. Par commodité, toutes les occurrences de
le \n séquence de caractères dans texte sont remplacés par de nouvelles lignes. Cette option peut, pour
exemple, être utilisé pour affecter la liste de fichiers générée à une variable makefile.

--file-list-épilogue texte
insérer texte à la fin de la liste des fichiers. Par commodité, toutes les occurrences du
\n séquence de caractères dans texte sont remplacés par de nouvelles lignes.

--file-list-delim texte
Délimitez les noms de fichiers écrits dans la liste de fichiers avec texte au lieu de nouvelles lignes. Comme un
commodité, toutes les occurrences du \n séquence de caractères dans texte sont remplacés par
nouvelles lignes.

arbre-cxx commander Options
--generate-polymorphe
Générez du code prenant en compte le polymorphisme. Spécifiez cette option si vous utilisez la substitution
groupes ou xsi : tapez. Utilisez le --type-polymorphe or --type-polymorphe-tout Option de
spécifier quelles hiérarchies de types sont polymorphes.

--type-polymorphe type
Indique que type est une racine d'une hiérarchie de type polymorphe. Le compilateur peut
déterminent souvent automatiquement quels types sont polymorphes en fonction de la substitution
déclarations de groupe. Cependant, vous devrez peut-être utiliser cette option si vous n'utilisez pas
groupes de substitution ou si des groupes de substitution sont définis dans un autre schéma. Vous
besoin de spécifier cette option lors de la compilation de chaque fichier de schéma qui fait référence type.
La type l'argument est un nom de type de schéma XML qui peut être éventuellement qualifié avec
un espace de noms dans le namespace#prénom formulaire.

--type-polymorphe-tout
Indiquez que tous les types doivent être traités comme polymorphes.

--plaque-polymorphe num
Spécifiez la plaque de carte polymorphe sur laquelle le code généré doit s'inscrire. Cette
La fonctionnalité est principalement utile pour séparer plusieurs schémas qui définissent le
mêmes types polymorphes.

--type-ordonné type
Indiquez cet ordre des éléments dans type est significatif. Un exemple serait un complexe
type avec choix illimité comme modèle de contenu où l'ordre des éléments en XML a
sémantique spécifique à l'application. Pour les types ordonnés, le compilateur génère un
membre de données de conteneur et un ensemble correspondant d'accesseurs et de modificateurs qui sont
utilisé pour capturer l'ordre des éléments et, pour le contenu mixte, du texte.

La type l'argument est un nom de type de schéma XML qui peut être éventuellement qualifié avec
un espace de noms dans le namespace#prénom former. Notez également que vous devrez spécifier
cette option lors de la compilation de chaque fichier de schéma qui a d'autres types ordonnés dérivés
de ce genre.

--dérivé du type ordonné
Traiter automatiquement les types dérivés de bases ordonnées comme également ordonnés. C'est
principalement utile si vous souhaitez pouvoir parcourir le contenu complet
en utilisant le conteneur de commande de contenu.

--type-ordonné-mixte
Traitez automatiquement les types complexes avec un contenu mixte comme ordonné.

--ordered-type-all
Indiquez que l'ordre des éléments dans tous les types est significatif.

--commande-conteneur type
Spécifiez un modèle de classe personnalisé qui doit être utilisé comme conteneur pour le contenu
ordre dans les types ordonnés au lieu de la valeur par défaut std::vecteur. Voir --type-ordonné en
plus d'informations sur le type commandé. Cette option est principalement utile si vous devez
effectuer des recherches plus complexes dans le conteneur de commande de contenu, par exemple par élément
identifiant. Dans ce cas, un conteneur comme Boost multi-index peut être plus pratique. Noter
que si vous utilisez un conteneur personnalisé, vous devrez probablement également inclure le
en-têtes pertinents à l'aide du --hxx-prologue* options.

--generate-sérialisation
Générer des fonctions de sérialisation. Les fonctions de sérialisation convertissent le modèle objet
retour à XML.

--generate-ostream
Générer des opérateurs d'insertion ostream (opérateur<) pour les types générés. Ceci permet
un pour imprimer facilement un fragment ou le modèle d'objet entier pour le débogage ou la journalisation.

--generate-doxygen
Générer des commentaires de documentation adaptés à l'extraction par le Doxygen
système documentaire. La documentation des annotations est ajoutée aux commentaires si
présent dans le schéma.

--générer-comparaison
Générer des opérateurs de comparaison (opérateur== ainsi que opérateur !=) pour les types complexes.
La comparaison est effectuée par membre.

--generate-default-ctor
Générez des constructeurs par défaut même pour les types qui ont des membres requis. Obligatoire
les membres d'une instance construite à l'aide d'un tel constructeur ne sont pas initialisés et
y accéder entraîne un comportement indéfini.

--generate-from-base-ctor
Générer des constructeurs qui attendent une instance d'un type de base suivi de tous
membres requis.

--suppress-assignation
Supprimez la génération d'opérateurs d'affectation de copie pour les types complexes. Si ce
option est spécifiée, les opérateurs d'affectation de copie pour ces types sont déclarés
privé et laissé sans mise en œuvre.

--générer-détacher
Générez des fonctions de détachement pour les éléments et attributs requis. Détacher les fonctions
pour les cardinalités facultatives et de séquence sont fournies par les conteneurs respectifs.
Ces fonctions permettent par exemple de déplacer des sous-arbres dans le modèle objet
soit au sein d'un même arbre, soit entre des arbres différents.

--generate-joker
Générez des accesseurs et des modificateurs ainsi que du code d'analyse et de sérialisation pour XML
Caractères génériques de schéma (tous ainsi que toutAttribut). Le contenu XML mis en correspondance par des caractères génériques est
présentés sous forme de fragments DOM. Notez que vous devez initialiser le runtime Xerces-C++
si vous utilisez cette option.

--generate-tout-type
Extraire et stocker le contenu du schéma XML n'importe quel type tapez comme un fragment DOM. Noter
dont vous avez besoin pour initialiser le runtime Xerces-C++ si vous utilisez cette option.

--générer-insertion os
Générer des opérateurs d'insertion de flux de représentation de données pour le os flux de sortie
taper. Répétez cette option pour spécifier plusieurs types de flux. Le flux ACE CDR
(ACE_SortieCDR) et RPC XDR sont reconnus par le compilateur et les
#comprendre les directives sont générées automatiquement. Pour les types de flux personnalisés, utilisez le
--hxx-prologue* options pour fournir les déclarations nécessaires.

--générer-extraction is
Générer des constructeurs d'extraction de flux de représentation de données pour le is flux d'entrée
taper. Répétez cette option pour spécifier plusieurs types de flux. Le flux ACE CDR
(ACE_CDR d'entrée) et RPC XDR sont reconnus par le compilateur et les
#comprendre les directives sont générées automatiquement. Pour les types de flux personnalisés, utilisez le
--hxx-prologue* options pour fournir les déclarations nécessaires.

--générer-forward
Générez un fichier d'en-tête séparé avec des déclarations directes pour les types en cours
généré.

--suppress-analyse
Supprimez la génération des fonctions d'analyse et des constructeurs. Utilisez cette option
pour réduire la taille du code généré lorsque l'analyse à partir de XML n'est pas nécessaire.

--generate-element-type
Générez des types au lieu de fonctions d'analyse et de sérialisation pour les éléments racine.
Ceci est principalement utile pour distinguer les modèles d'objet avec le même type de racine mais
avec différents éléments racines.

--generate-element-map
Générer une carte d'élément racine qui permet une analyse et une sérialisation uniformes de
plusieurs éléments racines. Cette option n'est valable qu'avec --générer-un élément-
type.

--generate-intellisens
Générez des solutions de contournement pour les bogues IntelliSense dans Visual Studio 2005 (8.0). Quand ce
est utilisée, le code résultant est légèrement plus détaillé. IntelliSense dans
Visual Studio 2008 (9.0) et versions ultérieures ne nécessitent pas ces solutions de contournement. Soutien
IntelliSense dans Visual Studio 2003 (7.1) est amélioré avec cette option mais est toujours
incomplet.

--omit-attributs-par-défaut
Omettez les attributs avec des valeurs par défaut et fixes des documents XML sérialisés.

--type-naming Catégorie
Spécifiez la convention de dénomination de type qui doit être utilisée dans le code généré. Valide
les styles sont knr (Par défaut), uccet Java. Voir la section CONVENTION DE NOMMAGE ci-dessous
pour plus d'information.

--nom-de-fonction Catégorie
Spécifiez la convention de nommage des fonctions qui doit être utilisée dans le code généré.
Les styles valides sont knr (Par défaut), lccet Java. Voir la section CONVENTION DE NOM
ci-dessous pour plus d'informations.

--type-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire le type de schéma XML
noms aux noms de type C++. Voir la section CONVENTION DE NOMMAGE ci-dessous pour plus
</br>L’Information.

--accesseur-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs aux noms de fonction d'accesseur C++. Voir la CONVENTION DE NOM
section ci-dessous pour plus d'informations.

--one-accessor-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs de cardinalité un aux noms de fonction d'accesseur C++. Voir le
CONVENTION DE NOMMAGE ci-dessous pour plus d'informations.

--opt-accessor-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs dont la cardinalité est facultative pour les noms de fonction d'accesseur C++. Voir
la section CONVENTION DE NOMMAGE ci-dessous pour plus d'informations.

--seq-accessor-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs avec une séquence de cardinalité aux noms de fonction d'accesseur C++. Voir
la section CONVENTION DE NOMMAGE ci-dessous pour plus d'informations.

--modifier-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs aux noms de fonction de modificateur C++. Voir la CONVENTION DE NOM
section ci-dessous pour plus d'informations.

--one-modifier-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs de cardinalité un aux noms de fonction de modificateur C++. Voir le
CONVENTION DE NOMMAGE ci-dessous pour plus d'informations.

--opt-modifier-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs dont la cardinalité est facultative pour les noms de fonction de modificateur C++. Voir
la section CONVENTION DE NOMMAGE ci-dessous pour plus d'informations.

--seq-modifier-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire les noms de schéma XML de
éléments/attributs avec séquence de cardinalité aux noms de fonction de modificateur C++. Voir
la section CONVENTION DE NOMMAGE ci-dessous pour plus d'informations.

--parser-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire l'élément XML Schema
noms aux noms de fonctions d'analyse C++. Voir la section CONVENTION DE NOM ci-dessous pour
pour en savoir davantage.

--sérialiseur-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire l'élément XML Schema
noms de fonctions de sérialisation C++. Voir la section CONVENTION DE NOMMAGE ci-dessous
pour plus d'information.

--const-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire XML Schema-derived
des noms aux noms de constantes C++. Voir la section CONVENTION DE NOMMAGE ci-dessous pour plus
</br>L’Information.

--énumérateur-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire XML Schema
valeurs d'énumération aux noms d'énumérateur C++. Voir la section CONVENTION DE NOMMAGE ci-dessous
pour plus d'information.

--element-type-regex regex
Ajouter regex à la liste des expressions régulières utilisées pour traduire l'élément XML Schema
noms aux noms de type d'élément C++. Voir la section CONVENTION DE NOMMAGE ci-dessous pour plus
</br>L’Information.

--name-regex-trace
Trace le processus d'application des expressions régulières spécifiées avec le nom
possibilités de transformation. Utilisez cette option pour découvrir pourquoi vos expressions régulières
ne faites pas ce que vous attendiez d'eux.

--root-element-premier
Traitez uniquement le premier élément global comme racine du document. Par défaut tout global
les éléments sont considérés comme des racines de document.

--root-element-dernier
Traiter uniquement le dernier élément global comme racine du document. Par défaut tout global
les éléments sont considérés comme des racines de document.

--root-element-all
Traitez tous les éléments globaux comme des racines de document. Ceci est le comportement par défaut. Par
en spécifiant explicitement cette option, vous pouvez supprimer l'avertissement émis si
plus d'un élément global est défini.

--root-element-aucun
Ne traitez aucun élément global comme des racines de document. Par défaut tous les éléments globaux
sont considérés comme des racines de document.

--élément-racine élément
Traiter seulement élément comme racine du document. Répétez cette option pour spécifier plusieurs
élément racine.

--type-personnalisé Localisation
Utilisez un type C++ personnalisé au lieu de la classe générée. le Localisation l'argument est dans le
formulaire prénom[=type[/base]], où prénom est un nom de type tel que défini dans XML Schema et
type est un nom de type C++ qui doit être utilisé à la place. Si type n'est pas présent ou
vide, le type personnalisé est supposé avoir le même nom et être défini dans le
même espace de noms que la classe générée aurait. Si base est spécifié alors le
la classe générée est toujours générée mais avec ce nom.

--regex-type-personnalisé regex
Utilisez des types C++ personnalisés au lieu des classes générées. le regex l'argument est dans le
formulaire /nom-pat/[type-sous/[base-sous/]], où nom-pat est un modèle regex qui
être comparés aux noms de type tels que définis dans XML Schema et type-sous est un type C++
substitution de nom qui devrait être utilisée à la place. Si type-sous n'est pas présent ou son
la substitution aboutit à une chaîne vide, le type personnalisé est supposé avoir le
même nom et être défini dans le même espace de noms que la classe générée aurait.
If base-sous est présent et sa substitution donne une chaîne non vide alors le
la classe générée est toujours générée mais avec le résultat de cette substitution comme son
Nom. Le modèle et les substitutions sont au format d'expression régulière Perl. Voir
également la section CITATION REGEX ET SHELL ci-dessous.

--les pièces num
Diviser le code source généré en num les pièces. Ceci est utile lors de la traduction de gros,
schémas monolithiques et un compilateur C++ n'est pas capable de compiler la source résultante
code à la fois (généralement en raison d'une mémoire insuffisante).

--parties-suffixe suffixe
Utilisez suffixe au lieu de la valeur par défaut '-' pour séparer le nom du fichier de la pièce
.

analyseur cxx commander Options
--type-map fichier de carte
Lire les informations de mappage du schéma XML vers le type C++ à partir de fichier de carte. Répétez cette option pour
spécifier plusieurs cartes de type. Les cartes de types sont considérées par ordre d'apparition et le
la première correspondance est utilisée. Par défaut, tous les types définis par l'utilisateur sont mappés sur annuler. Voir l'
TYPE CARTE section ci-dessous pour plus d'informations.

--xml-analyseur analyseur
Utilisez analyseur comme analyseur XML sous-jacent. Les valeurs valides sont xerces pour Xerces-C++
(par défaut) et expatriés pour les expatriés.

--generate-validation
Générer un code de validation. Le code de validation ("parser parfait") garantit que
les documents d'instance sont conformes au schéma. Le code de validation est généré par défaut
lorsque l'analyseur XML sous-jacent sélectionné n'est pas en cours de validation (expatriés).

--suppress-validation
Supprimer la génération du code de validation. La validation est supprimée par défaut
lorsque l'analyseur XML sous-jacent sélectionné est en cours de validation (xerces).

--generate-polymorphe
Générez du code prenant en compte le polymorphisme. Spécifiez cette option si vous utilisez la substitution
groupes ou xsi : tapez.

--generate-noop-impl
Générez un exemple d'implémentation d'analyseur qui ne fait rien (aucune opération). le
l'exemple d'implémentation peut ensuite être rempli avec le code spécifique à l'application. Pour un
fichier d'entrée sous la forme nom.xsd cette option déclenche la génération de deux
fichiers C++ supplémentaires sous la forme : nom-pimpl.hxx (en-tête d'implémentation de l'analyseur
fichier) et nom-pimpl.cxx (fichier source d'implémentation de l'analyseur).

--generate-print-impl
Générez un exemple d'implémentation d'analyseur qui imprime les données XML sur STDOUT. Pour un
fichier d'entrée sous la forme nom.xsd cette option déclenche la génération de deux
fichiers C++ supplémentaires sous la forme : nom-pimpl.hxx (en-tête d'implémentation de l'analyseur
fichier) et nom-pimpl.cxx (fichier source d'implémentation de l'analyseur).

--generate-test-pilote
Générez un pilote de test pour l'exemple d'implémentation de l'analyseur. Pour un fichier d'entrée dans
la forme nom.xsd cette option déclenche la génération d'un fichier C++ supplémentaire dans
la forme nom-pilote.cxx.

--force-écraser
Forcer l'écrasement des fichiers d'implémentation et de pilote de test existants. Utilisez ceci
option uniquement si cela ne vous dérange pas de perdre les modifications que vous avez apportées à l'échantillon
fichiers de mise en œuvre ou de pilote de test.

--root-element-premier
Indiquez que le premier élément global est la racine du document. Ces informations sont
utilisé pour générer le pilote de test pour l'exemple d'implémentation.

--root-element-dernier
Indiquez que le dernier élément global est la racine du document. Ces informations sont
utilisé pour générer le pilote de test pour l'exemple d'implémentation.

--élément-racine élément
Indique que élément est la racine du document. Ces informations sont utilisées pour générer
le pilote de test pour l'exemple d'implémentation.

--skel-type-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut _pskel construire les noms des
squelettes d'analyseurs générés.

--skel-file-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut -pskel construire les noms des
fichiers squelettes d'analyseur générés.

--impl-type-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut _bouton construire les noms des
implémentations d'analyseur pour les types de schéma XML intégrés ainsi qu'un exemple d'analyseur
mises en œuvre.

--impl-file-suffixe suffixe
Utilisez le fourni suffixe au lieu de la valeur par défaut - bouton construire les noms des
exemples de fichiers d'implémentation d'analyseur générés.

APPELLATION CONVENTION

Le compilateur peut être chargé d'utiliser une convention de nommage particulière dans le fichier généré.
code. Un certain nombre de conventions largement utilisées peuvent être sélectionnées à l'aide de la --type-naming ainsi que
--nom-de-fonction option. Une convention de nommage personnalisée peut être obtenue en utilisant le --taper-
regex, --accesseur-regex, --one-accessor-regex, --opt-accessor-regex, --seq-accessor-regex,
--modifier-regex, --one-modifier-regex, --opt-modifier-regex, --seq-modifier-regex,
--parser-regex, --sérialiseur-regex, --const-regex, --énumérateur-regexet --type-element-
regex options.

La --type-naming option spécifie la convention qui doit être utilisée pour nommer C++
les types. Les valeurs possibles pour cette option sont knr (Par défaut), uccet JavaL’ knr Plus-value
(signifie K&R) signifie la convention de nommage standard en minuscules avec le trait de soulignement
utilisé comme délimiteur de mots, par exemple : foo, foo_bar. le ucc (signifie supérieur-chameau-
cas) et Java valorise un synonyme de la même convention de nommage où la première lettre de
chaque mot du nom est en majuscule, par exemple : Foo, FooBar.

De même, le --nom-de-fonction L'option spécifie la convention qui doit être utilisée pour
nommer les fonctions C++. Les valeurs possibles pour cette option sont knr (Par défaut), lccet Java.
La knr valeur (signifie K&R) signifie la convention de nommage standard en minuscules avec
le trait de soulignement utilisé comme délimiteur de mot, par exemple : foo(), foo_bar(). le lcc Plus-value
(signifie minuscule-chameau-case) signifie une convention de nommage où la première lettre de chaque
mot sauf le premier est en majuscule, par exemple : foo(), fooBar(). le Java nommage
la convention est similaire à celle en minuscules, sauf que les fonctions d'accès sont
préfixé par get, les fonctions de modification sont préfixées par set, les fonctions d'analyse sont
préfixé par parse, et les fonctions de sérialisation sont préfixées par serialize, par exemple :
getFoo(), setFooBar(), parseRoot(), serializeRoot().

Notez que les conventions de nommage spécifiées avec le --type-naming ainsi que --nom-de-fonction
les options n'effectuent que des transformations limitées sur les noms provenant du schéma dans le
forme de noms de type, d'attribut et d'élément. En d'autres termes, pour obtenir des résultats cohérents,
vos schémas doivent suivre une convention de nommage similaire à celle que vous voudriez avoir
dans le code généré. Alternativement, vous pouvez utiliser le --*-expression régulière options (discutées ci-dessous)
pour effectuer d'autres transformations sur les noms qui proviennent du schéma.

La --type-regex, --accesseur-regex, --one-accessor-regex, --opt-accessor-regex, --suite-
accesseur-regex, --modifier-regex, --one-modifier-regex, --opt-modifier-regex, --suite-
modificateur-regex, --parser-regex, --sérialiseur-regex, --const-regex, --énumérateur-regexet
--element-type-regex les options vous permettent de spécifier des expressions régulières supplémentaires pour chaque nom
catégorie en plus de l'ensemble prédéfini qui est ajouté en fonction de la --type-naming
ainsi que --nom-de-fonction option. Les expressions fournies avec le --*-expression régulière Options
sont évalués avant toute expression prédéfinie. Cela vous permet de remplacer de manière sélective
certaines ou toutes les transformations prédéfinies. Lors du débogage de vos propres expressions, il est
souvent utile pour voir quelles expressions correspondent à quels noms. le --name-regex-trace option
vous permet de suivre le processus d'application d'expressions régulières aux noms.

La valeur pour le --*-expression régulière options doivent être une expression régulière de type perl sous la forme
/modèle/remplacement/. N'importe quel caractère peut être utilisé comme délimiteur au lieu de /. S'échapper
du caractère délimiteur dans modèle or remplacement n'est pas pris en charge. Tous les réguliers
les expressions pour chaque catégorie sont poussées dans une pile spécifique à la catégorie avec le dernier
expression spécifiée considérée en premier. La première correspondance qui réussit est utilisée. Pour le
--one-accessor-regex (accesseurs de cardinalité un), --opt-accessor-regex (accesseurs
avec cardinalité facultative), et --seq-accessor-regex (accesseurs avec séquence de cardinalité)
catégories les --accesseur-regex les expressions sont utilisées comme solution de secours. Pour le --un-
modificateur-regex, --opt-modifier-regexet --seq-modifier-regex catégories les --modificateur-
regex les expressions sont utilisées comme solution de secours. Pour le --element-type-regex catégorie le
--type-regex les expressions sont utilisées comme solution de secours.

Les expressions de nom de type (--type-regex) sont évalués sur la chaîne de nom qui a le
format suivant :

[namespace ]prénom[,prénom][,prénom][,prénom]

Les expressions de nom de type d'élément (--element-type-regex), n'est efficace que lorsque le
--generate-element-type est spécifiée, sont évalués sur la chaîne de nom qui a le
format suivant :

namespace prénom

Dans le format de nom de type, le namespace la partie suivie d'un espace n'est présente que pour le global
tapez des noms. Pour les types et éléments globaux définis dans les schémas sans espace de noms cible,
le namespace une partie est vide mais l'espace est toujours présent. Dans le format de nom de type après
la première prénom composant, jusqu'à trois autres prénom des composants peuvent être présents,
séparé par des virgules. Par example:

http://example.com/hello type

foo

foo, itérateur

foo,const,itérateur

L'ensemble suivant d'expressions régulières prédéfinies est utilisé pour transformer les noms de type lorsque
la convention de nommage en majuscule est sélectionnée :

/(?:[^ ]* ) ?([^,]+)/\u$1/

/(?:[^ ]* ) ?([^,]+),([^,]+)/\u$1\u$2/

/(?:[^ ]* ) ?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/

/(?:[^ ]* ) ?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/

Les expressions d'accesseur et de modificateur (--* accesseur-regex ainsi que --* modificateur-regex) sont
évalué sur la chaîne de nom qui a le format suivant :

prénom[,prénom][,prénom]

Après l'initiale prénom composant, jusqu'à deux prénom des composants peuvent être présents,
séparé par des virgules. Par example:

foo

dom, document

foo,par défaut,valeur

L'ensemble suivant d'expressions régulières prédéfinies est utilisé pour transformer les noms d'accesseurs
lorsque le Java la convention de nommage est sélectionnée :

/([^,]+)/obtenir\u$1/

/([^,]+),([^,]+)/obtenir\u$1\u$2/

/([^,]+),([^,]+),([^,]+)/obtenir\u$1\u$2\u$3/

Pour les catégories d'analyseur, de sérialiseur et d'énumérateur, le
les expressions sont évaluées sur des noms locaux d'éléments et sur des valeurs d'énumération,
respectivement. Par exemple, l'expression régulière prédéfinie suivante est utilisée pour
transformer les noms de fonction d'analyse lorsque le Java la convention de nommage est sélectionnée :

/(.+)/analyse\u$1/

La catégorie const est utilisée pour créer des noms de constante C++ pour l'élément/le joker/le texte
identifiants de contenu dans des types ordonnés.

Voir également la section CITATION REGEX ET SHELL ci-dessous.

TYPE CARTE

Les fichiers de mappage de types sont utilisés dans C++/Parser pour définir un mappage entre XML Schema et C++
les types. Le compilateur utilise ces informations pour déterminer les types de retour de Publier_*
fonctions dans les squelettes d'analyseur correspondant aux types de schéma XML ainsi qu'aux types d'arguments
pour les rappels correspondant aux éléments et attributs de ces types.

Le compilateur dispose d'un ensemble de règles de mappage prédéfinies qui mappent les types de schéma XML intégrés sur
types C++ appropriés (discutés ci-dessous) et tous les autres types pour annuler. En fournissant votre propre
types de cartes, vous pouvez remplacer ces règles prédéfinies. Le format du fichier de carte de type est
présenté ci-dessous :

namespace espace de noms de schéma [ espace de noms cxx ]
{
( comprendre nom de fichier; )*
([ type ] type-schéma type-cxx-ret [ type cxx-arg ]; )*
}

Les deux espace de noms de schéma ainsi que type-schéma sont des modèles de regex tandis que espace de noms cxx, cxx-ret-
typeet type cxx-arg sont des substitutions de modèle regex. Tous les noms peuvent être facultativement
entre " ", par exemple, pour inclure des espaces blancs.

espace de noms de schéma détermine l'espace de noms du schéma XML. Optionnel espace de noms cxx est préfixé à
chaque nom de type C++ dans cette déclaration d'espace de noms. type-cxx-ret est un nom de type C++ qui
est utilisé comme type de retour pour le Publier_* les fonctions. Optionnel type cxx-arg est un argument
type pour les fonctions de rappel correspondant aux éléments et attributs de ce type. Si cxx-
type d'argument n'est pas spécifié, la valeur par défaut est type-cxx-ret if type-cxx-ret se termine par * or &
(c'est-à-dire qu'il s'agit d'un pointeur ou d'une référence) et const type-cxx-ret& autrement. nom de fichier is
un nom de fichier au format " " ou < > et est ajouté avec le #comprendre directive à
le code généré.

La # caractère commence un commentaire qui se termine par une nouvelle ligne ou une fin de fichier. Pour spécifier un
nom qui contient # placez-le entre " ". Par example:

namespace http://www.example.com/xmlns/my my
{
inclure "mon.hxx" ;

# Passer les pommes par valeur.
#
pomme pomme;

# Passez les oranges comme des pointeurs.
#
orange orange_t* ;
}

Dans l'exemple ci-dessus, pour le http://www.example.com/xmlns/my#Orange Type de schéma XML, le
mon::orange_t* Le type C++ sera utilisé à la fois comme type de retour et comme type d'argument.

Plusieurs déclarations d'espace de noms peuvent être spécifiées dans un seul fichier. L'espace de noms
La déclaration peut également être complètement omise pour mapper les types dans un schéma sans espace de noms.
Par exemple:

inclure "mon.hxx" ;
pomme pomme;

namespace http://www.example.com/xmlns/my
{
orange "const orange_t*" ;
}

Le compilateur a un certain nombre de règles de mappage prédéfinies qui peuvent être présentées comme
fichiers de carte suivants. Les types intégrés de schéma XML basés sur des chaînes sont mappés soit sur
std :: string or std :: wstring selon le type de caractère sélectionné avec le --char-type
Option (carboniser par défaut).

namespace http://www.w3.org/2001/XMLSchema
{
booléen bool bool;

octet "signed char" "signed char" ;
unsignedByte "unsigned char" "unsigned char" ;

court court court;
unsignedShort "unsigned short" "unsigned short" ;

entier entier entier ;
unsignedInt "unsigned int" "unsigned int" ;

long "long long" "long long" ;
unsignedLong "unsigned long long" "unsigned long long" ;

entier "long long" "long long" ;

negativeInteger "long long" "long long" ;
nonPositiveInteger "long long" "long long" ;

positiveInteger "unsigned long long" "unsigned long long" ;
nonNegativeInteger "unsigned long long" "unsigned long long" ;

flotteur flotteur flotteur;
double double double;
décimal double double;

chaîne std::chaîne;
normalizedString std::string;
jeton std::string;
Nom std::string;
NMTOKEN std :: chaîne ;
NCName std ::string;
ID std ::string;
IDREF std :: chaîne ;
langue std::string;
anyURI std :: chaîne ;

NMTOKENS xml_schema ::string_sequence;
IDREFS xml_schema ::string_sequence;

QName xml_schema ::qname;

base64Std binaire::auto_ptr
std::auto_ptr ;
hexBinary std::auto_ptr
std::auto_ptr ;

date xml_schema::date;
dateHeure xml_schema ::date_heure;
durée xml_schema::duration;
gDay xml_schema :: gday;
gMonth xml_schema::gmois;
gMonthDay xml_schema :: gmonth_day;
gAnnée xml_schema::gyear;
gAnnéeMois xml_schema::gannée_mois;
temps xml_schema::time;
}

La dernière règle prédéfinie mappe tout ce qui n'a pas été mappé par les règles précédentes sur annuler:

espace de noms .*
{
.* vide vide ;
}

Lorsque vous fournissez vos propres cartes de types avec le --type-map option, ils sont évalués en premier.
Cela vous permet de remplacer de manière sélective les règles prédéfinies.

REGEX ET SHELL CITATION

Lors de la saisie d'un argument d'expression régulière dans la ligne de commande du shell, il est souvent
nécessaire d'utiliser des guillemets (en insérant l'argument entre " " ou ' ') afin d'éviter le
shell d'interpréter certains caractères, par exemple, les espaces comme séparateurs d'arguments et
$ en tant qu'extensions variables.

Malheureusement, il est difficile d'y parvenir d'une manière portable sur les shells POSIX,
tels que ceux trouvés sur GNU/Linux et UNIX, et le shell Windows. Par exemple, si vous utilisez " "
pour les guillemets, vous obtiendrez un mauvais résultat avec les shells POSIX si votre expression contient $.
La manière standard de gérer cela sur les systèmes POSIX est d'utiliser ' ' à la place.
Malheureusement, le shell Windows ne supprime pas ' ' des arguments lorsqu'ils sont transmis à
applications. Par conséquent, vous devrez peut-être utiliser ' ' pour POSIX et " " pour Windows ($ n'est pas
traité comme un caractère spécial sous Windows).

Alternativement, vous pouvez enregistrer les options d'expression régulière dans un fichier, une option par ligne,
et utilisez ce fichier avec le --fichier-options option. Avec cette approche, vous n'avez pas besoin de
s'inquiéter de la citation de shell.

DIAGNOSTIC

Si le fichier d'entrée n'est pas une définition de schéma XML W3C valide, xsdcxx émettra un diagnostic
messages à STDERR et quitter avec un code de sortie différent de zéro.

Utilisez xsdcxx en ligne à l'aide des services onworks.net