C++ srcML

Language Element Elements Subelements
FIXME: Not sorted!
Array Access <name> <name>, <index>
Function Call <call> <name>, <argument_list>, <argument>
Member Access <expr> <name>, <op:operator>
Dereference Member Access <expr> <name>, <op:operator>
sizeof <sizeof> <argument_list>, <argument>
Cast <op:operator> <name>
Variable Declaration <decl> <init>
Variable Declaration Statement <decl_stmt>
const <specifier>
const Funciton <specifier>
extern Block <extern> <lit:literal>, <block>
extern Specifier <specifier> <lit:literal>, <decl_stmt>, <function_stmt>, <block>
auto Specifier <specifier>
auto Type <name>
static <specifier>
typedef <typedef> <type>, <name>, <function_decl>
register <name>
restrict <specifier>
volatile <specifier>
inline <specifier>
struct Definition <struct> <name>, <super>
struct Declaration <struct_decl>
Bitfield <range> <lit:literal>, <name>
struct Varaiable Initialization <decl_stmt> <decl>, <init>, <block>
union Declaration <union_decl> <name>
union Definition <union> <name>, <block>
enum Declaration <enum> <name>, <block>
Array Declaration <decl> <name>, <index>
Array Declaration Initialization <init> <block>
Pointer Declaration <type:modifier>
Function Declaration <function_decl> <name>, <parameter_list>, <param>
Function Definition <function> <name>, <parameter_list>, <param>
Function Call <call> <name>, <argument_list>, <argument>
break <break>
Block <block>
continue Statement <continue>
do while Statement <do> <block>, <condition>
for Statement <for> <init>, <condition>, <incr>, <block>
goto Statement <goto> <name>
Label Statement <label> <name>
if Statement <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>
new <op:operator>
Reference Declaration <type:modifier>
static_cast <call> <argument_list>, <argument>
dynamic_cast <call> <argument_list>, <argument>
reinterpret_cast <call> <argument_list>, <argument>
delete <op:operator>
typeid <call> <argument_list>, <argument>
noexcept <noexcept> <argument_list>, <argument>
alignof <alignof> <argument_list>, <argument>
constexpr <specifier>
alignas <alignas> <argument_list>, <argument>
namespace <namespace> <name>, <block>
thread_local <specifier>
decltype <decltype> <argument_list>, <argument>
Type Aliasing <using>
Attribute <attribute> <expr>
Initialization with an initialization_list <call> <block>
Default Function Arguments <init> <expr>
RValue Reference <type:modifier>
Lamda Expression <lambda> <parameter_list>, <param>, <capture>, <argument>, <block>
throw <throw> <expr>
try <try> <block>, <catch>
catch <catch> <parameter_list>, <param>
Function try-catch <try> <catch>, <block>, <member_list>
Variadic Type Modifier <type:modifier>
final <specifier>
override <specifier>
class <class> <name>
class Declaration <class_decl> <name>
Constructor <constructor> <name>, <parameter_list>, <param>, <member_list>, <block>
Constructor Declaration <constructor_decl> <name>, <parameter_list>, <param>, <member_list>, <block>
Destructor <destructor> <name>
Destructor Declaration <destructor_decl> <name>
friend <specifier>
using <using> <name>
static_assert <call> <argument_list>, <argument>
virtual <specifier>
Abstract Function <lit:literal type="number">
this <name>
Deleted Function <specifier>
Default Function Implementation <specifier>
Operator Overloading Declaration <function_decl> <name>, <parameter_list>, <parm>
Operator Overloading Definition <function> <name>, <parameter_list>, <parm>
Implicit Conversion Operator Definition <function> <name>, <parameter_list>, <parm>
Implicit Conversion Operator Declaration <function> <name>, <parameter_list>, <parm>
Explicit Conversion Operator Declaration <function_decl> <specifier>, <name>, <parameter_list>, <parm>
Explicit Conversion Operator Definition <function> <specifier>, <name>, <parameter_list>, <parm>
explict <specifier>
template <template> <parameter_list>, <parameter>, <typename>
template Specifier <specifier> <parameter_list>, <parameter>, <typename>
Template Parameters <parameter_list> <param>
enum class <enum>
Default public Visibility <public type="default">
public Visibility <public>
Default private Visibility <private type="default">
private Visibility <private>
protected Visibility <protected>
protected Inheritance Specifier <specifier>
private Inheritance Specifier <specifier>
public Inheritance Specifier <specifier>
Inheritance List <super> <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>

Function Call

Element

  • <call>

SubElements

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

Examples

Typical Function Call

int x = atoi("50");
<decl_stmt><decl><type><name>int</name></type> <name>x</name> <init>= <expr><call><name>atoi</name><argument_list>(<argument><expr><lit:literal type="string">&quot;50&quot;</lit:literal></expr></argument>)</argument_list></call></expr></init></decl>;</decl_stmt>

