C srcML

Language Element Elements Subelements
FIXME: Not sorted!
Array Access <name> <name>, <index>
Array Declaration <decl> <name>, <index>
Array Declaration Initialization <init> <block>
auto <specifier>
Bitfield <range> <expr>, <lit:literal>
Block <block>
break Statement <break>
case Statement <case> <expr>
Cast <op:operator> <name>
const <specifier>
continue Statement <continue>
default Statement <default>
Dereference Member Access <expr> <name>, <op:operator>
do while Statement <do> <block>, <condition>
Empty Statement <empty_stmt>
enum Declaration <enum> <name>, <block>
extern Block <extern> <lit:literal>, <block>
extern Specifier <specifier> <lit:literal>, <decl_stmt>, <function_stmt>, <block>
for Statement <for> <init>, <condition>, <incr>, <block>
Function Call <call> <name>, <argument_list>, <argument>
Function Declaration <function_decl> <name>, <parameter_list>, <param>
Function Definition <function> <name>, <parameter_list>, <param>
goto Statement <goto> <name>
if Statement <if> <condition>, <then>, <else>, <elseif>
inline <specifier>
Label Statement <label> <name>
Member Access <expr> <name>, <op:operator>
Pointer Declaration <type:modifier>
register <name>
restrict <specifier>
return Statement <return>
sizeof <sizeof> <argument_list>, <argument>
static <specifier>
struct Declaration <struct_decl> <name>
struct Definition <struct> <name>, <block>
struct Variable Initialization <decl_stmt> <decl>, <init>, <block>
switch Statements <switch> <case>, <condition>, <block>
typedef <typedef> <type>, <name>, <function_decl>
union Declaration <union_decl> <name>, <block>
union Definition <union> <name>, <block>
Variable Declaration <decl> <init>
Variable Declaration Statement <decl_stmt>
volatile <specifier>
while Statement <while> <condition>, <block>
_Alignas <alignas> <argument_list>, <argument>
_Alignof <alignof> <argument_list>, <argument>
_Atomic <atomic> <argument_list>, <argument>
_Generic <generic_selection> <selector>, <association_list>, <association>
_Noreturn <name>
_Static_assert <assert type="static"> <argument_list>, <argument>
_Thread_local <name>
Operators
operators <op:operator>

Array Access

Element

  • <name>

SubElements

  • <name>
  • <index>

Example

a = x[5];
val = matrix[x][y];

<expr_stmt><expr><name>a</name> <op:operator>=</op:operator> <name><name>x</name><index>[<expr><lit:literal type="number">5</lit:literal></expr>]</index></name></expr>;</expr_stmt>
<expr_stmt><expr><name>val</name> <op:operator>=</op:operator> <name><name>matrix</name><index>[<expr><name>x</name></expr>]</index><index>[<expr><name>y</name></expr>]</index></name></expr>;</expr_stmt>

Array Declaration

Element

  • <decl>

SubElements

  • <name>
  • <index>

Examples

1

char A[2];

<decl_stmt><decl><type><name>char</name></type> <name><name>A</name><index>[<expr><lit:literal type="number">2</lit:literal></expr>]</index></name></decl>;</decl_stmt>

2

float matrix[10][15];

<decl_stmt><decl><type><name>float</name></type> <name><name>matrix</name><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index><index>[<expr><lit:literal type="number">15</lit:literal></expr>]</index></name></decl>;</decl_stmt>

3

struct {
    float x, y;
} complex[100];

<struct>struct <block>{
    <decl_stmt><decl><type><name>float</name></type> <name>x</name></decl><op:operator>,</op:operator> <decl><type ref="prev"/><name>y</name></decl>;</decl_stmt>
}</block> <decl><name><name>complex</name><index>[<expr><lit:literal type="number">100</lit:literal></expr>]</index></name></decl>;</struct>

4

extern char *name[];

<decl_stmt><decl><type><specifier>extern</specifier> <name>char</name> <type:modifier>*</type:modifier></type><name><name>name</name><index>[]</index></name></decl>;</decl_stmt>

Array Declaration Initialization

Element

  • <init>

SubElement

  • <block>

Examples

1

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

