Schema java-ml.xsd


schema location:  F:\javaML\xml\java-ml.xsd
 
Elements  Groups  Complex types  Simple types  Attr. groups 
anonymous-class  expr  htmlType  modifierType  location 
arguments  stmt  visibilityType 
array-initializer 
array-ref 
assignment-expr 
base 
binary-expr 
block 
break 
case 
cast-expr 
catch 
class 
code-fragment 
codeline 
comment 
conditional-expr 
constructor 
continue 
default-case 
dim-expr 
do-loop 
doc-comment 
exception 
extend 
false-case 
field 
field-access 
field-ref 
field-set 
finally 
formal-argument 
formal-arguments 
formal-ref 
formal-set 
if 
implement 
import 
instance-initializer 
instanceof-test 
interface 
java-class-file 
java-source-code 
java-source-program 
label 
literal-boolean 
literal-char 
literal-null 
literal-number 
literal-string 
local-variable 
local-variable-decl 
loop 
loop-init 
loop-update 
lvalue 
method 
modifier 
modifiers 
new 
new-array 
offset 
package-decl 
paren 
result 
return 
send 
separator 
sp 
static-initializer 
super 
super-call 
superclass 
switch 
switch-block 
synchronized 
target 
test 
this 
this-call 
throw 
throws 
token 
true-case 
try 
type 
type-dependences 
unary-expr 
var-initializer 
var-ref 
var-set 


element anonymous-class
diagram
children superclass implement constructor method field instance-initializer
used by
element new
attributes
Name  Type  Use  Default  Fixed  Annotation
abstract  xs:string        
final  xs:string        
synchronized  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="anonymous-class">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="superclass" minOccurs="0"/>
      <xs:element ref="implement" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="constructor"/>
        <xs:element ref="method"/>
        <xs:element ref="field"/>
        <xs:element ref="instance-initializer"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="abstract" type="xs:string"/>
    <xs:attribute name="final" type="xs:string"/>
    <xs:attribute name="synchronized" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element arguments
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements new send super-call this-call
source 
<xs:element name="arguments">
  <xs:complexType>
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element array-initializer
diagram
children array-initializer send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements array-initializer field new-array var-initializer
attributes
Name  Type  Use  Default  Fixed  Annotation
length  xs:string  required      
source 
<xs:element name="array-initializer">
  <xs:complexType>
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element ref="array-initializer"/>
      <xs:group ref="expr"/>
    </xs:choice>
    <xs:attribute name="length" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element array-ref
diagram
children base offset
used by
group expr
source 
<xs:element name="array-ref">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="base"/>
      <xs:element ref="offset"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element assignment-expr
diagram
children lvalue send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
op  xs:string  required      
source 
<xs:element name="assignment-expr">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="lvalue"/>
      <xs:group ref="expr"/>
    </xs:sequence>
    <xs:attribute name="op" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element base
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element array-ref
source 
<xs:element name="base">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element binary-expr
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
op  xs:string  required      
source 
<xs:element name="binary-expr">
  <xs:complexType>
    <xs:group ref="expr" minOccurs="2" maxOccurs="2"/>
    <xs:attribute name="op" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element block
diagram
children label block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements catch constructor finally method synchronized try
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="block">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="label" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="stmt" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element break
diagram
used by
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
targetname  xs:string        
source 
<xs:element name="break">
  <xs:complexType>
    <xs:attribute name="targetname" type="xs:string"/>
  </xs:complexType>
</xs:element>

element case
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element switch-block
source 
<xs:element name="case">
  <xs:complexType>
    <xs:sequence>
      <xs:group ref="expr"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element cast-expr
diagram
children type send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
source 
<xs:element name="cast-expr">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="type"/>
      <xs:group ref="expr"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element catch
diagram
children formal-argument block
used by
element try
source 
<xs:element name="catch">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="formal-argument"/>
      <xs:element ref="block"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element class
