xsdcxx - Online sa Cloud

PROGRAMA:

NAME

xsdcxx - W3C XML Schema sa C++ Compiler

SINOPSIS

xsdcxx utos [ pagpipilian ] file [ file ...]
xsdcxx Tulungan [ utos ]
xsdcxx bersyon

DESCRIPTION

xsdcxx bumubuo ng partikular sa bokabularyo, statically-type na C++ na pagmamapa mula sa W3C XML Schema
mga kahulugan. Ang partikular na pagmamapa upang makagawa ay pinipili ng a utos. Ang bawat pagmamapa ay may a
bilang ng mapping-specific pagpipilian na dapat lumitaw, kung mayroon man, pagkatapos ng utos. Input
Ang mga file ay dapat na mga kahulugan ng W3C XML Schema. Ang eksaktong hanay ng mga nabuong file ay nakasalalay
sa napiling pagmamapa at mga opsyon.

UTOS

cxx-puno
Bumuo ng C++/Tree mapping. Para sa bawat input file sa form pangalan.xsd ang
ang mga sumusunod na C++ file ay nabuo: pangalan.hxx (header file), pangalan.ixx (inline na file,
nabuo lamang kung ang --generate-inline ang pagpipilian ay tinukoy), pangalan.cxx (Pinagmulan
file), at pangalan-fwd.hxx (forward declaration file, nabuo lamang kung ang
--bumuo-pasulong ang pagpipilian ay tinukoy).

cxx-parser
Bumuo ng C++/Parser mapping. Para sa bawat input file sa form pangalan.xsd ang
ang mga sumusunod na C++ file ay nabuo: pangalan-pskel.hxx (parser skeleton header file),
pangalan-pskel.ixx (parser skeleton inline na file, nabuo lamang kung ang --bumuo-
inline ang opsyon ay tinukoy), at pangalan-pskel.cxx (parser skeleton source file). Kung
ang --generate-noop-impl or --generate-print-impl ang opsyon ay tinukoy, ang
ang mga sumusunod na karagdagang sample na pagpapatupad ng mga file ay nabuo: name-pimpl.hxx
(parser implementation header file) at name-pimpl.cxx (pagpapatupad ng parser
source file). Kung ang --generate-test-driver ang opsyon ay tinukoy, ang karagdagang
name-driver.cxx nabuo ang test driver file.

Tulungan I-print ang impormasyon sa paggamit at lumabas. Gamitin

xsdcxx Tulungan utos

para sa tulong na partikular sa command.

bersyon
I-print ang bersyon at lumabas.

Opsyon

Partikular sa utos pagpipilian, kung mayroon man, ay dapat lumitaw pagkatapos ng kaukulang utos.

pangkaraniwan pagpipilian
--std bersyon
Tukuyin ang pamantayan ng C++ kung saan dapat sumunod ang nabuong code. Mga wastong halaga
ay c++98 (default) at c++11.

Ang pamantayan ng C++ ay nakakaapekto sa iba't ibang aspeto ng nabuong code na tinatalakay
nang mas detalyado sa iba't ibang dokumentasyong tukoy sa pagmamapa. Sa pangkalahatan, kapag ang C++11 ay
pinili, ang nabuong code ay umaasa sa mga semantika at gamit ng paglipat std::unique_ptr
sa halip na hindi na ginagamit std::auto_ptr.

Kapag napili ang C++11 mode, karaniwan nang hindi mo kailangang magsagawa ng anumang karagdagang hakbang
maliban sa paganahin ang C++11 sa iyong C++ compiler, kung kinakailangan. Gagawin ng XSDCXX compiler
awtomatikong idagdag ang kinakailangang macro define sa nabuong mga file ng header na
ililipat ang header-only XSDCXX runtime library (libxsd) sa C++11 mode.
Gayunpaman, kung isasama mo ang alinman sa mga XSDCXX runtime header nang direkta sa iyong
application (karaniwang isasama mo lang ang mga nabuong header), pagkatapos ay kakailanganin mo
upang tukuyin ang XSD_CXX11 macro para sa iyong buong proyekto.

--char-type uri
Bumuo ng code gamit ang ibinigay na character uri sa halip na ang default tangke. Wasto
ang mga halaga ay tangke at wchar_t.

--char-encoding sa
Tukuyin ang pag-encode ng character na dapat gamitin sa nabuong code. Wasto
mga halaga para sa tangke ang uri ng karakter ay utf8 (default), iso8859-1, lcp (Xerces-C++
pahina ng lokal na code), at pasadya. Kung pumasa ka pasadya bilang halaga kung gayon kakailanganin mo
upang isama ang header ng pagpapatupad ng transcoder para sa iyong pag-encode sa simula
ng nabuong mga file ng header (tingnan ang --hxx-prologue pagpipilian).

Para sa wchar_t uri ng character ang tanging wastong halaga ay kotse at ang encoding ay
awtomatikong pinili sa pagitan ng UTF-16 at UTF-32/UCS-4, depende sa wchar_t
laki ng uri.

--output-dir dir
Isulat ang nabuong mga file sa dir sa halip na ang kasalukuyang direktoryo.

--generate-inline
Bumuo ng mga simpleng function inline. Ang pagpipiliang ito ay nagti-trigger ng paglikha ng inline na file.

--generate-xml-schema
Bumuo ng C++ header file na parang ang schema na pinagsama-sama ay tumutukoy sa XML Schema
namespace. Para sa C++/Tree mapping, ang magreresultang file ay maglalaman ng mga kahulugan
para sa lahat ng XML Schema na built-in na uri. Para sa C++/Parser mapping, ang resultang file
ay maglalaman ng mga kahulugan para sa lahat ng parser skeleton at pagpapatupad
naaayon sa mga built-in na uri ng XML Schema.

Ang schema file na ibinigay sa compiler ay hindi kailangang umiral at ginagamit lamang upang makuha
ang pangalan ng resultang header file. Gamitin ang --extern-xml-schema pagpipilian sa
isama ang file na ito sa mga nabuong file para sa iba pang mga schema.

--extern-xml-schema file
Isama ang isang header file na nagmula sa file sa halip na bumuo ng XML Schema
inline na pagmamapa ng namespace. Ang ibinigay na file ay hindi kailangang umiiral at ginagamit lamang ito
makuha ang pangalan ng kasamang header file. Gamitin ang --generate-xml-schema opsyon
para buuin ang header file na ito.

--namespace-map xns=cns
Namespace ng XML Schema sa mapa xns sa C++ namespace cns. Ulitin ang pagpipiliang ito upang tukuyin
pagmamapa para sa higit sa isang XML Schema namespace. Halimbawa, ang sumusunod na opsyon:

--namespace-map http://example.com/foo/bar=foo::bar

Mapa ang http://example.com/foo/bar XML Schema namespace sa foo::bar C + +
namespace.

--namespace-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang XML Schema namespace
mga pangalan sa mga pangalan ng namespace ng C++. regex ay isang regular na expression na katulad ng Perl sa anyo
/huwaran/kapalit/. Anumang character ay maaaring gamitin bilang delimiter sa halip na /.
Pagtakas sa karakter ng delimiter sa huwaran or kapalit ay hindi suportado.

Ang lahat ng mga regular na expression ay itinulak sa isang stack na may huling tinukoy
isinaalang-alang muna ang ekspresyon. Ginagamit ang unang laban na nagtagumpay. Regular
ang mga expression ay inilapat sa isang string sa form

filename namespace

Halimbawa, kung mayroon kang file hello.xsd may namespace http://example.com/hello at
Tumakbo ka xsd sa file na ito, ang string na pinag-uusapan ay:

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

Para sa built-in na XML Schema namespace ang string ay:

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

Ang sumusunod na tatlong hakbang ay ginagawa para sa bawat regular na expression hanggang sa tugma
ay matatagpuan:

1. Ang expression ay inilapat at kung ang resulta ay walang laman ang susunod na expression ay
isinaalang-alang

2. puwang / ay pinalitan ng ::.

3. Ang resulta ay na-verify na isang wastong pangalan ng saklaw ng C++ (hal, foo::bar). Kung ito
nagtagumpay ang pagsubok, ang resulta ay ginagamit bilang pangalan ng namespace ng C++.

Bilang halimbawa, ang sumusunod na expression ay nagmamapa ng mga namespace ng XML Schema sa form
http://example.com/foo/bar sa C++ namespaces sa form foo::bar:

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

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--namespace-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa --namespace-
regex opsyon. Gamitin ang opsyong ito para malaman kung bakit hindi gumagana ang iyong mga regular na expression
kung ano ang inaasahan mong gawin nila.