<decl_stmt><decl><type><name>int</name></type> <name><name>myArray</name><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index></name> <init>= <expr><block>{ <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr>, <expr><lit:literal type="number">5</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>

2

int a[6] = { [4] = 29, [2] = 15 };

<decl_stmt><decl><type><name>int</name></type> <name><name>a</name><index>[<expr><lit:literal type="number">6</lit:literal></expr>]</index></name> <init>= <expr><block>{ <expr><index>[<expr><lit:literal type="number">4</lit:literal></expr>]</index> <op:operator>=</op:operator> <lit:literal type="number">29</lit:literal></expr>, <expr><index>[<expr><lit:literal type="number">2</lit:literal></expr>]</index> <op:operator>=</op:operator> <lit:literal type="number">15</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>

auto

Element

  • <specifier>

Example

auto int x;

<decl_stmt><decl><type><specifier>auto</specifier> <name>int</name></type> <name>x</name></decl>;</decl_stmt>

Bitfield

Element

  • <range>

SubElements

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

Example

struct mybitfields
{
    int a : 5;
} test;

<struct>struct <name>mybitfields</name>
<block>{
    <decl_stmt><decl><type><name>int</name></type> <name>a</name> <range>: <expr><lit:literal type="number">5</lit:literal></expr></range></decl>;</decl_stmt>
}</block> <decl><name>test</name></decl>;</struct>

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>

break Statement

Element

  • <break>

Example

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>

case Statement

Element

  • <case>

SubElement

  • <expr>

Example

case THREE:

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

Cast

Element

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

SubElement

  • <name>

Example

double x = 0.0;
int y = (int)x;


<decl_stmt><decl><type><name>double</name></type> <name>x</name> <init>= <expr><lit:literal type="number">0.0</lit:literal></expr></init></decl>;</decl_stmt>
<decl_stmt><decl><type><name>int</name></type> <name>y</name> <init>= <expr><op:operator>(</op:operator><name>int</name><op:operator>)</op:operator><name>x</name></expr></init></decl>;</decl_stmt>

const

Element

  • <specifier>

Examples

1

const int x;
const X y;

<decl_stmt><decl><type><specifier>const</specifier> <name>int</name></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><specifier>const</specifier> <name>X</name></type> <name>y</name></decl>;</decl_stmt>

2

int const x;
X const y;

<decl_stmt><decl><type><name>int</name> <specifier>const</specifier></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>X</name> <specifier>const</specifier></type> <name>y</name></decl>;</decl_stmt>

continue Statement

Element

  • <continue>

Example

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>

default Statement

Element

  • <default>

Example

default:

<default>default:</default>

Dereference Member Access

Element

  • <expr>

SubElements

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

Example

 t->tm_sec;

 <expr_stmt><expr><name><name>t</name><op:operator>-&gt;</op:operator><name>tm_sec</name></name></expr>;</expr_stmt>

do while Statement

Element

  • <do>

SubElements

  • <block>
  • <condition>

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>

Empty Statement

Element

  • <empty_stmt>

Example

;

<empty_stmt>;</empty_stmt>

enum Declaration

Element

  • <enum>

SubElements

  • <name>
  • <block>

Examples

1

enum DAY {
    sunday = 0,
    monday,
    tuesday,
    wednesday,
    thursday,
    friday,
    saturday,
};

<enum>enum <name>DAY</name> <block>{
    <decl><name>sunday</name> <init>= <expr><lit:literal type="number">0</lit:literal></expr></init></decl><op:operator>,</op:operator>
    <decl><name>monday</name></decl><op:operator>,</op:operator>
    <decl><name>tuesday</name></decl><op:operator>,</op:operator>
    <decl><name>wednesday</name></decl><op:operator>,</op:operator>
    <decl><name>thursday</name></decl><op:operator>,</op:operator>
    <decl><name>friday</name></decl><op:operator>,</op:operator>
    <decl><name>saturday</name></decl><op:operator>,</op:operator>
}</block>;</enum>

2

enum DAY;

<enum>enum <name>DAY</name>;</enum>

3

enum { yes, no } response;

<enum>enum <block>{ <decl><name>yes</name></decl><op:operator>,</op:operator> <decl><name>no</name></decl> }</block> <decl><name>response</name></decl>;</enum>

extern Block

Element

  • <extern>

SubElements

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

Example

Extern Block with Linkage Specifier

extern "C" { }

<extern>extern <lit:literal type="string">&quot;C&quot;</lit:literal> <block>{ }</block></extern>

extern Specifier

Element

  • <specifier>

SubElements

  • <lit:literal>
    • Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
      • --literal
  • <decl_stmt>
  • <function_stmt>
  • <block>

Examples

External Variable

extern int X;

<decl_stmt><decl><type><specifier>extern</specifier> <name>int</name></type> <name>X</name></decl>;</decl_stmt>

External Structure

extern struct Z X;

<decl_stmt><decl><type><specifier>extern</specifier> struct <name>Z</name></type> <name>X</name></decl>;</decl_stmt>

External Function

extern void foo();

<function_decl><type><specifier>extern</specifier> <name>void</name></type> <name>foo</name><parameter_list>()</parameter_list>;</function_decl>

External Function with Linkage Specifier

extern "C" void foo();

<extern>extern <lit:literal type="string">&quot;C&quot;</lit:literal> <function_decl><type><name>void</name></type> <name>foo</name><parameter_list>()</parameter_list>;</function_decl></extern>

Extern Structure with Linkage Specifier

extern "C" struct Z X;

<extern>extern <lit:literal type="string">&quot;C&quot;</lit:literal> <decl_stmt><decl><type>struct <name>Z</name></type> <name>X</name></decl>;</decl_stmt></extern>

Extern Variable with Linkage Specifier

extern "C" int X;

<extern>extern <lit:literal type="string">&quot;C&quot;</lit:literal> <decl_stmt><decl><type><name>int</name></type> <name>X</name></decl>;</decl_stmt></extern>

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>

Function Call

Element

  • <call>

SubElements

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

Example

foo(x, y, z);

<expr_stmt><expr><call><name>foo</name><argument_list>(<argument><expr><name>x</name></expr></argument>, <argument><expr><name>y</name></expr></argument>, <argument><expr><name>z</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>

Function Declaration

Element

  • <function_decl>

SubElements

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

Examples

1

struct STUDENT sortstu( STUDENT a, STUDENT b );
void print(STUDENT a);

<function_decl><type>struct <name>STUDENT</name></type> <name>sortstu</name><parameter_list>( <param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>, <param><decl><type><name>STUDENT</name></type> <name>b</name></decl></param> )</parameter_list>;</function_decl>
<function_decl><type><name>void</name></type> <name>print</name><parameter_list>(<param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>)</parameter_list>;</function_decl>

2

void foo (int a[]);

<function_decl><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name></type> <name><name>a</name><index>[]</index></name></decl></param>)</parameter_list>;</function_decl>

3

void foo (int* a);

<function_decl><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>a</name></decl></param>)</parameter_list>;</function_decl>

4

int add_multiple_values (int number, ...);

<function_decl><type><name>int</name></type> <name>add_multiple_values</name> <parameter_list>(<param><decl><type><name>int</name></type> <name>number</name></decl></param>, <param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list>;</function_decl>

5

int func(a, b, c)
   int a;
   int b;
   int c;
{ }

<function><type><name>int</name></type> <name>func</name><parameter_list>(<param><decl><type><name>a</name></type></decl></param>, <param><decl><type><name>b</name></type></decl></param>, <param><decl><type><name>c</name></type></decl></param>)</parameter_list>
   <decl_stmt><decl><type><name>int</name></type> <name>a</name></decl>;</decl_stmt>
   <decl_stmt><decl><type><name>int</name></type> <name>b</name></decl>;</decl_stmt>
   <decl_stmt><decl><type><name>int</name></type> <name>c</name></decl>;</decl_stmt>
<block>{ }</block></function>

Function Definition

Element

  • <function>

SubElements

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

Examples

1

struct STUDENT sortstu( STUDENT a, STUDENT b ) {
    struct STUDENT x;
    return x;
}

<function><type>struct <name>STUDENT</name></type> <name>sortstu</name><parameter_list>( <param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>, <param><decl><type><name>STUDENT</name></type> <name>b</name></decl></param> )</parameter_list> <block>{
    <decl_stmt><decl><type>struct <name>STUDENT</name></type> <name>x</name></decl>;</decl_stmt>
    <return>return <expr><name>x</name></expr>;</return>
}</block></function>

2

void print(STUDENT a) { }

<function><type><name>void</name></type> <name>print</name><parameter_list>(<param><decl><type><name>STUDENT</name></type> <name>a</name></decl></param>)</parameter_list> <block>{ }</block></function>

3

void foo (int a[]) { } 

<function><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name></type> <name><name>a</name><index>[]</index></name></decl></param>)</parameter_list> <block>{ }</block></function>

4

void foo (int* a) { }

<function><type><name>void</name></type> <name>foo</name> <parameter_list>(<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>a</name></decl></param>)</parameter_list> <block>{ }</block></function>

5

int add_multiple_values (int number, ...) { }

<function><type><name>int</name></type> <name>add_multiple_values</name> <parameter_list>(<param><decl><type><name>int</name></type> <name>number</name></decl></param>, <param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{ }</block></function>

goto Statement

Element

  • <goto>

SubElement

  • <name>

Example

goto stop;

<goto>goto <name>stop</name>;</goto>

if Statement

Element

  • <if>

SubElements

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

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>

inline

Element

  • <specifier>

Example

inline void swapValues(int* a,int* b);

<function_decl><type><specifier>inline</specifier> <name>void</name></type> <name>swapValues</name><parameter_list>(<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>a</name></decl></param>,<param><decl><type><name>int</name><type:modifier>*</type:modifier></type> <name>b</name></decl></param>)</parameter_list>;</function_decl>

Label Statement

Element

  • <label>

SubElement

  • <name>

Example

stop:

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

Member Access

Element

  • <expr>

SubElements

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

Example

t.tm_sec;

<expr_stmt><expr><name><name>t</name><op:operator>.</op:operator><name>tm_sec</name></name></expr>;</expr_stmt>

Pointer Declaration

Element

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

Examples

1

char *message;

<decl_stmt><decl><type><name>char</name> <type:modifier>*</type:modifier></type><name>message</name></decl>;</decl_stmt>

2

int *pointers[10];

<decl_stmt><decl><type><name>int</name> <type:modifier>*</type:modifier></type><name><name>pointers</name><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index></name></decl>;</decl_stmt>

3

int (*pointer)[10];

<expr_stmt><expr><call><name>int</name> <argument_list>(<argument><expr><op:operator>*</op:operator><name>pointer</name></expr></argument>)</argument_list></call><index>[<expr><lit:literal type="number">10</lit:literal></expr>]</index></expr>;</expr_stmt>

4

int const *x;

<decl_stmt><decl><type><name>int</name> <specifier>const</specifier> <type:modifier>*</type:modifier></type><name>x</name></decl>;</decl_stmt>

5

int(*X)(void);
int(*X)(int, float);
int(*X)(char const*,...);

<function_decl><type><name>int</name></type>(<type:modifier>*</type:modifier><name>X</name>)<parameter_list>(<param><decl><type><name>void</name></type></decl></param>)</parameter_list>;</function_decl>
<function_decl><type><name>int</name></type>(<type:modifier>*</type:modifier><name>X</name>)<parameter_list>(<param><decl><type><name>int</name></type></decl></param>, <param><decl><type><name>float</name></type></decl></param>)</parameter_list>;</function_decl>
<function_decl><type><name>int</name></type>(<type:modifier>*</type:modifier><name>X</name>)<parameter_list>(<param><decl><type><name>char</name> <specifier>const</specifier><type:modifier>*</type:modifier></type></decl></param>,<param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list>;</function_decl>

6

int volatile *const z = &some_object;

<decl_stmt><decl><type><name>int</name> <specifier>volatile</specifier> <type:modifier>*</type:modifier><specifier>const</specifier></type> <name>z</name> <init>= <expr><op:operator>&amp;</op:operator><name>some_object</name></expr></init></decl>;</decl_stmt>

7

int *const volatile w = &some_object;

<decl_stmt><decl><type><name>int</name> <type:modifier>*</type:modifier><specifier>const</specifier> <specifier>volatile</specifier></type> <name>w</name> <init>= <expr><op:operator>&amp;</op:operator><name>some_object</name></expr></init></decl>;</decl_stmt>

register

Element

  • <name>

Example

register int x;
register float y;

<decl_stmt><decl><type><name>register</name> <name>int</name></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><name>register</name> <name>float</name></type> <name>y</name></decl>;</decl_stmt>

restrict

Element

  • <specifier>

Example

restrict double* x;
restrict union Z* x;

<decl_stmt><decl><type><specifier>restrict</specifier> <name>double</name><type:modifier>*</type:modifier></type> <name>x</name></decl>;</decl_stmt>
<decl_stmt><decl><type><specifier>restrict</specifier> union <name>Z</name><type:modifier>*</type:modifier></type> <name>x</name></decl>;</decl_stmt>

return Statement

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>

sizeof

Element

  • <sizeof>

SubElements

  • <argument_list>
  • <argument>

Example

sizeof(struct type);

<expr_stmt><expr><sizeof>sizeof<argument_list>(<argument>struct <expr><name>type</name></expr></argument>)</argument_list></sizeof></expr>;</expr_stmt>

static

Element

  • <specifier>

Examples

1

static int x;

<decl_stmt><decl><type><specifier>static</specifier> <name>int</name></type> <name>x</name></decl>;</decl_stmt>

2

static void foo();

<function_decl><type><specifier>static</specifier> <name>void</name></type> <name>foo</name><parameter_list>()</parameter_list>;</function_decl>

struct Declaration

Element

  • <struct_decl>

SubElement

  • <name>

Example

Forward Declaration

struct employee;

<struct_decl>struct <name>employee</name>;</struct_decl>

struct Definition

Element

  • <struct>

SubElements

  • <name>
  • <block>

Examples

Trivial Declaration

struct a {
    int x;
    double y;
    float z;
 };

<struct>struct <name>a</name> <block>{
    <decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>double</name></type> <name>y</name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>float</name></type> <name>z</name></decl>;</decl_stmt>
 }</block>;</struct>

Variable Of An Anonymous Struct Type

struct
{
    int x;
    int y;
} mystruct;

<struct>struct
<block>{
    <decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>int</name></type> <name>y</name></decl>;</decl_stmt>
}</block> <decl><name>mystruct</name></decl>;</struct>

Declaring A Struct And Instance

struct employee
{
    char name[20];
    int id;
    long class;
} temp;

<struct>struct <name>employee</name>
<block>{
    <decl_stmt><decl><type><name>char</name></type> <name><name>name</name><index>[<expr><lit:literal type="number">20</lit:literal></expr>]</index></name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>int</name></type> <name>id</name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>long</name></type> <name>class</name></decl>;</decl_stmt>
}</block> <decl><name>temp</name></decl>;</struct>

struct Variable Initialization

Element

  • <decl_stmt>

SubElements

  • <decl>
  • <init>
  • <block>

Examples

1

MY_TYPE a = { false, 234, 1.234 };

<decl_stmt><decl><type><name>MY_TYPE</name></type> <name>a</name> <init>= <expr><block>{ <expr><name>false</name></expr>, <expr><lit:literal type="number">234</lit:literal></expr>, <expr><lit:literal type="number">1.234</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>

2

MY_TYPE b = (MY_TYPE) { false, 234, 1.234 };

<decl_stmt><decl><type><name>MY_TYPE</name></type> <name>b</name> <init>= <expr><op:operator>(</op:operator><name>MY_TYPE</name><op:operator>)</op:operator> <block>{ <expr><name>false</name></expr>, <expr><lit:literal type="number">234</lit:literal></expr>, <expr><lit:literal type="number">1.234</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>

3

MY_TYPE c = { .flag = true, .value = 123, .stuff = 0.456 };

<decl_stmt><decl><type><name>MY_TYPE</name></type> <name>c</name> <init>= <expr><block>{ <expr><op:operator>.</op:operator><name>flag</name> <op:operator>=</op:operator> <name>true</name></expr>, <expr><op:operator>.</op:operator><name>value</name> <op:operator>=</op:operator> <lit:literal type="number">123</lit:literal></expr>, <expr><op:operator>.</op:operator><name>stuff</name> <op:operator>=</op:operator> <lit:literal type="number">0.456</lit:literal></expr> }</block></expr></init></decl>;</decl_stmt>

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>

typedef

Element

  • <typedef>

SubElements

  • <type>
  • <name>
  • <function_decl>

Examples

1

typedef char C;
typedef unsigned int WORD;
typedef char * pChar;
typedef char field [50]; 
typedef char field, *field2; 

<typedef>typedef <type><name>char</name></type> <name>C</name>;</typedef>
<typedef>typedef <type><name>unsigned</name> <name>int</name></type> <name>WORD</name>;</typedef>
<typedef>typedef <type><name>char</name> <type:modifier>*</type:modifier></type> <name>pChar</name>;</typedef>
<typedef>typedef <type><name>char</name></type> <name><name>field</name> <index>[<expr><lit:literal type="number">50</lit:literal></expr>]</index></name>;</typedef> 
<typedef>typedef <type><name>char</name></type> <name>field</name><op:operator>,</op:operator> <type:modifier>*</type:modifier><name>field2</name>;</typedef>

2

typedef struct club 
{
    char name[30];
    int size, year;
} GROUP;

<typedef>typedef <type><struct>struct <name>club</name> 
<block>{
    <decl_stmt><decl><type><name>char</name></type> <name><name>name</name><index>[<expr><lit:literal type="number">30</lit:literal></expr>]</index></name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>int</name></type> <name>size</name></decl><op:operator>,</op:operator> <name>year</name>;</decl_stmt>
}</block></struct></type> <name>GROUP</name>;</typedef>

3

typedef void DRAWF( int, int );

<typedef>typedef <function_decl><type><name>void</name></type> <name>DRAWF</name><parameter_list>( <param><decl><type><name>int</name></type></decl></param>, <param><decl><type><name>int</name></type></decl></param> )</parameter_list>;</function_decl></typedef>

4

typedef void (*DRAWF)( int, int );

<typedef>typedef <function_decl><type><name>void</name></type> (<type:modifier>*</type:modifier><name>DRAWF</name>)<parameter_list>( <param><decl><type><name>int</name></type></decl></param>, <param><decl><type><name>int</name></type></decl></param> )</parameter_list>;</function_decl></typedef>

union Declaration

Element

  • <union_decl>

SubElements

  • <name>
  • <block>

Example

union X;

<union_decl>union <name>X</name>;</union_decl>

union Definition

Element

  • <union>

SubElements

  • <name>
  • <block>

Example

union sign
{
    int svar;
    unsigned uvar;
} number;

<union>union <name>sign</name>
<block>{
    <decl_stmt><decl><type><name>int</name></type> <name>svar</name></decl>;</decl_stmt>
    <decl_stmt><decl><type><name>unsigned</name></type> <name>uvar</name></decl>;</decl_stmt>
}</block> <decl><name>number</name></decl>;</union>

Variable Declaration

Element

  • <decl>

SubElement

  • <init>
    • Only used when variable is initialized at declaration. See initialization examples for more details.

Examples

A Trivial Example

int x;

<decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>

struct, union and enum declarations

struct X y;
union X y;
enum X y;

<decl_stmt><decl><type>struct <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>union <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>enum <name>X</name></type> <name>y</name></decl>;</decl_stmt>

Variable Declaration Statement

Element

  • <decl_stmt>

Examples

A Trivial Example

int x;

<decl_stmt><decl><type><name>int</name></type> <name>x</name></decl>;</decl_stmt>

struct, union and enum declarations

struct X y;
union X y;
enum X y;

<decl_stmt><decl><type>struct <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>union <name>X</name></type> <name>y</name></decl>;</decl_stmt>
<decl_stmt><decl><type>enum <name>X</name></type> <name>y</name></decl>;</decl_stmt>

volatile

Element

  • <specifier>

Example

volatile int foo; 
int volatile foo;

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

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>

_Alignas

Element

  • <alignas>

SubElements

  • <argument_list>
  • <argument>

Examples

1

_Alignas(struct X) struct X y;

<decl_stmt><decl><type><alignas>_Alignas<argument_list>(</argument_list></alignas>struct <name>X</name></type></decl>) struct X y;</decl_stmt>

2

_Alignas(64) int y[4];

<decl_stmt><decl><type><alignas>_Alignas<argument_list>(<argument><expr><lit:literal type="number">64</lit:literal></expr></argument>)</argument_list></alignas> <name>int</name></type> <name><name>y</name><index>[<expr><lit:literal type="number">4</lit:literal></expr>]</index></name></decl>;</decl_stmt>

_Alignof

Element

  • <alignof>

SubElements

  • <argument_list>
  • <argument>

Example

_Alignof(union type);

<expr_stmt><expr><alignof>_Alignof<argument_list>(<argument><expr>union <name>type</name></expr></argument>)</argument_list></alignof></expr>;</expr_stmt>

_Atomic

Element

  • <atomic>

SubElements

  • <argument_list>
  • <argument>

Examples

1

_Atomic union X t;

_Atomic <decl_stmt><decl><type>union <name>X</name></type> <name>t</name></decl>;</decl_stmt>

2

_Atomic int t;

<decl_stmt><decl><type><atomic>_Atomic</atomic> <name>int</name></type> <name>t</name></decl>;</decl_stmt>

3

_Atomic(int) t;

<decl_stmt><decl><type><atomic>_Atomic<argument_list>(<argument><expr><name>int</name></expr></argument>)</argument_list></atomic></type> <name>t</name></decl>;</decl_stmt>

_Generic

The only use case for this keyword is within a macro, in which case srcML will not mark it up.

Element

  • <generic_selection>

SubElements

  • <selector>
  • <association_list>
  • <association>

Example

_Generic ( AnyExpression , int:5, double:5.0, default:0);

<expr_stmt><expr><generic_selection>_Generic ( <selector><expr><name>AnyExpression</name></expr></selector> <op:operator>,</op:operator> <association_list><association><type><name>int</name></type>:<expr><lit:literal type="number">5</lit:literal></expr></association><op:operator>,</op:operator> <association><type><name>double</name></type>:<expr><lit:literal type="number">5.0</lit:literal></expr></association><op:operator>,</op:operator> <association><type>default</type>:<expr><lit:literal type="number">0</lit:literal></expr></association></association_list>)</generic_selection></expr>;</expr_stmt>

_Noreturn

Element

  • <name>

Example

_Noreturn void die(const char *fmt, ...) { exit(EXIT_FAILURE); }

<function><type><specifier>_Noreturn</specifier> <name>void</name></type> <name>die</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>char</name> <type:modifier>*</type:modifier></type><name>fmt</name></decl></param>, <param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{ <expr_stmt><expr><call><name>exit</name><argument_list>(<argument><expr><name>EXIT_FAILURE</name></expr></argument>)</argument_list></call></expr>;</expr_stmt> }</block></function>

_Static_assert

Element

  • <assert type="static">

SubElements

  • <argument_list>
  • <argument>

Example

_Static_assert(DEBUG_LEVEL > 5, "Message");

<assert type="static">_Static_assert<argument_list>(<argument><expr><name>DEBUG_LEVEL</name> <op:operator>&gt;</op:operator> <lit:literal type="number">5</lit:literal></expr></argument>, <argument><expr><lit:literal type="string">&quot;Message&quot;</lit:literal></expr></argument>)</argument_list>;</assert>

_Thread_local

Element

  • <name>

Example

_Thread_local int x;

<decl_stmt><decl><type><specifier>_Thread_local</specifier> <name>int</name></type> <name>x</name></decl>;</decl_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>
Address Of & <op:operator>&amp;</op:operator>
Dereference * <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>
Left Shift Assign <<= <op:operator>&lt;&lt;=</op:operator>
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>
Comma , <op:operator>,</op:operator>
Conditional ? : <op:operator>?</op:operator>
<op:operator>:</op:operator>
Dot . <op:operator>.</op:operator>
Arrow -> <op:operator>-&gt;</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.