Déclarations globales de sortie XML du compilateur
Remonter à Utilitaires de ligne de commande - Index
Cette rubrique décrit tous les éléments qui peuvent apparaître dans la sortie XML générée à partir du code source Delphi ou C++ compilé.
Pour de plus amples informations sur la documentation XML générée par le compilateur, voir Documentation XML pour le code Delphi et Documentation XML pour le code C++.
Sommaire
- 1 Eléments
- 1.1 Elément : ancestor
- 1.2 Elément : class
- 1.3 Elément : element
- 1.4 Elément : enum
- 1.5 Elément : event
- 1.6 Elément : eventref
- 1.7 Elément : field
- 1.8 Elément : fieldref
- 1.9 Elément : file
- 1.10 Elément : function
- 1.11 Elément : members
- 1.12 Elément : methodref
- 1.13 Elément : parameter
- 1.14 Elément : parameters
- 1.15 Elément : property
- 1.16 Elément : propertyref
- 1.17 Elément : typedef
- 1.18 Elément : variable
- 2 Glossaire (concepts des schémas XML)
- 3 Voir aussi
Eléments
Une section Représentation de l'instance XML explique comment l'élément apparaîtra dans la sortie XML. Une section Représentation des composants du schéma décrit la structure que le XML suivra.
Elément : ancestor
| Nom | ancestor |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<ancestor
name=" xs:string [0..1]"
error=" xs:string [0..1]"
namespace=" xs:NMTOKEN [0..1]">
Start Choice [1]
<ancestor> ... </ancestor> [1]
<eventref> ... </eventref> [1]
<fieldref> ... </fieldref> [1]
<methodref> ... </methodref> [1]
<propertyref> ... </propertyref> [1]
End Choice
</ancestor>
Représentation des composants du schéma
<xs:element name="ancestor">
<xs:complexType>
<xs:choice>
<xs:element ref=" ancestor "/>
<xs:element ref=" eventref "/>
<xs:element ref=" fieldref "/>
<xs:element ref=" methodref "/>
<xs:element ref=" propertyref "/>
</xs:choice>
<xs:attribute name="name" type=" xs:string " use="optional"/>
<xs:attribute name="error" type=" xs:string " use="optional"/>
<xs:attribute name="namespace" type=" xs:NMTOKEN " use="optional"/>
</xs:complexType>
</xs:element>
Elément : class
| Nom | class |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<class
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:string [1]"
namespace=" xs:NMTOKEN [0..1]"
info=" xs:string [0..1]">
Start Choice [1]
<ancestor> ... </ancestor> [1]
<members> ... </members> [1]
End Choice
</class>
Représentation des composants du schéma
<xs:element name="class">
<xs:complexType>
<xs:choice>
<xs:element ref=" ancestor "/>
<xs:element ref=" members "/>
</xs:choice>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:string " use="required"/>
<xs:attribute name="namespace" type=" xs:NMTOKEN " use="optional"/>
<xs:attribute name="info" type=" xs:string " use="optional"/>
</xs:complexType>
</xs:element>
Elément : element
| Nom | element |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<element name=" xs:NMTOKEN [1]"/>
Représentation des composants du schéma
<xs:element name="element"> <xs:complexType> <xs:attribute name="name" type=" xs:NMTOKEN " use="required"/> </xs:complexType> </xs:element>
Elément : enum
| Nom | enum |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<enum name=" xs:string [1]"> <element> ... </element> [1..*] </enum>
Représentation des composants du schéma
<xs:element name="enum">
<xs:complexType>
<xs:sequence>
<xs:element ref=" element " maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="name" type=" xs:string " use="required"/>
</xs:complexType>
</xs:element>
Elément : event
| Nom | event |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<event
remove=" xs:NMTOKEN [1]"
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:NMTOKEN [1]"
type=" xs:NMTOKEN [1]"
add=" xs:NMTOKEN [1]"/>
Représentation des composants du schéma
<xs:element name="event">
<xs:complexType>
<xs:attribute name="remove" type=" xs:NMTOKEN " use="required"/>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
<xs:attribute name="type" type=" xs:NMTOKEN " use="required"/>
<xs:attribute name="add" type=" xs:NMTOKEN " use="required"/>
</xs:complexType>
</xs:element>
Elément : eventref
| Nom | eventref |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<eventref
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:NMTOKEN [1]"/>
Représentation des composants du schéma
<xs:element name="eventref">
<xs:complexType>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
</xs:complexType>
</xs:element>
Elément : field
| Nom | field |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<field
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:NMTOKEN [1]"
type=" xs:string [1]"/>
Représentation des composants du schéma
<xs:element name="field">
<xs:complexType>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
<xs:attribute name="type" type=" xs:string " use="required"/>
</xs:complexType>
</xs:element>
Elément : fieldref
| Nom | fieldref |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<fieldref
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:NMTOKEN [1]"/>
Représentation des composants du schéma
<xs:element name="fieldref">
<xs:complexType>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
</xs:complexType>
</xs:element>
Elément : file
| Nom | file |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<file
name=" xs:NMTOKEN [1]">
Start Choice [1]
<class> ... </class> [1]
<enum> ... </enum> [1]
<function> ... </function> [1]
<typedef> ... </typedef> [1]
<variable> ... </variable> [1]
End Choice
</file>
Représentation des composants du schéma
<xs:element name="file">
<xs:documentation>
"file" is to root/top-most level element generated by BCC32. It represents the source file processed unless a specific file was specified in the -Zx option.
</xs:documentation>
<xs:complexType>
<xs:choice>
<xs:element ref=" class "/>
<xs:element ref=" enum "/>
<xs:element ref=" function "/>
<xs:element ref=" typedef "/>
<xs:element ref=" variable "/>
</xs:choice>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
</xs:complexType>
</xs:element>
Elément : function
| Nom | function |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<function
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [0..1]"
name=" xs:string [1]"
type=" xs:string [1]"
callconv=" xs:NMTOKEN (value comes from list: {'__cdecl'|'__fastcall'|'__stdcall'}) [1]"
procflags=" xs:string [0..1]">
<parameters> ... </parameters> [0..1]
</function>
Représentation des composants du schéma
<xs:element name="function">
<xs:complexType>
<xs:sequence>
<xs:element ref=" parameters " minOccurs="0"/>
</xs:sequence>
<xs:attribute name="visibility" use="optional">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:string " use="required"/>
<xs:attribute name="type" type=" xs:string " use="required"/>
<xs:attribute name="callconv" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="__cdecl"/>
<xs:enumeration value="__fastcall"/>
<xs:enumeration value="__stdcall"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="procflags" type=" xs:string " use="optional"/>
</xs:complexType>
</xs:element>
Elément : members
| Nom | members |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<members>
Start Choice [1]
<class> ... </class> [1]
<enum> ... </enum> [1]
<event> ... </event> [1]
<field> ... </field> [1]
<function> ... </function> [1]
<property> ... </property> [1]
<typedef> ... </typedef> [1]
End Choice
</members>
Représentation des composants du schéma
<xs:element name="members">
<xs:complexType>
<xs:choice>
<xs:element ref=" class "/>
<xs:element ref=" enum "/>
<xs:element ref=" event "/>
<xs:element ref=" field "/>
<xs:element ref=" function "/>
<xs:element ref=" property "/>
<xs:element ref=" typedef "/>
</xs:choice>
</xs:complexType>
</xs:element>
Elément : methodref
| Nom | methodref |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<methodref
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:string [1]"/>
Représentation des composants du schéma
<xs:element name="methodref">
<xs:complexType>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:string " use="required"/>
</xs:complexType>
</xs:element>
Elément : parameter
| Nom | parameter |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<parameter name=" xs:string [1]" type=" xs:string [1]"/>
Représentation des composants du schéma
<xs:element name="parameter">
<xs:complexType>
<xs:attribute name="name" type=" xs:string " use="required"/>
<xs:attribute name="type" type=" xs:string " use="required"/>
</xs:complexType>
</xs:element>
</xs:element>
Elément : parameters
| Nom | parameters |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<parameters><parameter> ... </parameter> [1..*] </parameters>
Représentation des composants du schéma
<xs:element name="parameters">
<xs:complexType>
<xs:sequence>
<xs:element ref=" parameter " maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Elément : property
| Nom | property |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<property
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:NMTOKEN [1]"
write=" xs:NMTOKEN [0..1]"
type=" xs:string [1]"
read=" xs:NMTOKEN [1]"/>
Représentation des composants du schéma
<xs:element name="property">
<xs:complexType>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
<xs:attribute name="write" type=" xs:NMTOKEN " use="optional"/>
<xs:attribute name="type" type=" xs:string " use="required"/>
<xs:attribute name="read" type=" xs:NMTOKEN " use="required"/>
</xs:complexType>
</xs:element>
Elément : propertyref
| Nom | propertyref |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<propertyref
visibility=" xs:NMTOKEN (value comes from list: {'private'|'protected'|'public'}) [1]"
name=" xs:NMTOKEN [1]"/>
Représentation des composants du schéma
<xs:element name="propertyref">
<xs:complexType>
<xs:attribute name="visibility" use="required">
<xs:simpleType>
<xs:restriction base=" xs:NMTOKEN ">
<xs:enumeration value="private"/>
<xs:enumeration value="protected"/>
<xs:enumeration value="public"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
</xs:complexType>
</xs:element>
Elément : typedef
| Nom | typedef |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<typedef name=" xs:NMTOKEN [1]" type=" xs:string [1]"/>
Représentation des composants du schéma
<xs:element name="typedef">
<xs:complexType>
<xs:attribute name="name" type=" xs:NMTOKEN " use="required"/>
<xs:attribute name="type" type=" xs:string " use="required"/>
</xs:complexType>
</xs:element>
Elément : variable
| Nom | variable |
|---|---|
| Type | Type complexe défini localement |
| Initialisable à nil | non |
| Abstrait | non |
Représentation de l'instance XML
<variable name=" xs:ID [1]" type=" xs:string [1]"/>
Représentation des composants du schéma
<xs:element name="variable">
<xs:complexType>
<xs:attribute name="name" type=" xs:ID " use="required"/>
<xs:attribute name="type" type=" xs:string " use="required"/>
</xs:complexType>
</xs:element>
Glossaire (concepts des schémas XML)
Abstract s'applique aux définitions de types complexes et aux déclarations d'éléments. Un élément abstrait ou un type complexe ne peut pas être utilisé pour valider une instance d'élément. En cas de référence à un élément abstrait, seules les déclarations d'éléments qui peuvent se substituer à l'élément abstrait peuvent être utilisées pour valider l'instance. Pour les références aux définitions de types abstraites, seuls les types dérivés peuvent être utilisés.
Tous les éléments Model Group Child peuvent être fournis dans n'importe quel ordre dans les instances. Voir : http://www.w3.org/TR/xmlschema-1/#element-all.
Réduit les caractères retour chariot, passage à la ligne et tabulation (Whitespace Policy Replace) par un caractère espace (caractère Unicode 32). Réduit ensuite les séquences contiguës de caractères espace par un caractère espace unique, et retire les caractères espace de tête et de queue.
Disallowed Substitutions s'applique aux déclarations des éléments. Si la substitution est spécifiée, les membres du groupe de substitution ne peuvent pas être utilisés à la place de la déclaration d'élément donnée pour valider les instances d'éléments. Si des méthodes de dérivation, par exemple une extension ou une restriction, sont spécifiées, la déclaration d'élément donnée ne validera pas alors les instances d'éléments ayant des types dérivés du type de la déclaration d'élément en utilisant les méthodes de dérivation spécifiées. Normalement, les instances d'éléments peuvent redéfinir le type de leur déclaration en spécifiant un attribut xsi:type.
Key Constraint ressemble à Uniqueness Constraint, mais nécessite en plus que les valeurs spécifiées soient fournies. Voir : http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.
Key Reference Constraint garantit que les valeurs spécifiées doivent correspondre aux valeurs d'une contrainte de clé ou d'une contrainte à unicité. Voir : http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.
Model Group associe le contenu d'élément, en spécifiant l'ordre dans lequel le contenu d'élément peut apparaître et le nombre de répétitions possibles du groupe de contenus d'éléments. Voir : http://www.w3.org/TR/xmlschema-1/#Model_Groups.
Nillable s'applique aux déclarations des éléments. Si une déclaration d'élément est initialisable à nil, les instances peuvent utiliser l'attribut xsi:nil. L'attribut xsi:nil est l'attribut booléen nil de l'espace de nommage http://www.w3.org/2001/XMLSchema-instance. Si une instance d'élément a un attribut xsi:nil défini sur true, elle peut être laissée vide, même si sa déclaration d'élément peut comporter un contenu obligatoire.
Notation A est utilisée pour identifier le format d'une portion de données. Les valeurs des éléments et des attributs de type (Notation) doivent être issues des noms des notations déclarées. Voir : http://www.w3.org/TR/xmlschema-1/#cNotation_Declarations.
Preserve Whitespace Policy préserve les espaces exactement tels qu'ils apparaissent dans les instances.
Prohibited Derivations (méthodes de dérivation ne pouvant pas être utilisées pour créer des sous-types d'une définition de type donnée) s'applique aux définitions de types.
Prohibited Substitutions s'applique aux déclarations de types complexes. Empêche les sous-types, ayant été dérivés à l'aide de méthodes de dérivation spécifiées, de valider les instances d'éléments à la place de la définition de type donnée.
Replace Whitespace Policy remplace les caractères retour chariot, passage à la ligne et tabulation par le caractère espace (caractère Unicode 32).
Sequence Model Group Child (éléments) et les groupes de modèles doivent être fournis dans l'ordre spécifié dans les instances. Voir : http://www.w3.org/TR/xmlschema-1/#element-sequence.
Substitution Group Elements, membres d'un groupe de substitution, peuvent être utilisés là où l'élément head du groupe de substitution est référencé.
Substitution Group Exclusions s'applique aux déclarations des éléments. Empêche les déclarations d'éléments de se désigner elles-mêmes comme étant capables de substituer une déclaration d'élément donnée, si elles comportent des types qui sont dérivés du type de l'élément original en utilisant les méthodes de dérivation spécifiées.
Target Namespace identifie l'espace de nommage auquel les composants de ce schéma appartiennent. Si aucun espace de nommage cible n'est fourni, les composants du schéma n'appartiennent alors à aucun espace de nommage.
Uniqueness Constraint garantit l'unicité de la valeur d'un élément / attribut, ou d'une combinaison de valeurs, au sein d'une portée spécifiée. Voir : http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.