--nakareserba-pangalan n[=r]
Magdagdag ng pangalan n sa listahan ng mga pangalan na hindi dapat gamitin bilang mga identifier. Ang pangalan
maaaring opsyonal na sundan ng = at ang kapalit na pangalan r yan ang dapat gamitin
sa halip. Ang lahat ng mga C++ na keyword ay nasa listahang ito.

--include-with-brackets
Gumamit ng mga angle bracket (<>) sa halip na mga quotes ("") sa nabuo # isama mga direktiba

--include-prefix unlapi
Idagdag unlapi sa nabuo # isama mga landas ng direktiba.

Halimbawa, kung mayroon kang sumusunod na elemento ng pag-import sa iyong schema

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

at pinagsama-sama ang fragment na ito sa --include-prefix schema/, pagkatapos ay ang isama
direktiba sa nabuong code ay:

# isama "schemas/base.hxx"

--include-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit sa pagbabago # isama direktiba
mga landas. regex ay isang regular na expression na katulad ng Perl sa anyo /huwaran/kapalit/.
Anumang character ay maaaring gamitin bilang delimiter sa halip na /. Pagtakas sa delimiter
karakter sa huwaran or kapalit ay hindi suportado.

Ang lahat ng mga regular na expression ay itinulak sa isang stack na may huling tinukoy
isinaalang-alang muna ang ekspresyon. Ginagamit ang unang laban na nagtagumpay.

Bilang halimbawa, binabago ng sumusunod na expression ang mga landas sa anyo
schemas/foo/bar sa mga landas sa anyo nabuo/foo/bar:

%schemas/(.+)%generated/$1%

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--include-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa --isama-
regex opsyon. Gamitin ang opsyong ito para malaman kung bakit hindi gumagana ang iyong mga regular na expression
kung ano ang inaasahan mong gawin nila.

--guard-prefix unlapi
Idagdag unlapi sa mga nabuong header inclusion guard. Ang prefix ay binago sa itaas
case at mga character na ilegal sa isang preprocessor macro name ay pinapalitan ng
salungguhit. Kung hindi tinukoy ang opsyong ito, ang bahagi ng direktoryo ng input
schema file ay ginagamit bilang prefix.

--hxx-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default .hxx upang bumuo ng pangalan ng
file ng header. Tandaan na ang suffix na ito ay ginagamit din upang bumuo ng mga pangalan ng mga file ng header
naaayon sa kasama/na-import na mga schema.

--ixx-panlapi suffix
Gamitin ang ibinigay suffix sa halip na ang default .ixx upang bumuo ng pangalan ng
inline na file.

--cxx-panlapi suffix
Gamitin ang ibinigay suffix sa halip na ang default .cxx upang bumuo ng pangalan ng
source file.

--fwd-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default -fwd.hxx upang bumuo ng pangalan ng
ang pasulong na deklarasyon na file.

--hxx-regex regex
Gamitin ang ibinigay na expression upang bumuo ng pangalan ng header file. regex ay isang
Perl-like na regular na expression sa form /huwaran/kapalit/. Tandaan na ito
ginagamit din ang expression upang bumuo ng mga pangalan ng mga file ng header na naaayon sa
kasama/na-import na mga schema. Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--ixx-regex regex
Gamitin ang ibinigay na expression upang bumuo ng pangalan ng inline na file. regex ay isang
Perl-like na regular na expression sa form /huwaran/kapalit/. Tingnan din ang REGEX
AT SHELL QUOTING seksyon sa ibaba.

--cxx-regex regex
Gamitin ang ibinigay na expression upang bumuo ng pangalan ng source file. regex ay isang
Perl-like na regular na expression sa form /huwaran/kapalit/. Tingnan din ang REGEX
AT SHELL QUOTING seksyon sa ibaba.

--fwd-regex regex
Gamitin ang ibinigay na expression upang buuin ang pangalan ng pasulong na deklarasyon na file.
regex ay isang regular na expression na katulad ng Perl sa anyo /huwaran/kapalit/. Tingnan din
ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--hxx-prologue teksto
Isingit teksto sa simula ng header file.

--ixx-prologue teksto
Isingit teksto sa simula ng inline na file.

--cxx-prologue teksto
Isingit teksto sa simula ng source file.

--fwd-prologue teksto
Isingit teksto sa simula ng pasulong na deklarasyon na file.

--prologue teksto
Isingit teksto sa simula ng bawat nabuong file kung saan walang file-
tiyak na prologue.

--hxx-epilogue teksto
Isingit teksto sa dulo ng header file.

--ixx-epilogue teksto
Isingit teksto sa dulo ng inline na file.

--cxx-epilogue teksto
Isingit teksto sa dulo ng source file.

--fwd-epilogue teksto
Isingit teksto sa dulo ng pasulong na deklarasyon na file.

--epilogue teksto
Isingit teksto sa dulo ng bawat nabuong file kung saan walang file-specific
epilog.

--hxx-prologue-file file
Ipasok ang nilalaman ng file sa simula ng header file.

--ixx-prologue-file file
Ipasok ang nilalaman ng file sa simula ng inline na file.

--cxx-prologue-file file
Ipasok ang nilalaman ng file sa simula ng source file.

--fwd-prologue-file file
Ipasok ang nilalaman ng file sa simula ng pasulong na deklarasyon na file.

--prologue-file file
Ipasok ang nilalaman ng file sa simula ng bawat nabuong file kung saan
walang file-specific na prologue file.

--hxx-epilogue-file file
Ipasok ang nilalaman ng file sa dulo ng header file.

--ixx-epilogue-file file
Ipasok ang nilalaman ng file sa dulo ng inline na file.

--cxx-epilogue-file file
Ipasok ang nilalaman ng file sa dulo ng source file.

--fwd-epilogue-file file
Ipasok ang nilalaman ng file sa dulo ng pasulong na deklarasyon na file.

--epilogue-file file
Ipasok ang nilalaman ng file sa dulo ng bawat nabuong file kung saan mayroon
walang file-specific na epilogue file.

--export-simbolo simbolo
Isingit simbolo sa mga lugar kung saan ang DLL export/import control statements
(__declspec(dllexport/dllimport)) ay kinakailangan.

--export-xml-schema
Mga uri ng pag-export/pag-import sa namespace ng XML Schema gamit ang ibinigay na simbolo ng pag-export
sa --export-simbolo pagpipilian Ang XSD_NO_EXPORT Maaaring gamitin ang macro upang alisin ito
code sa panahon ng C++ compilation, na maaaring maging kapaki-pakinabang kung gusto mong gamitin ang pareho
nakabuo ng code sa maraming platform.

--export-maps
I-export ang mga mapa ng suporta ng polymorphism mula sa isang Win32 DLL kung saan naroon ang nabuong code na ito
nakalagay. Ito ay kinakailangan kapag ang iyong uri ng hierarchy ay nahahati sa ilang mga DLL
dahil kung hindi, ang bawat DLL ay magkakaroon ng sarili nitong hanay ng mga mapa. Sa ganitong sitwasyon ang
nabuong code para sa DLL na naglalaman ng mga batayang uri at/o pangkat ng pagpapalit
heads ay dapat na pinagsama-sama sa opsyong ito at ang nabuong code para sa lahat ng iba pang DLL
dapat ay pinagsama-sama sa --import-maps. Ang pagpipiliang ito ay may bisa lamang kasama ng
--bumuo-polymorphic. ang XSD_NO_EXPORT Maaaring gamitin ang macro upang alisin ang code na ito
sa panahon ng C++ compilation, na maaaring maging kapaki-pakinabang kung gusto mong gamitin ang pareho
nakabuo ng code sa maraming platform.

--import-maps
Mag-import ng mga mapa ng suporta sa polymorphism sa isang Win32 DLL o executable kung saan ito
naka-link ang nabuong code. Tingnan ang --export-maps opsyon na dokumentasyon para sa mga detalye.
Ang mga opsyon na ito ay may bisa lamang kasama ng --bumuo-polymorphic. ang XSD_NO_EXPORT
Maaaring gamitin ang macro upang alisin ang code na ito sa panahon ng C++ compilation, na maaaring maging kapaki-pakinabang kung
gusto mong gamitin ang parehong nabuong code sa maraming platform.