diagram
children doc-comment modifiers superclass implement class interface constructor method field static-initializer instance-initializer
used by
elements class interface java-class-file
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
id  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
identity constraints
  Name  Refer  Selector  Field(s)  
key  KeyConstructor    ./constructor  @id  
key  KeyMethod    ./method  @id  
key  KeyField    .//field  @id  
key  KeyFormalArgument    .//method/*/formal-argument|.//constructor/*/formal-argument  @id  
keyref  RefFormalArgument  KeyFormalArgument  .//formal-ref  @idref  
key  KeyLocalVariable    .//local-variable|.//catch/formal-argument  @id  
keyref  RefLocalVariable  KeyLocalVariable  .//var-ref  @idref  
source 
<xs:element name="class">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="doc-comment" minOccurs="0"/>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="superclass" minOccurs="0"/>
      <xs:element ref="implement" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="class"/>
        <xs:element ref="interface"/>
        <xs:element ref="constructor"/>
        <xs:element ref="method"/>
        <xs:element ref="field"/>
        <xs:element ref="static-initializer"/>
        <xs:element ref="instance-initializer"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attributeGroup ref="location"/>
    <xs:attribute name="id" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
  <xs:key name="KeyConstructor">
    <xs:selector xpath="./constructor"/>
    <xs:field xpath="@id"/>
  </xs:key>
  <xs:key name="KeyMethod">
    <xs:selector xpath="./method"/>
    <xs:field xpath="@id"/>
  </xs:key>
  <xs:key name="KeyField">
    <xs:selector xpath=".//field"/>
    <xs:field xpath="@id"/>
  </xs:key>
  <xs:key name="KeyFormalArgument">
    <xs:selector xpath=".//method/*/formal-argument|.//constructor/*/formal-argument"/>
    <xs:field xpath="@id"/>
  </xs:key>
  <xs:keyref name="RefFormalArgument" refer="KeyFormalArgument">
    <xs:selector xpath=".//formal-ref"/>
    <xs:field xpath="@idref"/>
  </xs:keyref>
  <xs:key name="KeyLocalVariable">
    <xs:selector xpath=".//local-variable|.//catch/formal-argument"/>
    <xs:field xpath="@id"/>
  </xs:key>
  <xs:keyref name="RefLocalVariable" refer="KeyLocalVariable">
    <xs:selector xpath=".//var-ref"/>
    <xs:field xpath="@idref"/>
  </xs:keyref>
</xs:element>

element code-fragment
diagram
source 
<xs:element name="code-fragment">
  <xs:complexType mixed="true"/>
</xs:element>

element codeline
diagram
children token comment sp
used by
element java-source-code
attributes
Name  Type  Use  Default  Fixed  Annotation
no  xs:integer        
refid  xs:string        
source 
<xs:element name="codeline">
  <xs:complexType>
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element ref="token" minOccurs="0"/>
      <xs:element ref="comment" minOccurs="0"/>
      <xs:element ref="sp" minOccurs="0"/>
    </xs:choice>
    <xs:attribute name="no" type="xs:integer"/>
    <xs:attribute name="refid" type="xs:string"/>
  </xs:complexType>
</xs:element>

element comment
diagram
used by
element codeline
attributes
Name  Type  Use  Default  Fixed  Annotation
idx  xs:string        
type  xs:string        
line  xs:integer        
column  xs:integer        
continued  xs:boolean        
source 
<xs:element name="comment">
  <xs:complexType mixed="true">
    <xs:attribute name="idx" type="xs:string"/>
    <xs:attribute name="type" type="xs:string"/>
    <xs:attribute name="line" type="xs:integer"/>
    <xs:attribute name="column" type="xs:integer"/>
    <xs:attribute name="continued" type="xs:boolean"/>
  </xs:complexType>
</xs:element>

