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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
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">"\nPress any key, Q to quit: "</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">"%c"</lit:literal></expr></argument>, <argument><expr><op:operator>&</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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
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>></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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
Example
t->tm_sec;
<expr_stmt><expr><name><name>t</name><op:operator>-></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>></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>></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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- <block>
Example
Extern Block with Linkage Specifier
extern "C" { }
<extern>extern <lit:literal type="string">"C"</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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
- <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">"C"</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">"C"</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">"C"</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><</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><</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>></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>></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>></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>></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>></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>></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>></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>></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><</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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
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
-
Note: This mark up is disabled by default and is enabled using the following command line argument/s with srcML:
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>&</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>&</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>>=</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>></op:operator> <lit:literal type="number">5</lit:literal></expr></argument>, <argument><expr><lit:literal type="string">"Message"</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>&</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><<</op:operator> |
Right Shift | >> |
<op:operator>>></op:operator> |
Less Then | < |
<op:operator><</op:operator> |
Greater Then | > |
<op:operator>></op:operator> |
Less Then or Equal To | <= |
<op:operator><=</op:operator> |
Greater Then or Equal To | >= |
<op:operator>>=</op:operator> |
Equals | == |
<op:operator>==</op:operator> |
Not Equal | != |
<op:operator>!=</op:operator> |
Bitwise And | & |
<op:operator>&</op:operator> |
Bitwise XOr | ^ |
<op:operator>^</op:operator> |
Bitwise Or | | |
<op:operator>|</op:operator> |
Logical And | && |
<op:operator>&&</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><<=</op:operator> |
Right Shift Assign | >>= |
<op:operator>>>=</op:operator> |
Bitwise And Assign | &= |
<op:operator>&=</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>-></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.