Explicit Operator Call

x = operator new(NewCapacityInBytes);
<expr_stmt><expr><name>x</name> <op:operator>=</op:operator> <call><name>operator new</name><argument_list>(<argument><expr><name>NewCapacityInBytes</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>

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>

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>

sizeof

Element

  • <sizeof>

SubElements

  • <argument_list>
  • <argument>

Examples

1

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

2

sizeof...(Args);
<expr_stmt><expr><sizeof>sizeof...<argument_list>(<argument><expr><name>Args</name></expr></argument>)</argument_list></sizeof></expr>;</expr_stmt>

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>

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>

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>

const Funciton

Element

  • <specifier>

Example

int foo() const;
<function_decl><type><name>int</name></type> <name>foo</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>

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>

auto Specifier

Element

  • <specifier>

Example

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

auto Type

Element

  • <name>

Examples

1

auto temp() -> int { }
<function><type><name>auto</name></type> <name>temp</name><parameter_list>()</parameter_list> -&gt; <type><name>int</name></type> <block>{ }</block></function>

2

auto i = 5;
<decl_stmt><decl><type><name>auto</name></type> <name>i</name> <init>= <expr><lit:literal type="number">5</lit:literal></expr></init></decl>;</decl_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>

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>{<public type="default">
    <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>
</public>}</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>

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>

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>

inline

Element

  • <specifier>

Examples

1

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>

2

inline namespace ns { }
<namespace><specifier>inline</specifier> namespace <name>ns</name> <block>{ }</block></namespace>

struct Definition

See Class for more examples.

Element

  • <struct>

SubElements

  • <name>
  • <super>

Examples

Trivial Declaration

struct a {
    int x;
    double y;
    float z;
 };
<struct>struct <name>a</name> <block>{<public type="default">
    <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>
 </public>}</block>;</struct>

Variable Of An Anonymous Struct Type

struct
{
    int x;
    int y;
} mystruct;
<struct>struct
<block>{<public type="default">
    <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>
</public>}</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>{<public type="default">
    <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>
</public>}</block> <decl><name>temp</name></decl>;</struct>

struct Declaration

Element

  • <struct_decl>

Example

Forward Declaration

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

Bitfield

Element

  • <range>

SubElements

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

Example

struct mybitfields
{
    int a : 5;
} test;
<struct>struct <name>mybitfields</name>
<block>{<public type="default">
    <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>
</public>}</block> <decl><name>test</name></decl>;</struct>

struct Varaiable 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><lit:literal type="boolean">false</lit:literal></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><lit:literal type="boolean">false</lit:literal></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> <lit:literal type="boolean">true</lit:literal></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>

union Declaration

Element

  • <union_decl>

SubElement

  • <name>

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>{<public type="default">
    <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>
</public>}</block> <decl><name>number</name></decl>;</union>

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>

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>{<public type="default">
    <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>
</public>}</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>

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>

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_decl><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_decl>

6

auto temp() -> int;
<function_decl><type><name>auto</name></type> <name>temp</name><parameter_list>()</parameter_list> -&gt; <type><name>int</name></type>;</function_decl>

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>

6

auto temp() -> int { }
<function><type><name>auto</name></type> <name>temp</name><parameter_list>()</parameter_list> -&gt; <type><name>int</name></type> <block>{ }</block></function>

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>

break

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>

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

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>

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 i : v)
    std::cout << i << ' ';
<for>for (<init><decl><type><name>int</name></type> <name>i</name> <range>: <expr><name>v</name></expr></range></decl></init>)
    <expr_stmt><expr><name><name>std</name><op:operator>::</op:operator><name>cout</name></name> <op:operator>&lt;&lt;</op:operator> <name>i</name> <op:operator>&lt;&lt;</op:operator> <lit:literal type="char">' '</lit:literal></expr>;</expr_stmt></for>

goto Statement

Element

  • <goto>

SubElement

  • <name>

Example

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

Label Statement

Element

  • <label>

SubElement

  • <name>

Example

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

if Statement

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>

new

Element

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

Examples

Regular new

new foo();
<expr_stmt><expr><op:operator>new</op:operator> <call><name>foo</name><argument_list>()</argument_list></call></expr>;</expr_stmt>

Array new 1

new foo[5];
<expr_stmt><expr><op:operator>new</op:operator> <name><name>foo</name><index>[<expr><lit:literal type="number">5</lit:literal></expr>]</index></name></expr>;</expr_stmt>

Array new 2

new foo[5]();
<expr_stmt><expr><op:operator>new</op:operator> <name><name>foo</name><index>[<expr><lit:literal type="number">5</lit:literal></expr>]</index></name><op:operator>(</op:operator><op:operator>)</op:operator></expr>;</expr_stmt>