element conditional-expr
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
source 
<xs:element name="conditional-expr">
  <xs:complexType>
    <xs:sequence>
      <xs:group ref="expr" minOccurs="3" maxOccurs="3"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element constructor
diagram
children doc-comment modifiers formal-arguments throws super-call this-call block
used by
elements anonymous-class class
attributes
Name  Type  Use  Default  Fixed  Annotation
id  xs:string        
name  xs:string  required      
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="constructor">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="doc-comment" minOccurs="0"/>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="formal-arguments"/>
      <xs:element ref="throws" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice minOccurs="0">
        <xs:element ref="super-call"/>
        <xs:element ref="this-call"/>
      </xs:choice>
      <xs:element ref="block"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:string"/>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element continue
diagram
used by
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
targetname  xs:string        
source 
<xs:element name="continue">
  <xs:complexType>
    <xs:attribute name="targetname" type="xs:string"/>
  </xs:complexType>
</xs:element>

element default-case
diagram
source 
<xs:element name="default-case">
  <xs:complexType/>
</xs:element>

element dim-expr
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element new-array
source 
<xs:element name="dim-expr">
  <xs:complexType>
    <xs:sequence>
      <xs:group ref="expr"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element do-loop
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super test
used by
group stmt
source 
<xs:element name="do-loop">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:group ref="expr" minOccurs="0"/>
      <xs:element ref="test" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element doc-comment
diagram
type htmlType
used by
elements class constructor field interface method
attributes
Name  Type  Use  Default  Fixed  Annotation
token  xs:string        
source 
<xs:element name="doc-comment" type="htmlType"/>

element exception
diagram
used by
element throws
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="exception">
  <xs:complexType mixed="true">
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element extend
diagram
used by
element interface
attributes
Name  Type  Use  Default  Fixed  Annotation
interface  xs:string  required      
source 
<xs:element name="extend">
  <xs:complexType>
    <xs:attribute name="interface" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element false-case
diagram
children block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element if
source 
<xs:element name="false-case">
  <xs:complexType>
    <xs:sequence>
      <xs:group ref="stmt" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element field
diagram
children doc-comment modifiers type var-initializer array-initializer send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements anonymous-class class interface
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
id  xs:string  required      
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="field">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="doc-comment" minOccurs="0"/>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="type"/>
      <xs:choice minOccurs="0">
        <xs:element ref="var-initializer" minOccurs="0"/>
        <xs:element ref="array-initializer"/>
        <xs:group ref="expr"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="id" type="xs:string" use="required"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element field-access
diagram
children type send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
idkind  xs:string        
source 
<xs:element name="field-access">
  <xs:complexType>
    <xs:choice>
      <xs:element ref="type"/>
      <xs:group ref="expr"/>
    </xs:choice>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attribute name="idkind" type="xs:string"/>
  </xs:complexType>
</xs:element>

element field-ref
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="field-ref">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element field-set
diagram
used by
element lvalue
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
idkind  xs:string        
source 
<xs:element name="field-set">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attribute name="idkind" type="xs:string"/>
  </xs:complexType>
</xs:element>

element finally
diagram
children block
used by
element try
source 
<xs:element name="finally">
  <xs:complexType>
    <xs:choice>
      <xs:element ref="block"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element formal-argument
diagram
children modifiers type
used by
elements catch formal-arguments
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
id  xs:string  required      
final  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="formal-argument">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="type"/>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="id" type="xs:string" use="required"/>
    <xs:attribute name="final" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element formal-arguments
diagram
children formal-argument
used by
elements constructor method
source 
<xs:element name="formal-arguments">
  <xs:complexType mixed="true">
    <xs:sequence minOccurs="0" maxOccurs="unbounded">
      <xs:element ref="formal-argument"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element formal-ref
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string  required      
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="formal-ref">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string" use="required"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element formal-set
diagram
used by
element lvalue
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="formal-set">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element if
diagram
children test true-case false-case
used by
group stmt
source 
<xs:element name="if">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="test"/>
      <xs:element ref="true-case"/>
      <xs:element ref="false-case" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element implement
