srcML v1.0.0 Java Documentation

Base Elements	XML Element	Subelements
comment	<comment type="line\|block"> <comment type="line" format="doxygen"> <comment type="block" format="doxygen\|javadoc">
literal	<literal type="boolean\|char\|null\|number\|string">
escape	<escape char="0xXX">
name	<name>

Statements	XML Element	Subelements
assert statement	<assert>	<expr>
block	<block>	<block_content>
break statement	<break>	<name>
case statement	<case>	<expr>
continue statement	<continue>	<name>
default statement	<default>
do while statement	<do>	<block>,<condition>
empty statement	<empty_stmt>
expression statement	<expr_stmt>	<expr>
for statement	<for>	<control>,<block>
if statement	<if_stmt>	<if>,<if type="elseif">,<else>
label statement	<label>	<name>
pseudo block	<block type="pseudo">	<block_content>
return statement	<return>	<expr>
switch statement	<switch>	<condition>,<block>,<case>,<default>
while statement	<while>	<condition>,<block>

Statement Subelements	XML Element	Subelements
block content	<block_content>
condition	<condition>	<expr>
control	<control>	<init>,<condition>,<incr>
else	<else>	<block>
else if	<if type="elseif">	<condition>,<block>
expression	<expr>	<name>,<operator>,<call>,<ternary>
if	<if>	<condition>,<block>
incr	<incr>	<expr>
then	<then>	<expr>
type	<type>	<specifier>,<name>

Specifiers	XML Element	Subelements
abstract	<specifier>abstract</specifier>
default method implementation	<specifier>default</specifier>
final	<specifier>final</specifier>
native	<specifier>native</specifier>
private	<specifier>private</specifier>
protected	<specifier>protected</specifier>
public	<specifier>public</specifier>
static	<specifier>static</specifier>
strictfp	<specifier>strictfp</specifier>
synchronized	<specifier>synchronized</specifier>
transient	<specifier>transient</specifier>
volatile	<specifier>volatile</specifier>

Declarations, Definitions, and Initializations	XML Element	Subelements
lambda functions	<lambda>	<parameter_list>,<block>
method definition	<function>	<type>,<name>,<parameter_list>,<block>
variable declaration	<decl_stmt>	<type>,<name>,<init>

Classes, Interfaces, Annotations, and Enums	XML Element	Subelements
annotation	<annotation>	<name>,<argument_list>
annotation definition	<annotation_defn>	<name>,<block>
class	<class>	<name>,<super_list>,<super>,<block>
constructor	<constructor>	<name>,<parameter_list>,<specifier>
default annotation property value	<default>
enum definition	<enum>	<block>,<name>
extends	<extends>	<name>,<super>
implements	<implements>	<name>,<super>
inheritance list	<super_list>	<extends>,<implements>,<super>
interface	<interface>	<name>,<block>
interface_decl	<interface_decl>	<name>
receiver parameter	<name>
static initialization block	<static>	<block>

Expressions	XML Element	Subelements
function call	<call>	<name>,<argument_list>
method reference	<name>
super	<name>
ternary operator	<ternary>	<condition>,<then>,<else>
this	<name>

Other	XML Element	Subelements
import	<import>	<name>
package	<package>	<name>
synchronized statement	<synchronized>	<init>,<block>

Exceptions	XML Element	Subelements
finally	<finally>	<block>
throw	<throw>	<expr>
throws	<throws>	<name>,<argument>
try	<try>	<init>,<block>,<catch>,<finally>

Generic	XML Element	Subelements
catch	<catch>	<parameter_list>,<block>
generic class definition	<class>	<name>,<parameter_list>,<block>
generic method definition	<function>	<name>,<parameter_list type="generic">,<block>
generic parameter	<extends>	<name>
generic variable declaration	<decl_stmt>	<decl>

line comment

Element

<comment type="line">

XPath Queries

comments
```
//src:comment
```
line comments
```
//src:comment[@type='line']
```

Example

// line

<comment type="line">// line</comment>

block comment

Element

<comment type="block">

XPath Queries

comments
```
//src:comment
```
block comments
```
//src:comment[@type='block']
```

Example

/*
    block
*/

<comment type="block">/*
    block
*/</comment>

doxygen line comment

Element

<comment type="line" format="doxygen">

XPath Queries

comments
```
//src:comment
```
doxygen comments
```
//src:comment[@format='doxygen']
```

Example

///
//!

<comment type="line" format="doxygen">///</comment>
<comment type="line" format="doxygen">//!</comment>

doxygen block comment

Element

<comment type="block" format="doxygen">

XPath Queries

comments
```
//src:comment
```
doxygen comments
```
//src:comment[@format='doxygen']
```

Example

/**
 * doxygen comment
 */
/*!
 * text
 */

<comment type="block" format="doxygen">/**
 * doxygen comment
 */</comment>
<comment type="block" format="doxygen">/*!
 * text
 */</comment>

javadoc block comment

Element

<comment type="block" format="javadoc">

XPath Queries

comments
```
//src:comment
```
javadoc comments
```
//src:comment[@format='javadoc']
```

Example

/**
 * javadoc comment
 */

<comment type="block" format="javadoc">/**
 * javadoc comment
 */</comment>

escape

Element

<escape char="0xXX">

Example


void process() {}

<escape char="0x0c"/>
<function><type><name>void</name></type> <name>process</name><parameter_list>()</parameter_list> <block>{<block_content/>}</block></function>

number literal

Element

<literal type="number">

XPath Query

number literals
```
//src:literal[@type='number']
```

Example

123;
42.0;

<expr_stmt><expr><literal type="number">123</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="number">42.0</literal></expr>;</expr_stmt>

character literal

Element

<literal type="char">

XPath Query

character literals
```
//src:literal[@type='char']
```

Example

'c';

<expr_stmt><expr><literal type="char">'c'</literal></expr>;</expr_stmt>

string literal

Element

<literal type="string">

XPath Query

string literals
```
//src:literal[@type='string']
```

Example

"Hello";
L"string";
u"UTF-16 string.";
U"UTF-32 string.";
R"a("()")a";
u8R"|||(a "raw UTF-8" string)|||";
uR"*(a "raw UTF-16" string)*";
UR"(a "raw UTF-32" string)";

<expr_stmt><expr><literal type="string">"Hello"</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">L"string"</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">u"UTF-16 string."</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">U"UTF-32 string."</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">R"a("()")a"</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">u8R"|||(a "raw UTF-8" string)|||"</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">uR"*(a "raw UTF-16" string)*"</literal></expr>;</expr_stmt>
<expr_stmt><expr><literal type="string">UR"(a "raw UTF-32" string)"</literal></expr>;</expr_stmt>

boolean literal

Element

<literal type="boolean">

XPath Query

boolean literals
```
//src:literal[@type='boolean']
```

Example

true;

<expr_stmt><expr><literal type="boolean">true</literal></expr>;</expr_stmt>

null literal

Element

<literal type="null">

XPath Query

null literals
```
//src:literal[@type='null']
```

Example

null;

<expr_stmt><expr><literal type="null">null</literal></expr>;</expr_stmt>

name

Element

<name>

XPath Query

All names (i.e., identifiers)
```
//src:name
```

Example

count;
a.b;
a.f();

<expr_stmt><expr><name>count</name></expr>;</expr_stmt>
<expr_stmt><expr><name><name>a</name><operator>.</operator><name>b</name></name></expr>;</expr_stmt>
<expr_stmt><expr><call><name><name>a</name><operator>.</operator><name>f</name></name><argument_list>()</argument_list></call></expr>;</expr_stmt>

if statement

Element

<if_stmt>

Subelements

<if>
<if type="elseif">
<else>

XPath Queries

if conditions
```
//src:if/src:condition
```
then
```
//src:if/src:block
```
else
```
//src:else/src:block
```
if statements without an else
```
//src:if_stmt[not(src:else)]
```
else if
```
//src:if[@type='elseif']
```
First if in a nested if statement
```
//src:if_stmt/src:if[1]
```
Second if in a nested if statement
```
//src:if_stmt/src:if[2]
```
Last if in a nested if statement
```
//src:if_stmt/src:if[last()]
```

Examples

if then

if (A)
    B;