--generate-dep
lumikha gumawa impormasyon ng dependency. Ang pagpipiliang ito ay nagpapalitaw sa paglikha ng .d
file na naglalaman ng mga dependency ng mga nabuong file sa pangunahing schema file bilang
pati na rin ang lahat ng mga schema file na kasama/na-import nito, palipat-lipat. Ito
Ang dependency file ay karaniwang kasama sa pangunahing makefile ipatupad
awtomatikong pagsubaybay sa dependency.

Tandaan din na ang awtomatikong pagbuo ng dependency ay hindi suportado sa file-per-
uri ng mode (--file-per-type). Sa kasong ito, ang lahat ng nabuong mga file ay ginawa
na may iisang compiler invocation at nakadepende sa lahat ng schema. Bilang isang resulta, ito ay
mas madaling magtatag ng naturang dependency nang manu-mano, marahil sa tulong ng
--file-list* mga pagpipilian.

--generate-dep-only
lumikha gumawa impormasyon ng dependency lamang.

--dep-phony
Bumuo ng mga huwad na target para sa mga kasama/na-import na schema file, na nagiging sanhi ng bawat isa na umasa
sa wala. Gumagana ang mga ganyang dummy rules gumawa mga error na dulot ng pag-alis ng
schema file nang hindi rin ina-update ang dependency file upang tumugma.

--dep-target target
Baguhin ang target ng panuntunan ng dependency. Bilang default, naglalaman ito ng lahat ng nabuo
C++ file pati na rin ang dependency file mismo, nang walang anumang prefix ng direktoryo. Kung
kailangan mo ng maraming target, pagkatapos ay maaari mong tukuyin ang mga ito bilang isang solong, space-
pinaghiwalay na argumento o maaari mong ulitin ang opsyong ito nang maraming beses.

--dep-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default .d upang bumuo ng pangalan ng
dependency file.

--dep-regex regex
Gamitin ang ibinigay na expression upang bumuo ng pangalan ng dependency file. regex is
isang regular na expression na katulad ng Perl sa anyo /huwaran/kapalit/. Tingnan din ang
REGEX AT SHELL QUOTING seksyon sa ibaba.

--disable-warning balaan
Huwag paganahin ang babala sa pag-print gamit ang id balaan. Kung lahat ay tinukoy para sa warning id noon
lahat ng mga babala ay hindi pinagana.

--options-file file
Basahin ang mga karagdagang opsyon mula sa file. Ang bawat opsyon ay dapat na lumabas sa isang hiwalay na linya
opsyonal na sinusundan ng espasyo at isang halaga ng opsyon. Mga walang laman na linya at linya na nagsisimula
sa # ay hindi pinapansin. Ang mga halaga ng opsyon ay maaaring ilakip sa doble (") o walang asawa (')
mga panipi upang mapanatili ang mga nangunguna at sumusunod na mga whitespace pati na rin upang tukuyin ang walang laman
mga halaga. Kung ang value mismo ay naglalaman ng trailing o nangungunang mga quote, lagyan ito ng isang
dagdag na pares ng mga panipi, halimbawa '"x"'. Non-leading at non-trailing quotes ay
binibigyang kahulugan bilang bahagi ng halaga ng opsyon.

Ang mga semantika ng pagbibigay ng mga opsyon sa isang file ay katumbas ng pagbibigay ng pareho
set ng mga opsyon sa parehong pagkakasunud-sunod sa command line sa punto kung saan ang
--options-file ang opsyon ay tinukoy maliban na ang shell escaping at quoting ay
hindi kailangan. Maaari mong ulitin ang opsyong ito upang tumukoy ng higit sa isang file ng mga opsyon.

--show-sloc
Ipakita ang bilang ng mga nabuong pisikal na linya ng source ng code (SLOC).

--sloc-limit num
Suriin kung ang bilang ng mga nabuong pisikal na linya ng source ng code (SLOC) ay hindi
lumampas num.

--proprietary-lisensya
Ipahiwatig na ang nabuong code ay lisensyado sa ilalim ng isang pagmamay-ari na lisensya sa halip na
ang GPL.

--pasadyang-literal file
Mag-load ng custom na XML string sa C++ literal na mga pagmamapa mula sa file. Ang mekanismong ito ay maaaring
kapaki-pakinabang kung gumagamit ka ng custom na character encoding at ilan sa mga string sa iyong
schema, halimbawa mga pangalan ng elemento/attribute o enumeration value, ay naglalaman ng hindi-
Mga character na ASCII. Sa kasong ito, kakailanganin mong magbigay ng custom na pagmamapa sa C++
literal para sa naturang mga string. Ang format ng file na ito ay tinukoy sa custom-
literals.xsd XML Schema file na makikita sa direktoryo ng dokumentasyon.

--preserve-anonymous
Panatilihin ang mga hindi kilalang uri. Bilang default, ang mga anonymous na uri ay awtomatikong pinangalanan sa
mga pangalang hango sa mga nakapaloob na elemento/attribute. Dahil ipinatupad ang mga pagmamapa
sa pamamagitan ng compiler na ito ay nangangailangan ng lahat ng uri na pangalanan, ang pagpipiliang ito ay kapaki-pakinabang lamang kung ikaw
Gustong tiyakin na ang iyong mga schema ay walang mga anonymous na uri.

--show-anonymous
Ipakita ang mga elemento at katangian na hindi kilalang uri. Ang pagpipiliang ito ay gumagawa lamang
kahulugan kasama ang --preserve-anonymous pagpipilian.

--anonymous-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang makakuha ng mga pangalan para sa hindi nagpapakilalang
mga uri mula sa mga kalakip na katangian/elemento. regex ay isang regular na katulad ng Perl
pagpapahayag sa anyo /huwaran/kapalit/. Anumang karakter ay maaaring gamitin bilang a
delimiter sa halip na /. Pagtakas sa karakter ng delimiter sa huwaran or
kapalit ay hindi suportado.

Ang lahat ng mga regular na expression ay itinulak sa isang stack na may huling tinukoy
isinaalang-alang muna ang ekspresyon. Ginagamit ang unang laban na nagtagumpay. Regular
ang mga expression ay inilapat sa isang string sa form

filename namespace xpath

Halimbawa:

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

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

Bilang halimbawa, ang sumusunod na expression ay gumagawa ng lahat ng mga nagmula na pangalan na magsimula sa
malaking titik. Ito ay maaaring maging kapaki-pakinabang kapag ang iyong kombensiyon sa pagbibigay ng pangalan ay nangangailangan ng uri
mga pangalan na magsisimula sa malalaking titik:

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

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--anonymous-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa --anonymous-
regex opsyon. Gamitin ang opsyong ito para malaman kung bakit hindi gumagana ang iyong mga regular na expression
kung ano ang inaasahan mong gawin nila.

--mapa ng lokasyon ol=nl
Imapa ang orihinal na lokasyon ng schema ol na tinukoy sa XML Schema kasama ang o
mag-import ng mga elemento sa bagong lokasyon ng schema nl. Ulitin ang opsyong ito para mag-map ng higit sa isa
lokasyon ng schema. Halimbawa, ang sumusunod na opsyon ay nagmamapa ng
http://example.com/foo.xsd URL sa foo.xsd lokal na file.

--mapa ng lokasyon http://example.com/foo.xsd=foo.xsd

--lokasyon-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang i-map ang mga lokasyon ng schema na
na tinukoy sa XML Schema isama o i-import ang mga elemento. regex ay isang Perl-like
regular na pagpapahayag sa anyo /huwaran/kapalit/. Anumang karakter ay maaaring gamitin bilang
isang delimiter sa halip na /. Pagtakas sa karakter ng delimiter sa huwaran or
kapalit ay hindi suportado. Ang lahat ng mga regular na expression ay itinulak sa isang stack
na may huling tinukoy na expression na unang isinasaalang-alang. Ang unang laban na nagtagumpay
Ginagamit.

Halimbawa, ang sumusunod na expression ay nagmamapa ng mga lokasyon ng URL sa form
http://example.com/foo/bar.xsd sa mga lokal na file sa form bar.xsd:

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

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--lokasyon-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa --lokasyon-
regex opsyon. Gamitin ang opsyong ito para malaman kung bakit hindi gumagana ang iyong mga regular na expression
kung ano ang inaasahan mong gawin nila.