diagram
used by
elements anonymous-class class
attributes
Name  Type  Use  Default  Fixed  Annotation
interface  xs:string  required      
idref  xs:string        
idkind  xs:string        
source 
<xs:element name="implement">
  <xs:complexType mixed="true">
    <xs:attribute name="interface" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attribute name="idkind" type="xs:string"/>
  </xs:complexType>
</xs:element>

element import
diagram
used by
element java-class-file
attributes
Name  Type  Use  Default  Fixed  Annotation
module  xs:string  required      
source 
<xs:element name="import">
  <xs:complexType>
    <xs:attribute name="module" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element instance-initializer
diagram
children block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements anonymous-class class
source 
<xs:element name="instance-initializer">
  <xs:complexType mixed="true">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:group ref="stmt"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element instanceof-test
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super type
used by
group expr
source 
<xs:element name="instanceof-test">
  <xs:complexType>
    <xs:sequence>
      <xs:choice>
        <xs:group ref="expr"/>
      </xs:choice>
      <xs:element ref="type"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element interface
diagram
children doc-comment modifiers extend class method field
used by
elements class java-class-file
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
id  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="interface">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="doc-comment" minOccurs="0"/>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="extend" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="class"/>
        <xs:element ref="method"/>
        <xs:element ref="field"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="id" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element java-class-file
diagram
children package-decl import class interface
used by
element java-source-program
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string        
version  xs:string        
source 
<xs:element name="java-class-file">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="package-decl" minOccurs="0"/>
      <xs:element ref="import" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="class"/>
        <xs:element ref="interface"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string"/>
    <xs:attribute name="version" type="xs:string"/>
  </xs:complexType>
</xs:element>

element java-source-code
diagram
children codeline separator
used by
element java-source-program
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string        
id  xs:string        
source 
<xs:element name="java-source-code">
  <xs:complexType>
    <xs:sequence maxOccurs="unbounded">
      <xs:element ref="codeline" minOccurs="0"/>
      <xs:element ref="separator" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string"/>
    <xs:attribute name="id" type="xs:string"/>
  </xs:complexType>
</xs:element>

element java-source-program
diagram
children java-class-file type-dependences java-source-code
source 
<xs:element name="java-source-program">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="java-class-file" maxOccurs="unbounded"/>
      <xs:element ref="type-dependences" minOccurs="0"/>
      <xs:element ref="java-source-code" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element label
diagram
used by
element block
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
source 
<xs:element name="label">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element literal-boolean
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
value  xs:NMTOKEN  required      
source 
<xs:element name="literal-boolean">
  <xs:complexType>
    <xs:attribute name="value" use="required">
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="true"/>
          <xs:enumeration value="false"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
</xs:element>

element literal-char
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
value  xs:string  required      
source 
<xs:element name="literal-char">
  <xs:complexType>
    <xs:attribute name="value" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element literal-null
diagram
used by
group expr
source 
<xs:element name="literal-null">
  <xs:complexType/>
</xs:element>

element literal-number
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
value  xs:string  required      
kind  xs:NMTOKEN        
base  xs:string    10    
source 
<xs:element name="literal-number">
  <xs:complexType>
    <xs:attribute name="value" type="xs:string" use="required"/>
    <xs:attribute name="kind">
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="integer"/>
          <xs:enumeration value="long"/>
          <xs:enumeration value="float"/>
          <xs:enumeration value="double"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="base" type="xs:string" default="10"/>
  </xs:complexType>
</xs:element>

element literal-string
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
value  xs:string  required      
source 
<xs:element name="literal-string">
  <xs:complexType>
    <xs:attribute name="value" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element local-variable