std::nothrow new

new (std::nothrow) char [50000000];
<expr_stmt><expr><op:operator>new</op:operator> <op:operator>(</op:operator><name><name>std</name><op:operator>::</op:operator><name>nothrow</name></name><op:operator>)</op:operator> <name><name>char</name> <index>[<expr><lit:literal type="number">50000000</lit:literal></expr>]</index></name></expr>;</expr_stmt>

Placement new

new (place) int;
<expr_stmt><expr><op:operator>new</op:operator> <op:operator>(</op:operator><name>place</name><op:operator>)</op:operator> <name>int</name></expr>;</expr_stmt>

Reference 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

Example

int& x;
<decl_stmt><decl><type><name>int</name><type:modifier>&amp;</type:modifier></type> <name>x</name></decl>;</decl_stmt>

static_cast

Element

  • <call>

SubElements

  • <argument_list>
  • <argument>

Example

static_cast<node*>(ptr);
<expr_stmt><expr><call><name><name>static_cast</name><argument_list>&lt;<argument><expr><name>node</name><op:operator>*</op:operator></expr></argument>&gt;</argument_list></name><argument_list>(<argument><expr><name>ptr</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>

dynamic_cast

Element

  • <call>

SubElements

  • <argument_list>
  • <argument>

Example

dynamic_cast<Square*>(boxPtr);
<expr_stmt><expr><call><name><name>dynamic_cast</name><argument_list>&lt;<argument><expr><name>Square</name><op:operator>*</op:operator></expr></argument>&gt;</argument_list></name><argument_list>(<argument><expr><name>boxPtr</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>

reinterpret_cast

Element

  • <call>

SubElements

  • <argument_list>
  • <argument>

Example

reinterpret_cast<double>(number);
<expr_stmt><expr><call><name><name>reinterpret_cast</name><argument_list>&lt;<argument><expr><name>double</name></expr></argument>&gt;</argument_list></name><argument_list>(<argument><expr><name>number</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>

delete

Element

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

Examples

Regular delete

delete x;
<expr_stmt><expr><op:operator>delete</op:operator> <name>x</name></expr>;</expr_stmt>

Array delete

delete [] x;
<expr_stmt><expr><op:operator>delete</op:operator> <index>[]</index> <name>x</name></expr>;</expr_stmt>

typeid

Element

  • <call>

SubElements

  • <argument_list>
  • <argument>

Example

typeid(x);
<expr_stmt><expr><call><name>typeid</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr>;</expr_stmt>

noexcept

Element

  • <noexcept>

SubElements

  • <argument_list>
  • <argument>

Examples

1

noexcept (foo(x));
<expr_stmt><expr><noexcept>noexcept <argument_list>(<argument><expr><call><name>foo</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></argument>)</argument_list></noexcept></expr>;</expr_stmt>

2

void no_throw() noexcept { }
<function><type><name>void</name></type> <name>no_throw</name><parameter_list>()</parameter_list> <noexcept>noexcept</noexcept> <block>{ }</block></function>

alignof

Element

  • <alignof>

SubElements

  • <argument_list>
  • <argument>

Example

alignof(T);
<expr_stmt><expr><alignof>alignof<argument_list>(<argument><expr><name>T</name></expr></argument>)</argument_list></alignof></expr>;</expr_stmt>

constexpr

Element

  • <specifier>

Examples

1

constexpr const int* xp = addr(x);
<decl_stmt><decl><type><specifier>constexpr</specifier> <specifier>const</specifier> <name>int</name><type:modifier>*</type:modifier></type> <name>xp</name> <init>= <expr><call><name>addr</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></init></decl>;</decl_stmt>

2

constexpr const int* addr(const int& ir) { return &ir; }
<function><type><specifier>constexpr</specifier> <specifier>const</specifier> <name>int</name><type:modifier>*</type:modifier></type> <name>addr</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>int</name><type:modifier>&amp;</type:modifier></type> <name>ir</name></decl></param>)</parameter_list> <block>{ <return>return <expr><op:operator>&amp;</op:operator><name>ir</name></expr>;</return> }</block></function>

alignas

Element

  • <alignas>

SubElements

  • <argument_list>
  • <argument>

Example

alignas(MyType);
<decl_stmt><decl><type><alignas>alignas<argument_list>(<argument><expr><name>MyType</name></expr></argument>)</argument_list></alignas></type></decl>;</decl_stmt>

namespace

Element

  • <namespace>

SubElements

  • <name>
  • <block>

Examples

1

namespace ns { }
<namespace>namespace <name>ns</name> <block>{ }</block></namespace>

2

inline namespace ns { }
<namespace><specifier>inline</specifier> namespace <name>ns</name> <block>{ }</block></namespace>

3

namespace ns;
<namespace>namespace <name>ns</name>;</namespace>

4

using namespace ns;
<using>using namespace <name>ns</name>;</using>

5

namespace new_name = ns; 
<namespace>namespace <name>new_name</name> = <name>ns</name>;</namespace> 

6

namespace { }
<namespace>namespace <block>{ }</block></namespace>

thread_local

Element

  • <specifier>

Example

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

decltype

Element

  • <decltype>

SubElements

  • <argument_list>
  • <argument>

Examples

1

decltype(int) i;
<decl_stmt><decl><type><decltype>decltype<argument_list>(<argument><expr><name>int</name></expr></argument>)</argument_list></decltype></type> <name>i</name></decl>;</decl_stmt>

2

decltype(int)
decltype<expr_stmt><expr><op:operator>(</op:operator><name>int</name><op:operator>)</op:operator></expr></expr_stmt>

Type Aliasing

Element

  • <using>

Example

template<class T> using Vec = vector<T, Alloc<T>>;
<using><template>template<parameter_list>&lt;<param><type><name>class</name></type> <name>T</name></param>&gt;</parameter_list></template> using <name>Vec</name> <init>= <type><expr><name><name>vector</name><argument_list>&lt;<argument><expr><name>T</name></expr></argument>, <argument><expr><name><name>Alloc</name><argument_list>&lt;<argument><expr><name>T</name></expr></argument>&gt;</argument_list></name></expr></argument>&gt;</argument_list></name></expr></type></init>;</using>

Attribute

Element

  • <attribute>

SubElement

  • <expr>

Example

[[noreturn]] void std::exit() { }
<function><type><attribute>[[<expr><name>noreturn</name></expr>]]</attribute> <name>void</name></type> <name><name>std</name><op:operator>::</op:operator><name>exit</name></name><parameter_list>()</parameter_list> <block>{ }</block></function>

Initialization with an initialization_list

Element

  • <call>

SubElement

  • <block>

Example

T x{ arg };
<decl_stmt><decl><type><name>T</name></type> <name>x</name><argument_list>{ <argument><expr><name>arg</name></expr></argument> }</argument_list></decl>;</decl_stmt>

Default Function Arguments

Element

  • <init>

SubElement

  • <expr>

Example

void point(int x = 3, int y = 4);
<function_decl><type><name>void</name></type> <name>point</name><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name> <init>= <expr><lit:literal type="number">3</lit:literal></expr></init></decl></param>, <name>int</name> <name>y</name> <op:operator>=</op:operator> <lit:literal type="number">4</lit:literal>)</parameter_list>;</function_decl>

RValue Reference

Element

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

Example

int&& x;
<decl_stmt><decl><type><name>int</name><type:modifier>&amp;&amp;</type:modifier></type> <name>x</name></decl>;</decl_stmt>

Lamda Expression

Element

  • <lambda>

SubElements

  • <parameter_list>
  • <param>
  • <capture>
  • <argument>
  • <block>

Examples

1

[](int x) { return 0;} 
<expr_stmt><expr><lambda><capture>[]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt> 

2

[] { return 0; } 
<expr_stmt><expr><lambda><capture>[]</capture> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return> }</block></lambda></expr></expr_stmt> 