--file-per-type
Bumuo ng hiwalay na hanay ng mga C++ na file para sa bawat uri na tinukoy sa XML Schema. Tandaan
na sa mode na ito kailangan mo lamang i-compile ang (mga) root schema at ang code ay magiging
nabuo para sa lahat ng kasama at na-import na mga schema. Pangunahin ang compilation mode na ito
kapaki-pakinabang kapag ang ilan sa iyong mga schema ay hindi maaaring i-compile nang hiwalay o magkaroon ng cyclic
dependencies na may kasamang uri ng pamana. Iba pang mga opsyon na nauugnay sa mode na ito
ay: --type-file-regex, --schema-file-regex, --fat-type-file, at --file-list.

--type-file-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng uri sa file
mga pangalan kapag ang --file-per-type ang pagpipilian ay tinukoy. regex ay isang regular na katulad ng Perl
pagpapahayag sa anyo /huwaran/kapalit/. Anumang karakter ay maaaring gamitin bilang a
delimiter sa halip na /. Pagtakas sa karakter ng delimiter sa huwaran or
kapalit ay hindi suportado. Ang lahat ng mga regular na expression ay itinulak sa isang stack
na may huling tinukoy na expression na unang isinasaalang-alang. Ang unang laban na nagtagumpay
Ginagamit. Ang mga regular na expression ay inilalapat sa isang string sa form

namespace uri-pangalan

Halimbawa, ang sumusunod na uri ng mga mapa ng expression foo na tinukoy sa
http://example.com/bar namespace sa pangalan ng file bar-foo:

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

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--type-file-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa --type-file-
regex opsyon. Gamitin ang opsyong ito para malaman kung bakit hindi gumagana ang iyong mga regular na expression
kung ano ang inaasahan mong gawin nila.

--schema-file-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng file ng schema
kapag ang --file-per-type ang pagpipilian ay tinukoy. regex ay isang regular na katulad ng Perl
pagpapahayag sa anyo /huwaran/kapalit/. Anumang karakter ay maaaring gamitin bilang a
delimiter sa halip na /. Pagtakas sa karakter ng delimiter sa huwaran or
kapalit ay hindi suportado. Ang lahat ng mga regular na expression ay itinulak sa isang stack
na may huling tinukoy na expression na unang isinasaalang-alang. Ang unang laban na nagtagumpay
Ginagamit. Ang mga Regular Expression ay inilalapat sa ganap na landas ng filesystem ng a
schema file at ang resulta, kasama ang bahagi ng direktoryo, kung mayroon man, ay ginagamit upang kunin
ang # isama mga direktibong landas pati na rin ang nabuong mga landas ng C++ na file. Ang pagpipiliang ito,
kasama ng --type-file-regex ay pangunahing kapaki-pakinabang upang ilagay ang nabuong mga file sa
mga subdirectory o upang malutas ang mga salungatan sa pangalan ng file.

Halimbawa, ang sumusunod na expression ay nagmamapa ng mga schema file sa foo/1.0.0/
subdirectory sa mga file sa foo/ subdirectory. Bilang resulta, ang # isama
ang mga direktibong landas para sa mga naturang schema ay nasa foo/schema.hxx form at ang
ang mga nabuong C++ na file ay ilalagay sa foo/ subdirectory:

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

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

--schema-file-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa --schema-file-
regex opsyon. Gamitin ang opsyong ito para malaman kung bakit hindi gumagana ang iyong mga regular na expression
kung ano ang inaasahan mong gawin nila.

--fat-type-file
Bumuo ng code na naaayon sa mga global na elemento sa mga uri ng file sa halip na schema
file kapag ang --type-file-regex ang pagpipilian ay tinukoy. Pangunahin ang pagpipiliang ito
kapaki-pakinabang kapag sinusubukang i-minimize ang dami ng object code na naka-link sa isang
maipapatupad sa pamamagitan ng packaging na pinagsama-samang nabuong code sa isang static (archive) library.

--file-list file
Sumulat ng isang listahan ng mga nabuong C++ na file sa file. Ang pagpipiliang ito ay pangunahing kapaki-pakinabang sa
file-per-type na compilation mode (--file-per-type) upang lumikha ng isang listahan ng nabuong C++
mga file, halimbawa, bilang isang makefile fragment.

--file-list-prologue teksto
Isingit teksto sa simula ng listahan ng file. Bilang kaginhawahan, lahat ng mga pangyayari ng
ang \n pagkakasunud-sunod ng karakter sa teksto ay pinalitan ng mga bagong linya. Ang pagpipiliang ito ay maaaring, para sa
halimbawa, gamitin upang italaga ang nabuong listahan ng file sa isang makefile variable.

--file-list-epilogue teksto
Isingit teksto sa dulo ng listahan ng file. Bilang kaginhawahan, lahat ng mga pangyayari ng
\n pagkakasunud-sunod ng karakter sa teksto ay pinalitan ng mga bagong linya.

--file-list-delim teksto
Itakda ang mga pangalan ng file na nakasulat sa listahan ng file na may teksto sa halip na mga bagong linya. Bilang isang
kaginhawahan, lahat ng mga pangyayari ng \n pagkakasunud-sunod ng karakter sa teksto ay pinalitan ng
mga bagong linya.

cxx-puno utos pagpipilian
--bumuo-polymorphic
Bumuo ng polymorphism-aware code. Tukuyin ang opsyong ito kung gagamit ka ng pagpapalit
mga pangkat o xsi: uri. Gamitin ang --polymorphic-uri or --polymorphic-type-lahat pagpipilian sa
tukuyin kung aling uri ng mga hierarchy ang polymorphic.

--polymorphic-uri uri
Ipahiwatig iyon uri ay isang ugat ng isang polymorphic type hierarchy. Pwede ang compiler
madalas awtomatikong tinutukoy kung aling mga uri ang polymorphic batay sa pagpapalit
mga deklarasyon ng grupo. Gayunpaman, maaaring kailanganin mong gamitin ang opsyong ito kung hindi mo ginagamit
mga pangkat ng pagpapalit o kung ang mga pangkat ng pagpapalit ay tinukoy sa ibang schema. Ikaw
kailangang tukuyin ang opsyong ito kapag kino-compile ang bawat schema file na nagre-refer uri.
Ang uri Ang argumento ay isang XML Schema type na pangalan na maaaring opsyonal na maging kwalipikado sa
isang namespace sa namespace#pangalan form.

--polymorphic-type-lahat
Ipahiwatig na ang lahat ng uri ay dapat ituring bilang polymorphic.

--polymorphic-plate num
Tukuyin ang polymorphic map plate kung saan dapat irehistro ang nabuong code. Ito
Ang functionality ay pangunahing kapaki-pakinabang upang paghiwalayin ang maramihang mga schema na tumutukoy sa
parehong mga polymorphic na uri.

--uri-uri uri
Ipahiwatig ang pagkakasunud-sunod ng elemento sa uri ay makabuluhan. Ang isang halimbawa ay magiging isang kumplikado
mag-type na may walang hangganang pagpipilian bilang isang modelo ng nilalaman kung saan mayroon ang pagkakasunud-sunod ng elemento sa XML
semantics na tukoy sa aplikasyon. Para sa mga uri ng ordered ang compiler ay bumubuo ng isang espesyal
miyembro ng data ng container at isang kaukulang hanay ng mga accessor at modifier na
ginagamit upang makuha ang pagkakasunud-sunod ng mga elemento at, para sa halo-halong nilalaman, ng teksto.

Ang uri Ang argumento ay isang XML Schema type na pangalan na maaaring opsyonal na maging kwalipikado sa
isang namespace sa namespace#pangalan anyo. Tandaan din na kakailanganin mong tukuyin
ang opsyong ito kapag kino-compile ang bawat schema file na may iba pang mga order na uri na hinango
mula sa ganitong uri.

--ordered-type-derived
Awtomatikong ituring ang mga uri na hinango mula sa mga nakaayos na base gaya ng iniutos din. Ito ay
pangunahing kapaki-pakinabang kung gusto mong maulit ang kumpletong nilalaman
gamit ang container ng order ng nilalaman.

--ordered-type-mixed
Awtomatikong ituring ang mga kumplikadong uri na may halo-halong nilalaman ayon sa pagkakasunod-sunod.

--ordered-type-lahat
Ipahiwatig na ang pagkakasunud-sunod ng elemento sa lahat ng uri ay makabuluhan.