diagram
children var-initializer
used by
element local-variable-decl
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
id  xs:string  required      
continued  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="local-variable">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="var-initializer" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="id" type="xs:string" use="required"/>
    <xs:attribute name="continued" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element local-variable-decl
diagram
children modifiers type local-variable
used by
element loop-init
group stmt
source 
<xs:element name="local-variable-decl">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="type"/>
      <xs:element ref="local-variable" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element loop
diagram
children loop-init test loop-update block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
kind  xs:NMTOKEN        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="loop">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="loop-init" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="test" minOccurs="0"/>
      <xs:element ref="loop-update" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice minOccurs="0">
        <xs:group ref="stmt"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="kind">
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="for"/>
          <xs:enumeration value="while"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element loop-init
diagram
children local-variable-decl send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element loop
source 
<xs:element name="loop-init">
  <xs:complexType>
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element ref="local-variable-decl"/>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element loop-update
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element loop
source 
<xs:element name="loop-update">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element lvalue
diagram
children var-set field-set formal-set send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element assignment-expr
source 
<xs:element name="lvalue">
  <xs:complexType>
    <xs:choice>
      <xs:element ref="var-set"/>
      <xs:element ref="field-set"/>
      <xs:element ref="formal-set"/>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element method
diagram
children doc-comment modifiers type formal-arguments throws block
used by
elements anonymous-class class interface
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
id  xs:string  required      
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="method">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="doc-comment" minOccurs="0"/>
      <xs:element ref="modifiers" minOccurs="0"/>
      <xs:element ref="type"/>
      <xs:element ref="formal-arguments"/>
      <xs:element ref="throws" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="block" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="id" type="xs:string" use="required"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element modifier
diagram
used by
element modifiers
attributes
Name  Type  Use  Default  Fixed  Annotation
name  modifierType        
source 
<xs:element name="modifier">
  <xs:complexType>
    <xs:attribute name="name" type="modifierType"/>
  </xs:complexType>
</xs:element>

element modifiers
diagram
children modifier
used by
elements class constructor field formal-argument interface local-variable-decl method
source 
<xs:element name="modifiers">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="modifier" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element new
diagram
children type arguments anonymous-class
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
idref  xs:string  required      
idkind  xs:string        
source 
<xs:element name="new">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="type"/>
      <xs:element ref="arguments"/>
      <xs:element ref="anonymous-class" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="idref" type="xs:string" use="required"/>
    <xs:attribute name="idkind" type="xs:string"/>
  </xs:complexType>
</xs:element>

element new-array
diagram
children type dim-expr array-initializer
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
dimensions  xs:string  required      
source 
<xs:element name="new-array">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="type"/>
      <xs:element ref="dim-expr" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="array-initializer" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="dimensions" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element offset
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element array-ref
source 
<xs:element name="offset">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element package-decl
diagram
used by
element java-class-file
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
source 
<xs:element name="package-decl">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element paren
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
source 
<xs:element name="paren">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element result
diagram
source 
<xs:element name="result">
  <xs:complexType mixed="true"/>
</xs:element>

element return
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="return">
  <xs:complexType mixed="true">
    <xs:choice minOccurs="0">
      <xs:choice minOccurs="0">
        <xs:group ref="expr"/>
      </xs:choice>
    </xs:choice>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element send
diagram
children target arguments
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
message  xs:string  required      
idref  xs:string        
idkind  xs:string        
source 
<xs:element name="send">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="target" minOccurs="0"/>
      <xs:element ref="arguments"/>
    </xs:sequence>
    <xs:attribute name="message" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attribute name="idkind" type="xs:string"/>
  </xs:complexType>
</xs:element>

element separator
diagram
used by
element java-source-code
source 
<xs:element name="separator"/>

element sp
diagram
used by
element codeline
source 
<xs:element name="sp"/>

element static-initializer
diagram
children block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements class var-initializer
source 
<xs:element name="static-initializer">
  <xs:complexType mixed="true">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:group ref="stmt"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element super
