Java srcML

Language Element Elements Subelements
FIXME: Not sorted!
Variable Declaration And Initialization <decl_stmt> <decl>, <init>
Function Call <call> <name>, <argument_list>, <argument>
break <break>
Block <block>
continue <continue>
do while Statement <do> <block>, <condition>, <while>
for Statement <for> <init>, <condition>, <incr>, <block>
Label Statement <label> <name>
if <if> <else>, <elseif>, <condition>, <block>, <then>
Empty Statement <empty_stmt>
return <return>
switch Statements <switch> <case>, <condition>, <block>
case Statements <case> <expr>
while Statement <while> <condition>, <block>
Conditional Operator <op:operator>
Class Definition <class> <name>, <block>
Method Definition <function> <name>, <type>, <block>, <parameter_list>, <param>
abstract <specifier>
catch <catch> <parameter_list>, <param>, <block>
default <default>, <specifier>
extends <extends> <name>
final <specifier>
finally <finally> <block>
implements <implements> <name>
import <import> <name>
interface <class type="interface"> <name>, <block>
native <specifier>
package <package> <name>
private <specifier>
protected <specifier>
public <specifier>
static <specifier> <block>
super <name>
synchronized <specifier>, <synchronized>
throw <throw> <expt>
throws <throws> <argument>
transient <specifier>
try <try> <init>, <block>, <catch>, <finally>
volatile <specifier>
Annotation Definition <class type="interface">
Annotation Use <annotation> <name>, <argument_list>, <argument>
enum Definition <enum> <block>, <name>
Lambda Functions <lambda> <block>, <expr>, <parameter_list>, <param>
this <name>
Anonymous Class <class> <super>, <block>
Generic Class Definition <class> <block>, <name>, <argument_list>, <argument>
Generic Variable Declaration <decl_stmt> <decl>
Generic Method Definition <function> <name>, <argument_list>, <argument>, <parameter_list>, <param>, <block>
Bound Generic Parameter <extends> <name>
Wildcard <extends> <name>
Method Reference <name>
assert <assert> <expr>
strictfp <specifier>
Constructor <Constructor> <name>, <parameter_list>, <param>, <block>
Constructor Declaration <Constructor_decl> <name>, <parameter_list>, <param>
Receiver Parameter <name>
Cast <expr>
Operators
operators <op:operator>

Variable Declaration And Initialization

Element

  • <decl_stmt>

SubElements

  • <decl>
  • <init>

Examples

1

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

2

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

3

String str = new String(data);

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

4

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

5

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

Function Call

Element

  • <call>

SubElements

  • <name>
  • <argument_list>
  • <argument>

Example

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

break

Element

  • <break>

Examples