--order-lalagyan uri
Tumukoy ng custom na template ng klase na dapat gamitin bilang container para sa content
mag-order sa mga uri ng order sa halip na ang default std::vector. Tingnan --uri-uri para
higit pang impormasyon sa uri ng order. Ang pagpipiliang ito ay pangunahing kapaki-pakinabang kung kailangan mo
magsagawa ng mas kumplikadong mga paghahanap sa container ng order ng nilalaman, halimbawa ayon sa elemento
id. Sa kasong ito, maaaring maging mas maginhawa ang isang container tulad ng Boost multi-index. Tandaan
na kung gumagamit ng custom na lalagyan, malamang na kakailanganin mo ring isama ang
nauugnay na mga header gamit ang --hxx-prologue* mga pagpipilian.

--bumuo-serialization
Bumuo ng mga serialization function. Kino-convert ng mga serialization function ang object model
bumalik sa XML.

--bumuo-ostream
Bumuo ng mga ostream insertion operator (operator<) para sa mga nabuong uri. Ito ay nagpapahintulot
isa upang madaling mag-print ng isang fragment o ang buong object model para sa pag-debug o pag-log.

--bumuo-doxygen
Bumuo ng mga komento sa dokumentasyon na angkop para sa pagkuha ng Doxygen
sistema ng dokumentasyon. Ang dokumentasyon mula sa mga anotasyon ay idinaragdag sa mga komento kung
naroroon sa schema.

--bumuo-paghahambing
Bumuo ng mga operator ng paghahambing (operator== at operator!=) para sa mga kumplikadong uri.
Ang paghahambing ay isinagawa ayon sa miyembro.

--generate-default-ctor
Bumuo ng mga default na konstruktor kahit para sa mga uri na nangangailangan ng mga miyembro. Kailangan
Ang mga miyembro ng isang instance na binuo gamit ang naturang constructor ay hindi sinisimulan at
ang pag-access sa mga ito ay nagreresulta sa hindi natukoy na pag-uugali.

--generate-from-base-ctor
Bumuo ng mga konstruktor na umaasa ng isang halimbawa ng isang uri ng base na sinusundan ng lahat
kinakailangang mga miyembro.

--suppress-assignment
Pigilan ang pagbuo ng mga operator ng pagtatalaga ng kopya para sa mga kumplikadong uri. Kung ito
ang opsyon ay tinukoy, ang mga operator ng pagtatalaga ng kopya para sa mga ganitong uri ay idineklara
pribado at iniwang hindi naipatupad.

--generate-detach
Bumuo ng mga detach function para sa mga kinakailangang elemento at katangian. Tanggalin ang mga function
para sa opsyonal at pagkakasunod-sunod na mga kardinal ay ibinibigay ng kani-kanilang mga lalagyan.
Ang mga function na ito, halimbawa, ay nagbibigay-daan sa iyong ilipat ang mga sub-puno sa object model
alinman sa loob ng parehong puno o sa pagitan ng iba't ibang mga puno.

--bumuo-wildcard
Bumuo ng mga accessor at modifier pati na rin ang pag-parse at serialization code para sa XML
Mga wildcard ng schema (anumang at anumangKatangian). Ang nilalamang XML na tinutugma ng mga wildcard ay
ipinakita bilang mga fragment ng DOM. Tandaan na kailangan mong simulan ang Xerces-C++ runtime
kung ginagamit mo ang opsyong ito.

--bumuo-anumang-uri
I-extract at iimbak ang nilalaman ng XML Schema kahit anong uri i-type bilang fragment ng DOM. Tandaan
na kailangan mong simulan ang Xerces-C++ runtime kung ginagamit mo ang opsyong ito.

--generate-insertion os
Bumuo ng data representation stream insertion operator para sa os stream ng output
uri. Ulitin ang opsyong ito upang tumukoy ng higit sa isang uri ng stream. Ang stream ng ACE CDR
(ACE_OutputCDR) at RPC XDR ay kinikilala ng compiler at kinakailangan
# isama ang mga direktiba ay awtomatikong nabuo. Para sa mga custom na uri ng stream gamitin ang
--hxx-prologue* mga opsyon upang magbigay ng mga kinakailangang deklarasyon.

--generate-extraction is
Bumuo ng data representation stream extraction constructors para sa is input stream
uri. Ulitin ang opsyong ito upang tumukoy ng higit sa isang uri ng stream. Ang stream ng ACE CDR
(ACE_InputCDR) at RPC XDR ay kinikilala ng compiler at kinakailangan
# isama ang mga direktiba ay awtomatikong nabuo. Para sa mga custom na uri ng stream gamitin ang
--hxx-prologue* mga opsyon upang magbigay ng mga kinakailangang deklarasyon.

--bumuo-pasulong
Bumuo ng isang hiwalay na file ng header na may mga pasulong na deklarasyon para sa mga uri nito
nabuo

--sugpuin-pag-parse
Pigilan ang pagbuo ng mga function ng pag-parse at mga konstruktor. Gamitin ang opsyong ito
upang bawasan ang nabuong laki ng code kapag hindi kailangan ang pag-parse mula sa XML.

--generate-element-type
Bumuo ng mga uri sa halip na pag-parse at serialization function para sa mga elemento ng ugat.
Ito ay pangunahing kapaki-pakinabang upang makilala ang mga modelo ng bagay na may parehong uri ng ugat ngunit
na may iba't ibang elemento ng ugat.

--generate-element-map
Bumuo ng root element map na nagbibigay-daan sa pare-parehong pag-parse at serialization ng
maramihang mga elemento ng ugat. Ang pagpipiliang ito ay may bisa lamang kasama ng --bumuo ng elemento-
uri.

--bumuo-intellisense
Bumuo ng mga workaround para sa mga IntelliSense bug sa Visual Studio 2005 (8.0). Kapag ganito
ang opsyon ay ginagamit, ang resultang code ay bahagyang mas verbose. IntelliSense sa
Ang Visual Studio 2008 (9.0) at mas bago ay hindi nangangailangan ng mga workaround na ito. Suporta para sa
Ang IntelliSense sa Visual Studio 2003 (7.1) ay napabuti sa opsyong ito ngunit nananatili pa rin
hindi kumpleto.

--omit-default-attributes
Alisin ang mga attribute na may default at fixed value mula sa mga serialized na XML na dokumento.

--type-naming estilo
Tukuyin ang uri ng pagpapangalan ng convention na dapat gamitin sa nabuong code. Wasto
ang mga istilo ay knr (default), ucc, at Dyaba. Tingnan ang seksyong NAMING CONVENTION sa ibaba
para sa karagdagang impormasyon.

--function-naming estilo
Tukuyin ang function na pagpapangalan ng convention na dapat gamitin sa nabuong code.
Ang mga wastong istilo ay knr (default), lcc, at Dyaba. Tingnan ang seksyong PAGPANGALAN NG KONVENSYON
sa ibaba para sa karagdagang impormasyon.

--type-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang uri ng XML Schema
mga pangalan sa C++ type na mga pangalan. Tingnan ang seksyong NAMING CONVENTION sa ibaba para sa higit pa
impormasyon.

--accessor-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute sa mga pangalan ng function ng C++ accessor. Tingnan ang NAMING CONVENTION
seksyon sa ibaba para sa karagdagang impormasyon.

--one-accessor-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute na may cardinality one sa mga pangalan ng function ng C++ accessor. Tingnan ang
NAMING CONVENTION section sa ibaba para sa karagdagang impormasyon.

--opt-accessor-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute na may cardinality na opsyonal sa mga pangalan ng function ng C++ accessor. Tingnan mo
ang seksyong NAMING CONVENTION sa ibaba para sa karagdagang impormasyon.

--seq-accessor-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute na may pagkakasunud-sunod ng cardinality sa mga pangalan ng function ng C++ accessor. Tingnan mo
ang seksyong NAMING CONVENTION sa ibaba para sa karagdagang impormasyon.

--modifier-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute sa mga pangalan ng function ng modifier ng C++. Tingnan ang NAMING CONVENTION
seksyon sa ibaba para sa karagdagang impormasyon.

--one-modifier-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute na may cardinality one sa mga pangalan ng function ng modifier ng C++. Tingnan ang
NAMING CONVENTION section sa ibaba para sa karagdagang impormasyon.

--opt-modifier-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute na may cardinality na opsyonal sa mga pangalan ng function ng C++ modifier. Tingnan mo
ang seksyong NAMING CONVENTION sa ibaba para sa karagdagang impormasyon.