diagram
used by
group expr
source 
<xs:element name="super">
  <xs:complexType/>
</xs:element>

element super-call
diagram
children arguments
used by
element constructor
source 
<xs:element name="super-call">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="arguments"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element superclass
diagram
used by
elements anonymous-class class
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="superclass">
  <xs:complexType mixed="true">
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element switch
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super switch-block
used by
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="switch">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:choice>
        <xs:group ref="expr"/>
      </xs:choice>
      <xs:element ref="switch-block" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element switch-block
diagram
children case block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element switch
source 
<xs:element name="switch-block">
  <xs:complexType>
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="case"/>
      </xs:choice>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="stmt"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element synchronized
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super block
used by
group stmt
source 
<xs:element name="synchronized">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:group ref="expr"/>
      <xs:element ref="block"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element target
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super type
used by
element send
source 
<xs:element name="target">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
      <xs:element ref="type"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element test
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements do-loop if loop
source 
<xs:element name="test">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element this
diagram
used by
group expr
source 
<xs:element name="this">
  <xs:complexType/>
</xs:element>

element this-call
diagram
children arguments
used by
element constructor
source 
<xs:element name="this-call">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="arguments"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element throw
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group stmt
source 
<xs:element name="throw">
  <xs:complexType mixed="true">
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element throws
diagram
children exception
used by
elements constructor method
source 
<xs:element name="throws">
  <xs:complexType mixed="true">
    <xs:sequence maxOccurs="unbounded">
      <xs:element ref="exception"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

element token
diagram
used by
element codeline
attributes
Name  Type  Use  Default  Fixed  Annotation
idx  xs:string        
id  xs:string        
idref  xs:string        
idkind  xs:string        
afterEol  xs:boolean        
line  xs:integer        
column  xs:integer        
type  xs:string        
deprecated  xs:boolean        
lexeme  xs:string        
source 
<xs:element name="token">
  <xs:complexType>
    <xs:attribute name="idx" type="xs:string"/>
    <xs:attribute name="id" type="xs:string"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attribute name="idkind" type="xs:string"/>
    <xs:attribute name="afterEol" type="xs:boolean"/>
    <xs:attribute name="line" type="xs:integer"/>
    <xs:attribute name="column" type="xs:integer"/>
    <xs:attribute name="type" type="xs:string"/>
    <xs:attribute name="deprecated" type="xs:boolean"/>
    <xs:attribute name="lexeme" type="xs:string"/>
  </xs:complexType>
</xs:element>

element true-case
diagram
children block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
element if
source 
<xs:element name="true-case">
  <xs:complexType>
    <xs:choice minOccurs="0">
      <xs:group ref="stmt"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element try
diagram
children block catch finally
used by
group stmt
attributes
Name  Type  Use  Default  Fixed  Annotation
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="try">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element ref="block"/>
      <xs:element ref="catch" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="finally" minOccurs="0"/>
    </xs:sequence>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element type
diagram
used by
elements cast-expr field field-access formal-argument instanceof-test local-variable-decl method new new-array target
attributes
Name  Type  Use  Default  Fixed  Annotation
primitive  xs:string        
name  xs:string  required      
dimensions  xs:string        
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="type">
  <xs:complexType mixed="true">
    <xs:attribute name="primitive" type="xs:string"/>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="dimensions" type="xs:string"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element type-dependences
diagram
children type-dependence
used by
element java-source-program
identity constraints
  Name  Refer  Selector  Field(s)  