3

[](int x) -> int { return 0;} 
<expr_stmt><expr><lambda><capture>[]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> -&gt; <type><name>int</name></type> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt> 

4

[i](int x) { return i; } 
<expr_stmt><expr><lambda><capture>[<argument><name>i</name></argument>]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><name>i</name></expr>;</return> }</block></lambda></expr></expr_stmt> 

5

[=](int x) { return 0;} 
<expr_stmt><expr><lambda><capture>[<argument><type:modifier>=</type:modifier></argument>]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt> 

6

[&](int x) { return 0;} 
<expr_stmt><expr><lambda><capture>[<argument><type:modifier>&amp;</type:modifier></argument>]</capture><parameter_list>(<param><decl><type><name>int</name></type> <name>x</name></decl></param>)</parameter_list> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt> 

7

[=](int const& x) mutable { return 0;} 
<expr_stmt><expr><lambda><capture>[<argument><type:modifier>=</type:modifier></argument>]</capture><parameter_list>(<param><decl><type><name>int</name> <specifier>const</specifier><type:modifier>&amp;</type:modifier></type> <name>x</name></decl></param>)</parameter_list> <specifier>mutable</specifier> <block>{ <return>return <expr><lit:literal type="number">0</lit:literal></expr>;</return>}</block></lambda></expr></expr_stmt> 

throw

Element

  • <throw>

SubElement

  • <expr>

Examples

1

throw;
<throw>throw;</throw>

2