--seq-modifier-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang mga pangalan ng XML Schema ng
mga elemento/attribute na may cardinality sequence sa mga pangalan ng function ng modifier ng C++. Tingnan mo
ang seksyong NAMING CONVENTION sa ibaba para sa karagdagang impormasyon.

--parser-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang elemento ng XML Schema
mga pangalan sa C++ parsing function na mga pangalan. Tingnan ang seksyong NAMING CONVENTION sa ibaba para sa
karagdagang informasiyon.

--serializer-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang elemento ng XML Schema
mga pangalan sa C++ serialization function na mga pangalan. Tingnan ang seksyong NAMING CONVENTION sa ibaba
para sa karagdagang impormasyon.

--const-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang XML Schema-derived
mga pangalan sa C++ na palaging mga pangalan. Tingnan ang seksyong NAMING CONVENTION sa ibaba para sa higit pa
impormasyon.

--enumerator-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang XML Schema
mga halaga ng enumeration sa mga pangalan ng enumerator ng C++. Tingnan ang seksyong NAMING CONVENTION sa ibaba
para sa karagdagang impormasyon.

--element-type-regex regex
Idagdag regex sa listahan ng mga regular na expression na ginagamit upang isalin ang elemento ng XML Schema
mga pangalan sa mga pangalan ng uri ng elemento ng C++. Tingnan ang seksyong NAMING CONVENTION sa ibaba para sa higit pa
impormasyon.

--name-regex-trace
Sundan ang proseso ng paglalapat ng mga regular na expression na tinukoy sa pangalan
mga pagpipilian sa pagbabago. Gamitin ang opsyong ito para malaman kung bakit ang iyong mga regular na expression
huwag mong gawin ang inaasahan mong gawin nila.

--ugat-elemento-una
Tratuhin lamang ang unang pandaigdigang elemento bilang isang ugat ng dokumento. Bilang default lahat ng global
ang mga elemento ay itinuturing na mga ugat ng dokumento.

--ugat-element-huling
Tratuhin lamang ang huling pandaigdigang elemento bilang isang ugat ng dokumento. Bilang default lahat ng global
ang mga elemento ay itinuturing na mga ugat ng dokumento.

--ugat-element-lahat
Tratuhin ang lahat ng mga pandaigdigang elemento bilang mga ugat ng dokumento. Ito ang default na pag-uugali. Sa pamamagitan ng
tahasang tinukoy ang opsyong ito maaari mong sugpuin ang babala na ibinibigay kung
higit sa isang pandaigdigang elemento ang tinukoy.

--ugat-element-wala
Huwag ituring ang anumang pandaigdigang elemento bilang mga ugat ng dokumento. Bilang default, lahat ng global na elemento
ay itinuturing na mga ugat ng dokumento.

--ugat-elemento sangkap
Treat lang sangkap bilang ugat ng dokumento. Ulitin ang opsyong ito upang tumukoy ng higit sa isa
elemento ng ugat.

--pasadyang-uri mapa
Gumamit ng custom na uri ng C++ sa halip na ang nabuong klase. Ang mapa ang argumento ay nasa
anyo pangalan[=uri[/base]], saan pangalan ay isang uri ng pangalan gaya ng tinukoy sa XML Schema at
uri ay isang uri ng C++ na pangalan na dapat gamitin sa halip. Kung uri ay wala o
walang laman pagkatapos ang pasadyang uri ay ipinapalagay na may parehong pangalan at tinukoy sa
kaparehong namespace gaya ng makukuha ng nabuong klase. Kung base ay tinukoy pagkatapos ay ang
nabuong klase ay nabuo pa rin ngunit may ganoong pangalan.

--custom-type-regex regex
Gumamit ng mga custom na uri ng C++ sa halip na ang mga nabuong klase. Ang regex ang argumento ay nasa
anyo /name-pat/[uri-sub/[base-sub/]], saan name-pat ay isang regex pattern na gagawin
maitugma sa mga pangalan ng uri gaya ng tinukoy sa XML Schema at uri-sub ay isang uri ng C++
pagpapalit ng pangalan na dapat gamitin sa halip. Kung uri-sub ay wala o nito
ang pagpapalit ay nagreresulta sa isang walang laman na string at ang pasadyang uri ay ipinapalagay na mayroong
parehong pangalan at tukuyin sa parehong namespace na magkakaroon ng nabuong klase.
If base-sub ay naroroon at ang pagpapalit nito ay nagreresulta sa isang hindi walang laman na string pagkatapos ay ang
nabuong klase ay nabuo pa rin ngunit sa resulta ng pagpapalit na ito bilang nito
pangalan. Ang pattern at mga pagpapalit ay nasa format ng regular na expression ng Perl. Tingnan mo
gayundin ang seksyon ng REGEX AT SHELL QUOTING sa ibaba.

--mga bahagi num
Hatiin ang nabuong source code sa num mga bahagi. Ito ay kapaki-pakinabang kapag nagsasalin ng malaki,
Ang mga monolithic schemas at isang C++ compiler ay hindi kayang i-compile ang nagreresultang source
code nang sabay-sabay (karaniwan ay dahil sa hindi sapat na memorya).

--parts-suffix suffix
paggamit suffix sa halip na ang default '-' upang paghiwalayin ang pangalan ng file mula sa bahagi
numero.

cxx-parser utos pagpipilian
--type-map mapfile
Basahin ang XML Schema sa C++ type mapping information mula sa mapfile. Ulitin ang pagpipiliang ito sa
tukuyin ang ilang uri ng mga mapa. Isinasaalang-alang ang uri ng mga mapa sa pagkakasunud-sunod ng hitsura at ang
ginamit ang unang tugma. Bilang default, lahat ng uri na tinukoy ng user ay nakamapa sa walang bisa. Tingnan ang
TYPE MAPA seksyon sa ibaba para sa karagdagang impormasyon.

--xml-parser pares
paggamit pares bilang pinagbabatayan na XML parser. Ang mga wastong halaga ay xerces para sa Xerces-C++
(default) at expat para sa Expat.

--generate-validation
Bumuo ng validation code. Tinitiyak iyon ng validation code ("perpektong parser")
instance na mga dokumento ay umaayon sa schema. Ang validation code ay nabuo bilang default
kapag ang napiling pinagbabatayan na XML parser ay hindi nagpapatunay (expat).

--suppress-validation
Pigilan ang pagbuo ng validation code. Ang pagpapatunay ay pinigilan bilang default
kapag ang napiling pinagbabatayan na XML parser ay nagpapatunay (xerces).

--bumuo-polymorphic
Bumuo ng polymorphism-aware code. Tukuyin ang opsyong ito kung gagamit ka ng pagpapalit
mga pangkat o xsi: uri.

--generate-noop-impl
Bumuo ng sample na pagpapatupad ng parser na walang ginagawa (walang operasyon). Ang
ang sample na pagpapatupad ay maaaring punan ng code na tukoy sa application. Para sa
input file sa form pangalan.xsd ang pagpipiliang ito ay nagpapalitaw ng henerasyon ng dalawa
karagdagang C++ file sa form: name-pimpl.hxx (header ng pagpapatupad ng parser
file) at name-pimpl.cxx (pinagmulan ng file ng pagpapatupad ng parser).

--generate-print-impl
Bumuo ng sample na pagpapatupad ng parser na nagpi-print ng XML data sa STDOUT. Para sa
input file sa form pangalan.xsd ang pagpipiliang ito ay nagpapalitaw ng henerasyon ng dalawa
karagdagang C++ file sa form: name-pimpl.hxx (header ng pagpapatupad ng parser
file) at name-pimpl.cxx (pinagmulan ng file ng pagpapatupad ng parser).

--generate-test-driver
Bumuo ng test driver para sa sample na pagpapatupad ng parser. Para sa isang input file sa
ang form pangalan.xsd ang pagpipiliang ito ay nagti-trigger ng pagbuo ng isang karagdagang C++ file sa
ang form name-driver.cxx.

--force-overwrite
Sapilitang i-overwriting ang kasalukuyang pagpapatupad at mga test driver file. Gamitin mo to
opsyon lamang kung hindi mo iniisip na mawala ang mga pagbabagong ginawa mo sa sample
pagpapatupad o mga file ng driver ng pagsubok.

--ugat-elemento-una
Ipahiwatig na ang unang pandaigdigang elemento ay ang ugat ng dokumento. Ang impormasyong ito ay
ginamit upang bumuo ng test driver para sa sample na pagpapatupad.