key  KeyTypeSignature    .//type-dependence  @signature  
keyref  RefTypeSignature  KeyTypeSignature  type-ref  @signature  
keyref  RefType  KeyTypeSignature  type|exception  @idref  
source 
<xs:element name="type-dependences">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="type-dependence" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="type-ref" minOccurs="0" maxOccurs="unbounded">
              <xs:complexType>
                <xs:attribute name="signature" type="xs:string" use="required"/>
              </xs:complexType>
            </xs:element>
          </xs:sequence>
          <xs:attribute name="filename" type="xs:string" use="required"/>
          <xs:attribute name="signature" type="xs:string" use="required"/>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:key name="KeyTypeSignature">
    <xs:selector xpath=".//type-dependence"/>
    <xs:field xpath="@signature"/>
  </xs:key>
  <xs:keyref name="RefTypeSignature" refer="KeyTypeSignature">
    <xs:selector xpath="type-ref"/>
    <xs:field xpath="@signature"/>
  </xs:keyref>
  <xs:keyref name="RefType" refer="KeyTypeSignature">
    <xs:selector xpath="type|exception"/>
    <xs:field xpath="@idref"/>
  </xs:keyref>
</xs:element>

element type-dependences/type-dependence
diagram
children type-ref
attributes
Name  Type  Use  Default  Fixed  Annotation
filename  xs:string  required      
signature  xs:string  required      
source 
<xs:element name="type-dependence" maxOccurs="unbounded">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="type-ref" minOccurs="0" maxOccurs="unbounded">
        <xs:complexType>
          <xs:attribute name="signature" type="xs:string" use="required"/>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
    <xs:attribute name="filename" type="xs:string" use="required"/>
    <xs:attribute name="signature" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element type-dependences/type-dependence/type-ref
diagram
attributes
Name  Type  Use  Default  Fixed  Annotation
signature  xs:string  required      
source 
<xs:element name="type-ref" minOccurs="0" maxOccurs="unbounded">
  <xs:complexType>
    <xs:attribute name="signature" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

element unary-expr
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
op  xs:string  required      
post  xs:NMTOKEN        
source 
<xs:element name="unary-expr">
  <xs:complexType>
    <xs:choice>
      <xs:group ref="expr"/>
    </xs:choice>
    <xs:attribute name="op" type="xs:string" use="required"/>
    <xs:attribute name="post">
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="true"/>
          <xs:enumeration value="false"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
</xs:element>

element var-initializer
diagram
children static-initializer array-initializer send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements field local-variable
source 
<xs:element name="var-initializer">
  <xs:complexType>
    <xs:choice minOccurs="0">
      <xs:element ref="static-initializer"/>
      <xs:element ref="array-initializer"/>
      <xs:group ref="expr"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

element var-ref
diagram
used by
group expr
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="var-ref">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

element var-set
diagram
used by
element lvalue
attributes
Name  Type  Use  Default  Fixed  Annotation
name  xs:string  required      
idref  xs:string        
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:element name="var-set">
  <xs:complexType>
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="idref" type="xs:string"/>
    <xs:attributeGroup ref="location"/>
  </xs:complexType>
</xs:element>

group expr
diagram
children send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements arguments array-initializer assignment-expr base binary-expr case cast-expr conditional-expr dim-expr do-loop field field-access instanceof-test loop-init loop-update lvalue offset paren return switch synchronized target test throw unary-expr var-initializer
group stmt
source 
<xs:group name="expr">
  <xs:choice>
    <xs:element ref="send"/>
    <xs:element ref="new"/>
    <xs:element ref="new-array"/>
    <xs:element ref="var-ref"/>
    <xs:element ref="formal-ref"/>
    <xs:element ref="field-ref"/>
    <xs:element ref="field-access"/>
    <xs:element ref="array-ref"/>
    <xs:element ref="paren"/>
    <xs:element ref="assignment-expr"/>
    <xs:element ref="conditional-expr"/>
    <xs:element ref="binary-expr"/>
    <xs:element ref="unary-expr"/>
    <xs:element ref="cast-expr"/>
    <xs:element ref="instanceof-test"/>
    <xs:element ref="literal-number"/>
    <xs:element ref="literal-string"/>
    <xs:element ref="literal-char"/>
    <xs:element ref="literal-boolean"/>
    <xs:element ref="literal-null"/>
    <xs:element ref="this"/>
    <xs:element ref="super"/>
  </xs:choice>