1

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(<init>;</init><condition>;</condition><incr/>) <block>{
    <expr_stmt><expr><call><name>printf_s</name><argument_list>( <argument><expr><lit:literal type="string">&quot;\nPress any key, Q to quit: &quot;</lit: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><lit:literal type="string">&quot;%c&quot;</lit:literal></expr></argument>, <argument><expr><op:operator>&amp;</op:operator><name>c</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    <if>if <condition>(<expr><name>c</name> <op:operator>==</op:operator> <lit:literal type="char">'Q'</lit:literal></expr>)</condition><then>
        <break>break;</break></then></if>
}</block></for>

2

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

Block

Element

  • <block>

Example

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

continue

Element

  • <continue>

Examples

1

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

2

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

do while Statement

Element

  • <do>

SubElements

  • <block>
  • <condition>
  • <while>

Examples

1

do {
    y = f( x );
    x--;
} while ( x > 0 );
<do>do <block>{
    <expr_stmt><expr><name>y</name> <op:operator>=</op: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><op:operator>--</op:operator></expr>;</expr_stmt>
}</block> while <condition>( <expr><name>x</name> <op:operator>&gt;</op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition>;</do>

2

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

<do>do <expr_stmt><expr><name>x</name><op:operator>--</op:operator></expr>;</expr_stmt> while <condition>( <expr><name>x</name> <op:operator>&gt;</op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition>;</do>

for Statement

Element

  • <for>

SubElements

  • <init>
  • <condition>
  • <incr>
  • <block>

Examples

1

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

2

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

3

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

4

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

Label Statement

Element

  • <label>

SubElement

  • <name>

Example

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

if

Element

  • <if>

SubElements

  • <else>
  • <elseif>
  • <condition>
  • <block>
  • <then>

Examples

1

if(x > 5)
    y+=4
<if>if<condition>(<expr><name>x</name> <op:operator>&gt;</op:operator> <lit:literal type="number">5</lit:literal></expr>)</condition><then>
    <expr_stmt><expr><name>y</name><op:operator>+=</op:operator><lit:literal type="number">4</lit:literal></expr></expr_stmt></then></if>

2

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

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

3

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

4

if ( i > 0 )           /* Without braces */
    if ( j > i )
        x = j;
    else
        x = i;
<if>if <condition>( <expr><name>i</name> <op:operator>&gt;</op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then>           <comment type="block">/* Without braces */</comment>
    <if>if <condition>( <expr><name>j</name> <op:operator>&gt;</op:operator> <name>i</name></expr> )</condition><then>
        <expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>j</name></expr>;</expr_stmt></then>
    <else>else
        <expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>i</name></expr>;</expr_stmt></else></if></then></if>

5

if ( i > 0 ) 
{                      /* With braces */
    if ( j > i )
        x = j;
}
else
    x = i;
<if>if <condition>( <expr><name>i</name> <op:operator>&gt;</op:operator> <lit:literal type="number">0</lit:literal></expr> )</condition><then> 
<block>{                      <comment type="block">/* With braces */</comment>
    <if>if <condition>( <expr><name>j</name> <op:operator>&gt;</op:operator> <name>i</name></expr> )</condition><then>
        <expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>j</name></expr>;</expr_stmt></then></if>
}</block></then>
<else>else
    <expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <name>i</name></expr>;</expr_stmt></else></if>

6

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

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

Empty Statement

Element

  • <empty_stmt>

Example

;
<empty_stmt>;</empty_stmt>

return

Element

  • <return>

Examples

1

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

2

return;
<return>return;</return>

switch Statements

Element

  • <switch>

SubElements

  • <case>
  • <condition>
  • <block>

Examples

1

switch( c ) 
{
    case 'A':
        capa++;
    case 'a':
        lettera++;
    default :
        total++;
}
<switch>switch<condition>( <expr><name>c</name></expr> )</condition> 
<block>{
    <case>case <expr><lit:literal type="char">'A'</lit:literal></expr>:
        <expr_stmt><expr><name>capa</name><op:operator>++</op:operator></expr>;</expr_stmt>
    </case><case>case <expr><lit:literal type="char">'a'</lit:literal></expr>:
        <expr_stmt><expr><name>lettera</name><op:operator>++</op:operator></expr>;</expr_stmt>
    </case><default>default :
        <expr_stmt><expr><name>total</name><op:operator>++</op:operator></expr>;</expr_stmt>
</default>}</block></switch>

2

switch( i ) 
{
    case -1:
        n++;
        break;
    case 0 :
        z++;
        break;
    case 1 :
        p++;
        break;
}
<switch>switch<condition>( <expr><name>i</name></expr> )</condition> 
<block>{
    <case>case <expr><op:operator>-</op:operator><lit:literal type="number">1</lit:literal></expr>:
        <expr_stmt><expr><name>n</name><op:operator>++</op:operator></expr>;</expr_stmt>
        <break>break;</break>
    </case><case>case <expr><lit:literal type="number">0</lit:literal></expr> :
        <expr_stmt><expr><name>z</name><op:operator>++</op:operator></expr>;</expr_stmt>
        <break>break;</break>
    </case><case>case <expr><lit:literal type="number">1</lit:literal></expr> :
        <expr_stmt><expr><name>p</name><op:operator>++</op:operator></expr>;</expr_stmt>
        <break>break;</break>
</case>}</block></switch>

case Statements

Element

  • <case>

SubElement

  • <expr>

Example

case THREE:
<case>case <expr><name>THREE</name></expr>:</case>

while Statement

Element

  • <while>

SubElements

  • <condition>
  • <block>

Example

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

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

Conditional Operator

Element

  • <op:operator>
    • Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
      • --operator

Example

x ? "a" : "b";
<expr_stmt><expr><name>x</name> <op:operator>?</op:operator> <lit:literal type="string">&quot;a&quot;</lit:literal> <op:operator>:</op:operator> <lit:literal type="string">&quot;b&quot;</lit:literal></expr>;</expr_stmt>

Class Definition

Element

  • <class>

SubElements

  • <name>
  • <block>

Example

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

Method Definition

Element

  • <function>

SubElements

  • <name>
  • <type>
  • <block>
  • <parameter_list>
  • <param>

Examples

1

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

2

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

abstract

Element

  • <specifier>

Examples

1

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

2

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

catch

Element

  • <catch>

SubElements

  • <parameter_list>
  • <param>
  • <block>

Examples

1

try {

} catch (Exception e){

} 

<try>try <block>{

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

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

2

try { 
} catch(Exception varName) {

} catch(Exception2 varName) {

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

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

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

3

try {

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

}
<try>try <block>{

}</block> <catch>catch<parameter_list>(<param><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></param>)</parameter_list> <block>{

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

default

Elements

  • <default>
  • <specifier>

Examples

Default Case

default:
<default>default:</default>

Default Attribute Property Value

   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><lit:literal type="number">1</lit:literal></expr></init></default>;</function_decl>
   <function_decl><type><name>String</name></type> <name>lastModified</name><parameter_list>()</parameter_list> <default>default <init><expr><lit:literal type="string">&quot;N/A&quot;</lit:literal></expr></init></default>;</function_decl>

Default Method Implementation

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

extends

Element

  • <extends>

SubElement

  • <name>

Example

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

final

Element

  • <specifier>

Examples

1

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

2

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></function>

3

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

finally

Element

  • <finally>

SubElement

  • <block>

Example

try {

} catch (Exception e) {

} finally {

} 
<try>try <block>{

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

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

}</block></finally></try> 

implements

Element

  • <implements>

SubElement

  • <name>

Example

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

import

Element

  • <import>

SubElement

  • <name>

Example

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

interface

Element

  • <class type="interface">

SubElements

  • <name>
  • <block>

Example

public interface IPolygon
{
    public float getArea();
    public int getNumberOfSides();
    public int getCircumference();
}
<class type="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></class>

native

Element

  • <specifier>

Example

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

package

Element

  • <package>

SubElement

  • <name>

Example

package com.mycompany;

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

private

Element

  • <specifier>

Examples

1

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

2

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

3

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

protected

Element

  • <specifier>

Examples

1

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

2

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

3

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

public

Element

  • <specifier>

Examples

1

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

2

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

3

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

static

Element

  • <specifier>

SubElement

  • <block>

Examples

1

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><lit:literal type="number">100</lit:literal></expr></init></decl>;</decl_stmt>
<decl_stmt><decl><type><specifier>static</specifier> <name>int</name></type> <name>_numObjects</name> <init>= <expr><lit:literal type="number">0</lit:literal></expr></init></decl>;</decl_stmt>

2

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

3

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

4

class Cls {
    static {

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

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

super

Element

  • <name>

Example

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

synchronized

Elements

  • <specifier>
  • <synchronized>

Examples

1

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></function>

2

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

throw

Element

  • <throw>

SubElement

  • <expt>

Example

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

throws

Element

  • <throws>

SubElement

  • <argument>

Examples

1

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

2

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 <name>MyExceptionType2</name></expr></argument></throws> <block>{ }</block></function>

3

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></function>

transient

Element

  • <specifier>

Example

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

try

Element

  • <try>

SubElements

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

Examples

1

try {

} finally {

} 
<try>try <block>{

}</block> <finally>finally <block>{

}</block></finally></try> 

2

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><op:operator>new</op:operator> <call><name>BufferedReader</name><argument_list>(<argument><expr><op:operator>new</op: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>{
    <return>return <expr><call><name><name>br</name><op:operator>.</op:operator><name>readLine</name></name><argument_list>()</argument_list></call></expr>;</return>
}</block></try>

3

try {

} catch(Exception varName) {

}
<try>try <block>{

}</block> <catch>catch<parameter_list>(<param><decl><type><name>Exception</name></type> <name>varName</name></decl></param>)</parameter_list> <block>{

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

volatile

Element

  • <specifier>

Example

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

Annotation Definition

Element

  • <class type="interface">

Example

@interface ClassPreambleAnnotation {
}
<class type="interface"><annotation>@</annotation>interface <expr_stmt><expr><name>ClassPreambleAnnotation</name> <block>{
}</block></expr></expr_stmt></class>

Annotation Use

Element

  • <annotation>

SubElements

  • <name>
  • <argument_list>
  • <argument>

Example

@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> <op:operator>=</op:operator> <lit:literal type="string">&quot;Benjamin Franklin&quot;</lit:literal></expr></argument>, <argument><expr><name>date</name> <op:operator>=</op:operator> <lit:literal type="string">&quot;3/27/2003&quot;</lit:literal></expr></argument>)</argument_list></annotation>
<annotation>@<name>Inventor</name><argument_list>(<argument><expr><lit:literal type="string">&quot;Benjamin Franklin&quot;</lit:literal></expr></argument>)</argument_list></annotation>
class <name>Cls</name> <block>{
}</block></class>

enum Definition

Element

  • <enum>

SubElements

  • <block>
  • <name>

Example

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

Lambda Functions

Element

  • <lambda>

SubElements

  • <block>
  • <expr>
  • <parameter_list>
  • <param>

Examples

1

(a, b) -> a - b;
<expr_stmt><expr><lambda><parameter_list>(<param><decl><name>a</name></decl></param>, <param><decl><name>b</name></decl></param>)</parameter_list> <op:operator>-&gt;</op:operator> <expr><name>a</name> <op:operator>-</op:operator> <name>b</name></expr></lambda></expr>;</expr_stmt>

2

(Person p) -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25
<expr_stmt><expr><lambda><parameter_list>(<param><decl><type><name>Person</name></type> <name>p</name></decl></param>)</parameter_list> <op:operator>-&gt;</op:operator> <expr><call><name><name>p</name><op:operator>.</op:operator><name>getGender</name></name><argument_list>()</argument_list></call> <op:operator>==</op:operator> <name><name>Person</name><op:operator>.</op:operator><name>Sex</name><op:operator>.</op:operator><name>MALE</name></name>
        <op:operator>&amp;&amp;</op:operator> <call><name><name>p</name><op:operator>.</op:operator><name>getAge</name></name><argument_list>()</argument_list></call> <op:operator>&gt;=</op:operator> <lit:literal type="number">18</lit:literal>
        <op:operator>&amp;&amp;</op:operator> <call><name><name>p</name><op:operator>.</op:operator><name>getAge</name></name><argument_list>()</argument_list></call> <op:operator>&lt;=</op:operator> <lit:literal type="number">25</lit:literal></expr></lambda></expr></expr_stmt>

3

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

4

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

5

() -> 42
<expr_stmt><expr><lambda><parameter_list>()</parameter_list> <op:operator>-&gt;</op:operator> <expr><lit:literal type="number">42</lit:literal></expr></lambda></expr></expr_stmt>

this

Element

  • <name>

Examples

1

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

2

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

Anonymous Class

Element

  • <class>

SubElements

  • <super>
  • <block>

Example

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><op:operator>new</op: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><lit:literal type="string">&quot;mundo&quot;</lit:literal></expr></init></decl>;</decl_stmt>
    <function><type><specifier>public</specifier> <name>void</name></type> <name>greet</name><parameter_list>()</parameter_list> <block>{
        <expr_stmt><expr><call><name>greetSomeone</name><argument_list>(<argument><expr><lit:literal type="string">&quot;mundo&quot;</lit:literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    }</block></function>
    <function><type><specifier>public</specifier> <name>void</name></type> <name>greetSomeone</name><parameter_list>(<param><decl><type><name>String</name></type> <name>someone</name></decl></param>)</parameter_list> <block>{
        <expr_stmt><expr><name>name</name> <op:operator>=</op:operator> <name>someone</name></expr>;</expr_stmt>
        <expr_stmt><expr><call><name><name>System</name><op:operator>.</op:operator><name>out</name><op:operator>.</op:operator><name>println</name></name><argument_list>(<argument><expr><lit:literal type="string">&quot;Hola, &quot;</lit:literal> <op:operator>+</op:operator> <name>name</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>
    }</block></function>
}</block></class></expr></init></decl>;</decl_stmt>

Generic Class Definition

Element

  • <class>

SubElements

  • <block>
  • <name>
  • <argument_list>
  • <argument>

Example

class Box<T> {
}
<class>class <name><name>Box</name><argument_list>&lt;<argument><name>T</name></argument>&gt;</argument_list></name> <block>{
}</block></class>

Generic Variable Declaration

Element

  • <decl_stmt>

SubElement

  • <decl>

Examples

1

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

2

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

Generic Method Definition

Element

  • <function>

SubElements

  • <name>
  • <argument_list>
  • <argument>
  • <parameter_list>
  • <param>
  • <block>

Example

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

Bound Generic Parameter

Element

  • <extends>

SubElement

  • <name>

Examples

1

public <U extends Number> void inspect(U u){
}
<function><type><specifier>public</specifier> <argument_list>&lt;<argument><name>U</name> <extends>extends <name>Number</name></extends></argument>&gt;</argument_list> <name>void</name></type> <name>inspect</name><parameter_list>(<param><decl><type><name>U</name></type> <name>u</name></decl></param>)</parameter_list><block>{
}</block></function>

2

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

3

<T extends Foo & Bar> void doSomething(T input) {
}
<function><type><argument_list>&lt;<argument><name>T</name> <extends>extends <name>Foo</name></extends> <op:operator>&amp;</op:operator> <name>Bar</name></argument>&gt;</argument_list> <name>void</name></type> <name>doSomething</name><parameter_list>(<param><decl><type><name>T</name></type> <name>input</name></decl></param>)</parameter_list> <block>{
}</block></function>

Wildcard

Element

  • <extends>

SubElement

  • <name>

Examples

Upper Bound Wildcard

public static void process(List<? extends Foo> list)
<decl_stmt><decl><type><specifier>public</specifier> <specifier>static</specifier> <name>void</name></type> <name>process</name><argument_list>(<argument><expr><name><name>List</name><argument_list>&lt;<argument><name>?</name> <extends>extends <name>Foo</name></extends></argument>&gt;</argument_list></name> <name>list</name></expr></argument>)</argument_list></decl></decl_stmt>

Unbound Wildcard

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

Lower Bound Wildcard

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

Method Reference

Element

  • <name>

Examples

1

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

2

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

3

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

4

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

assert

Element

  • <assert>

SubElement

  • <expr>

Example

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

strictfp

Element

  • <specifier>

Example

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

Constructor

Element

  • <Constructor>

SubElements

  • <name>
  • <parameter_list>
  • <param>
  • <block>

Example

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

Constructor Declaration

Element

  • <Constructor_decl>

SubElements

  • <name>
  • <parameter_list>
  • <param>

Example

class MyType {
    MyType();
}
<class>class <name>MyType</name> <block>{
    <constructor_decl><name>MyType</name><parameter_list>()</parameter_list>;</constructor_decl>
}</block></class>

Receiver Parameter

Element

  • <name>

Example

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

Cast

Element

  • <expr>

Example

(Cls)x;
<expr_stmt><expr><op:operator>(</op:operator><name>Cls</name><op:operator>)</op:operator><name>x</name></expr>;</expr_stmt>

Operators

Name Operator srcML
Pre Increment ++ <op:operator>++</op:operator>
Post Increment ++ <op:operator>++</op:operator>
Pre Decrement -- <op:operator>--</op:operator>
Post Decrement -- <op:operator>--</op:operator>
Unary Minus - <op:operator>-</op:operator>
Bitwise Not ~ <op:operator>~</op:operator>
Logical Not ! <op:operator>!</op:operator>
Multiplication * <op:operator>*</op:operator>
Division / <op:operator>/</op:operator>
Modulus % <op:operator>%</op:operator>
Addition + <op:operator>+</op:operator>
Subtraction - <op:operator>-</op:operator>
Left Shift << <op:operator>&lt;&lt;</op:operator>
Right Shift >> <op:operator>&gt;&gt;</op:operator>
Less Then < <op:operator>&lt;</op:operator>
Greater Then > <op:operator>&gt;</op:operator>
Less Then or Equal To <= <op:operator>&lt;=</op:operator>
Greater Then or Equal To >= <op:operator>&gt;=</op:operator>
Equals == <op:operator>==</op:operator>
Not Equal != <op:operator>!=</op:operator>
Bitwise And & <op:operator>&amp;</op:operator>
Bitwise XOr ^ <op:operator>^</op:operator>
Bitwise Or | <op:operator>|</op:operator>
Logical And && <op:operator>&amp;&amp;</op:operator>
Logical Or || <op:operator>||</op:operator>
Assignment = <op:operator>=</op:operator>
Multiply Assign *= <op:operator>*=</op:operator>
Divide Assign /= <op:operator>/=</op:operator>
Modulus Assign %= <op:operator>%=</op:operator>
Add Assign += <op:operator>+=</op:operator>
Subtract Assign -= <op:operator>-=</op:operator>
Signed Left Shift Assign <<= <op:operator>&lt;&lt;=</op:operator>
Signed Right Shift Assign >>= <op:operator>&gt;&gt;=</op:operator>
Bitwise And Assign &= <op:operator>&amp;=</op:operator>
Bitwise XOr Assign ^= <op:operator>^=</op:operator>
Bitwise Or Assign |= <op:operator>|=</op:operator>
Unsigned Right Shift >>> <op:operator>&gt;&gt;&gt;</op:operator>
Unsigned Right Shift Assign >>>= <op:operator>&gt;&gt;&gt;</op:operator>
instanceof instanceof <op:operator>instanceof</op:operator>
new new <op:operator>new</op:operator>

NOTE: Operator mark up within srcML is not enabled by default and srcML must be run with the --operator command line option to enable it.