--ugat-element-huling
Ipahiwatig na ang huling pandaigdigang elemento ay ang ugat ng dokumento. Ang impormasyong ito ay
ginamit upang bumuo ng test driver para sa sample na pagpapatupad.

--ugat-elemento sangkap
Ipahiwatig iyon sangkap ay ang ugat ng dokumento. Ang impormasyong ito ay ginagamit upang makabuo
ang test driver para sa sample na pagpapatupad.

--skel-type-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default _pskel upang bumuo ng mga pangalan ng
nakabuo ng mga parser skeleton.

--skel-file-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default -pskel upang bumuo ng mga pangalan ng
nabuong parser skeleton file.

--impl-type-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default _bugaw upang bumuo ng mga pangalan ng
mga pagpapatupad ng parser para sa mga built-in na uri ng XML Schema pati na rin ang sample na parser
mga pagpapatupad.

--impl-file-suffix suffix
Gamitin ang ibinigay suffix sa halip na ang default -bugaw upang bumuo ng mga pangalan ng
nakabuo ng mga sample na file ng pagpapatupad ng parser.

PANGALAN KONSEENSYA

Ang compiler ay maaaring turuan na gumamit ng isang partikular na kombensiyon sa pagbibigay ng pangalan sa nabuong
code. Ang isang bilang ng malawakang ginagamit na mga kombensiyon ay maaaring mapili gamit ang --type-naming at
--function-naming mga pagpipilian. Maaaring makamit ang isang custom na convention sa pagpapangalan gamit ang --uri-
regex, --accessor-regex, --one-accessor-regex, --opt-accessor-regex, --seq-accessor-regex,
--modifier-regex, --one-modifier-regex, --opt-modifier-regex, --seq-modifier-regex,
--parser-regex, --serializer-regex, --const-regex, --enumerator-regex, at --uri-elemento-
regex mga pagpipilian.

Ang --type-naming Tinutukoy ng opsyon ang convention na dapat gamitin para sa pagbibigay ng pangalan sa C++
mga uri. Ang mga posibleng halaga para sa opsyong ito ay knr (default), ucc, at Dyaba. ang knr halaga
(na nangangahulugang K&R) ay nangangahulugang ang pamantayan, maliit na kaso ng kombensiyon sa pagbibigay ng pangalan na may salungguhit
ginamit bilang isang salitang delimiter, halimbawa: foo, foo_bar. Ang ucc (sambit para sa upper-camel-
kaso) at Dyaba pinahahalagahan ang isang kasingkahulugan para sa parehong convention ng pagbibigay ng pangalan kung saan ang unang titik ng
ang bawat salita sa pangalan ay naka-capitalize, halimbawa: Foo, FooBar.

Katulad nito, ang --function-naming ang opsyon ay tumutukoy sa convention na dapat gamitin para sa
pagbibigay ng pangalan sa mga function ng C++. Ang mga posibleng halaga para sa opsyong ito ay knr (default), lcc, at Dyaba.
Ang knr value (na nangangahulugang K&R) ay nangangahulugan ng pamantayan, maliit na case na kombensiyon sa pagbibigay ng pangalan sa
ang salungguhit na ginamit bilang delimiter ng salita, halimbawa: foo(), foo_bar(). Ang lcc halaga
(na nangangahulugang lower-camel-case) ay nangangahulugang isang kombensiyon ng pagbibigay ng pangalan kung saan ang unang titik ng bawat isa
salita maliban sa una ay naka-capitalize, halimbawa: foo(), fooBar(). Ang Dyaba pagpapangalan
Ang convention ay katulad ng lower-camel-case na isa maliban na ang mga function ng accessor ay
may prefix na get, ang mga function ng modifier ay may prefix na set, ang mga function ng pag-parse ay
prefix na may parse, at ang serialization function ay prefixed na may serialize, halimbawa:
getFoo(), setFooBar(), parseRoot(), serializeRoot().

Tandaan na ang mga kombensiyon sa pagbibigay ng pangalan na tinukoy sa --type-naming at --function-naming
ang mga opsyon ay nagsasagawa lamang ng mga limitadong pagbabago sa mga pangalan na nagmumula sa schema sa
anyo ng uri, katangian, at mga pangalan ng elemento. Sa madaling salita, para makakuha ng pare-parehong resulta,
ang iyong mga schema ay dapat sumunod sa isang katulad na kombensiyon sa pagbibigay ng pangalan gaya ng gusto mong magkaroon
sa nabuong code. Bilang kahalili, maaari mong gamitin ang --*-regex mga pagpipilian (tinalakay sa ibaba)
upang magsagawa ng mga karagdagang pagbabago sa mga pangalan na nagmula sa schema.

Ang --type-regex, --accessor-regex, --one-accessor-regex, --opt-accessor-regex, --seq-
accessor-regex, --modifier-regex, --one-modifier-regex, --opt-modifier-regex, --seq-
modifier-regex, --parser-regex, --serializer-regex, --const-regex, --enumerator-regex, at
--element-type-regex Binibigyang-daan ka ng mga opsyon na tumukoy ng mga karagdagang regular na expression para sa bawat pangalan
kategorya bilang karagdagan sa paunang natukoy na hanay na idinagdag depende sa --type-naming
at --function-naming mga pagpipilian. Mga ekspresyong ibinibigay kasama ng --*-regex pagpipilian
ay sinusuri bago ang anumang paunang natukoy na mga expression. Nagbibigay-daan ito sa iyong piliing i-override
ilan o lahat ng paunang natukoy na pagbabago. Kapag nagde-debug ng iyong sariling mga expression, ito ay
kadalasang kapaki-pakinabang upang makita kung aling mga expression ang tumutugma sa kung aling mga pangalan. Ang --name-regex-trace opsyon
nagbibigay-daan sa iyo na subaybayan ang proseso ng paglalapat ng mga regular na expression sa mga pangalan.

Ang halaga para sa --*-regex ang mga opsyon ay dapat na isang perl-like na regular na expression sa form
/huwaran/kapalit/. Anumang character ay maaaring gamitin bilang delimiter sa halip na /. Nakatakas
ng karakter ng delimiter sa huwaran or kapalit ay hindi suportado. Lahat ng regular
ang mga expression para sa bawat kategorya ay itinutulak sa isang stack na tukoy sa kategorya na may huli
ang tinukoy na expression ay isinasaalang-alang muna. Ginagamit ang unang laban na nagtagumpay. Para sa
--one-accessor-regex (mga accessor na may cardinality one), --opt-accessor-regex (mga accessor
na may cardinality opsyonal), at --seq-accessor-regex (mga accessor na may cardinality sequence)
mga kategorya ang --accessor-regex ang mga expression ay ginagamit bilang isang fallback. Para sa --isa-
modifier-regex, --opt-modifier-regex, at --seq-modifier-regex mga kategorya ang --modifier-
regex ang mga expression ay ginagamit bilang isang fallback. Para sa --element-type-regex kategorya ang
--type-regex ang mga expression ay ginagamit bilang isang fallback.

Ang uri ng mga expression ng pangalan (--type-regex) ay sinusuri sa string ng pangalan na mayroong
sumusunod na format:

[namespace ]pangalan[,pangalan][,pangalan][,pangalan]

Ang mga expression ng pangalan ng uri ng elemento (--element-type-regex), epektibo lamang kapag ang
--generate-element-type ang opsyon ay tinukoy, ay sinusuri sa string ng pangalan na mayroong
sumusunod na format:

namespace pangalan

Sa format ng pangalan ng uri ang namespace bahagi na sinusundan ng isang espasyo ay naroroon lamang para sa global
uri ng mga pangalan. Para sa mga pandaigdigang uri at elemento na tinukoy sa mga schema na walang target na namespace,
ang namespace walang laman ang bahagi ngunit naroroon pa rin ang espasyo. Sa format ng pangalan ng uri pagkatapos
ang paunang pangalan component, hanggang sa tatlong karagdagang pangalan ang mga sangkap ay maaaring naroroon,
pinaghihiwalay ng kuwit. Halimbawa:

http://example.com/hello uri

foo

foo, iterator

foo,const,iterator

Ang sumusunod na hanay ng mga paunang natukoy na regular na expression ay ginagamit upang baguhin ang mga pangalan ng uri kapag
napili ang upper-camel-case na kombensiyon sa pagbibigay ng pangalan:

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

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

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

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

Ang mga expression ng accessor at modifier (--*accessor-regex at --*modifier-regex) ay
nasuri sa string ng pangalan na may sumusunod na format:

pangalan[,pangalan][,pangalan]

Pagkatapos ng inisyal pangalan component, hanggang sa dalawang karagdagang pangalan ang mga sangkap ay maaaring naroroon,
pinaghihiwalay ng kuwit. Halimbawa:

foo

dom, dokumento

foo,default,halaga

Ang sumusunod na hanay ng mga paunang natukoy na regular na expression ay ginagamit upang baguhin ang mga pangalan ng accessor
kapag ang Dyaba Napili ang kombensyon ng pagbibigay ng pangalan:

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

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

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

Para sa parser, serializer, at enumerator na mga kategorya, ang kaukulang regular
ang mga expression ay sinusuri sa mga lokal na pangalan ng mga elemento at sa mga halaga ng enumeration,
ayon sa pagkakabanggit. Halimbawa, ginagamit ang sumusunod na paunang-natukoy na regular na expression
baguhin ang mga pangalan ng function ng parsing kapag ang Dyaba Napili ang kombensyon ng pagbibigay ng pangalan:

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

Ang kategorya ng const ay ginagamit upang lumikha ng C++ na mga pare-parehong pangalan para sa elemento/wildcard/text
content id sa mga nakaayos na uri.

Tingnan din ang seksyong REGEX AT SHELL QUOTING sa ibaba.

TYPE MAPA

Ang uri ng mga file ng mapa ay ginagamit sa C++/Parser upang tukuyin ang pagmamapa sa pagitan ng XML Schema at C++
mga uri. Ginagamit ng compiler ang impormasyong ito upang matukoy ang mga uri ng pagbabalik ng post_*
function sa mga parser skeleton na tumutugma sa mga uri ng XML Schema pati na rin sa mga uri ng argumento
para sa mga callback na nauugnay sa mga elemento at katangian ng mga ganitong uri.

Ang compiler ay may set ng mga paunang natukoy na panuntunan sa pagmamapa kung saan nagmamapa ng mga built-in na XML Schema na uri
angkop na mga uri ng C++ (tinalakay sa ibaba) at lahat ng iba pang uri sa walang bisa. Sa pamamagitan ng pagbibigay ng iyong sarili
uri ng mga mapa na maaari mong i-override ang mga paunang natukoy na panuntunang ito. Ang format ng uri ng file ng mapa ay
ipinakita sa ibaba:

namespace schema-namespace [ cxx-namespace ]
{
( isama pangalan ng file; )*
([ uri ] uri ng schema cxx-ret-type [ cxx-arg-type ]; )*
}

Kapwa schema-namespace at uri ng schema ay mga regex pattern habang cxx-namespace, cxx-ret-
uri, at cxx-arg-type ay mga pagpapalit ng regex pattern. Ang lahat ng mga pangalan ay maaaring opsyonal
nakapaloob sa " ", halimbawa, upang isama ang mga puting puwang.

schema-namespace tinutukoy ang XML Schema namespace. Opsyonal cxx-namespace ay prefixed sa
bawat pangalan ng uri ng C++ sa deklarasyon ng namespace na ito. cxx-ret-type ay isang uri ng C++ na pangalan na
ay ginagamit bilang isang uri ng pagbabalik para sa post_* mga function. Opsyonal cxx-arg-type ay isang argumento
uri para sa mga function ng callback na tumutugma sa mga elemento at katangian ng ganitong uri. Kung cxx-
uri ng arg ay hindi tinukoy, ito ay default sa cxx-ret-type if cxx-ret-type nagtatapos sa * or &
(iyon ay, ito ay isang pointer o isang sanggunian) at const cxx-ret-type& kung hindi man. pangalan ng file is
isang pangalan ng file alinman sa " " o < ​​> na format at idinaragdag kasama ng # isama direktiba sa
ang nabuong code.

Ang # Nagsisimula ang character ng komento na nagtatapos sa isang bagong linya o dulo ng file. Upang tukuyin ang a
pangalan na naglalaman ng # ilakip ito sa " ". Halimbawa:

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

# Ipasa ang mga mansanas ayon sa halaga.
#
mansanas na mansanas;

# Ipasa ang mga dalandan bilang mga pointer.
#
orange orange_t*;
}

Sa halimbawa sa itaas, para sa http://www.example.com/xmlns/my#kahel Uri ng XML Schema, ang
my::orange_t* Ang uri ng C++ ay gagamitin bilang parehong mga uri ng pagbabalik at argumento.

Maaaring tukuyin ang ilang deklarasyon ng namespace sa isang file. Ang namespace
ang deklarasyon ay maaari ding ganap na alisin sa mga uri ng mapa sa isang schema na walang namespace.
Halimbawa:

isama ang "my.hxx";
mansanas na mansanas;

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

Ang compiler ay may ilang paunang natukoy na mga panuntunan sa pagmamapa na maaaring ipakita bilang ang
sumusunod na mga file ng mapa. Ang mga string-based na XML Schema na built-in na uri ay nakamapa sa alinman
std::string or std::wstring depende sa uri ng karakter na pinili gamit ang --char-type
pagpipilian (tangke bilang default).

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

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

maikli maikli maikli;
unsignedShort "unsigned short" "unsigned short";

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

mahaba "mahabang mahaba" "mahabang mahaba";
unsignedLong "unsigned long long" "unsigned long long";

integer "mahaba ang haba" "mahaba ang haba";

negativeInteger "mahaba-haba" "mahaba-haba";
nonPositiveInteger "mahaba-haba" "mahaba-haba";

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

lumutang lumutang lumutang;
doble doble doble;
decimal double double;

string std::string;
normalizedString std::string;
token std::string;
Pangalan std::string;
NMTOKEN std::string;
NCName std::string;
ID std::string;
IDREF std::string;
wika std::string;
anyURI std::string;

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

QName xml_schema::qname;

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

petsa xml_schema::date;
dateTime xml_schema::date_time;
tagal xml_schema::tagal;
gDay xml_schema::gday;
gMonth xml_schema::gmonth;
gMonthDay xml_schema::gmonth_day;
gYear xml_schema::gyear;
gYearMonth xml_schema::gyear_month;
oras xml_schema::oras;
}

Ang huling na-predefine na panuntunan ay nagmamapa ng anumang bagay na hindi nakamapa ng mga nakaraang panuntunan sa walang bisa:

namespace .*
{
.* void void;
}

Kapag nagbigay ka ng sarili mong uri ng mga mapa na may --type-map opsyon, sinusuri muna ang mga ito.
Nagbibigay-daan ito sa iyong piliing i-override ang mga paunang natukoy na panuntunan.

REGEX AT KABIBI NAGSISIPI

Kapag nagpapasok ng isang regular na expression na argumento sa shell command line ito ay madalas
kinakailangan na gumamit ng pagsipi (kalakip ang argumento sa " " o ' ') upang maiwasan ang
shell mula sa pagbibigay-kahulugan sa ilang mga character, halimbawa, mga puwang bilang mga separator ng argumento at
$ bilang mga variable na pagpapalawak.

Sa kasamaang palad, mahirap makamit ito sa paraang madaling madala sa mga shell ng POSIX,
tulad ng mga matatagpuan sa GNU/Linux at UNIX, at Windows shell. Halimbawa, kung gumagamit ka ng " "
para sa pag-quote makakakuha ka ng isang maling resulta sa POSIX shell kung ang iyong expression ay naglalaman ng $.
Ang karaniwang paraan ng pagharap dito sa mga sistema ng POSIX ay ang paggamit ng ' ' sa halip.
Sa kasamaang palad, hindi inaalis ng Windows shell ang ' ' mula sa mga argumento kapag ipinasa ang mga ito sa
mga aplikasyon. Bilang resulta, maaaring kailanganin mong gumamit ng ' ' para sa POSIX at " " para sa Windows ($ ay hindi
itinuturing bilang isang espesyal na karakter sa Windows).

Bilang kahalili, maaari mong i-save ang mga opsyon sa regular na expression sa isang file, isang opsyon sa bawat linya,
at gamitin ang file na ito kasama ang --options-file opsyon. Sa diskarteng ito hindi mo na kailangan
mag-alala tungkol sa pag-quote ng shell.

DIAGNOSTICS

Kung ang input file ay hindi wastong kahulugan ng W3C XML Schema, xsdcxx maglalabas ng diagnostic
mga mensahe sa STDERR at lumabas gamit ang non-zero exit code.

Gumamit ng xsdcxx online gamit ang mga serbisyo ng onworks.net