xsdcxx - Online nel cloud

PROGRAMMA:

NOME

xsdcxx - dallo schema XML W3C al compilatore C++

SINOSSI

xsdcxx command [ Opzioni ] filetto [ filetto ...]
xsdcxx Aiuto [ command ]
xsdcxx versione

DESCRIZIONE

xsdcxx genera mappatura C++ tipizzata staticamente specifica per il vocabolario da W3C XML Schema
definizioni. La mappatura particolare da produrre è selezionata da a command. Ogni mappatura ha un
numero di mappature specifiche Opzioni che dovrebbe apparire, se del caso, dopo il command. Ingresso
i file dovrebbero essere le definizioni dello schema XML W3C. L'insieme esatto dei file generati dipende
sulla mappatura e sulle opzioni selezionate.

COMANDI

cxx-albero
Genera la mappatura C++/Tree. Per ogni file di input nel modulo nome.xsd , il
vengono generati i seguenti file C++: nome.hxx (file di intestazione), nome.ixx (file in linea,
generato solo se il --genera-inline l'opzione è specificata), nome.cxx (Fonte
file), e nome-fwd.hxx (file di dichiarazione forward, generato solo se il
--genera-forward l'opzione è specificata).

analizzatore cxx
Genera la mappatura C++/Parser. Per ogni file di input nel modulo nome.xsd , il
vengono generati i seguenti file C++: nome-pskel.hxx (file di intestazione dello scheletro del parser),
nome-pskel.ixx (file inline scheletro parser, generato solo se il --creare-
inline opzione è specificata), e nome-pskel.cxx (file sorgente dello scheletro del parser). Se
, il --generate-noop-impl or --genera-print-impl l'opzione è specificata, il
vengono generati i seguenti file di implementazione di esempio aggiuntivi: nome-pimpl.hxx
(file di intestazione dell'implementazione del parser) e nome-pimpl.cxx (implementazione del parser
file sorgente). Se la --genera-test-driver l'opzione è specificata, l'addizionale
nome-driver.cxx viene generato il file del driver di prova.

Aiuto Stampa le informazioni sull'utilizzo ed esci. Uso

xsdcxx Aiuto command

per l'aiuto specifico del comando.

versione
Stampa la versione ed esci.

VERSIONI

Specifico del comando Opzioni, se presente, dovrebbe apparire dopo il corrispondente command.

comune Opzioni
--std versione
Specificare lo standard C++ a cui deve conformarsi il codice generato. Valori validi
sono c ++ 98 (predefinito) e c ++ 11.

Lo standard C++ influenza vari aspetti del codice generato che vengono discussi
in modo più dettagliato in vari documenti specifici per la mappatura. Nel complesso, quando C++ 11 è
selezionato, il codice generato si basa sulla semantica di spostamento e utilizza std::ptr_unico
invece di deprecato std::auto_ptr.

Quando è selezionata la modalità C++ 11, normalmente non è necessario eseguire ulteriori passaggi
oltre a abilitare C++11 nel compilatore C++, se necessario. Il compilatore XSDCXX lo farà
aggiungere automaticamente la macro necessaria definisce ai file di intestazione generati che
cambierà la libreria runtime XSDCXX di sola intestazione (libxd) alla modalità C++11.
Tuttavia, se includi una delle intestazioni di runtime XSDCXX direttamente nel tuo
applicazione (normalmente includi solo le intestazioni generate), quindi avrai bisogno
per definire il XSD_CXX11 macro per l'intero progetto.

--tipo-char Digitare
Genera codice utilizzando il carattere fornito Digitare invece del valore predefinito serbatoio. Valido
i valori sono serbatoio ed wchar_t.

--char-codifica enc
Specificare la codifica dei caratteri da utilizzare nel codice generato. Valido
valori per il serbatoio tipo di carattere sono utf8 (Impostazione predefinita), iso8859-1, LCP (Xerces-C++
code page locale), e costume. Se passi costume come il valore di cui avrai bisogno
per includere l'intestazione di implementazione del transcodificatore per la tua codifica all'inizio
dei file di intestazione generati (vedi il --hxx-prologo opzione).

Per la wchar_t tipo di carattere l'unico valore valido è auto e la codifica è
selezionato automaticamente tra UTF-16 e UTF-32/UCS-4, a seconda del wchar_t
dimensione del tipo.

--dir-output dir
Scrivi i file generati su dir invece della directory corrente.

--genera-inline
Genera semplici funzioni in linea. Questa opzione attiva la creazione del file in linea.

--genera-xml-schema
Genera un file di intestazione C++ come se lo schema in fase di compilazione definisce lo schema XML
spazio dei nomi. Per la mappatura C++/Tree, il file risultante conterrà le definizioni
per tutti i tipi incorporati di XML Schema. Per la mappatura C++/Parser, il file risultante
conterrà le definizioni per tutti gli scheletri e le implementazioni del parser
corrispondenti ai tipi incorporati di XML Schema.

Il file di schema fornito al compilatore non deve esistere e viene utilizzato solo per derivare
il nome del file di intestazione risultante. Utilizzare il --schema-xml-extern opzione a
includere questo file nei file generati per altri schemi.

--schema-xml-extern filetto
Includere un file di intestazione derivato da filetto invece di generare lo schema XML
mappatura dello spazio dei nomi in linea. Il file fornito non deve esistere e viene utilizzato solo per
derivare il nome del file di intestazione incluso. Utilizzare il --genera-xml-schema opzione
per generare questo file di intestazione.

--namespace-mappa xns=cns
Mappa dello spazio dei nomi dello schema XML xns allo spazio dei nomi C++ cns. Ripeti questa opzione per specificare
mappatura per più di uno spazio dei nomi dello schema XML. Ad esempio, la seguente opzione:

--namespace-mappa http://example.com/foo/bar=pippo::bar

mapperà il http://example.com/foo/bar spazio dei nomi dello schema XML per il pippo::bar C++
spazio dei nomi.

--namespace-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre lo spazio dei nomi dello schema XML
nomi ai nomi dello spazio dei nomi C++. regex è un'espressione regolare tipo Perl nella forma
/modello/sostituzione/. Qualsiasi carattere può essere usato come delimitatore invece di /.
Sfuggire al carattere delimitatore in modello or sostituzione non è supportato.

Tutte le espressioni regolari vengono inserite in uno stack con l'ultima specificata
espressione considerata per prima. Viene utilizzata la prima corrispondenza riuscita. Regolare
le espressioni vengono applicate a una stringa nella forma

Nome del file namespace

Ad esempio, se hai file ciao.xsd con spazio dei nomi http://example.com/hello ed
tu corri xsd su questo file, allora la stringa in questione sarà:

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

Per lo spazio dei nomi dello schema XML integrato la stringa è:

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

I seguenti tre passaggi vengono eseguiti per ogni espressione regolare fino alla corrispondenza
è stato trovato:

1. L'espressione viene applicata e se il risultato è vuoto l'espressione successiva è
considerato.

2. Tutti / sono sostituiti con ::.

3. Si verifica che il risultato sia un nome di ambito C++ valido (ad es. pippo::bar). Se questo
test ha esito positivo, il risultato viene utilizzato come nome dello spazio dei nomi C++.

Ad esempio, la seguente espressione mappa gli spazi dei nomi dello schema XML nella forma
http://example.com/foo/bar agli spazi dei nomi C++ nella forma pippo::bar:

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

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--namespace-regex-traccia
Traccia il processo di applicazione delle espressioni regolari specificate con il --spazio dei nomi-
regex opzione. Usa questa opzione per scoprire perché le tue espressioni regolari non funzionano
quello che ti aspettavi che facessero.

--nome-riservato n[=r]
Aggiungi nome n all'elenco dei nomi che non devono essere utilizzati come identificatori. Il nome
può facoltativamente essere seguito da = e il nome sostitutivo r che dovrebbe essere usato
invece. Tutte le parole chiave C++ sono già in questo elenco.

--include-con-parentesi
Usa parentesi angolari (<>) invece delle virgolette ("") in generato #includere direttive.

--include-prefisso prefisso
Aggiungi prefisso generare #includere percorsi direttivi.

Ad esempio, se avessi il seguente elemento di importazione nel tuo schema

<importa spazio dei nomi="..." schemaLocation="base.xsd"/>

e compilato questo frammento con --include-prefisso schemi/, quindi includi
direttiva nel codice generato sarebbe:

#includere "schemi/base.hxx"

--include-regex regex
Aggiungi regex alla lista delle espressioni regolari usate per trasformare #includere Direttive
percorsi. regex è un'espressione regolare tipo Perl nella forma /modello/sostituzione/.
Qualsiasi carattere può essere usato come delimitatore invece di /. Sfuggire al delimitatore
personaggio modello or sostituzione non è supportato.

Tutte le espressioni regolari vengono inserite in uno stack con l'ultima specificata
espressione considerata per prima. Viene utilizzata la prima corrispondenza riuscita.

Ad esempio, la seguente espressione trasforma i percorsi nella forma
schemi/pippo/bar a percorsi nella forma generato/pippo/bar:

%schemi/(.+)%generati/$1%

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--include-regex-traccia
Traccia il processo di applicazione delle espressioni regolari specificate con il --includere-
regex opzione. Usa questa opzione per scoprire perché le tue espressioni regolari non funzionano
quello che ti aspettavi che facessero.

--prefisso-guardia prefisso
Aggiungi prefisso alle protezioni di inclusione dell'intestazione generate. Il prefisso viene trasformato in superiore
maiuscole e minuscole e i caratteri non ammessi nel nome di una macro del preprocessore vengono sostituiti con
sottolineature. Se questa opzione non è specificata, la parte della directory dell'input
schema viene utilizzato come prefisso.

--hxx-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito .hxx per costruire il nome del
file di intestazione. Nota che questo suffisso è usato anche per costruire i nomi dei file di intestazione
corrispondenti a schemi inclusi/importati.

--ixx-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito .ixx per costruire il nome del
file in linea.

--cxx-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito .cxx per costruire il nome del
file sorgente.

--fwd-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito -fwd.hxx costruire il nome di
il file della dichiarazione anticipata.

--hxx-regex regex
Utilizzare l'espressione fornita per costruire il nome del file di intestazione. regex è un
Espressione regolare tipo Perl nella forma /modello/sostituzione/. Nota che questo
espressione è anche usata per costruire nomi di file di intestazione corrispondenti a
schemi inclusi/importati. Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--ixx-regex regex
Utilizzare l'espressione fornita per costruire il nome del file in linea. regex è un
Espressione regolare tipo Perl nella forma /modello/sostituzione/. Vedi anche la REGEX
E CITAZIONE CONCHIGLIA di seguito.

--cxx-regex regex
Utilizzare l'espressione fornita per costruire il nome del file di origine. regex è un
Espressione regolare tipo Perl nella forma /modello/sostituzione/. Vedi anche la REGEX
E CITAZIONE CONCHIGLIA di seguito.

--fwd-regex regex
Utilizzare l'espressione fornita per costruire il nome del file di dichiarazione anticipata.
regex è un'espressione regolare tipo Perl nella forma /modello/sostituzione/. Vedi anche
la sezione REGEX E SHELL CITAZIONE di seguito.

--hxx-prologo testo
inserire testo all'inizio del file di intestazione.

--ixx-prologo testo
inserire testo all'inizio del file in linea.

--cxx-prologo testo
inserire testo all'inizio del file sorgente.

--fwd-prologo testo
inserire testo all'inizio del file di dichiarazione anticipata.

--prologo testo
inserire testo all'inizio di ogni file generato per il quale non esiste un file-
prologo specifico.

--hxx-epilogo testo
inserire testo alla fine del file di intestazione.

--ixx-epilogo testo
inserire testo alla fine del file in linea.

--cxx-epilogo testo
inserire testo alla fine del file sorgente.

--fwd-epilogo testo
inserire testo alla fine del file di dichiarazione anticipata.

--epilogo testo
inserire testo alla fine di ogni file generato per il quale non esiste un file specifico
epilogo.

--hxx-prologo-file filetto
Inserisci il contenuto del filetto all'inizio del file di intestazione.

--ixx-prologo-file filetto
Inserisci il contenuto del filetto all'inizio del file in linea.

--cxx-prologo-file filetto
Inserisci il contenuto del filetto all'inizio del file sorgente.

--fwd-prologo-file filetto
Inserisci il contenuto del filetto all'inizio del file di dichiarazione anticipata.

--prologo-file filetto
Inserisci il contenuto del filetto all'inizio di ogni file generato per cui
non esiste un file di prologo specifico per il file.

--hxx-file-epilogo filetto
Inserisci il contenuto del filetto alla fine del file di intestazione.

--ixx-file-epilogo filetto
Inserisci il contenuto del filetto alla fine del file in linea.

--cxx-file-epilogo filetto
Inserisci il contenuto del filetto alla fine del file sorgente.

--fwd-epilogo-file filetto
Inserisci il contenuto del filetto alla fine del file di dichiarazione anticipata.

--file-epilogo filetto
Inserisci il contenuto del filetto alla fine di ogni file generato per il quale c'è
nessun file di epilogo specifico per il file.

--simbolo-di-esportazione simbolo
inserire simbolo nei luoghi in cui le dichiarazioni di controllo di esportazione/importazione DLL
(__declspec(dllexport/dllimport)) sono necessari.

--export-schema-xml
Esporta/importa i tipi nello spazio dei nomi dello schema XML utilizzando il simbolo di esportazione fornito
con la --simbolo-di-esportazione opzione. Il XSD_NO_EXPORT la macro può essere usata per ometterlo
codice durante la compilazione C++, che può essere utile se si desidera utilizzare lo stesso
codice generato su più piattaforme.

--export-mappe
Esporta le mappe di supporto del polimorfismo da una DLL Win32 in cui è presente il codice generato
posizionato. Ciò è necessario quando la gerarchia dei tipi è suddivisa in più DLL
poiché altrimenti ogni DLL avrà il proprio set di mappe. In questa situazione il
codice generato per la DLL che contiene i tipi di base e/o il gruppo di sostituzione
head dovrebbe essere compilato con questa opzione e il codice generato per tutte le altre DLL
dovrebbe essere compilato con --import-mappe. Questa opzione è valida solo insieme a
--genera-polimorfico. XSD_NO_EXPORT la macro può essere utilizzata per omettere questo codice
durante la compilazione C++, che può essere utile se si desidera utilizzare lo stesso
codice generato su più piattaforme.

--import-mappe
Importa le mappe di supporto del polimorfismo su una DLL Win32 o eseguibile in cui questo
il codice generato è collegato. Vedi il --export-mappe documentazione dell'opzione per i dettagli.
Questa opzione è valida solo insieme a --genera-polimorfico. XSD_NO_EXPORT
macro può essere utilizzata per omettere questo codice durante la compilazione C++, il che può essere utile se
desideri utilizzare lo stesso codice generato su più piattaforme.

--genera-dep
Generare make informazioni sulla dipendenza Questa opzione attiva la creazione del .d
file contenente le dipendenze dei file generati sul file schema principale come
così come tutti i file di schema che include/importa, in modo transitivo. Questo
il file delle dipendenze viene quindi normalmente incluso nel file main makefile di attuare
monitoraggio automatico delle dipendenze.

Si noti inoltre che la generazione automatica delle dipendenze non è supportata nel file-per-
modalità tipo (--file-per-tipo). In questo caso vengono prodotti tutti i file generati
con una singola chiamata del compilatore e dipendono da tutti gli schemi. Di conseguenza, è
più facile stabilire tale dipendenza manualmente, magari con l'aiuto del
--elenco-file* opzioni.

--genera-dep-only
Generare make solo informazioni sulla dipendenza.

--dep-falso
Genera obiettivi fasulli per i file di schema inclusi/importati, facendo sì che ciascuno di essi dipenda
su niente. Tali regole fittizie funzionano in giro make errori causati dalla rimozione di
schema senza aggiornare anche il file di dipendenza in modo che corrisponda.

--dep-bersaglio bersaglio
Modificare la destinazione della regola di dipendenza. Di default contiene tutto il generato
File C++ e il file delle dipendenze stesso, senza alcun prefisso di directory. Se
hai bisogno di più obiettivi, quindi puoi specificarli come un singolo, spazio-
argomento separato oppure puoi ripetere questa opzione più volte.

--dep-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito .d per costruire il nome del
file delle dipendenze.

--dep-regex regex
Utilizzare l'espressione fornita per costruire il nome del file di dipendenza. regex is
un'espressione regolare tipo Perl nella forma /modello/sostituzione/. Vedi anche il
CITAZIONE REGEX E SHELL di seguito.

--disabilita-avviso avvertire
Disabilita l'avviso di stampa con id avvertire. Se contro tutti i è specificato per l'ID avviso quindi
tutti gli avvisi sono disabilitati.

--file-opzioni filetto
Leggi ulteriori opzioni da filetto. Ogni opzione dovrebbe apparire su una riga separata
facoltativamente seguito da spazio e un valore di opzione. Righe vuote e righe che iniziano
con # vengono ignorati. I valori delle opzioni possono essere racchiusi tra doppi (") o singolo (')
virgolette per preservare gli spazi bianchi iniziali e finali e per specificare il vuoto
i valori. Se il valore stesso contiene virgolette iniziali o finali, racchiuderlo con an
un paio di virgolette in più, per esempio '"X"'. Le quotazioni non iniziali e non finali sono
interpretato come parte del valore dell'opzione.

La semantica di fornire opzioni in un file è equivalente a fornire le stesse
insieme di opzioni nello stesso ordine sulla riga di comando nel punto in cui il
--file-opzioni l'opzione è specificata eccetto che l'escape della shell e la citazione è
non richiesto. È possibile ripetere questa opzione per specificare più di un file di opzioni.

--show-sloc
Mostra il numero di righe di codice sorgente fisiche generate (SLOC).

--limite-sloc num
Verificare che il numero di righe di codice sorgente fisiche generate (SLOC) non lo sia
superare num.

--licenza-proprietaria
Indica che il codice generato è concesso in licenza con una licenza proprietaria anziché
la GPL.

--letterali personalizzati filetto
Carica la stringa XML personalizzata nelle mappature letterali C++ da filetto. Questo meccanismo può essere
utile se stai usando una codifica dei caratteri personalizzata e alcune delle stringhe nel tuo
schemi, ad esempio nomi di elementi/attributi o valori di enumerazione, contengono non
caratteri ASCII. In questo caso dovrai fornire una mappatura personalizzata in C++
letterali per tali stringhe. Il formato di questo file è specificato nella personalizzato
letterali.xsd File XML Schema che si trova nella directory della documentazione.

--preserva-anonimo
Conserva i tipi anonimi. Per impostazione predefinita, i tipi anonimi vengono denominati automaticamente con
nomi derivati ​​dagli elementi/attributi che li racchiudono. Perché le mappature sono state implementate
da questo compilatore richiedono che tutti i tipi siano nominati, questa opzione è utile solo se tu
vuoi assicurarti che i tuoi schemi non abbiano tipi anonimi.

--mostra-anonimo
Mostra elementi e attributi di tipo anonimo. Questa opzione rende solo
senso insieme al --preserva-anonimo opzione.

--anonimo-regex regex
Aggiungi regex all'elenco delle espressioni regolari usate per derivare nomi per anonimo
tipi dagli attributi/elementi che li racchiudono. regex è un normale tipo Perl
espressione nella forma /modello/sostituzione/. Qualsiasi carattere può essere usato come a
delimitatore invece di /. Sfuggire al carattere delimitatore in modello or
sostituzione non è supportato.

Tutte le espressioni regolari vengono inserite in uno stack con l'ultima specificata
espressione considerata per prima. Viene utilizzata la prima corrispondenza riuscita. Regolare
le espressioni vengono applicate a una stringa nella forma

Nome del file namespace xpath

Per esempio:

ciao.xsd http://example.com/hello elemento

ciao.xsd http://example.com/hello tipo/elemento

Ad esempio, la seguente espressione fa iniziare tutti i nomi derivati ​​con
lettere maiuscole. Questo potrebbe essere utile quando la convenzione di denominazione richiede il tipo
nomi che iniziano con le lettere maiuscole:

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

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--anonimo-regex-trace
Traccia il processo di applicazione delle espressioni regolari specificate con il --anonimo-
regex opzione. Usa questa opzione per scoprire perché le tue espressioni regolari non funzionano
quello che ti aspettavi che facessero.

--Mappa di localizzazione ol=nl
Mappa la posizione dello schema originale ol che è specificato nello schema XML include o
importare elementi nella nuova posizione dello schema nl. Ripeti questa opzione per mappare più di una
posizione dello schema. Ad esempio, la seguente opzione mappa il
http://example.com/foo.xsd URL del foo.xsd file locale.

--Mappa di localizzazione http://example.com/foo.xsd=pippo.xsd

--espressione-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per mappare le posizioni dello schema che sono
specificati nello schema XML includono o importano elementi. regex è simile a Perl
espressione regolare nella forma /modello/sostituzione/. Qualsiasi carattere può essere usato come
un delimitatore invece di /. Sfuggire al carattere delimitatore in modello or
sostituzione non è supportato. Tutte le espressioni regolari vengono inserite in uno stack
con l'ultima espressione specificata considerata per prima. La prima partita che riesce
viene utilizzato.

Ad esempio, la seguente espressione mappa le posizioni degli URL nel modulo
http://example.com/foo/bar.xsd ai file locali nel modulo barra.xsd:

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

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--location-regex-traccia
Traccia il processo di applicazione delle espressioni regolari specificate con il --Posizione-
regex opzione. Usa questa opzione per scoprire perché le tue espressioni regolari non funzionano
quello che ti aspettavi che facessero.

--file-per-tipo
Genera un set separato di file C++ per ogni tipo definito in XML Schema. Nota
che in questa modalità devi solo compilare lo schema(i) di root e il codice sarà
generato per tutti gli schemi inclusi e importati. Questa modalità di compilazione è principalmente
utile quando alcuni dei tuoi schemi non possono essere compilati separatamente o hanno ciclico
dipendenze che implicano l'ereditarietà del tipo. Altre opzioni relative a questa modalità
siamo: --tipo-file-regex, --schema-file-regex, --file-tipo-fate --elenco-file.

--tipo-file-regex regex
Aggiungi regex all'elenco delle espressioni regolari usate per tradurre i nomi dei tipi in file
nomi quando il --file-per-tipo l'opzione è specificata. regex è un normale tipo Perl
espressione nella forma /modello/sostituzione/. Qualsiasi carattere può essere usato come a
delimitatore invece di /. Sfuggire al carattere delimitatore in modello or
sostituzione non è supportato. Tutte le espressioni regolari vengono inserite in uno stack
con l'ultima espressione specificata considerata per prima. La prima partita che riesce
si usa. Le espressioni regolari vengono applicate a una stringa nella forma

namespace nome-tipo

Ad esempio, la seguente mappa di espressione type foo che è definito nel
http://example.com/bar spazio dei nomi al nome del file bar-pippo:

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

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--tipo-file-regex-traccia
Traccia il processo di applicazione delle espressioni regolari specificate con il --tipo-file-
regex opzione. Usa questa opzione per scoprire perché le tue espressioni regolari non funzionano
quello che ti aspettavi che facessero.

--schema-file-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dei file di schema
quando l' --file-per-tipo l'opzione è specificata. regex è un normale tipo Perl
espressione nella forma /modello/sostituzione/. Qualsiasi carattere può essere usato come a
delimitatore invece di /. Sfuggire al carattere delimitatore in modello or
sostituzione non è supportato. Tutte le espressioni regolari vengono inserite in uno stack
con l'ultima espressione specificata considerata per prima. La prima partita che riesce
si usa. Le espressioni regolari vengono applicate al percorso assoluto del filesystem di a
schema e il risultato, inclusa la parte della directory, se presente, viene utilizzato per derivare
, il #includere percorsi delle direttive così come i percorsi dei file C++ generati. Questa opzione,
con --tipo-file-regex sono principalmente utili per posizionare i file generati in
sottodirectory o per risolvere conflitti di nomi di file.

Ad esempio, l'espressione seguente mappa i file di schema in pippo/1.0.0/
sottodirectory ai file nel pippo/ sottodirectory. Di conseguenza, il #includere
i percorsi direttivi per tali schemi saranno in foo/schema.hxx form e il
i file C++ generati verranno inseriti nel pippo/ sottodirectory:

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

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

--schema-file-regex-trace
Traccia il processo di applicazione delle espressioni regolari specificate con il --file-schema-
regex opzione. Usa questa opzione per scoprire perché le tue espressioni regolari non funzionano
quello che ti aspettavi che facessero.

--file-tipo-fat
Genera codice corrispondente agli elementi globali in file di tipo anziché schema
file quando il --tipo-file-regex l'opzione è specificata. Questa opzione è principalmente
utile quando si cerca di ridurre al minimo la quantità di codice oggetto collegato a un
eseguibile impacchettando il codice generato compilato in una libreria statica (archivio).

--elenco-file filetto
Scrivi un elenco di file C++ generati su filetto. Questa opzione è utile principalmente nel
modalità di compilazione file per tipo (--file-per-tipo) per creare un elenco di C++ . generati
file, ad esempio, come frammento di makefile.

--file-list-prologo testo
inserire testo all'inizio dell'elenco dei file. Per comodità, tutte le occorrenze di
, il \n sequenza di caratteri in testo vengono sostituite con nuove linee. Questa opzione può, per
esempio, essere utilizzato per assegnare l'elenco di file generato a una variabile makefile.

--file-list-epilogo testo
inserire testo alla fine dell'elenco dei file. Per comodità, tutte le occorrenze del
\n sequenza di caratteri in testo vengono sostituite con nuove linee.

--file-elenco-delim testo
Delimitare i nomi dei file scritti nell'elenco dei file con testo invece di nuove righe. Come un
convenienza, tutte le occorrenze del \n sequenza di caratteri in testo sono sostituiti con
nuove linee.

cxx-albero command Opzioni
--genera-polimorfico
Genera codice in grado di riconoscere il polimorfismo. Specifica questa opzione se usi la sostituzione
gruppi o xsi:tipo. Usa il --tipo-polimorfo or --tipo-polimorfo-tutto opzione a
specificare quali gerarchie di tipi sono polimorfiche.

--tipo-polimorfo Digitare
Indica quello Digitare è una radice di una gerarchia di tipi polimorfici. Il compilatore può
spesso determinano automaticamente quali tipi sono polimorfici in base alla sostituzione
dichiarazioni di gruppo Tuttavia, potrebbe essere necessario utilizzare questa opzione se non si utilizza
gruppi di sostituzione o se i gruppi di sostituzione sono definiti in un altro schema. Voi
è necessario specificare questa opzione durante la compilazione di ogni file di schema che fa riferimento Digitare.
I Digitare argomento è un nome di tipo XML Schema che può essere qualificato facoltativamente con
uno spazio dei nomi nel namespace#Nome forma.

--tipo-polimorfo-tutto
Indicare che tutti i tipi devono essere trattati come polimorfici.

--lastra-polimorfa num
Specificare la mappa polimorfica su cui il codice generato dovrebbe essere registrato. Questo
funzionalità è principalmente utile per separare più schemi che definiscono il
stessi tipi polimorfici.

--tipo-ordinato Digitare
Indica l'ordine degli elementi in Digitare è significativo. Un esempio potrebbe essere un complesso
tipo con scelta illimitata come modello di contenuto in cui l'ordine degli elementi in XML ha
semantica specifica dell'applicazione. Per i tipi ordinati il ​​compilatore genera uno speciale
membro dei dati del contenitore e un insieme corrispondente di funzioni di accesso e modificatori che sono
utilizzato per catturare l'ordine degli elementi e, per i contenuti misti, del testo.

I Digitare argomento è un nome di tipo XML Schema che può essere qualificato facoltativamente con
uno spazio dei nomi nel namespace#Nome modulo. Nota anche che dovrai specificare
questa opzione quando si compila ogni file di schema che ha altri tipi ordinati derivati
da questo tipo.

--derivato-tipo-ordinato
Tratta automaticamente come ordinati anche i tipi derivati ​​da basi ordinate. Questo è
utile principalmente se desideri essere in grado di scorrere l'intero contenuto
utilizzando il contenitore dell'ordine dei contenuti.

--tipo-ordinato-misto
Tratta automaticamente i tipi complessi con contenuto misto come ordinato.

--tipo-ordinato-tutto
Indica che l'ordine degli elementi in tutti i tipi è significativo.

--contenitore-ordine Digitare
Specifica un modello di classe personalizzato che dovrebbe essere usato come contenitore per il contenuto
ordina in tipi ordinati invece del predefinito std :: vector. Vedere --tipo-ordinato per
maggiori informazioni sul tipo ordinato. Questa opzione è utile soprattutto se è necessario
eseguire ricerche più complesse nel contenitore dell'ordine dei contenuti, ad esempio per elemento
ID. In questo caso, un contenitore come Boost multi-index potrebbe essere più conveniente. Nota
che se utilizzi un contenitore personalizzato, molto probabilmente dovrai includere anche il
intestazioni pertinenti utilizzando il --hxx-prologo* opzioni.

--genera-serializzazione
Genera funzioni di serializzazione. Le funzioni di serializzazione convertono il modello a oggetti
torna all'XML.

--genera-ostream
Genera operatori di inserimento ostream (operatore<) per i tipi generati. Questo permette
uno per stampare facilmente un frammento o l'intero modello a oggetti per il debug o la registrazione.

--genera-doxygen
Genera commenti alla documentazione adatti all'estrazione da parte di Doxygen
sistema di documentazione. La documentazione dalle annotazioni viene aggiunta ai commenti se
presente nello schema.

--genera-confronto
Genera operatori di confronto (operatore== ed operatore!=) per tipi complessi.
Il confronto viene eseguito per membro.

--genera-default-ctor
Genera costruttori predefiniti anche per i tipi che hanno membri obbligatori. Necessario
i membri di un'istanza costruita utilizzando un tale costruttore non sono inizializzati e
accedervi si traduce in un comportamento indefinito.

--genera-from-base-ctor
Genera costruttori che si aspettano un'istanza di un tipo base seguito da all
membri richiesti.

--sopprimi-assegnazione
Sopprimere la generazione di operatori di assegnazione della copia per i tipi complessi. Se questo
l'opzione è specificata, gli operatori di assegnazione della copia per tali tipi sono dichiarati
privato e non attuato.

--genera-stacca
Genera funzioni di distacco per gli elementi e gli attributi richiesti. Funzioni di distacco
per le cardinalità facoltative e di sequenza sono fornite dai rispettivi contenitori.
Queste funzioni, ad esempio, consentono di spostare sottoalberi nel modello a oggetti
all'interno dello stesso albero o tra alberi diversi.

--genera carattere jolly
Genera accessori e modificatori, nonché codice di analisi e serializzazione per XML
Caratteri jolly dello schema (in qualsiasi ed qualsiasi attributo). Il contenuto XML abbinato ai caratteri jolly è
presentati come frammenti DOM. Nota che è necessario inizializzare il runtime Xerces-C++
se stai usando questa opzione

--genera-qualsiasi-tipo
Estrarre e archiviare il contenuto dello schema XML qualsiasi tipo digita come un frammento DOM. Nota
che è necessario inizializzare il runtime Xerces-C++ se si utilizza questa opzione.

--genera-inserimento os
Genera operatori di inserimento del flusso di rappresentazione dei dati per il os flusso di uscita
genere. Ripetere questa opzione per specificare più di un tipo di flusso. Il flusso ACE CDR
(ACE_OutputCDR) e RPC XDR sono riconosciuti dal compilatore e dal necessario
#includere le direttive vengono generate automaticamente. Per i tipi di streaming personalizzati usa il
--hxx-prologo* possibilità di fornire le necessarie dichiarazioni.

--genera-estrazione is
Genera costruttori di estrazione del flusso di rappresentazione dei dati per il is flusso di input
genere. Ripetere questa opzione per specificare più di un tipo di flusso. Il flusso ACE CDR
(ACE_InputCDR) e RPC XDR sono riconosciuti dal compilatore e dal necessario
#includere le direttive vengono generate automaticamente. Per i tipi di streaming personalizzati usa il
--hxx-prologo* possibilità di fornire le necessarie dichiarazioni.

--genera-forward
Genera un file di intestazione separato con dichiarazioni anticipate per i tipi in corso
generato.

--sopprimi-analisi
Sopprime la generazione delle funzioni di analisi e dei costruttori. Usa questa opzione
per ridurre la dimensione del codice generato quando non è necessaria l'analisi da XML.

--genera-tipo-elemento
Genera tipi anziché funzioni di analisi e serializzazione per gli elementi radice.
Questo è principalmente utile per distinguere i modelli di oggetti con lo stesso tipo di radice ma
con diversi elementi di radice.

--genera-element-map
Genera una mappa dell'elemento radice che consente l'analisi uniforme e la serializzazione di
più elementi radice. Questa opzione è valida solo insieme a --genera-elemento-
Digitare.

--genera-intellisense
Genera soluzioni alternative per i bug di IntelliSense in Visual Studio 2005 (8.0). Quando questo
viene utilizzata l'opzione, il codice risultante è leggermente più dettagliato. IntelliSense in
Visual Studio 2008 (9.0) e versioni successive non richiedono queste soluzioni alternative. Supporto per
IntelliSense in Visual Studio 2003 (7.1) è migliorato con questa opzione ma è ancora
incompleto.

--omit-default-attributi
Omettere attributi con valori predefiniti e fissi da documenti XML serializzati.

--nome-tipo style
Specificare la convenzione di denominazione del tipo da utilizzare nel codice generato. Valido
gli stili sono no (Impostazione predefinita), ucce Giava. Vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito
per maggiori informazioni.

--nome-funzione style
Specificare la convenzione di denominazione della funzione da utilizzare nel codice generato.
Gli stili validi sono no (Impostazione predefinita), LCCe Giava. Vedere la sezione CONVENZIONE DEI DENOMINAZIONI
sotto per maggiori informazioni.

--tipo-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre il tipo di schema XML
nomi ai nomi di tipo C++. Per ulteriori informazioni, vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito
informazioni.

--accessor-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi ai nomi delle funzioni di accesso C++. Vedi la CONVENZIONE DEL DENOMINAZIONE
sezione seguente per ulteriori informazioni.

--one-accessor-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi con cardinalità da uno a nomi di funzioni di accesso C++. Vedi il
CONVENZIONE DI DENOMINAZIONE sezione sottostante per ulteriori informazioni.

--opt-accessor-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi con cardinalità opzionale per i nomi delle funzioni di accesso C++. Vedere
la sezione CONVENZIONE NAMING di seguito per ulteriori informazioni.

--seq-accessor-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi con sequenza di cardinalità ai nomi delle funzioni di accesso C++. Vedere
la sezione CONVENZIONE NAMING di seguito per ulteriori informazioni.

--modificatore-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi ai nomi delle funzioni del modificatore C++. Vedi la CONVENZIONE DEL DENOMINAZIONE
sezione seguente per ulteriori informazioni.

--one-modificatore-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi con cardinalità da uno a nomi di funzioni modificatori C++. Vedi il
CONVENZIONE DI DENOMINAZIONE sezione sottostante per ulteriori informazioni.

--opt-modificatore-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi con cardinalità opzionale per i nomi delle funzioni del modificatore C++. Vedere
la sezione CONVENZIONE NAMING di seguito per ulteriori informazioni.

--seq-modificatore-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre i nomi dello schema XML di
elementi/attributi con sequenza di cardinalità a nomi di funzioni modificatori C++. Vedere
la sezione CONVENZIONE NAMING di seguito per ulteriori informazioni.

--parser-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre l'elemento dello schema XML
nomi ai nomi delle funzioni di analisi C++. Vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito per
maggiori informazioni.

--serializer-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre l'elemento dello schema XML
nomi ai nomi delle funzioni di serializzazione C++. Vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito
per maggiori informazioni.

--const-regex regex
Aggiungi regex alla lista delle espressioni regolari usate per tradurre XML Schema-derived
nomi ai nomi delle costanti C++. Per ulteriori informazioni, vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito
informazioni.

--enumeratore-regex regex
Aggiungi regex alla lista delle espressioni regolari usate per tradurre XML Schema
valori di enumerazione ai nomi degli enumeratori C++. Vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito
per maggiori informazioni.

--elemento-tipo-regex regex
Aggiungi regex all'elenco delle espressioni regolari utilizzate per tradurre l'elemento dello schema XML
nomi ai nomi dei tipi di elementi C++. Per ulteriori informazioni, vedere la sezione CONVENZIONE DI DENOMINAZIONE di seguito
informazioni.

--nome-regex-traccia
Traccia il processo di applicazione delle espressioni regolari specificate con il nome
opzioni di trasformazione Usa questa opzione per scoprire perché le tue espressioni regolari
non fare quello che ti aspettavi che facessero.

--elemento-root-primo
Tratta solo il primo elemento globale come radice del documento. Per impostazione predefinita tutto globale
gli elementi sono considerati radici del documento.

--root-elemento-last
Tratta solo l'ultimo elemento globale come radice del documento. Per impostazione predefinita tutto globale
gli elementi sono considerati radici del documento.

--elemento-root-tutto
Tratta tutti gli elementi globali come radici del documento. Questo è il comportamento predefinito. Di
specificando esplicitamente questa opzione è possibile sopprimere l'avviso che viene emesso se
è definito più di un elemento globale.

--elemento-root-none
Non trattare alcun elemento globale come radice del documento. Per impostazione predefinita tutti gli elementi globali
sono considerate radici del documento.

--elemento-radice elemento
Trattare solo elemento come radice del documento. Ripeti questa opzione per specificarne più di uno
elemento radice.

--tipo personalizzato carta geografica
Usa un tipo C++ personalizzato invece della classe generata. Il carta geografica l'argomento è nel
modulo Nome[=Digitare[/base]], dove Nome è un nome di tipo come definito in XML Schema e
Digitare è un nome di tipo C++ che dovrebbe essere usato al suo posto. Se Digitare non è presente o
vuoto allora si presume che il tipo personalizzato abbia lo stesso nome e sia definito nel
stesso spazio dei nomi della classe generata. Se base è specificato allora il
la classe generata è ancora generata ma con quel nome.

--regex-tipo-personalizzato regex
Usa tipi C++ personalizzati invece delle classi generate. Il regex l'argomento è nel
modulo /nome-pat/[tipo-sub/[base-sub/]], dove nome-pat è un modello regex che sarà
essere confrontato con i nomi dei tipi come definito in XML Schema e tipo-sub è un tipo C++
sostituzione del nome che dovrebbe essere utilizzata al suo posto. Se tipo-sub non è presente o è
la sostituzione risulta in una stringa vuota, quindi si presume che il tipo personalizzato abbia il
stesso nome ed essere definito nello stesso spazio dei nomi della classe generata.
If base-sub è presente e la sua sostituzione risulta in una stringa non vuota quindi il
la classe generata è ancora generata ma con il risultato di questa sostituzione come suo
nome. Il modello e le sostituzioni sono nel formato delle espressioni regolari Perl. Vedere
anche la sezione REGEX E SHELL CITAZIONE di seguito.

--parti num
Dividi il codice sorgente generato in num parti. Questo è utile quando si traducono grandi,
schemi monolitici e un compilatore C++ non è in grado di compilare il sorgente risultante
codice in una volta (di solito a causa di memoria insufficiente).

--parti-suffisso suffisso
Usa il suffisso invece dell'impostazione predefinita '-'per separare il nome del file dalla parte
numero.

analizzatore cxx command Opzioni
--tipo-mappa mapfile
Leggi da XML Schema a C++ type mapping information from mapfile. Ripeti questa opzione per
specificare diverse mappe di tipo. Le mappe dei tipi sono considerate in ordine di apparizione e di
viene utilizzata la prima corrispondenza. Per impostazione predefinita, tutti i tipi definiti dall'utente sono mappati su nulla. Vedere il
DIGITA MAPPA sezione sottostante per maggiori informazioni.

--xml-parser parser
Usa il parser come parser XML sottostante. I valori validi sono xerces per Xerces-C++
(predefinito) e expat per espatriati

--genera-validazione
Genera codice di convalida. Il codice di convalida ("parser perfetto") assicura che
i documenti di istanza sono conformi allo schema. Il codice di convalida è generato per impostazione predefinita
quando il parser XML sottostante selezionato non convalida (expat).

--sopprimi-convalida
Sopprimere la generazione del codice di convalida. La convalida è soppressa per impostazione predefinita
quando il parser XML sottostante selezionato sta convalidando (xerces).

--genera-polimorfico
Genera codice in grado di riconoscere il polimorfismo. Specifica questa opzione se usi la sostituzione
gruppi o xsi:tipo.

--generate-noop-impl
Genera un'implementazione del parser di esempio che non fa nulla (nessuna operazione). Il
l'implementazione di esempio può quindi essere riempita con il codice specifico dell'applicazione. Per un
inserire il file nel modulo nome.xsd questa opzione attiva la generazione di due
file C++ aggiuntivi nella forma: nome-pimpl.hxx (intestazione di implementazione del parser
file) e nome-pimpl.cxx (file sorgente di implementazione del parser).

--genera-print-impl
Genera un'implementazione del parser di esempio che stampa i dati XML su STDOUT. Per un
inserire il file nel modulo nome.xsd questa opzione attiva la generazione di due
file C++ aggiuntivi nella forma: nome-pimpl.hxx (intestazione di implementazione del parser
file) e nome-pimpl.cxx (file sorgente di implementazione del parser).

--genera-test-driver
Genera un driver di prova per l'implementazione del parser di esempio. Per un file di input in
la forma nome.xsd questa opzione attiva la generazione di un file C++ aggiuntivo in
la forma nome-driver.cxx.

--sovrascrittura forzata
Forza la sovrascrittura dell'implementazione esistente e dei file del driver di test. Usa questo
opzione solo se non ti dispiace perdere le modifiche che hai fatto nel campione
implementazione o file del driver di test.

--elemento-root-primo
Indica che il primo elemento globale è la radice del documento. Questa informazione è
utilizzato per generare il driver di prova per l'implementazione di esempio.

--root-elemento-last
Indica che l'ultimo elemento globale è la radice del documento. Questa informazione è
utilizzato per generare il driver di prova per l'implementazione di esempio.

--elemento-radice elemento
Indica quello elemento è la radice del documento. Queste informazioni vengono utilizzate per generare
il test driver per l'implementazione di esempio.

--suffisso-tipo-skel suffisso
Usa il fornito suffisso invece del valore predefinito _pskel costruire i nomi dei
scheletri parser generati.

--skel-file-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito -pskel costruire i nomi dei
file di scheletro del parser generati.

--impl-tipo-suffisso suffisso
Usa il fornito suffisso invece del valore predefinito _brufolo costruire i nomi dei
implementazioni del parser per i tipi di schema XML incorporati e parser di esempio
implementazioni.

--impl-suffisso-file suffisso
Usa il fornito suffisso invece del valore predefinito -brufolo costruire i nomi dei
file di implementazione del parser di esempio generati.

NOMINAZIONE CONVENZIONE

Il compilatore può essere istruito ad usare una particolare convenzione di denominazione nel file generato
codice. È possibile selezionare una serie di convenzioni ampiamente utilizzate utilizzando il --nome-tipo ed
--nome-funzione opzioni. È possibile ottenere una convenzione di denominazione personalizzata utilizzando il pulsante --genere-
regex, --accessor-regex, --one-accessor-regex, --opt-accessor-regex, --seq-accessor-regex,
--modificatore-regex, --one-modificatore-regex, --opt-modificatore-regex, --seq-modificatore-regex,
--parser-regex, --serializer-regex, --const-regex, --enumeratore-regexe --tipo-elemento-
regex opzioni.

I --nome-tipo opzione specifica la convenzione che dovrebbe essere usata per nominare C++
tipi. I valori possibili per questa opzione sono no (Impostazione predefinita), ucce Giava. no APPREZZIAMO
(sta per K&R) indica la convenzione di denominazione standard in minuscolo con il carattere di sottolineatura
usato come delimitatore di parole, ad esempio: foo, foo_bar. Il ucc (sta per upper-camel-
caso) e Giava valori a sinonimi per la stessa convenzione di denominazione in cui la prima lettera di
ogni parola nel nome è in maiuscolo, ad esempio: Foo, FooBar.

Allo stesso modo, il --nome-funzione opzione specifica la convenzione che dovrebbe essere usata per
denominare le funzioni C++. I valori possibili per questa opzione sono no (Impostazione predefinita), LCCe Giava.
I no value (sta per K&R) indica la convenzione di denominazione standard in minuscolo con
il carattere di sottolineatura utilizzato come delimitatore di parole, ad esempio: foo(), foo_bar(). Il LCC APPREZZIAMO
(sta per minuscolo-camel) indica una convenzione di denominazione in cui la prima lettera di ciascuno
la parola tranne la prima è in maiuscolo, ad esempio: foo(), fooBar(). Il Giava di denominazione
convenzione è simile a quella minuscola, tranne per il fatto che le funzioni di accesso sono
precedute da get, le funzioni di modifica sono precedute da set, le funzioni di analisi sono
prefisso con parse e le funzioni di serializzazione sono precedute da serialize, ad esempio:
getFoo(), setFooBar(), parseRoot(), serializeRoot().

Notare che le convenzioni di denominazione specificate con il --nome-tipo ed --nome-funzione
le opzioni eseguono solo trasformazioni limitate sui nomi che provengono dallo schema nel
forma del tipo, dell'attributo e dei nomi degli elementi. In altre parole, per ottenere risultati coerenti,
i tuoi schemi dovrebbero seguire una convenzione di denominazione simile a quella che vorresti avere
nel codice generato. In alternativa, puoi utilizzare il ----regex opzioni (discusse di seguito)
per eseguire ulteriori trasformazioni sui nomi che provengono dallo schema.

I --tipo-regex, --accessor-regex, --one-accessor-regex, --opt-accessor-regex, --segue-
funzione di accesso-regex, --modificatore-regex, --one-modificatore-regex, --opt-modificatore-regex, --segue-
modificatore-regex, --parser-regex, --serializer-regex, --const-regex, --enumeratore-regexe
--elemento-tipo-regex le opzioni ti consentono di specificare espressioni regolari extra per ogni nome
categoria in aggiunta al set predefinito che viene aggiunto a seconda del --nome-tipo
ed --nome-funzione opzioni. Espressioni fornite con ----regex Opzioni
vengono valutati prima di qualsiasi espressione predefinita. Ciò consente di eseguire l'override in modo selettivo
alcune o tutte le trasformazioni predefinite. Quando si esegue il debug delle proprie espressioni, è
spesso utile per vedere quali espressioni corrispondono a quali nomi. Il --nome-regex-traccia opzione
consente di tracciare il processo di applicazione delle espressioni regolari ai nomi.

Il valore per ----regex le opzioni dovrebbero essere un'espressione regolare simile a Perl nella forma
/modello/sostituzione/. Qualsiasi carattere può essere usato come delimitatore invece di /. in fuga
del carattere delimitatore in modello or sostituzione non è supportato. Tutti i regolari
le espressioni per ogni categoria vengono inserite in uno stack specifico della categoria con l'ultima
espressione specificata considerata per prima. Viene utilizzata la prima corrispondenza riuscita. Per il
--one-accessor-regex (accessori con cardinalità uno), --opt-accessor-regex (accessori
con cardinalità opzionale), e --seq-accessor-regex (accessori con sequenza di cardinalità)
categorie il --accessor-regex le espressioni vengono utilizzate come fallback. Per il --uno-
modificatore-regex, --opt-modificatore-regexe --seq-modificatore-regex categorie il --modificatore-
regex le espressioni vengono utilizzate come fallback. Per il --elemento-tipo-regex categoria il
--tipo-regex le espressioni vengono utilizzate come fallback.

Le espressioni del nome del tipo (--tipo-regex) vengono valutati sulla stringa del nome che ha il
seguente formato:

[namespace ]Nome[,Nome][,Nome][,Nome]

Le espressioni del nome del tipo di elemento (--elemento-tipo-regex), efficace solo quando il
--genera-tipo-elemento l'opzione è specificata, vengono valutati sulla stringa del nome che ha il
seguente formato:

namespace Nome

Nel formato del nome del tipo il namespace parte seguita da uno spazio è presente solo per global
nomi di tipo. Per i tipi e gli elementi globali definiti negli schemi senza uno spazio dei nomi di destinazione,
, il namespace parte è vuota ma lo spazio è ancora presente. Nel formato del nome del tipo dopo
iniziale Nome componente, fino a tre aggiuntivi Nome componenti possono essere presenti,
separati da virgole. Per esempio:

http://example.com/hello Digitare

foo

pippo, iteratore

foo, const, iteratore

Il seguente set di espressioni regolari predefinite viene utilizzato per trasformare i nomi dei tipi quando
viene selezionata la convenzione di denominazione maiuscola:

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

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

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

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

Le espressioni di accesso e di modifica (--*accessor-regex ed --*modificatore-regex) siamo
valutato sulla stringa del nome che ha il seguente formato:

Nome[,Nome][,Nome]

Dopo l'iniziale Nome componente, fino a due aggiuntivi Nome componenti possono essere presenti,
separati da virgole. Per esempio:

foo

dom, documento

pippo,predefinito,valore

Il seguente set di espressioni regolari predefinite viene utilizzato per trasformare i nomi delle funzioni di accesso
quando l' Giava convenzione di denominazione è selezionata:

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

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

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

Per le categorie parser, serializzatore ed enumeratore, il corrispondente regolare
le espressioni sono valutate sui nomi locali degli elementi e sui valori di enumerazione,
rispettivamente. Ad esempio, la seguente espressione regolare predefinita viene utilizzata per
trasformare i nomi delle funzioni di analisi quando il Giava convenzione di denominazione è selezionata:

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

La categoria const viene utilizzata per creare nomi di costanti C++ per l'elemento/carattere jolly/testo
ID contenuto in tipi ordinati.

Vedere anche la sezione CITAZIONE DI REGEX E SHELL di seguito.

TIPO MAP

I file di mappa dei tipi vengono utilizzati in C++/Parser per definire una mappatura tra XML Schema e C++
tipi. Il compilatore usa queste informazioni per determinare i tipi restituiti di inviare_*
funzioni negli scheletri del parser corrispondenti ai tipi di XML Schema e ai tipi di argomenti
per i callback corrispondenti a elementi e attributi di questi tipi.

Il compilatore ha una serie di regole di mappatura predefinite che mappano i tipi di schema XML incorporati a
tipi C++ adatti (discussi di seguito) e tutti gli altri tipi a nulla. Fornendo il proprio
mappe di tipo è possibile sovrascrivere queste regole predefinite. Il formato del file map di tipo è
presentato di seguito:

namespace schema-spazio dei nomi [ cxx-spazio dei nomi ]
{
( includere nome del file; )*
([ Digitare ] tipo di schema cxx-ret-tipo [ cxx-arg-tipo ]; )*
}

Entrambi schema-spazio dei nomi ed tipo di schema sono modelli regex mentre cxx-spazio dei nomi, cxx-ret-
Digitaree cxx-arg-tipo sono sostituzioni di pattern regex. Tutti i nomi possono essere facoltativamente
racchiuso tra " ", ad esempio, per includere spazi bianchi.

schema-spazio dei nomi determina lo spazio dei nomi dello schema XML. Opzionale cxx-spazio dei nomi ha il prefisso
ogni nome di tipo C++ in questa dichiarazione dello spazio dei nomi. cxx-ret-tipo è un nome di tipo C++ che
viene utilizzato come tipo di ritorno per il inviare_* funzioni. Opzionale cxx-arg-tipo è un argomento
type per le funzioni di callback corrispondenti a elementi e attributi di questo tipo. Se cxx-
tipo arg non è specificato, il valore predefinito è cxx-ret-tipo if cxx-ret-tipo termina con * or &
(cioè è un puntatore o un riferimento) e const cxx-ret-tipo& altrimenti. nome del file is
un nome di file nel formato " " o < ​​> e viene aggiunto con il #includere direttiva a
il codice generato.

I # carattere inizia un commento che termina con una nuova riga o con la fine del file. Per specificare a
nome che contiene # racchiuderlo tra " ". Per esempio:

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

# Passa le mele per valore.
#
mela mela;

# Passa le arance come puntatori.
#
arancione arancione_t*;
}