throw std::runtime_error("msg");
<throw>throw <expr><call><name><name>std</name><op:operator>::</op:operator><name>runtime_error</name></name><argument_list>(<argument><expr><lit:literal type="string">&quot;msg&quot;</lit:literal></expr></argument>)</argument_list></call></expr>;</throw>

3

void f() throw(X, Y);
<function_decl><type><name>void</name></type> <name>f</name><parameter_list>()</parameter_list> <throw>throw<argument_list>(<argument><expr><name>X</name></expr></argument>, <argument><expr><name>Y</name></expr></argument>)</argument_list></throw>;</function_decl>

try

Element

  • <try>

SubElements

  • <block>
  • <catch>

Example

try {

}
<try>try <block>{

}</block></try>

catch

Element

  • <catch>

SubElements

  • <parameter_list>
  • <param>

Examples

1

try {

} catch(const std::exception& e) {

}
<try>try <block>{

}</block> <catch>catch<parameter_list>(<param><decl><type><specifier>const</specifier> <name><name>std</name><op:operator>::</op:operator><name>exception</name></name><type:modifier>&amp;</type:modifier></type> <name>e</name></decl></param>)</parameter_list> <block>{

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

2

catch(...) {

}
<catch>catch<parameter_list>(<param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{

}</block></catch>

Function try-catch

Element

  • <try>

SubElements

  • <catch>
  • <block>
  • <member_list>

Examples

1

struct S {
    S(const std::string& arg) try : m(arg) {        
    } catch(const std::exception& e) {
    } // implicit throw; here
};
<struct>struct <name>S</name> <block>{<public type="default">
    <constructor><name>S</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name><name>std</name><op:operator>::</op:operator><name>string</name></name><type:modifier>&amp;</type:modifier></type> <name>arg</name></decl></param>)</parameter_list> <try>try <member_list>: <call><name>m</name><argument_list>(<argument><expr><name>arg</name></expr></argument>)</argument_list></call> </member_list><block>{        
    }</block> <catch>catch<parameter_list>(<param><decl><type><specifier>const</specifier> <name><name>std</name><op:operator>::</op:operator><name>exception</name></name><type:modifier>&amp;</type:modifier></type> <name>e</name></decl></param>)</parameter_list> <block>{
    }</block></catch></try></constructor> <comment type="line">// implicit throw; here</comment>
</public>}</block>;</struct>

2

int f(int n) try {

} catch(...) {

}
<function><type><name>int</name></type> <name>f</name><parameter_list>(<param><decl><type><name>int</name></type> <name>n</name></decl></param>)</parameter_list> <name>try</name> <block>{

}</block></function> <catch>catch<parameter_list>(<param><decl><type><type:modifier>...</type:modifier></type></decl></param>)</parameter_list> <block>{

}</block></catch>

Variadic Type Modifier

Element

  • <type:modifier>

Example

int x(f...);
<function_decl><type><name>int</name></type> <name>x</name><parameter_list>(<param><decl><type><name>f</name><type:modifier>...</type:modifier></type></decl></param>)</parameter_list>;</function_decl>

final

Element

  • <specifier>

Examples

1

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

2

class X final { };
<class>class <name>X</name> <specifier>final</specifier> <block>{<private type="default"> </private>}</block>;</class>

override

Element

  • <specifier>

Example

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

class

Element

  • <class>

SubElement

  • <name>

Examples

1

class Foo { };
<class>class <name>Foo</name> <block>{<private type="default"> </private>}</block>;</class>

2

class Foo;
<class_decl>class <name>Foo</name>;</class_decl>

3

class Foo
    :public bar
{ };
<class>class <name>Foo</name>
    <super>:<specifier>public</specifier> <name>bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>

4

class Foo {
public:
protected:
private:
};
<class>class <name>Foo</name> <block>{<private type="default">
</private><public>public:
</public><protected>protected:
</protected><private>private:
</private>}</block>;</class>

5

class Foo {
    Foo() { }
};
<class>class <name>Foo</name> <block>{<private type="default">
    <constructor><name>Foo</name><parameter_list>()</parameter_list> <block>{ }</block></constructor>
</private>}</block>;</class>

6

class Foo {
    foo();
}
<class>class <name>Foo</name> <block>{<private type="default">
    <constructor_decl><name>foo</name><parameter_list>()</parameter_list>;</constructor_decl>
</private>}</block><decl/></class>

7

class Foo {
    ~Foo() { }
};
<class>class <name>Foo</name> <block>{<private type="default">
    <destructor><name>~<name>Foo</name></name><parameter_list>()</parameter_list> <block>{ }</block></destructor>
</private>}</block>;</class>

8

class Foo {
    ~Foo();
}
<class>class <name>Foo</name> <block>{<private type="default">
    <destructor_decl><name>~<name>Foo</name></name><parameter_list>()</parameter_list>;</destructor_decl>
</private>}</block><decl/></class>

class Declaration

Element

  • <class_decl>

SubElement

  • <name>

Example

class Foo;
<class_decl>class <name>Foo</name>;</class_decl>

Constructor

Element

  • <constructor>

SubElements

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

Examples

1

class Foo{
    Foo()
        :x(5)
    { }
};
<class>class <name>Foo</name><block>{<private type="default">
    <constructor><name>Foo</name><parameter_list>()</parameter_list>
        <member_list>:<call><name>x</name><argument_list>(<argument><expr><lit:literal type="number">5</lit:literal></expr></argument>)</argument_list></call>
    </member_list><block>{ }</block></constructor>
</private>}</block>;</class>

2

Foo::Foo()
    :x(5)
{ }
<constructor><name><name>Foo</name><op:operator>::</op:operator><name>Foo</name></name><parameter_list>()</parameter_list>
    <member_list>:<call><name>x</name><argument_list>(<argument><expr><lit:literal type="number">5</lit:literal></expr></argument>)</argument_list></call>
</member_list><block>{ }</block></constructor>

Constructor Declaration

Element

  • <constructor_decl>

SubElements

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

Example

class Foo {
    Foo();
};
<class>class <name>Foo</name> <block>{<private type="default">
    <constructor_decl><name>Foo</name><parameter_list>()</parameter_list>;</constructor_decl>
</private>}</block>;</class>

Destructor

Element

  • <destructor>

SubElement

  • <name>

Examples

1

class Foo {
    ~Foo() { }
};
<class>class <name>Foo</name> <block>{<private type="default">
    <destructor><name>~<name>Foo</name></name><parameter_list>()</parameter_list> <block>{ }</block></destructor>
</private>}</block>;</class>

2

Foo::~Foo() { }
<destructor><name><name>Foo</name><op:operator>::</op:operator>~<name>Foo</name></name><parameter_list>()</parameter_list> <block>{ }</block></destructor>

Destructor Declaration

Element

  • <destructor_decl>

SubElement

  • <name>

Example

class Foo {
    ~Foo();
};
<class>class <name>Foo</name> <block>{<private type="default">
    <destructor_decl><name>~<name>Foo</name></name><parameter_list>()</parameter_list>;</destructor_decl>
</private>}</block>;</class>

friend

Element

  • <specifier>

Example

class Matrix {
    friend Vector operator*(const Matrix&, const Vector&);
};
<class>class <name>Matrix</name> <block>{<private type="default">
    <function_decl><type><specifier>friend</specifier> <name>Vector</name></type> <name>operator*</name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>Matrix</name><type:modifier>&amp;</type:modifier></type></decl></param>, <param><decl><type><specifier>const</specifier> <name>Vector</name><type:modifier>&amp;</type:modifier></type></decl></param>)</parameter_list>;</function_decl>
</private>}</block>;</class>

