Attribute

Node describing an "attribute" as it appeared in the source. For example:
int x __attribute__ ((unused)); // Declaration with an Attribute

Anchor
AttributeArgument AttributeArgument

Attribute Argument

Node describing the arguments of an attribute. For example:

void f() __attribute__ ((interrupt("IRQ"))); // Attribute Argument "interrupt"

Attribute Group

Value is "\"IRQ\""

If the argument of an attribute is an expression that is evaluated to a constant, the value of the attribute is that constant converted to a stringNode describing an attribute group. For example:

alignas(sizeof(int)*2) int g; // Value is "8" - when sizeof(int) equals 4

If the argument of an attribute is a type name, the attribute value is the full name of that type. For example:

alignas(long long) int g; // Value is "long long"

Attribute Group

Node describing an attribute group. For example:

void fx1() { /* ... */; }
void fx2() __attribute__

void fx1() { /* ... */; }
void fx2() __attribute__((weak, alias("fx1")));// Both attributes have the same Attribute Group

Explicit Template Instance

Explicit template instances for types, functions and variables. For example:

template <typename T> void func(){}
template void func<int>(); // Explicit Template Instance
template <typename T> class C { T m1; };
template class C <int>; // Explicit Template Instance

Friend

Friend function declaration. For example:

void friendFunc();
class Foo {
public:
    friend void friendFunc();     // Friend
};

Functions

Function declarations. This includes Global and Member functions..

Global Function

Global function declaration. For example:

void globalFunc1();  
   // Global Function, IsDecl is true
   // IsImplementation is false
   // HasVoid is true	
void globalFunc2() { }     
   // Global Function, IsDecl is true
   // IsImplementation is true
   // HasEllipsis is true

Member Function

Member function declaration. For example:

class Foo {
public:
	Foo () {};	  // Member Function, IsDefaultConstructor is true
	void func();  // Member Function	
};

Parameter

Parameters include parameter and this.

Parameter

Function parameter declaration. For example:

void func(int i); // i is parameter whose type is int

This

Parameter usage. For example:

class T{
T* func(T t){return this; } //this parameter
}; } //this parameter
}

Anchor
static_assert static_assert

static_assert 

Static assertion declaration. For example:

static_assert(sizeof(int) == 8, "Incorrect size of int type");
    // Condition property points to: sizeof(int) == 8
    // Message property points to: "Incorrect size of int type"

Variables

Variables include global, local, and member variables.

Global Variable

Global Variable. For example:

int global;    // Global Variable, IsDecl is true
global = 3;    // Global Variable, IsDecl is false

Local Variable

Local Variable. For example:

void func() {
   int local;   // Local Variable, IsDecl is true
   local = 3;   // Local Variable, IsDecl is false
}

Member Variable

Member Variable. For example:

class Foo {
public:
  Foo() : member(0) { }  // Member Variable, IsDecl is false
private:
  int member;            // Member Variable, IsDecl is true
};

Block

Block statement. Normally contains other statements. Begins and ends with curly braces. For example:

void func() {       // block
}

Case Lable

Represents a case or default label in a switch statement. For example:

void func(int i) {
    switch(i) {
    case 1:             // Case Label
        break;          
    case 3:             // Case Label
    default:            // Case Label
        break;
    }
  }

Simple

A statement that does not fall into any other statement category. The simple statement's body usually contains an expression. For example:

void func(int & i) {
    i++;            // Simple statement
}

Empty

An empty ; statement. For example:

void func() {
    if(true);             // Empty statement
}

break

Break statement. For example:

bool bar();
void func() {
   while(1) {
      if (bar()) {
          break;    // break
      }
   }
}

case

Case statement. For example:

void func(int i) {
    switch(i) {
    case 1: { break; }  // case
    case 2: { break; }  // case
    }
}

catch

Catch statement used for exception handling. For example:

void bar();
void func(int i) {
    try {
       bar();
    } catch (...) {     // catch
    }
}

continue

Continue statement used in loops. For example:

bool bar(int);
void func(int i) {
    while(i--) {
       if (bar(i)) {
          continue;     // continue
       }
    }
}

default

Default statement used inside a switch statement. For example:

void func(int i) {
    switch(i) {
    case 1: { break; }
    case 2: { break; }
    default: { break; }            // default
    }
}

do

while

Do while loop statement. For example:

void func(int i) {
    do {                            // do while
        i--;
    } while (i);
}

for

For loop statement. For example:

void bar();
void func() {
   for (int i = 0; i < 10; i++) {  // for
      bar();
   }
}

for range

Range-based for loop statement. For example:

void bar();
void func() {
   for (auto iterator : range_expr) {  // for
      bar();
   }
}

goto

Goto statement. For example:

void func(bool done) {
   if (done) {
      goto end;             // goto
   }
   end:
}

if

If statement. For example:

void func(bool done) {
   if (done) {             // if
       return; 
   }
}

return

Return statement. For example:

int func() {
   return 0;               // return
}

switch

Switch statement. For example:

void func(int i) {
    switch(i) {             // switch
    case 1: { break; }
    case 2: { break; }
    default: { break; }
    }
}

try

Try statement. For example:

void bar();
void func(int i) {
    try {                  // try
        bar();
    } catch (...) {
    }
}

while

While statement. For example:

void func(int i) {
   while (i--) {  // while
   }
}

Complex

Non-primitive types. This category contains the following types:

Array

Array type. For example:

char buf[1024];   
      // buf is Variable of Type Array or Type char.

Builtin

Non-primitive type builtin for a given compiler.

Class

User-defined class type. For example:

class Foo { }; // class

Anchor
Decltype Decltype

Decltype

Type defined with the decltype specifier. For example:

int i;
decltype(i) k;            // k is Variable of Type Decltype to Type int.

Enum

User-defined enum type. For example:

enum E { }; //Enum type

Function

Function type. Used for function pointers. For example:

void foo(void (*ptr)(int)) {   // ptr is Pointer of Type Function
    ptr(3);
}

Reference

Reference type. Used for passing by reference. For example:

void func(int &i) {  // i is Parameter of Type Reference to Type int
   i = 3;
}

struct

Struct type. For example:

struct Foo { }; // struct

Template Parameter

A template parameter in template class declaration. For example:

template <typename T> class Temp{}; // Template Parameter: T

Typedef

Typedef type. For example:

typedef int INT;
INT x;            
      // x is Variable of Type Typedef to Type int.

Union

Union type. For example":

union MyUnion {   // union
    int x;
    char *y;
};

Primitive

All primitive types. This category contains the following types:

bool

Primitive type bool. For example:

bool b; // b is Variable of Type bool

char

Primitive type char. For example:

char c; // c is Variable of Type char

double

Primitive type double. For example:

double d; // d is Variable of Type double

float

is Variable of Type double

Anchor
double complex double complex

double complex

Type double _Complex. For example:

double _Complex fd;   // fd is Variable of Type double _Complex

float

Primitive type float. For example:

float f; // f is Variable of Type float

Anchor
float complex float complex

float complex

Type float _ComplexPrimitive type float. For example:

float

 _Complex fc;   //

 fc is Variable of Type float _Complex

int

Primitive type int. For example:

int i; // i is Variable of Type int

long

Primitive type long. For example:

long x; // x is Variable of Type long

long double

Primitive type long double. For example:

long double d; // d is Variable of Type long double

Anchor
long double complex long double complex

long double complex

Type long double _Complex. For example:

long double _Complex fd;   // fd is Variable of Type long double _Complex

pointer

Pointer type. For example:

char * name; 
 // name is Variable of Type pointer to type char.

short

Primitive type short. For example:

short x; // x is Variable of Type short

void

Primitive type void. Used for void pointers. For example:

void * p; 
 // p is Variable of Type pointer to type void.

wchar_t

Primitive type wchar_t. For example:

wchar_t c; // c is Variable of Type wchar_t

std::nullptr_t

The type of pointer literal. Example:

decltype(nullptr) t; // variable of std::nullptr_t type