Nell'esempio sopra, per http://www.example.com/xmlns/my#arancia Tipo di schema XML, il
mio::orange_t* Il tipo C++ verrà utilizzato sia come tipo restituito che come tipo argomento.

È possibile specificare diverse dichiarazioni dello spazio dei nomi in un singolo file. Lo spazio dei nomi
La dichiarazione può anche essere completamente omessa per mappare i tipi in uno schema senza uno spazio dei nomi.
Per esempio:

includi "my.hxx";
mela mela;

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

Il compilatore ha un numero di regole di mappatura predefinite che possono essere presentate come
seguenti file di mappa. I tipi incorporati dello schema XML basato su stringhe sono mappati su entrambi
std::stringa or std::wstring a seconda del tipo di carattere selezionato con il --tipo-char
opzione (serbatoio per impostazione predefinita).

namespace http://www.w3.org/2001/XMLSchema
{
booleano booleano booleano;

byte "signed char" "signed char";
unsignedByte "unsigned char" "unsigned char";

corto corto corto;
unsignedShort "unsigned short" "unsigned short";

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

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

intero "lungo lungo" "lungo lungo";

negativeIntero "lungo lungo" "lungo lungo";
nonPositiveInteger "lungo lungo" "lungo lungo";

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

galleggiante galleggiante galleggiante;
doppio doppio doppio;
doppio decimale doppio;

stringa std::stringa;
normalizedString std::string;
token std::stringa;
Nome std::string;
NMTOKEN std::stringa;
NCName std::stringa;
ID std::stringa;
IDREF std::stringa;
lingua std::stringa;
qualsiasiURI std::stringa;

NMTOKENS schema_xml::sequenza_stringa;
IDREFS schema_xml::sequenza_stringa;

QNome schema_xml::qnome;

base64Binary std::auto_ptr
std::auto_ptr ;
hexBinary std::auto_ptr
std::auto_ptr ;

data xml_schema::data;
dateTime schema_xml::data_ora;
durata xml_schema::durata;
gDay xml_schema::gday;
gMese xml_schema::gmese;
gMonthDay schema_xml::gmonth_day;
gAnno xml_schema::ganno;
gAnnoMese xml_schema::ganno_mese;
ora xml_schema::ora;
}