<if_stmt><if>if <condition>(<expr><name>A</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>B</name></expr>;</expr_stmt></block_content></block></if></if_stmt>

if then else

if (A)
    B;
else
    C;

<if_stmt><if>if <condition>(<expr><name>A</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>B</name></expr>;</expr_stmt></block_content></block></if>
<else>else<block type="pseudo"><block_content>
    <expr_stmt><expr><name>C</name></expr>;</expr_stmt></block_content></block></else></if_stmt>

if then elseif

if (A)
    B;
else if (A2)
    C;
else
    D:

<if_stmt><if>if <condition>(<expr><name>A</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>B</name></expr>;</expr_stmt></block_content></block></if>
<if type="elseif">else if <condition>(<expr><name>A2</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>C</name></expr>;</expr_stmt></block_content></block></if>
<else>else<block type="pseudo"><block_content>
    <label><name>D</name>:</label></block_content></block></else></if_stmt>

if(x > 5)
    y+=4;

<if_stmt><if>if<condition>(<expr><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr>;</expr_stmt></block_content></block></if></if_stmt>

if ( i > 0 ) {
    y = x / i;
}

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr>;</expr_stmt>
</block_content>}</block></if></if_stmt>

if ( i > 0 )
    y = x / i;
else {
    x = i;
    y = f( x );
}

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr>;</expr_stmt></block_content></block></if>
<else>else <block>{<block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr>;</expr_stmt>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr>;</expr_stmt>
</block_content>}</block></else></if_stmt>

Without braces

if ( i > 0 )
    if ( j > i )
        x = j;
    else
        x = i;

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition><block type="pseudo"><block_content>
    <if_stmt><if>if <condition>( <expr><name>j</name> <operator>&gt;</operator> <name>i</name></expr> )</condition><block type="pseudo"><block_content>
        <expr_stmt><expr><name>x</name> <operator>=</operator> <name>j</name></expr>;</expr_stmt></block_content></block></if>
    <else>else<block type="pseudo"><block_content>
        <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr>;</expr_stmt></block_content></block></else></if_stmt></block_content></block></if></if_stmt>

With braces

if ( i > 0 ) {
    if ( j > i )
        x = j;
}
else
    x = i;

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
    <if_stmt><if>if <condition>( <expr><name>j</name> <operator>&gt;</operator> <name>i</name></expr> )</condition><block type="pseudo"><block_content>
        <expr_stmt><expr><name>x</name> <operator>=</operator> <name>j</name></expr>;</expr_stmt></block_content></block></if></if_stmt>
</block_content>}</block></if>
<else>else<block type="pseudo"><block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr>;</expr_stmt></block_content></block></else></if_stmt>

if ( i > 0 ) {
 	x = i;
}
else if( i < 0)
	x = q;
else
    x = j;

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
 	<expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr>;</expr_stmt>
</block_content>}</block></if>
<if type="elseif">else if<condition>( <expr><name>i</name> <operator>&lt;</operator> <literal type="number">0</literal></expr>)</condition><block type="pseudo"><block_content>
	<expr_stmt><expr><name>x</name> <operator>=</operator> <name>q</name></expr>;</expr_stmt></block_content></block></if>
<else>else<block type="pseudo"><block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>j</name></expr>;</expr_stmt></block_content></block></else></if_stmt>

while statement

Element

<while>

Subelements

<condition>
<block>

XPath Queries

while loops
```
//src:while
```
while-loop conditions
```
//src:while/src:condition
```
while loops with a condition containing the variable i
```
//src:while[src:condition//src:name='i']
```

Example

while ( i >= 0 ) {
    string1[i] = string2[i];
    i--;
}

<while>while <condition>( <expr><name>i</name> <operator>&gt;=</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
    <expr_stmt><expr><name><name>string1</name><index>[<expr><name>i</name></expr>]</index></name> <operator>=</operator> <name><name>string2</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt>
    <expr_stmt><expr><name>i</name><operator>--</operator></expr>;</expr_stmt>
</block_content>}</block></while>

for statement

Element

<for>

Subelements

<control>
<block>

XPath Queries

for loops
```
//src:for
```
for-loop initialization statements
```
//src:for/src:control/src:init
```
for-loop conditions
```
//src:for/src:control/src:condition
```
for-loop increments
```
//src:for/src:control/src:incr
```
for loops that declare a variable with a single character name (e.g. x, i or y)
```
//src:for[string-length(src:control/src:init/src:decl/src:name)=1]
```

for loops with post-increment in the increment expression

//src:for[src:control/src:incr/src:expr//following-sibling::src:operator='++']

Examples

for( ;; ) { }

<for>for<control>( <init>;</init><condition>;</condition> <incr/>)</control> <block>{<block_content> </block_content>}</block></for>

for (i = 0; i < max; i++ ) {
    if ( line[i] == ' ' ) {
        space++;
    }
    if ( line[i] == '\t' ) {
        tab++;
    }
}

<for>for <control>(<init><expr><name>i</name> <operator>=</operator> <literal type="number">0</literal></expr>;</init> <condition><expr><name>i</name> <operator>&lt;</operator> <name>max</name></expr>;</condition> <incr><expr><name>i</name><operator>++</operator></expr></incr> )</control> <block>{<block_content>
    <if_stmt><if>if <condition>( <expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>==</operator> <literal type="char">' '</literal></expr> )</condition> <block>{<block_content>
        <expr_stmt><expr><name>space</name><operator>++</operator></expr>;</expr_stmt>
    </block_content>}</block></if></if_stmt>
    <if_stmt><if>if <condition>( <expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>==</operator> <literal type="char">'\t'</literal></expr> )</condition> <block>{<block_content>
        <expr_stmt><expr><name>tab</name><operator>++</operator></expr>;</expr_stmt>
    </block_content>}</block></if></if_stmt>
</block_content>}</block></for>

for (int i = 0; i < 10; ++i)
    a += x[i];

<for>for <control>(<init><decl><type><name>int</name></type> <name>i</name> <init>= <expr><literal type="number">0</literal></expr></init></decl>;</init> <condition><expr><name>i</name> <operator>&lt;</operator> <literal type="number">10</literal></expr>;</condition> <incr><expr><operator>++</operator><name>i</name></expr></incr>)</control><block type="pseudo"><block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt></block_content></block></for>

for (int item : numbers) {
    System.out.println("Count is: " + item);
}

<for>for <control>(<init><decl><type><name>int</name></type> <name>item</name> <range>: <expr><name>numbers</name></expr></range></decl></init>)</control> <block>{<block_content>
    <expr_stmt><expr><call><name><name>System</name><operator>.</operator><name>out</name><operator>.</operator><name>println</name></name><argument_list>(<argument><expr><literal type="string">"Count is: "</literal> <operator>+</operator> <name>item</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
</block_content>}</block></for>

Empty for statement

for (auto  p = v.begin(); p != v.end() && *p != 0; ++p)
    ;

<for>for <control>(<init><decl><type><name>auto</name></type>  <name>p</name> <init>= <expr><call><name><name>v</name><operator>.</operator><name>begin</name></name><argument_list>()</argument_list></call></expr></init></decl>;</init> <condition><expr><name>p</name> <operator>!=</operator> <call><name><name>v</name><operator>.</operator><name>end</name></name><argument_list>()</argument_list></call> <operator>&amp;&amp;</operator> <operator>*</operator><name>p</name> <operator>!=</operator> <literal type="number">0</literal></expr>;</condition> <incr><expr><operator>++</operator><name>p</name></expr></incr>)</control><block type="pseudo"><block_content>
    <empty_stmt>;</empty_stmt></block_content></block></for>

do while statement

Element

<do>

Subelements

<block>
<condition>

XPath Queries

do-while loops
```
//src:do
```
do-while loops with a condition containing the variable counter
```
//src:do[src:condition//src:name='counter']
```

Examples

do {
    y = f( x );
    x--;
} while ( x > 0 );

<do>do <block>{<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr>;</expr_stmt>
    <expr_stmt><expr><name>x</name><operator>--</operator></expr>;</expr_stmt>
</block_content>}</block> while <condition>( <expr><name>x</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition>;</do>

do counter--; while (counter > 0);

<do>do<block type="pseudo"><block_content> <expr_stmt><expr><name>counter</name><operator>--</operator></expr>;</expr_stmt></block_content></block> while <condition>(<expr><name>counter</name> <operator>&gt;</operator> <literal type="number">0</literal></expr>)</condition>;</do>

break statement

Element

<break>

Subelement

<name>

XPath Queries

break statements
```
//src:break
```
break statements in for loops
```
//src:for//src:break
```
for loops with break statements
```
//src:for[.//src:break]
```
break statements that break to the exit label
```
//src:break[src:name='exit']
```

Examples

char c;
for(;;) {
    printf_s( "\nPress any key, Q to quit: " );

    // Convert to character value
    scanf_s("%c", &c);
    if (c == 'Q')
        break;
}

<decl_stmt><decl><type><name>char</name></type> <name>c</name></decl>;</decl_stmt>
<for>for<control>(<init>;</init><condition>;</condition><incr/>)</control> <block>{<block_content>
    <expr_stmt><expr><call><name>printf_s</name><argument_list>( <argument><expr><literal type="string">"\nPress any key, Q to quit: "</literal></expr></argument> )</argument_list></call></expr>;</expr_stmt>

    <comment type="line">// Convert to character value</comment>
    <expr_stmt><expr><call><name>scanf_s</name><argument_list>(<argument><expr><literal type="string">"%c"</literal></expr></argument>, <argument><expr><operator>&amp;</operator><name>c</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    <if_stmt><if>if <condition>(<expr><name>c</name> <operator>==</operator> <literal type="char">'Q'</literal></expr>)</condition><block type="pseudo"><block_content>
        <break>break;</break></block_content></block></if></if_stmt>
</block_content>}</block></for>

break label;

<break>break <name>label</name>;</break>

continue statement

Element

<continue>

Subelement

<name>

XPath Queries

continue statements
```
//src:continue
```
continue statements that branch to the outerloop label
```
//src:continue[src:name='outerloop']
```

Examples

while ( i-- > 0 ) {
    x = f(i);
    if (x == 1) {
        continue;
    }
    y += x * x;
}

<while>while <condition>( <expr><name>i</name><operator>--</operator> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <call><name>f</name><argument_list>(<argument><expr><name>i</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    <if_stmt><if>if <condition>(<expr><name>x</name> <operator>==</operator> <literal type="number">1</literal></expr>)</condition> <block>{<block_content>
        <continue>continue;</continue>
    </block_content>}</block></if></if_stmt>
    <expr_stmt><expr><name>y</name> <operator>+=</operator> <name>x</name> <operator>*</operator> <name>x</name></expr>;</expr_stmt>
</block_content>}</block></while>

continue label;

<continue>continue <name>label</name>;</continue>

label statement

Element

<label>

Subelement

<name>

XPath Query

labels
```
//src:label
```

Example

stop:

<label><name>stop</name>:</label>

return statement

Element

<return>

Subelement

<expr>

XPath Queries

return statements
```
//src:return
```
return expressions
```
//src:return/src:expr
```
return statements that return true
```
//src:return[src:expr='true']
```
functions with more then one return
```
//src:function[count(.//src:return)>1]
```

Examples

return;

<return>return;</return>

return true;

<return>return <expr><name>true</name></expr>;</return>

return( s * (long long)s );

<return>return<expr><operator>(</operator> <name>s</name> <operator>*</operator> <operator>(</operator><name>long</name> <name>long</name><operator>)</operator><name>s</name> <operator>)</operator></expr>;</return>

switch statement

Element

<switch>

Subelements

<condition>
<block>
<case>
<default>

XPath Queries

switch statements
```
//src:switch
```
switch-statement conditions
```
//src:switch/src:condition
```

Examples

switch (c) {

    case 'A':
        ++capa;
    case 'a':
        ++lettera;
    default :
        ++total;
}

<switch>switch <condition>(<expr><name>c</name></expr>)</condition> <block>{<block_content>

    <case>case <expr><literal type="char">'A'</literal></expr>:</case>
        <expr_stmt><expr><operator>++</operator><name>capa</name></expr>;</expr_stmt>
    <case>case <expr><literal type="char">'a'</literal></expr>:</case>
        <expr_stmt><expr><operator>++</operator><name>lettera</name></expr>;</expr_stmt>
    <default>default :</default>
        <expr_stmt><expr><operator>++</operator><name>total</name></expr>;</expr_stmt>
</block_content>}</block></switch>

switch (i) {

    case -1:
        ++n;
        break;
    case 0 :
        ++z;
        break;
    case 1 :
        ++p;
        break;
}

<switch>switch <condition>(<expr><name>i</name></expr>)</condition> <block>{<block_content>

    <case>case <expr><operator>-</operator><literal type="number">1</literal></expr>:</case>
        <expr_stmt><expr><operator>++</operator><name>n</name></expr>;</expr_stmt>
        <break>break;</break>
    <case>case <expr><literal type="number">0</literal></expr> :</case>
        <expr_stmt><expr><operator>++</operator><name>z</name></expr>;</expr_stmt>
        <break>break;</break>
    <case>case <expr><literal type="number">1</literal></expr> :</case>
        <expr_stmt><expr><operator>++</operator><name>p</name></expr>;</expr_stmt>
        <break>break;</break>
</block_content>}</block></switch>

case statement

Element

<case>

Subelement

<expr>

XPath Queries

case labels
```
//src:case
```
case labels that use SATURDAY
```
//src:case[.//src:name='SATURDAY']
```

switch statements with a case that uses SATURDAY

//src:switch[src:block/src:block_content/src:case//src:name='SATURDAY']

Examples

case x:

<case>case <expr><name>x</name></expr>:</case>

case SATURDAY:

<case>case <expr><name>SATURDAY</name></expr>:</case>

default statement

Element

<default>

XPath Queries

default labels
```
//src:default
```

switch statements with a default label

//src:switch[src:block/src:block_content/src:default]

Example

default case

default:

<default>default:</default>

assert statement

Element

<assert>

Subelement

<expr>

XPath Queries

assert statements
```
//src:assert
```
methods with assert statements
```
//src:function[.//src:assert]
```

Example

assert expr1 : expr2 ;

<assert>assert <expr><name>expr1</name> <operator>:</operator> <name>expr2</name></expr> ;</assert>

block

Element

<block>

Subelement

<block_content>

XPath Queries

blocks
```
//src:block
```
variable declarations in a block
```
//src:block//src:decl_stmt
```

top-level variable declarations in a block

//src:block/src:block_content/src:decl_stmt

Example

{
    line[i] = x;
    x++;
    i--;
}

<block>{<block_content>
    <expr_stmt><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>=</operator> <name>x</name></expr>;</expr_stmt>
    <expr_stmt><expr><name>x</name><operator>++</operator></expr>;</expr_stmt>
    <expr_stmt><expr><name>i</name><operator>--</operator></expr>;</expr_stmt>
</block_content>}</block>

pseudo block

Element

<block type="pseudo">

Subelement

<block_content>

XPath Queries

all pseudo blocks
```
//src:block[@type='pseudo']
```
all non pseudo blocks
```
//src:block[not(@type='pseudo')]
```

variable declarations in a pseudo block

//src:block[@type='pseudo']//src:decl_stmt

top-level variable declarations in a pseudo block

//src:block[@type='pseudo']/src:block_content/src:decl_stmt

expression statement

Element

<expr_stmt>

Subelement

<expr>

XPath Query

expression statements
```
//src:expr_stmt
```

Example

i++;

<expr_stmt><expr><name>i</name><operator>++</operator></expr>;</expr_stmt>

empty statement

Element

<empty_stmt>

XPath Query

empty statements
```
//src:empty_stmt
```

Example

<empty_stmt>;</empty_stmt>

condition

Element

<condition>

Subelement

<expr>

XPath Queries

conditions, including ternary conditions
```
//src:condition
```
condition expressions
```
//src:condition/src:expr
```
if conditions
```
//src:if/src:condition
```
while conditions
```
//src:while/src:condition
```
do while conditions
```
//src:do/src:condition
```
ternary conditions
```
//src:ternary/src:condition
```

Examples

if(x > 5)
    y+=4;

<if_stmt><if>if<condition>(<expr><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr>;</expr_stmt></block_content></block></if></if_stmt>

while ( i >= 0 ) {
    string1[i] = string2[i];
    i--;
}

<while>while <condition>( <expr><name>i</name> <operator>&gt;=</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
    <expr_stmt><expr><name><name>string1</name><index>[<expr><name>i</name></expr>]</index></name> <operator>=</operator> <name><name>string2</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt>
    <expr_stmt><expr><name>i</name><operator>--</operator></expr>;</expr_stmt>
</block_content>}</block></while>

do counter--; while (counter > 0);

<do>do<block type="pseudo"><block_content> <expr_stmt><expr><name>counter</name><operator>--</operator></expr>;</expr_stmt></block_content></block> while <condition>(<expr><name>counter</name> <operator>&gt;</operator> <literal type="number">0</literal></expr>)</condition>;</do>

type

Element

<type>

Subelements

<specifier>
<name>

XPath Queries

types
```
//src:type
```
declaration types
```
//src:decl/src:type
```
function types
```
//src:function/src:type
```
function declaration types
```
//src:function_decl/src:type
```

Examples

final int speedlimit=90;

<decl_stmt><decl><type><specifier>final</specifier> <name>int</name></type> <name>speedlimit</name><init>=<expr><literal type="number">90</literal></expr></init></decl>;</decl_stmt>

public final String myFinalMethod() {
}

<function><type><specifier>public</specifier> <specifier>final</specifier> <name>String</name></type> <name>myFinalMethod</name><parameter_list>()</parameter_list> <block>{<block_content>
</block_content>}</block></function>

abstract String myMethod();

<function_decl><type><specifier>abstract</specifier> <name>String</name></type> <name>myMethod</name><parameter_list>()</parameter_list>;</function_decl>

block content

Element

<block_content>

XPath Queries

block contents
```
//src:block_content
```
declaration block_contents
```
//src:decl/src:block/src:block_content
```

function block_contents

//src:function/src:block/src:block_content

Example

{
    line[i] = x;
    x++;
    i--;
}

<block>{<block_content>
    <expr_stmt><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>=</operator> <name>x</name></expr>;</expr_stmt>
    <expr_stmt><expr><name>x</name><operator>++</operator></expr>;</expr_stmt>
    <expr_stmt><expr><name>i</name><operator>--</operator></expr>;</expr_stmt>
</block_content>}</block>

expression

Element

<expr>

Subelements

<name>
<operator>
<call>
<ternary>

XPath Query

expressions
```
//src:expr
```

Examples

a + b

<expr><name>a</name> <operator>+</operator> <name>b</name></expr>

System.out.println("Hello World!");

<expr_stmt><expr><call><name><name>System</name><operator>.</operator><name>out</name><operator>.</operator><name>println</name></name><argument_list>(<argument><expr><literal type="string">"Hello World!"</literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>

a ? x : y;

<expr_stmt><expr><ternary><condition><expr><name>a</name></expr> ?</condition><then> <expr><name>x</name></expr> </then><else>: <expr><name>y</name></expr></else></ternary></expr>;</expr_stmt>

if

Element

<if>

Subelements

<condition>
<block>

XPath Query

all ifs
```
//src:if
```

Examples

if(x > 5)
    y+=4;

<if_stmt><if>if<condition>(<expr><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr>;</expr_stmt></block_content></block></if></if_stmt>

if ( i > 0 ) {
    y = x / i;
}

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition> <block>{<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr>;</expr_stmt>
</block_content>}</block></if></if_stmt>

if ( i > 0 )
    y = x / i;
else {
    x = i;
    y = f( x );
}

<if_stmt><if>if <condition>( <expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr> )</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr>;</expr_stmt></block_content></block></if>
<else>else <block>{<block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr>;</expr_stmt>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr>;</expr_stmt>
</block_content>}</block></else></if_stmt>

then

Element

<then>

Subelement

<expr>

XPath Query

then parts of ternary
```
//src:then
```

Example

a ? x : y;

<expr_stmt><expr><ternary><condition><expr><name>a</name></expr> ?</condition><then> <expr><name>x</name></expr> </then><else>: <expr><name>y</name></expr></else></ternary></expr>;</expr_stmt>

else

Element

<else>

Subelement

<block>

XPath Query

all elses
```
//src:else
```

Example

if then else

if (A)
    B;
else
    C;

<if_stmt><if>if <condition>(<expr><name>A</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>B</name></expr>;</expr_stmt></block_content></block></if>
<else>else<block type="pseudo"><block_content>
    <expr_stmt><expr><name>C</name></expr>;</expr_stmt></block_content></block></else></if_stmt>

else if

Element

<if type="elseif">

Subelements

<condition>
<block>

XPath Query

all else ifs
```
//src:if[@type='elseif']
```

Example

if then elseif

if (A)
    B;
else if (A2)
    C;
else
    D:

<if_stmt><if>if <condition>(<expr><name>A</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>B</name></expr>;</expr_stmt></block_content></block></if>
<if type="elseif">else if <condition>(<expr><name>A2</name></expr>)</condition><block type="pseudo"><block_content>
    <expr_stmt><expr><name>C</name></expr>;</expr_stmt></block_content></block></if>
<else>else<block type="pseudo"><block_content>
    <label><name>D</name>:</label></block_content></block></else></if_stmt>

control

Element

<control>

Subelements

<init>
<condition>
<incr>

XPath Query

initialization, condition, and increment of for loops
```
//src:control
```

Example

for (int i = 0; i < 10; ++i)
    a += x[i];

<for>for <control>(<init><decl><type><name>int</name></type> <name>i</name> <init>= <expr><literal type="number">0</literal></expr></init></decl>;</init> <condition><expr><name>i</name> <operator>&lt;</operator> <literal type="number">10</literal></expr>;</condition> <incr><expr><operator>++</operator><name>i</name></expr></incr>)</control><block type="pseudo"><block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt></block_content></block></for>

incr

Element

<incr>

Subelement

<expr>

XPath Query

increment of for loops
```
//src:incr
```

Example

for (int i = 0; i < 10; ++i)
    a += x[i];

<for>for <control>(<init><decl><type><name>int</name></type> <name>i</name> <init>= <expr><literal type="number">0</literal></expr></init></decl>;</init> <condition><expr><name>i</name> <operator>&lt;</operator> <literal type="number">10</literal></expr>;</condition> <incr><expr><operator>++</operator><name>i</name></expr></incr>)</control><block type="pseudo"><block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr>;</expr_stmt></block_content></block></for>

volatile

Element

<specifier>volatile</specifier>

XPath Query

volatile variables

//src:decl[src:type/src:specifier='volatile']

Example

volatile int sharedVal;

<decl_stmt><decl><type><specifier>volatile</specifier> <name>int</name></type> <name>sharedVal</name></decl>;</decl_stmt>

abstract

Element

<specifier>abstract</specifier>

XPath Queries

abstract classes
```
//src:class[src:specifier='abstract']
```

abstract methods

//src:function[src:type/src:specifier='abstract']

Examples

abstract class MyClass {
}

<class><specifier>abstract</specifier> class <name>MyClass</name> <block>{
}</block></class>

abstract String myMethod();

<function_decl><type><specifier>abstract</specifier> <name>String</name></type> <name>myMethod</name><parameter_list>()</parameter_list>;</function_decl>

default method implementation

Element

<specifier>default</specifier>

XPath Query

methods with default implementations

//src:function[src:type/src:specifier='default']

Example

default ZonedDateTime getZonedDateTime(String zoneString) { return null; }

<function><type><specifier>default</specifier> <name>ZonedDateTime</name></type> <name>getZonedDateTime</name><parameter_list>(<parameter><decl><type><name>String</name></type> <name>zoneString</name></decl></parameter>)</parameter_list> <block>{<block_content> <return>return <expr><literal type="null">null</literal></expr>;</return> </block_content>}</block></function>

final

Element

<specifier>final</specifier>

XPath Queries

final classes
```
//src:class[src:specifier='final']
```

final methods

//src:function[src:type/src:specifier='final']

final variable declarations

//src:decl[src:type/src:specifier='final']

Examples

public final class MyFinalClass {
}

<class><specifier>public</specifier> <specifier>final</specifier> class <name>MyFinalClass</name> <block>{
}</block></class>

public final String myFinalMethod() {
}

<function><type><specifier>public</specifier> <specifier>final</specifier> <name>String</name></type> <name>myFinalMethod</name><parameter_list>()</parameter_list> <block>{<block_content>
</block_content>}</block></function>

final int speedlimit=90;

<decl_stmt><decl><type><specifier>final</specifier> <name>int</name></type> <name>speedlimit</name><init>=<expr><literal type="number">90</literal></expr></init></decl>;</decl_stmt>

synchronized

Element

<specifier>synchronized</specifier>

XPath Query

synchronized methods

//src:function[src:type/src:specifier='synchronized']

Example

public synchronized String mySyncMethod() {
}

<function><type><specifier>public</specifier> <specifier>synchronized</specifier> <name>String</name></type> <name>mySyncMethod</name><parameter_list>()</parameter_list> <block>{<block_content>
</block_content>}</block></function>

transient

Element

<specifier>transient</specifier>

XPath Query

transient variable declarations

//src:decl[src:type/src:specifier='transient']

Example

transient String password;

<decl_stmt><decl><type><specifier>transient</specifier> <name>String</name></type> <name>password</name></decl>;</decl_stmt>

native

Element

<specifier>native</specifier>

XPath Query

native function declarations

//src:function_decl[src:type/src:specifier='native']

Example

native String getProcessorType();

<function_decl><type><specifier>native</specifier> <name>String</name></type> <name>getProcessorType</name><parameter_list>()</parameter_list>;</function_decl>

private

Element

<specifier>private</specifier>

XPath Queries

private classes
```
//src:class[src:specifier='private']
```

private member variables

//src:class//src:decl_stmt[src:decl/src:type/src:specifier='private']

private methods

//src:function[src:type/src:specifier='private']

Examples

public class MyPublicClass {
    private class Helper
    {
    }
}

<class><specifier>public</specifier> class <name>MyPublicClass</name> <block>{
    <class><specifier>private</specifier> class <name>Helper</name>
    <block>{
    }</block></class>
}</block></class>

private int i;

<decl_stmt><decl><type><specifier>private</specifier> <name>int</name></type> <name>i</name></decl>;</decl_stmt>

private String myMethod() {
}

<function><type><specifier>private</specifier> <name>String</name></type> <name>myMethod</name><parameter_list>()</parameter_list> <block>{<block_content>
</block_content>}</block></function>

protected

Element

<specifier>protected</specifier>

XPath Queries

protected classes
```
//src:class[src:specifier='protected']
```

protected member variables

//src:class//src:decl_stmt[src:decl/src:type/src:specifier='protected']

protected methods

//src:function[src:type/src:specifier='protected']

Examples

public class Temp {
    protected class MyProtectedClass
    {
    }
}

<class><specifier>public</specifier> class <name>Temp</name> <block>{
    <class><specifier>protected</specifier> class <name>MyProtectedClass</name>
    <block>{
    }</block></class>
}</block></class>

protected int i;

<decl_stmt><decl><type><specifier>protected</specifier> <name>int</name></type> <name>i</name></decl>;</decl_stmt>

protected String myMethod() {
}

<function><type><specifier>protected</specifier> <name>String</name></type> <name>myMethod</name><parameter_list>()</parameter_list> <block>{<block_content>
</block_content>}</block></function>

public

Element

<specifier>public</specifier>

XPath Queries

public classes
```
//src:class[src:specifier='public']
```

public member variables

//src:class//src:decl_stmt[src:decl/src:type/src:specifier='public']

public methods

//src:function[src:type/src:specifier='public']

Examples

public class MyPrivateClass {
}

<class><specifier>public</specifier> class <name>MyPrivateClass</name> <block>{
}</block></class>

public int i = 50;

<decl_stmt><decl><type><specifier>public</specifier> <name>int</name></type> <name>i</name> <init>= <expr><literal type="number">50</literal></expr></init></decl>;</decl_stmt>

public String getName() { }

<function><type><specifier>public</specifier> <name>String</name></type> <name>getName</name><parameter_list>()</parameter_list> <block>{<block_content> </block_content>}</block></function>

static

Element

<specifier>static</specifier>

XPath Queries

static methods

//src:function[src:type/src:specifier='static']

static classes
```
//src:class[src:specifier='static']
```

static variables

//src:decl[src:type/src:specifier='static']

Examples

public final static int MAX_OBJECTS = 100;
static int _numObjects = 0;

<decl_stmt><decl><type><specifier>public</specifier> <specifier>final</specifier> <specifier>static</specifier> <name>int</name></type> <name>MAX_OBJECTS</name> <init>= <expr><literal type="number">100</literal></expr></init></decl>;</decl_stmt>
<decl_stmt><decl><type><specifier>static</specifier> <name>int</name></type> <name>_numObjects</name> <init>= <expr><literal type="number">0</literal></expr></init></decl>;</decl_stmt>

static class MyStaticClass {
}

<class><specifier>static</specifier> class <name>MyStaticClass</name> <block>{
}</block></class>

static int getNumObjects() {
}

<function><type><specifier>static</specifier> <name>int</name></type> <name>getNumObjects</name><parameter_list>()</parameter_list> <block>{<block_content>
</block_content>}</block></function>

strictfp

Element

<specifier>strictfp</specifier>

XPath Query

strictfp classes
```
//src:class[src:specifier='strictfp']
```

Example

strictfp class FooNum {
}

<class><specifier>strictfp</specifier> class <name>FooNum</name> <block>{
}</block></class>

variable declaration

Element

<decl_stmt>

Subelements

<type>
<name>
<init>

XPath Queries

variable declaration statements
```
//src:decl_stmt
```
variable declarations
```
//src:decl
```
variable declarations with an initialization
```
//src:decl[src:init]
```
array declarations
```
//src:decl[src:name/src:index]
```

Examples

boolean result = true;
char capitalC = 'C';

<decl_stmt><decl><type><name>boolean</name></type> <name>result</name> <init>= <expr><literal type="boolean">true</literal></expr></init></decl>;</decl_stmt>
<decl_stmt><decl><type><name>char</name></type> <name>capitalC</name> <init>= <expr><literal type="char">'C'</literal></expr></init></decl>;</decl_stmt>

char data[] = {'a', 'b', 'c'};

<decl_stmt><decl><type><name>char</name></type> <name><name>data</name><index>[]</index></name> <init>= <expr><block>{<expr><literal type="char">'a'</literal></expr>, <expr><literal type="char">'b'</literal></expr>, <expr><literal type="char">'c'</literal></expr>}</block></expr></init></decl>;</decl_stmt>

String str = new String(data);

<decl_stmt><decl><type><name>String</name></type> <name>str</name> <init>= <expr><operator>new</operator> <call><name>String</name><argument_list>(<argument><expr><name>data</name></expr></argument>)</argument_list></call></expr></init></decl>;</decl_stmt>

String cde = "cde";

<decl_stmt><decl><type><name>String</name></type> <name>cde</name> <init>= <expr><literal type="string">"cde"</literal></expr></init></decl>;</decl_stmt>

int[][] multi = new int[5][10];

<decl_stmt><decl><type><name><name>int</name><index>[]</index><index>[]</index></name></type> <name>multi</name> <init>= <expr><operator>new</operator> <name><name>int</name><index>[<expr><literal type="number">5</literal></expr>]</index><index>[<expr><literal type="number">10</literal></expr>]</index></name></expr></init></decl>;</decl_stmt>

method definition

Element

<function>

Subelements

<type>
<name>
<parameter_list>
<block>

XPath Queries

method definitions
```
//src:function
```
method-definition return types
```
//src:function/src:type
```

method-definition parameters

//src:function/src:parameter_list/src:parameter

method definitions with two parameters

//src:function[count(src:parameter_list/src:parameter)=2]

method-definition names
```
//src:function/src:name
```

Examples

int getArea() {
    return width * height;
}

<function><type><name>int</name></type> <name>getArea</name><parameter_list>()</parameter_list> <block>{<block_content>
    <return>return <expr><name>width</name> <operator>*</operator> <name>height</name></expr>;</return>
</block_content>}</block></function>

Polygon polygonFrom(Point... corners) { }

<function><type><name>Polygon</name></type> <name>polygonFrom</name><parameter_list>(<parameter><decl><type><name>Point</name><modifier>...</modifier></type> <name>corners</name></decl></parameter>)</parameter_list> <block>{<block_content> </block_content>}</block></function>

lambda functions

Element

<lambda>

Subelements

<parameter_list>
<block>

XPath Query

lambda functions
```
//src:lambda
```

Examples

(a, b) -> a - b;

<expr_stmt><expr><lambda><parameter_list>(<parameter><decl><name>a</name></decl></parameter>, <parameter><decl><name>b</name></decl></parameter>)</parameter_list> -&gt;<block type="pseudo"><block_content> <expr><name>a</name> <operator>-</operator> <name>b</name></expr></block_content></block></lambda></expr>;</expr_stmt>

(Person p) -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25

<expr><lambda><parameter_list>(<parameter><decl><type><name>Person</name></type> <name>p</name></decl></parameter>)</parameter_list> -&gt;<block type="pseudo"><block_content> <expr><call><name><name>p</name><operator>.</operator><name>getGender</name></name><argument_list>()</argument_list></call> <operator>==</operator> <name><name>Person</name><operator>.</operator><name>Sex</name><operator>.</operator><name>MALE</name></name>
        <operator>&amp;&amp;</operator> <call><name><name>p</name><operator>.</operator><name>getAge</name></name><argument_list>()</argument_list></call> <operator>&gt;=</operator> <literal type="number">18</literal>
        <operator>&amp;&amp;</operator> <call><name><name>p</name><operator>.</operator><name>getAge</name></name><argument_list>()</argument_list></call> <operator>&lt;=</operator> <literal type="number">25</literal></expr></block_content></block></lambda></expr>

(int a, int b) -> {  return a + b; }

<expr_stmt><expr><lambda><parameter_list>(<parameter><decl><type><name>int</name></type> <name>a</name></decl></parameter>, <parameter><decl><type><name>int</name></type> <name>b</name></decl></parameter>)</parameter_list> -&gt; <block>{<block_content>  <return>return <expr><name>a</name> <operator>+</operator> <name>b</name></expr>;</return> </block_content>}</block></lambda></expr></expr_stmt>

() -> System.out.println("Hello World");

<expr_stmt><expr><lambda><parameter_list>()</parameter_list> -&gt;<block type="pseudo"><block_content> <expr><call><name><name>System</name><operator>.</operator><name>out</name><operator>.</operator><name>println</name></name><argument_list>(<argument><expr><literal type="string">"Hello World"</literal></expr></argument>)</argument_list></call></expr></block_content></block></lambda></expr>;</expr_stmt>

() -> 42

<expr><lambda><parameter_list>()</parameter_list> -&gt;<block type="pseudo"><block_content> <expr><literal type="number">42</literal></expr></block_content></block></lambda></expr>

class

Element

<class>

Subelements

<name>
<super_list>
<super>
<block>

XPath Queries

class definitions
```
//src:class
```
anonymous class definitions
```
//src:class[not(src:name)]
```

Examples

class Pair {
}

<class>class <name>Pair</name> <block>{
}</block></class>

class DerivedClass extends BaseClass {
}

<class>class <name>DerivedClass</name> <super_list><extends>extends <super><name>BaseClass</name></super></extends></super_list> <block>{
}</block></class>

HelloWorld spanishGreeting = new HelloWorld() {
    String name = "mundo";
    public void greet() {
        greetSomeone("mundo");
    }
    public void greetSomeone(String someone) {
        name = someone;
        System.out.println("Hola, " + name);
    }
};

<decl_stmt><decl><type><name>HelloWorld</name></type> <name>spanishGreeting</name> <init>= <expr><operator>new</operator> <class><super><name>HelloWorld</name></super><argument_list>()</argument_list> <block>{
    <decl_stmt><decl><type><name>String</name></type> <name>name</name> <init>= <expr><literal type="string">"mundo"</literal></expr></init></decl>;</decl_stmt>
    <function><type><specifier>public</specifier> <name>void</name></type> <name>greet</name><parameter_list>()</parameter_list> <block>{<block_content>
        <expr_stmt><expr><call><name>greetSomeone</name><argument_list>(<argument><expr><literal type="string">"mundo"</literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    </block_content>}</block></function>
    <function><type><specifier>public</specifier> <name>void</name></type> <name>greetSomeone</name><parameter_list>(<parameter><decl><type><name>String</name></type> <name>someone</name></decl></parameter>)</parameter_list> <block>{<block_content>
        <expr_stmt><expr><name>name</name> <operator>=</operator> <name>someone</name></expr>;</expr_stmt>
        <expr_stmt><expr><call><name><name>System</name><operator>.</operator><name>out</name><operator>.</operator><name>println</name></name><argument_list>(<argument><expr><literal type="string">"Hola, "</literal> <operator>+</operator> <name>name</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    </block_content>}</block></function>
}</block></class></expr></init></decl>;</decl_stmt>

interface

Element

<interface>

Subelements

<name>
<block>

XPath Query

interfaces
```
//src:interface
```

Example

public interface IPolygon {
	public float getArea();
	public int getNumberOfSides();
	public int getCircumference();
}

<interface><specifier>public</specifier> interface <name>IPolygon</name> <block>{
	<function_decl><type><specifier>public</specifier> <name>float</name></type> <name>getArea</name><parameter_list>()</parameter_list>;</function_decl>
	<function_decl><type><specifier>public</specifier> <name>int</name></type> <name>getNumberOfSides</name><parameter_list>()</parameter_list>;</function_decl>
	<function_decl><type><specifier>public</specifier> <name>int</name></type> <name>getCircumference</name><parameter_list>()</parameter_list>;</function_decl>
}</block></interface>

interface_decl

Element

<interface_decl>

Subelement

<name>

XPath Query

interface declarations
```
//src:interface_decl
```

annotation definition

Element

<annotation_defn>

Subelements

<name>
<block>

XPath Query

annotation definitions
```
//src:annotation_defn
```

Example

@interface ClassPreambleAnnotation {
}

<annotation_defn>@interface <name>ClassPreambleAnnotation</name> <block>{
}</block></annotation_defn>

annotation

Element

<annotation>

Subelements

<name>
<argument_list>

XPath Queries

annotations
```
//src:annotation
```
-Deprecated annotations
```
//src:annotation[src:name='Deprecated']
```

Examples

@Entity
@Author( name = "Benjamin Franklin", date = "3/27/2003")
@Inventor("Benjamin Franklin")
class Cls {
}

<class><annotation>@<name>Entity</name></annotation>
<annotation>@<name>Author</name><argument_list>( <argument><expr><name>name</name> <operator>=</operator> <literal type="string">"Benjamin Franklin"</literal></expr></argument>, <argument><expr><name>date</name> <operator>=</operator> <literal type="string">"3/27/2003"</literal></expr></argument>)</argument_list></annotation>
<annotation>@<name>Inventor</name><argument_list>(<argument><expr><literal type="string">"Benjamin Franklin"</literal></expr></argument>)</argument_list></annotation>
class <name>Cls</name> <block>{
}</block></class>

@Entity
@Author( name = "Benjamin Franklin", date = "3/27/2003")
@Inventor("Benjamin Franklin")

<decl><annotation>@<name>Entity</name></annotation>
<annotation>@<name>Author</name><argument_list>( <argument><expr><name>name</name> <operator>=</operator> <literal type="string">"Benjamin Franklin"</literal></expr></argument>, <argument><expr><name>date</name> <operator>=</operator> <literal type="string">"3/27/2003"</literal></expr></argument>)</argument_list></annotation>
@<name>Inventor</name><argument_list>(<argument><expr><literal type="string">"Benjamin Franklin"</literal></expr></argument>)</argument_list></decl>

inheritance list

Element

<super_list>

Subelements

<extends>
<implements>
<super>

XPath Queries

classes with at least one super class
```
//src:class[src:super_list/src:super]
```

classes that inherit from bar

//src:class[src:super_list/src:super/src:name='bar']

Example

class Foo implements Bar {
}

<class>class <name>Foo</name> <super_list><implements>implements <super><name>Bar</name></super></implements></super_list> <block>{
}</block></class>

enum definition

Element

<enum>

Subelements

<block>
<name>

XPath Queries

enums
```
//src:enum
```
enum names
```
//src:enum/src:name
```

Example

enum Planet {
    MERCURY,
    VENUS,
    EARTH,
    MARS,
    JUPITER,
    SATURN,
    URANUS,
    NEPTUNE;
}

<enum>enum <name>Planet</name> <block>{
    <decl><name>MERCURY</name></decl>,
    <decl><name>VENUS</name></decl>,
    <decl><name>EARTH</name></decl>,
    <decl><name>MARS</name></decl>,
    <decl><name>JUPITER</name></decl>,
    <decl><name>SATURN</name></decl>,
    <decl><name>URANUS</name></decl>,
    <decl><name>NEPTUNE</name></decl>;
}</block></enum>

extends

Element

<extends>

Subelements

<name>
<super>

XPath Queries

extends
```
//src:extends
```

classes that extend from BaseClass

//src:class[src:super_list/src:extends/src:name='BaseClass']

Example

class DerivedClass extends BaseClass {
}

<class>class <name>DerivedClass</name> <super_list><extends>extends <super><name>BaseClass</name></super></extends></super_list> <block>{
}</block></class>

implements

Element

<implements>

Subelements

<name>
<super>

XPath Queries

implements
```
//src:implements
```

classes which implement IVehicle

//src:class[src:super_list/src:implements/src:name='IVehicle']

Example

public class Truck implements IVehicle {
}

<class><specifier>public</specifier> class <name>Truck</name> <super_list><implements>implements <super><name>IVehicle</name></super></implements></super_list> <block>{
}</block></class>

constructor

Element

<constructor>

Subelements

<name>
<parameter_list>
<specifier>

XPath Query

constructors
```
//src:constructor
```

Examples

class MyType {
    MyType() { }
}

<class>class <name>MyType</name> <block>{
    <constructor><name>MyType</name><parameter_list>()</parameter_list> <block>{<block_content> </block_content>}</block></constructor>
}</block></class>

static void method() {
    System.out.println("This is a method");
}

<function><type><specifier>static</specifier> <name>void</name></type> <name>method</name><parameter_list>()</parameter_list> <block>{<block_content>
    <expr_stmt><expr><call><name><name>System</name><operator>.</operator><name>out</name><operator>.</operator><name>println</name></name><argument_list>(<argument><expr><literal type="string">"This is a method"</literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>
</block_content>}</block></function>

receiver parameter

Element

<name>

XPath Query

constructors with a receiver parameter

//src:constructor[src:parameter_list/src:parameter/src:decl/src:name/src:name='this']

Example

public void foo(MyType MyType.this) { }

<function><type><specifier>public</specifier> <name>void</name></type> <name>foo</name><parameter_list>(<parameter><decl><type><name>MyType</name></type> <name><name>MyType</name><operator>.</operator><name>this</name></name></decl></parameter>)</parameter_list> <block>{<block_content> </block_content>}</block></function>

static initialization block

Element

<static>

Subelement

<block>

XPath Query

static initialization blocks
```
//src:static
```

Example

class Cls {
	static {

	}  
}

<class>class <name>Cls</name> <block>{
	<static>static <block>{<block_content>

	</block_content>}</block></static>  
}</block></class>

default annotation property value

Element

<default>

XPath Query

annotation properties with a default value
```
//src:function_decl[src:default]
```

Example

   int currentRevision() default 1;
   String lastModified() default "N/A";

   <function_decl><type><name>int</name></type> <name>currentRevision</name><parameter_list>()</parameter_list> <default>default <init><expr><literal type="number">1</literal></expr></init></default>;</function_decl>
   <function_decl><type><name>String</name></type> <name>lastModified</name><parameter_list>()</parameter_list> <default>default <init><expr><literal type="string">"N/A"</literal></expr></init></default>;</function_decl>

function call

Element

<call>

Subelements

<name>
<argument_list>

XPath Query

function calls
```
//src:call
```

Example

System.out.println("Hello World!");

<expr_stmt><expr><call><name><name>System</name><operator>.</operator><name>out</name><operator>.</operator><name>println</name></name><argument_list>(<argument><expr><literal type="string">"Hello World!"</literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>

ternary operator

Element

<ternary>

Subelements

<condition>
<then>
<else>

XPath Query

ternary operators
```
//src:ternary
```

Example

a ? x : y;

<expr_stmt><expr><ternary><condition><expr><name>a</name></expr> ?</condition><then> <expr><name>x</name></expr> </then><else>: <expr><name>y</name></expr></else></ternary></expr>;</expr_stmt>

this

Element

<name>

XPath Query

this
```
//src:name[.='this']
```

Examples

this.x = x;

<expr_stmt><expr><name><name>this</name><operator>.</operator><name>x</name></name> <operator>=</operator> <name>x</name></expr>;</expr_stmt>

public Rectangle() {
    this(0, 0, 1, 1);
}

<constructor><specifier>public</specifier> <name>Rectangle</name><parameter_list>()</parameter_list> <block>{<block_content>
    <expr_stmt><expr><call><name>this</name><argument_list>(<argument><expr><literal type="number">0</literal></expr></argument>, <argument><expr><literal type="number">0</literal></expr></argument>, <argument><expr><literal type="number">1</literal></expr></argument>, <argument><expr><literal type="number">1</literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>
</block_content>}</block></constructor>

super

Element

<name>

XPath Query

calls to a super constructor
```
//src:call[src:name='super']
```

Example

super(args)

<expr><call><name>super</name><argument_list>(<argument><expr><name>args</name></expr></argument>)</argument_list></call></expr>

method reference

Element

<name>

XPath Query

expressions with a method reference

//src:expr[src:name/src:operator='::' or src:operator='::']

Examples

IdentifierType::methodName;

<expr_stmt><expr><name>IdentifierType</name><operator>::</operator><name>methodName</name></expr>;</expr_stmt>

ClsName.super::<T> MethodName;

<expr_stmt><expr><name><name>ClsName</name><operator>.</operator><name>super</name></name><operator>::</operator><operator>&lt;</operator><name>T</name><operator>&gt;</operator> <name>MethodName</name></expr>;</expr_stmt>

ClsName::<T> new;

<expr_stmt><expr><name>ClsName</name><operator>::</operator><operator>&lt;</operator><name>T</name><operator>&gt;</operator> <operator>new</operator></expr>;</expr_stmt>

int[]::new

<expr><name><name>int</name><index>[]</index></name><operator>::</operator><operator>new</operator></expr>

import

Element

<import>

Subelement

<name>

XPath Query

import statements
```
//src:import
```

Example

import java.io.File;
import java.net.*;

<import>import <name><name>java</name><operator>.</operator><name>io</name><operator>.</operator><name>File</name></name>;</import>
<import>import <name><name>java</name><operator>.</operator><name>net</name><operator>.</operator><name>*</name></name>;</import>

package

Element

<package>

Subelement

<name>

XPath Query

package declarations
```
//src:package
```

Example

package com.mycompany;

<package>package <name><name>com</name><operator>.</operator><name>mycompany</name></name>;</package>

synchronized statement

Element

<synchronized>

Subelements

<init>
<block>

XPath Query

synchronization statements
```
//src:synchronized
```

Example

synchronized (syncObj) {
}

<synchronized>synchronized <init>(<expr><name>syncObj</name></expr>)</init> <block>{<block_content>
</block_content>}</block></synchronized>

throw

Element

<throw>

Subelement

<expr>

XPath Query

uses of throw
```
//src:throw
```

Example

throw new IOException("error reading file");

<throw>throw <expr><operator>new</operator> <call><name>IOException</name><argument_list>(<argument><expr><literal type="string">"error reading file"</literal></expr></argument>)</argument_list></call></expr>;</throw>

throws

Element

<throws>

Subelements

<name>
<argument>

XPath Queries

uses of throws
```
//src:throws
```
functions with a throws specification
```
//src:function[src:throws]
```

Examples

public void readFile(String filename) throws IOException {
}

<function><type><specifier>public</specifier> <name>void</name></type> <name>readFile</name><parameter_list>(<parameter><decl><type><name>String</name></type> <name>filename</name></decl></parameter>)</parameter_list> <throws>throws <argument><expr><name>IOException</name></expr></argument></throws> <block>{<block_content>
</block_content>}</block></function>

public MyOtherType foo() throws MyExceptionType throws MyExceptionType2 {
}

<function><type><specifier>public</specifier> <name>MyOtherType</name></type> <name>foo</name><parameter_list>()</parameter_list> <throws>throws <argument><expr><name>MyExceptionType</name> <throws>throws <argument><expr><name>MyExceptionType2</name> <block>{
}</block></expr></argument></throws></expr></argument></throws></function>

public MyOtherType foo() throws MyExceptionType, MyExceptionType2 {
}

<function><type><specifier>public</specifier> <name>MyOtherType</name></type> <name>foo</name><parameter_list>()</parameter_list> <throws>throws <argument><expr><name>MyExceptionType</name></expr></argument>, <argument><expr><name>MyExceptionType2</name></expr></argument></throws> <block>{<block_content>
</block_content>}</block></function>

throws MyExceptionType, MyExceptionType2

<throws>throws <argument><expr><name>MyExceptionType</name></expr></argument>, <argument><expr><name>MyExceptionType2</name></expr></argument></throws>

try

Element

<try>

Subelements

<init>
<block>
<catch>
<finally>

XPath Queries

try blocks
```
//src:try
```
try blocks with a resource list
```
//src:try[src:init]
```
try blocks with only a finally block
```
//src:try[src:finally][not(src:catch)]
```
try blocks with a catch and a finally block
```
//src:try[src:finally][src:catch]
```

Examples

try {

} finally {
	
}

<try>try <block>{<block_content>

</block_content>}</block> <finally>finally <block>{<block_content>
	
</block_content>}</block></finally></try>

try (BufferedReader br = new BufferedReader(new FileReader(path))) {
	return br.readLine();
}

<try>try <init>(<decl><type><name>BufferedReader</name></type> <name>br</name> <init>= <expr><operator>new</operator> <call><name>BufferedReader</name><argument_list>(<argument><expr><operator>new</operator> <call><name>FileReader</name><argument_list>(<argument><expr><name>path</name></expr></argument>)</argument_list></call></expr></argument>)</argument_list></call></expr></init></decl>)</init> <block>{<block_content>
	<return>return <expr><call><name><name>br</name><operator>.</operator><name>readLine</name></name><argument_list>()</argument_list></call></expr>;</return>
</block_content>}</block></try>

try {

} catch(Exception varName) {
	
}

<try>try <block>{<block_content>

</block_content>}</block> <catch>catch<parameter_list>(<parameter><decl><type><name>Exception</name></type> <name>varName</name></decl></parameter>)</parameter_list> <block>{<block_content>
	
</block_content>}</block></catch></try>

finally

Element

<finally>

Subelement

<block>

XPath Query

finally blocks
```
//src:finally
```

Example

try {

} catch (Exception e) {

} finally {
	
}

<try>try <block>{<block_content>

</block_content>}</block> <catch>catch <parameter_list>(<parameter><decl><type><name>Exception</name></type> <name>e</name></decl></parameter>)</parameter_list> <block>{<block_content>

</block_content>}</block></catch> <finally>finally <block>{<block_content>
	
</block_content>}</block></finally></try>

generic class definition

Element

<class>

Subelements

<name>
<parameter_list>
<block>

XPath Query

generic classes

//src:class[src:name/src:parameter_list]

Example

class Box<T> {
}

<class>class <name><name>Box</name><parameter_list>&lt;<parameter><name>T</name></parameter>&gt;</parameter_list></name> <block>{
}</block></class>

catch

Element

<catch>

Subelements

<parameter_list>
<block>

XPath Query

catch blocks
```
//src:catch
```

Examples

try {

} catch (Exception e) {

}

<try>try <block>{<block_content>

</block_content>}</block> <catch>catch <parameter_list>(<parameter><decl><type><name>Exception</name></type> <name>e</name></decl></parameter>)</parameter_list> <block>{<block_content>

</block_content>}</block></catch></try>

try { 
} catch(Exception varName) {

} catch(Exception2 varName) {

}

<try>try <block>{<block_content> 
</block_content>}</block> <catch>catch<parameter_list>(<parameter><decl><type><name>Exception</name></type> <name>varName</name></decl></parameter>)</parameter_list> <block>{<block_content>

</block_content>}</block></catch> <catch>catch<parameter_list>(<parameter><decl><type><name>Exception2</name></type> <name>varName</name></decl></parameter>)</parameter_list> <block>{<block_content>

</block_content>}</block></catch></try>

try {

} catch(Exception | Exception2 | Exception3 | Exception4 varName) {
	
}

<try>try <block>{<block_content>

</block_content>}</block> <catch>catch<parameter_list>(<parameter><decl><type><name>Exception</name></type> | <type><name>Exception2</name></type> | <type><name>Exception3</name></type> | <type><name>Exception4</name></type> <name>varName</name></decl></parameter>)</parameter_list> <block>{<block_content>
	
</block_content>}</block></catch></try>

generic variable declaration

Element

<decl_stmt>

Subelement

<decl>

XPath Query

generic types used in variable declarations

//src:decl[src:type/src:name/src:argument_list]

Examples

Box<Integer> integerBox;

<decl_stmt><decl><type><name><name>Box</name><argument_list type="generic">&lt;<argument><name>Integer</name></argument>&gt;</argument_list></name></type> <name>integerBox</name></decl>;</decl_stmt>

Box<Integer> integerBox = new Box<>();

<decl_stmt><decl><type><name><name>Box</name><argument_list type="generic">&lt;<argument><name>Integer</name></argument>&gt;</argument_list></name></type> <name>integerBox</name> <init>= <expr><operator>new</operator> <call><name><name>Box</name><argument_list type="generic">&lt;&gt;</argument_list></name><argument_list>()</argument_list></call></expr></init></decl>;</decl_stmt>

generic method definition

Element

<function>

Subelements

<name>
<parameter_list type="generic">
<block>

XPath Query

generic methods

//src:function[src:type/src:argument_list]

Example

public <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
}

<function><type><specifier>public</specifier> <parameter_list type="generic">&lt;<parameter><name>K</name></parameter>, <parameter><name>V</name></parameter>&gt;</parameter_list> <name>boolean</name></type> <name>compare</name><parameter_list>(<parameter><decl><type><name><name>Pair</name><argument_list type="generic">&lt;<argument><name>K</name></argument>, <argument><name>V</name></argument>&gt;</argument_list></name></type> <name>p1</name></decl></parameter>, <parameter><decl><type><name><name>Pair</name><argument_list type="generic">&lt;<argument><name>K</name></argument>, <argument><name>V</name></argument>&gt;</argument_list></name></type> <name>p2</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>

generic parameter

Element

<extends>

Subelement

<name>

XPath Queries

bound generic parameters
```
//src:argument[src:extends]
```

classes with a bound generic parameter

//src:class[src:name/src:parameter_list/src:parameter/src:extends]

methods with a bound generic parameter

//src:function[src:type/src:argument_list/src:argument/src:extends]

functions with a generic wildcard parameter that has an upper bound

//src:function[src:parameter_list/src:parameter/src:decl/src:type/src:name/src:argument_list/src:argument[src:name='?'][src:extends]]

functions with a generic wildcard parameter that is unbound

//src:function[src:parameter_list/src:parameter/src:decl/src:type/src:name/src:argument_list/src:argument[src:name='?'][not(src:extends)][not(src:super)]]

functions with a generic wildcard parameter that has a lower bound

//src:function[src:parameter_list/src:parameter/src:decl/src:type/src:name/src:argument_list/src:argument[src:name='?'][src:super]]

Examples

public <U extends Number> void inspect(U u) {
}

<function><type><specifier>public</specifier> <parameter_list type="generic">&lt;<parameter><name>U</name> <extends>extends <name>Number</name></extends></parameter>&gt;</parameter_list> <name>void</name></type> <name>inspect</name><parameter_list>(<parameter><decl><type><name>U</name></type> <name>u</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>

<T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
}

<function><type><parameter_list type="generic">&lt;<parameter><name>T</name> <extends>extends <name><name>Comparable</name><argument_list type="generic">&lt;<argument><name>T</name></argument>&gt;</argument_list></name></extends></parameter>&gt;</parameter_list> <name>int</name></type> <name>countGreaterThan</name><parameter_list>(<parameter><decl><type><name><name>T</name><index>[]</index></name></type> <name>anArray</name></decl></parameter>, <parameter><decl><type><name>T</name></type> <name>elem</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>

<T extends Foo & Bar> void doSomething(T input) {
}

<function><type><parameter_list type="generic">&lt;<parameter><name>T</name> <extends>extends <name>Foo</name></extends> <operator>&amp;</operator> <name>Bar</name></parameter>&gt;</parameter_list> <name>void</name></type> <name>doSomething</name><parameter_list>(<parameter><decl><type><name>T</name></type> <name>input</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>

upper bound wildcard

public static void process(List<? extends Foo> list) {
}

<function><type><specifier>public</specifier> <specifier>static</specifier> <name>void</name></type> <name>process</name><parameter_list>(<parameter><decl><type><name><name>List</name><argument_list type="generic">&lt;<argument><name>?</name> <extends>extends <name>Foo</name></extends></argument>&gt;</argument_list></name></type> <name>list</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>

unbound wildcard

void printList(List<?> list) {
}

<function><type><name>void</name></type> <name>printList</name><parameter_list>(<parameter><decl><type><name><name>List</name><argument_list type="generic">&lt;<argument><name>?</name></argument>&gt;</argument_list></name></type> <name>list</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>

lower bound wildcard

void addNumbers(List<? super Integer> list) {
}

<function><type><name>void</name></type> <name>addNumbers</name><parameter_list>(<parameter><decl><type><name><name>List</name><argument_list type="generic">&lt;<argument><name>?</name> <super>super <name>Integer</name></super></argument>&gt;</argument_list></name></type> <name>list</name></decl></parameter>)</parameter_list> <block>{<block_content>
</block_content>}</block></function>