using

Element

  • <using>

SubElement

  • <name>

Examples

1

using namespace std;
<using>using namespace <name>std</name>;</using>

2

using Base::reference;
<using>using <name><name>Base</name><op:operator>::</op:operator><name>reference</name></name>;</using>

static_assert

Element

  • <call>

SubElements

  • <argument_list>
  • <argument>

Example

static_assert(cond, "msg");
<expr_stmt><expr><call><name>static_assert</name><argument_list>(<argument><expr><name>cond</name></expr></argument>, <argument><expr><lit:literal type="string">&quot;msg&quot;</lit:literal></expr></argument>)</argument_list></call></expr>;</expr_stmt>

virtual

Element

  • <specifier>

Example

virtual void dump() const;
<function_decl><type><specifier>virtual</specifier> <name>void</name></type> <name>dump</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>

Abstract Function

Element

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

Example

struct Foo {
    virtual void dump() const = 0;
};
<struct>struct <name>Foo</name> <block>{<public type="default">
    <function_decl><type><specifier>virtual</specifier> <name>void</name></type> <name>dump</name><parameter_list>()</parameter_list> <specifier>const</specifier> = <lit:literal type="number">0</lit:literal>;</function_decl>
</public>}</block>;</struct>

this

Element

  • <name>

Example

this->x = 5;
<expr_stmt><expr><name><name>this</name><op:operator>-&gt;</op:operator><name>x</name></name> <op:operator>=</op:operator> <lit:literal type="number">5</lit:literal></expr>;</expr_stmt>

Deleted Function

Element

  • <specifier>

Example

void dump() = delete;
<function_decl><type><name>void</name></type> <name>dump</name><parameter_list>()</parameter_list> = <specifier>delete</specifier>;</function_decl>

Default Function Implementation

Element

  • <specifier>

Example