L'ultima regola predefinita mappa tutto ciò che non è stato mappato dalle regole precedenti a nulla:

spazio dei nomi .*
{
.* vuoto vuoto;
}

Quando fornisci le tue mappe di tipo con il --tipo-mappa opzione, vengono valutati per primi.
Ciò consente di sovrascrivere in modo selettivo le regole predefinite.

REGEX E SHELL CITAZIONE

Quando si immette un argomento di un'espressione regolare nella riga di comando della shell è spesso
necessario utilizzare le virgolette (racchiudendo l'argomento tra " " o ' ') per evitare che
shell dall'interpretazione di determinati caratteri, ad esempio spazi come separatori di argomenti e
$ come espansioni variabili.

Sfortunatamente è difficile raggiungere questo obiettivo in un modo che sia portatile tra le shell POSIX,
come quelli che si trovano su GNU/Linux e UNIX e sulla shell di Windows. Ad esempio, se usi " "
per la citazione otterrai un risultato sbagliato con le shell POSIX se la tua espressione contiene $.
Il modo standard di gestire questo problema sui sistemi POSIX è usare invece ' '.
Sfortunatamente, la shell di Windows non rimuove ' ' dagli argomenti quando vengono passati a
applicazioni. Di conseguenza potresti dover usare ' ' per POSIX e " " per Windows ($ non è
trattato come un carattere speciale su Windows).

In alternativa, puoi salvare le opzioni delle espressioni regolari in un file, un'opzione per riga,
e usa questo file con il --file-opzioni opzione. Con questo approccio non è necessario
preoccupati per la citazione della shell.

DIAGNOSTICA

Se il file di input non è una definizione di schema XML W3C valida, xsdcxx emetterà diagnostica
messaggi a Stderr ed esci con codice di uscita diverso da zero.

Usa xsdcxx online utilizzando i servizi onworks.net