</xs:group>

group stmt
diagram
children block local-variable-decl try throw if switch loop do-loop return continue break synchronized send new new-array var-ref formal-ref field-ref field-access array-ref paren assignment-expr conditional-expr binary-expr unary-expr cast-expr instanceof-test literal-number literal-string literal-char literal-boolean literal-null this super
used by
elements block false-case instance-initializer loop static-initializer switch-block true-case
source 
<xs:group name="stmt">
  <xs:choice>
    <xs:element ref="block"/>
    <xs:element ref="local-variable-decl"/>
    <xs:element ref="try"/>
    <xs:element ref="throw"/>
    <xs:element ref="if"/>
    <xs:element ref="switch"/>
    <xs:element ref="loop"/>
    <xs:element ref="do-loop"/>
    <xs:element ref="return"/>
    <xs:element ref="continue"/>
    <xs:element ref="break"/>
    <xs:element ref="synchronized"/>
    <xs:group ref="expr"/>
  </xs:choice>
</xs:group>

complexType htmlType
diagram
used by
element doc-comment
attributes
Name  Type  Use  Default  Fixed  Annotation
token  xs:string        
source 
<xs:complexType name="htmlType" mixed="true">
  <xs:sequence>
    <xs:any namespace="http://www.w3.org/1999/xhtml" processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
  </xs:sequence>
  <xs:attribute name="token" type="xs:string"/>
</xs:complexType>

simpleType modifierType
type restriction of xs:NMTOKEN
used by
attribute modifier/@name
facets
enumeration public
enumeration private
enumeration protected
enumeration abstract
enumeration final
enumeration static
enumeration synchronized
enumeration volatile
enumeration transient
enumeration native
source 
<xs:simpleType name="modifierType">
  <xs:restriction base="xs:NMTOKEN">
    <xs:enumeration value="public"/>
    <xs:enumeration value="private"/>
    <xs:enumeration value="protected"/>
    <xs:enumeration value="abstract"/>
    <xs:enumeration value="final"/>
    <xs:enumeration value="static"/>
    <xs:enumeration value="synchronized"/>
    <xs:enumeration value="volatile"/>
    <xs:enumeration value="transient"/>
    <xs:enumeration value="native"/>
  </xs:restriction>
</xs:simpleType>

simpleType visibilityType
type restriction of xs:NMTOKEN
facets
enumeration public
enumeration private
enumeration protected
source 
<xs:simpleType name="visibilityType">
  <xs:restriction base="xs:NMTOKEN">
    <xs:enumeration value="public"/>
    <xs:enumeration value="private"/>
    <xs:enumeration value="protected"/>
  </xs:restriction>
</xs:simpleType>

attributeGroup location
used by
elements anonymous-class block class class constructor exception field field-ref formal-argument formal-ref formal-set interface local-variable loop method return superclass switch try type var-ref var-set
attributes
Name  Type  Use  Default  Fixed  Annotation
line  xs:string        
col  xs:string        
end-line  xs:string        
end-col  xs:string        
commentToken  xs:string        
startToken  xs:string        
endToken  xs:string        
idkind  xs:string        
source 
<xs:attributeGroup name="location">
  <xs:attribute name="line" type="xs:string"/>
  <xs:attribute name="col" type="xs:string"/>
  <xs:attribute name="end-line" type="xs:string"/>
  <xs:attribute name="end-col" type="xs:string"/>
  <xs:attribute name="commentToken" type="xs:string"/>
  <xs:attribute name="startToken" type="xs:string"/>
  <xs:attribute name="endToken" type="xs:string"/>
  <xs:attribute name="idkind" type="xs:string"/>
</xs:attributeGroup>


XML Schema documentation generated with XMLSPY Schema Editor http://www.altova.com/xmlspy