class Foo {
    Foo() = default;
};
<class>class <name>Foo</name> <block>{<private type="default">
    <constructor_decl><name>Foo</name><parameter_list>()</parameter_list> = <specifier>default</specifier>;</constructor_decl>
</private>}</block>;</class>

Operator Overloading Declaration

Element

  • <function_decl>

SubElements

  • <name>
  • <parameter_list>
  • <parm>

Example

Foo& operator=(Foo&& );
<function_decl><type><name>Foo</name><type:modifier>&amp;</type:modifier></type> <name>operator=</name><parameter_list>(<param><decl><type><name>Foo</name><type:modifier>&amp;&amp;</type:modifier></type></decl></param> )</parameter_list>;</function_decl>

Operator Overloading Definition

Element

  • <function>

SubElements

  • <name>
  • <parameter_list>
  • <parm>

Example

bool operator==(Foo const&, Foo const& ) { }
<function><type><name>bool</name></type> <name>operator==</name><parameter_list>(<param><decl><type><name>Foo</name> <specifier>const</specifier><type:modifier>&amp;</type:modifier></type></decl></param>, <param><decl><type><name>Foo</name> <specifier>const</specifier><type:modifier>&amp;</type:modifier></type></decl></param> )</parameter_list> <block>{ }</block></function>

Implicit Conversion Operator Definition

Element

  • <function>

SubElements

  • <name>
  • <parameter_list>
  • <parm>

Example

operator Foo() const;
<function_decl><name>operator Foo</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>

Implicit Conversion Operator Declaration

Element

  • <function>

SubElements

  • <name>
  • <parameter_list>
  • <parm>

Example

operator Foo() const { return x->foo; }
<function><name>operator Foo</name><parameter_list>()</parameter_list> <specifier>const</specifier> <block>{ <return>return <expr><name><name>x</name><op:operator>-&gt;</op:operator><name>foo</name></name></expr>;</return> }</block></function>

Explicit Conversion Operator Declaration

Element

  • <function_decl>

SubElements

  • <specifier>
  • <name>
  • <parameter_list>
  • <parm>

Example

explicit operator int*() const;
<function_decl><type><specifier>explicit</specifier></type> <name>operator int*</name><parameter_list>()</parameter_list> <specifier>const</specifier>;</function_decl>

Explicit Conversion Operator Definition

Element

  • <function>

SubElements

  • <specifier>
  • <name>
  • <parameter_list>
  • <parm>

Example

explicit operator int*() const { return nullptr; }
<function><type><specifier>explicit</specifier></type> <name>operator int*</name><parameter_list>()</parameter_list> <specifier>const</specifier> <block>{ <return>return <expr><lit:literal type="null">nullptr</lit:literal></expr>;</return> }</block></function>

explict

Element

  • <specifier>

Example

class Foo{ 
    explicit Foo(X const& x);
};
<class>class <name>Foo</name><block>{<private type="default"> 
    <constructor_decl><specifier>explicit</specifier> <name>Foo</name><parameter_list>(<param><decl><type><name>X</name> <specifier>const</specifier><type:modifier>&amp;</type:modifier></type> <name>x</name></decl></param>)</parameter_list>;</constructor_decl>
</private>}</block>;</class>

template

Element

  • <template>

SubElements

  • <parameter_list>
  • <parameter>
  • <typename>

Examples

Templated Class

template<typename T>
class Foo {
};
<class><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T</name></param>&gt;</parameter_list></template>
class <name>Foo</name> <block>{<private type="default">
</private>}</block>;</class>

Templated Function

template<typename T>
void swap(T& lhs, T& rhs);
<function_decl><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T</name></param>&gt;</parameter_list></template>
<type><name>void</name></type> <name>swap</name><parameter_list>(<param><decl><type><name>T</name><type:modifier>&amp;</type:modifier></type> <name>lhs</name></decl></param>, <param><decl><type><name>T</name><type:modifier>&amp;</type:modifier></type> <name>rhs</name></decl></param>)</parameter_list>;</function_decl>

Partial Template Specialization

template<typename T>
class Foo<T, void>
{

};
<class><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T</name></param>&gt;</parameter_list></template>
class <name><name>Foo</name><argument_list>&lt;<argument><expr><name>T</name></expr></argument>, <argument><expr><name>void</name></expr></argument>&gt;</argument_list></name>
<block>{<private type="default">

</private>}</block>;</class>

Template Member Function Template

template<typename T1>
template<typename T2>
int string<T1>::compare(const T2& s) { }
<function><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T1</name></param>&gt;</parameter_list></template>
<template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T2</name></param>&gt;</parameter_list></template>
<type><name>int</name></type> <name><name><name>string</name><argument_list>&lt;<argument><expr><name>T1</name></expr></argument>&gt;</argument_list></name><op:operator>::</op:operator><name>compare</name></name><parameter_list>(<param><decl><type><specifier>const</specifier> <name>T2</name><type:modifier>&amp;</type:modifier></type> <name>s</name></decl></param>)</parameter_list> <block>{ }</block></function>

template Specifier

Element

  • <specifier>

SubElements

  • <parameter_list>
  • <parameter>
  • <typename>

Example

Template as a Specifier

typename t::template iterator<int>::value_type v;
<decl_stmt><decl><type><typename>typename</typename> <name><name>t</name><op:operator>::</op:operator><name><specifier>template</specifier> <name>iterator</name><argument_list>&lt;<argument><expr><name>int</name></expr></argument>&gt;</argument_list></name><op:operator>::</op:operator><name>value_type</name></name></type> <name>v</name></decl>;</decl_stmt>

Template Parameters

Element

  • <parameter_list>

SubElement

  • <param>

Examples

typename Parameter

template<typename T>
struct Foo { };
<struct><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T</name></param>&gt;</parameter_list></template>
struct <name>Foo</name> <block>{<public type="default"> </public>}</block>;</struct>

class Parameter

template<class T>
struct Foo { };
<struct><template>template<parameter_list>&lt;<param><type><name>class</name></type> <name>T</name></param>&gt;</parameter_list></template>
struct <name>Foo</name> <block>{<public type="default"> </public>}</block>;</struct>

Default Template Parameter

template<typename T = Bar>
class Foo { };
<class><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type> <name>T</name> <init>= <expr><name>Bar</name></expr></init></param>&gt;</parameter_list></template>
class <name>Foo</name> <block>{<private type="default"> </private>}</block>;</class>

Template Parameter Pack

template<class ... Types> struct Tuple {};
<struct><template>template<parameter_list>&lt;<param><type><name>class</name> <type:modifier>...</type:modifier></type> <name>Types</name></param>&gt;</parameter_list></template> struct <name>Tuple</name> <block>{<public type="default"/>}</block>;</struct>

Template Template Parameter

template<template<typename> class C>
class Foo { };
<class><template>template<parameter_list>&lt;<param><type><template>template<parameter_list>&lt;<param><type><typename>typename</typename></type></param>&gt;</parameter_list></template> <name>class</name></type> <name>C</name></param>&gt;</parameter_list></template>
class <name>Foo</name> <block>{<private type="default"> </private>}</block>;</class>

enum class

Element

  • <enum>

Example

enum class Color {RED, GREEN, BLUE};

<enum>enum class <name>Color</name> <block>{<decl><name>RED</name></decl><op:operator>,</op:operator> <decl><name>GREEN</name></decl><op:operator>,</op:operator> <decl><name>BLUE</name></decl>}</block>;</enum>

Default public Visibility

Element

  • <public type="default">

Example

struct Foo {

};
<struct>struct <name>Foo</name> <block>{<public type="default">

</public>}</block>;</struct>

public Visibility

Element

  • <public>

Example

class Foo {
public:
};
<class>class <name>Foo</name> <block>{<private type="default">
</private><public>public:
</public>}</block>;</class>

Default private Visibility

Element

  • <private type="default">

Example

class Foo
{

};
<class>class <name>Foo</name>
<block>{<private type="default">

</private>}</block>;</class>

private Visibility

Element

  • <private>

Example

struct Foo {
private:
};
<struct>struct <name>Foo</name> <block>{<public type="default">
</public><private>private:
</private>}</block>;</struct>

protected Visibility

Element

  • <protected>

Example

class Foo {
protected:
};
<class>class <name>Foo</name> <block>{<private type="default">
</private><protected>protected:
</protected>}</block>;</class>

protected Inheritance Specifier

Element

  • <specifier>

Example

class Foo
    :protected Bar
{ };
<class>class <name>Foo</name>
    <super>:<specifier>protected</specifier> <name>Bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>

private Inheritance Specifier

Element

  • <specifier>

Example

class Foo
    :private Bar
{ };
<class>class <name>Foo</name>
    <super>:<specifier>private</specifier> <name>Bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>

public Inheritance Specifier

Element

  • <specifier>

Example

class Foo
    :public Bar
{ };
<class>class <name>Foo</name>
    <super>:<specifier>public</specifier> <name>Bar</name></super>
<block>{<private type="default"> </private>}</block>;</class>

Inheritance List

Element

  • <super>

SubElement

  • <name>

Example

class Foo
    :Bar1, OtherBar
{ };
<class>class <name>Foo</name>
    <super>:<name>Bar1</name>, <name>OtherBar</name></super>
<block>{<private type="default"> </private>}</block>;</class>

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>
Sceope :: <op:operator>::</op:operator>
Pointer To Member .* <op:operator>.*</op:operator>
Dereference Pointer To Member ->* <op:operator>-&gt;*</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.