Intuicio++ language syntax

grammar.h

#ifndef __GRAMMAR_H__
#define __GRAMMAR_H__

#include "std_extension.h"
#include <pegtl.hh>

namespace IntuicioPlusPlus
{
    namespace Grammar
    {

        struct expression;
        struct statement;
        struct statements;
        struct block;
        struct variable;
        struct identifier;
        struct access_struct;
        struct access_type;
        struct cast_suffix;
        struct type_specifier;
        namespace ControlFlow
        {
            struct inlined_condition;
        }
        namespace Function
        {
            struct definition_anonymous;
            namespace Call
            {
                struct arguments;
            }
            struct call;
        }
        namespace Class
        {
            struct type;
        }
        namespace MetaAttribute
        {
            struct meta_instance;
            struct definition;
        }
        struct semicolons : pegtl::plus< pegtl::one< ';' > > {};
        namespace Comment
        {
            struct inlined : pegtl::seq< pegtl::two< '/' >, pegtl::until< pegtl::eolf > > {};
            struct block : pegtl::seq< pegtl::string< '/', '*' >, pegtl::until< pegtl::string< '*', '/' > > > {};
        }
        struct comment : pegtl::sor< Comment::inlined, Comment::block > {};
        struct whitespaces : pegtl::plus< pegtl::sor< pegtl::space, comment > > {};
        struct whitespaces_any : pegtl::star< pegtl::sor< pegtl::space, comment > > {};
        struct static_keyword : pegtl::string< 's', 't', 'a', 't', 'i', 'c' > {};
        struct using_keyword : pegtl::string< 'u', 's', 'i', 'n', 'g' > {};
        struct namespace_keyword : pegtl::string< 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e' > {};
        struct namespace_block : pegtl::seq< namespace_keyword, whitespaces, identifier, pegtl::star< access_struct >, whitespaces_any, block > {};
        struct using_namespace_statement : pegtl::seq< using_keyword, whitespaces, namespace_keyword, whitespaces, identifier, pegtl::star< access_struct >, whitespaces_any, semicolons > {};
        struct public_keyword : pegtl::string< 'p', 'u', 'b', 'l', 'i', 'c' > {};
        struct private_keyword : pegtl::string< 'p', 'r', 'i', 'v', 'a', 't', 'e' > {};
        struct protected_keyword : pegtl::string< 'p', 'r', 'o', 't', 'e', 'c', 't', 'e', 'd' > {};
        struct internal_keyword : pegtl::string< 'i', 'n', 't', 'e', 'r', 'n', 'a', 'l' > {};
        struct access_mode : pegtl::sor< public_keyword, private_keyword, protected_keyword, internal_keyword > {};
        struct identifier : pegtl::identifier {};
        struct array_specifier : pegtl::seq< pegtl::one< '[' >, whitespaces_any, expression, whitespaces_any, pegtl::one< ']' > > {};
        struct alias_keyword : pegtl::string< 'a', 'l', 'i', 'a', 's' > {};
        struct alias_statement : pegtl::seq< alias_keyword, whitespaces, identifier, type_specifier, whitespaces_any, semicolons > {};;
        struct default_keyword : pegtl::string< 'd', 'e', 'f', 'a', 'u', 'l', 't' > {};
        struct default_value : pegtl::seq< default_keyword, whitespaces, Class::type, pegtl::star< access_type > > {};
        struct new_keyword : pegtl::string< 'n', 'e', 'w' > {};
        struct delete_keyword : pegtl::string< 'd', 'e', 'l', 'e', 't', 'e' > {};
        struct object_create : pegtl::seq< new_keyword, whitespaces, pegtl::sor< Function::call, pegtl::seq< identifier, pegtl::star< access_struct > > >, whitespaces_any, pegtl::opt< array_specifier > > {};
        struct object_destroy_statement : pegtl::seq< delete_keyword, whitespaces, expression, whitespaces_any, semicolons > {};
        namespace Number
        {
            struct integer_literal : pegtl::seq< pegtl::opt< pegtl::one< '+', '-' > >, pegtl::plus< pegtl::digit > > {};
            struct float_literal : pegtl::seq< pegtl::opt< pegtl::one< '+', '-' > >, pegtl::plus< pegtl::digit >, pegtl::one< '.' >, pegtl::plus< pegtl::digit > > {};
            struct hex_literal : pegtl::seq< pegtl::string< '0', 'x' >, pegtl::plus< pegtl::xdigit > > {};
        }
        struct number : pegtl::sor< Number::hex_literal, Number::float_literal, Number::integer_literal > {};
        namespace String
        {
            struct unicode : pegtl::seq< pegtl::one< 'u' >, pegtl::rep< 4, pegtl::must< pegtl::xdigit > > > {};
            struct escaped_character : pegtl::one< '"', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
            struct escaped : pegtl::sor< escaped_character, unicode > {};
            struct unescaped : pegtl::utf8::range< 0x20, 0x10FFFF > {};
            struct character : pegtl::if_then_else< pegtl::one< '\\' >, pegtl::must< escaped >, unescaped > {};
        }
        struct string : pegtl::seq< pegtl::one< '"' >, pegtl::until< pegtl::one< '"' >, String::character > > {};
        struct access_struct : pegtl::seq< whitespaces_any, pegtl::one< '.' >, whitespaces_any, identifier > {};
        struct access_type : pegtl::seq< whitespaces_any, pegtl::one< '.' >, whitespaces_any, Class::type > {};
        struct access_array : pegtl::seq< whitespaces_any, pegtl::one< '[' >, whitespaces_any, expression, whitespaces_any, pegtl::one< ']' > > {};
        struct access : pegtl::sor< access_struct, access_type, access_array > {};
        struct value : pegtl::seq< pegtl::sor< default_value, object_create, Function::definition_anonymous, Function::call, ControlFlow::inlined_condition, identifier, number, string >, pegtl::star< access >, pegtl::opt< cast_suffix > > {};
        struct type_data : pegtl::seq< Class::type, pegtl::star< access_type > > {};
        struct type_object : pegtl::seq< pegtl::one< '^' >, whitespaces_any, Class::type, pegtl::star< access_type > > {};
        struct type_pointer : pegtl::seq< pegtl::one< '*' >, whitespaces_any, Class::type, pegtl::star< access_type > > {};
        struct type_specifier : pegtl::seq< whitespaces_any, pegtl::one< ':' >, whitespaces_any, pegtl::sor< type_pointer, type_object, type_data > > {};
        struct cast_suffix : pegtl::seq< whitespaces_any, pegtl::string< '-', '>' >, whitespaces_any, pegtl::opt< pegtl::sor< type_pointer, type_object, type_data > > > {};
        namespace Operators
        {
            struct add : pegtl::one< '+' > {};
            struct subtract : pegtl::one< '-' > {};
            struct multiply : pegtl::one< '*' > {};
            struct divide : pegtl::one< '/' > {};
            struct assign : pegtl::one< '=' > {};
            struct add_assign : pegtl::string< '+', '=' > {};
            struct subtract_assign : pegtl::string< '-', '=' > {};
            struct multiply_assign : pegtl::string< '*', '=' > {};
            struct divide_assign : pegtl::string< '/', '=' > {};
            struct negate_assign : pegtl::string< '~', '=' > {};
            struct increment : pegtl::two< '+' > {};
            struct decrement : pegtl::two< '-' > {};
            struct logical_and : pegtl::two< '&' > {};
            struct logical_or : pegtl::two< '|' > {};
            struct logical_not : pegtl::one< '!' > {};
            struct bitwise_and : pegtl::one< '&' > {};
            struct bitwise_or : pegtl::one< '|' > {};
            struct bitwise_xor : pegtl::one< '^' > {};
            struct bitwise_not : pegtl::one< '~' > {};
            struct bitwise_lshift : pegtl::two< '<' > {};
            struct bitwise_rshift : pegtl::two< '>' > {};
            struct conditional_equal : pegtl::two< '=' > {};
            struct conditional_not_equal : pegtl::sor< pegtl::string< '!', '=' >, pegtl::string< '<', '>' > > {};
            struct conditional_less : pegtl::one< '<' > {};
            struct conditional_greater : pegtl::one< '>' > {};
            struct conditional_less_or_equal : pegtl::string< '<', '=' > {};
            struct conditional_greater_or_equal : pegtl::string< '>', '=' > {};
            struct array_access_operator : pegtl::string< '[', ']' > {};
            struct operation_prefix : pegtl::sor< subtract, logical_not, bitwise_not, increment, decrement > {};
            struct operation_suffix : pegtl::sor< increment, decrement > {};
            struct binary_operation : pegtl::sor< add, subtract, multiply, divide > {};
            struct logical_operation : pegtl::sor< logical_and, logical_or > {};
            struct bitwise_operation : pegtl::sor< bitwise_and, bitwise_or, bitwise_xor, bitwise_lshift, bitwise_rshift > {};
            struct conditional_operation : pegtl::sor< conditional_equal, conditional_not_equal, conditional_less_or_equal, conditional_greater_or_equal, conditional_less, conditional_greater > {};
            struct operation : pegtl::sor< conditional_operation, binary_operation, logical_operation, bitwise_operation > {};
            struct assignment : pegtl::sor< assign, add_assign, subtract_assign, multiply_assign, divide_assign, negate_assign > {};
        }
        namespace ControlFlow
        {
            struct return_keyword : pegtl::string< 'r', 'e', 't', 'u', 'r', 'n' > {};
            struct return_statement : pegtl::seq< return_keyword, whitespaces_any, expression, whitespaces_any, semicolons > {};
            struct continue_keyword : pegtl::string< 'c', 'o', 'n', 't', 'i', 'n', 'u', 'e' > {};
            struct continue_statement : pegtl::seq< continue_keyword, whitespaces_any, semicolons > {};
            struct break_keyword : pegtl::string< 'b', 'r', 'e', 'a', 'k' > {};
            struct break_statement : pegtl::seq< break_keyword, whitespaces_any, semicolons > {};
            struct if_keyword : pegtl::string< 'i', 'f' > {};
            struct else_keyword : pegtl::string< 'e', 'l', 's', 'e' > {};
            struct if_statement : pegtl::seq< if_keyword, whitespaces_any, expression, whitespaces_any, pegtl::sor< block, statement > > {};
            struct else_if_statement : pegtl::seq< else_keyword, whitespaces_any, if_statement > {};
            struct else_statement : pegtl::seq< else_keyword, whitespaces_any, pegtl::sor< block, statement > > {};
            struct condition_statement : pegtl::seq< if_statement, whitespaces_any, pegtl::star< else_if_statement, whitespaces_any >, pegtl::opt< else_statement > > {};
            struct inlined_condition_test : pegtl::sor< expression > {};
            struct inlined_condition_true : pegtl::sor< expression > {};
            struct inlined_condition_false : pegtl::sor< expression > {};
            struct inlined_condition : pegtl::seq< pegtl::one< '?' >, whitespaces_any, pegtl::one< '(' >, whitespaces_any, inlined_condition_test, whitespaces_any, pegtl::one< ';' >, whitespaces_any, inlined_condition_true, whitespaces_any, pegtl::one< ';' >, whitespaces_any, inlined_condition_false, whitespaces_any, pegtl::one< ')' > > {};
            struct for_keyword : pegtl::string< 'f', 'o', 'r' > {};
            struct for_stage_init : pegtl::opt< pegtl::sor< variable, expression > > {};
            struct for_stage_condition : pegtl::opt< expression > {};
            struct for_stage_iteration : pegtl::opt< expression > {};
            struct for_stages : pegtl::seq< pegtl::one< '(' >, whitespaces_any, for_stage_init, whitespaces_any, pegtl::one< ';' >, whitespaces_any, for_stage_condition, whitespaces_any, pegtl::one< ';' >, whitespaces_any, for_stage_iteration, whitespaces_any, pegtl::one< ')' > > {};
            struct for_statement : pegtl::seq< for_keyword, whitespaces_any, for_stages, whitespaces_any, pegtl::sor< block, statement > > {};
            struct foreach_keyword : pegtl::string< 'f', 'o', 'r', 'e', 'a', 'c', 'h' > {};
            struct foreach_stage : pegtl::seq< pegtl::one< '(' >, whitespaces_any, variable, whitespaces_any, pegtl::string< 'i', 'n' >, whitespaces_any, pegtl::sor< value, expression >, whitespaces_any, pegtl::one< ')' > > {};
            struct foreach_statement : pegtl::seq< foreach_keyword, whitespaces_any, foreach_stage, whitespaces_any, pegtl::sor< block, statement > > {};
            struct while_keyword : pegtl::string< 'w', 'h', 'i', 'l', 'e' > {};
            struct while_statement : pegtl::seq< while_keyword, whitespaces_any, expression, whitespaces_any, pegtl::sor< block, statement > > {};
        }
        namespace Variable
        {
            struct assignment;
            struct declaration : pegtl::seq< pegtl::opt< access_mode, whitespaces >, pegtl::opt< static_keyword, whitespaces >, identifier, type_specifier > {};
            struct assignment_expression : pegtl::sor< assignment, expression > {};
            struct declaration_assignment : pegtl::seq< declaration, whitespaces_any, Operators::assign, whitespaces_any, assignment_expression > {};
            struct declaration_instantiation : pegtl::seq< declaration, whitespaces_any, Function::Call::arguments > {};
            struct assignment : pegtl::seq< identifier, pegtl::star< access >, pegtl::opt< cast_suffix >, whitespaces_any, Operators::assignment, whitespaces_any, assignment_expression > {};
        }
        struct variable : pegtl::sor< Variable::declaration_assignment, Variable::declaration_instantiation, Variable::declaration, Variable::assignment > {};
        struct variable_statement : pegtl::seq< variable, whitespaces_any, semicolons > {};
        struct block : pegtl::seq< pegtl::one< '{' >, whitespaces_any, pegtl::opt< statements >, whitespaces_any, pegtl::one< '}' > > {};
        namespace Function
        {
            namespace Definition
            {
                struct argument_list : pegtl::opt< Variable::declaration, whitespaces_any, pegtl::star< pegtl::one< ',' >, whitespaces_any, Variable::declaration > > {};
                struct arguments : pegtl::seq< pegtl::one< '(' >, whitespaces_any, argument_list, whitespaces_any, pegtl::one< ')' > > {};
            }
            struct definition_statement : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, pegtl::opt< static_keyword, whitespaces >, identifier, whitespaces_any, Definition::arguments, type_specifier, whitespaces_any, block > {};
            struct definition_anonymous : pegtl::seq< pegtl::one< '@' >, whitespaces_any, Definition::arguments, type_specifier, whitespaces_any, block > {};
            struct definition_operator_statement : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, pegtl::opt< static_keyword, whitespaces >, pegtl::sor< Operators::operation, Operators::array_access_operator >, whitespaces_any, Definition::arguments, type_specifier, whitespaces_any, block > {};
            namespace Call
            {
                struct argument_list : pegtl::opt< expression, whitespaces_any, pegtl::star< pegtl::one< ',' >, whitespaces_any, expression > > {};
                struct arguments : pegtl::seq< pegtl::one< '(' >, whitespaces_any, argument_list, whitespaces_any, pegtl::one< ')' > > {};
            }
            struct call : pegtl::seq< identifier, pegtl::star< access_struct >, whitespaces_any, Call::arguments > {};
            struct call_statement : pegtl::seq< call, whitespaces_any, semicolons > {};
        }
        namespace Class
        {
            struct template_parameters;
            struct keyword : pegtl::string< 'c', 'l', 'a', 's', 's' > {};
            struct get_keyword : pegtl::string< 'g', 'e', 't' > {};
            struct set_keyword : pegtl::string< 's', 'e', 't' > {};
            struct type : pegtl::seq< identifier, whitespaces_any, pegtl::opt< template_parameters > > {};
            struct template_parameters : pegtl::seq< pegtl::one< '<' >, whitespaces_any, type, whitespaces_any, pegtl::star< pegtl::one< ',' >, whitespaces_any, type, whitespaces_any >, pegtl::one< '>' > > {};
            struct inheritance : pegtl::seq< whitespaces_any, pegtl::one< ':' >, whitespaces_any, type, pegtl::star< whitespaces_any, pegtl::one< ',' >, whitespaces_any, type > > {};
            struct constructor : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, identifier, whitespaces_any, Function::Definition::arguments, whitespaces_any, block > {};
            struct destructor : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, pegtl::one< '~' >, identifier, whitespaces_any, Function::Definition::arguments, whitespaces_any, block > {};
            struct property_getter : pegtl::seq< pegtl::opt< access_mode, whitespaces >, get_keyword, whitespaces_any, block > {};
            struct property_setter : pegtl::seq< pegtl::opt< access_mode, whitespaces >, set_keyword, whitespaces_any, block > {};
            struct property : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, pegtl::opt< static_keyword, whitespaces >, Variable::declaration, whitespaces_any, pegtl::one< '{' >, whitespaces_any, pegtl::opt< property_getter >, whitespaces_any, pegtl::opt< property_setter >, whitespaces_any, pegtl::one< '}' > > {};
            struct body : pegtl::seq< pegtl::one< '{' >, whitespaces_any, pegtl::star< pegtl::sor< destructor, constructor, property, variable_statement, Function::definition_operator_statement, Function::definition_statement >, whitespaces_any >, pegtl::one< '}' > > {};
            struct definition_statement : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, keyword, whitespaces, identifier, whitespaces_any, pegtl::opt< template_parameters, whitespaces_any >, pegtl::opt< inheritance, whitespaces_any >, body > {};
        }
        namespace Enumeration
        {
            struct keyword : pegtl::string< 'e', 'n', 'u', 'm' > {};
            struct field : pegtl::seq< identifier, pegtl::opt< whitespaces_any, Operators::assign, whitespaces_any, pegtl::sor< value, expression > > > {};
            struct body : pegtl::seq< pegtl::one< '{' >, whitespaces_any, field, whitespaces_any, pegtl::star< pegtl::one< ',' >, whitespaces_any, field, whitespaces_any >, pegtl::one< '}' > > {};
            struct definition_statement : pegtl::seq< pegtl::star< MetaAttribute::definition, whitespaces_any >, pegtl::opt< access_mode, whitespaces >, keyword, whitespaces, identifier, pegtl::opt< type_specifier >, whitespaces_any, body > {};
        }
        namespace MetaAttribute
        {
            struct meta_instance : pegtl::seq< identifier, pegtl::star< access_struct >, whitespaces_any, pegtl::opt< Function::Call::arguments > > {};
            struct definition : pegtl::seq< pegtl::one< '[' >, whitespaces_any, meta_instance, whitespaces_any, pegtl::star< pegtl::one< ',' >, whitespaces_any, meta_instance, whitespaces_any >, pegtl::one< ']' > > {};
        }
        namespace Parallel
        {
            struct keyword : pegtl::string< 'p', 'a', 'r', 'a', 'l', 'l', 'e', 'l' > {};
            struct local_mode : pegtl::string< 'l', 'o', 'c', 'a', 'l' > {};
            struct parent_mode : pegtl::string< 'p', 'a', 'r', 'e', 'n', 't' > {};
            struct global_mode : pegtl::string< 'g', 'l', 'o', 'b', 'a', 'l' > {};
            struct with_keyword : pegtl::string< 'w', 'i', 't', 'h' > {};
            struct mode : pegtl::sor< local_mode, parent_mode, global_mode > {};
            struct hardware_repeats : pegtl::string< 'h', 'a', 'r', 'd', 'w', 'a', 'r', 'e' > {};
            struct repeats : pegtl::sor< hardware_repeats, Number::integer_literal > {};
            struct block_statement : pegtl::seq< keyword, whitespaces, mode, whitespaces, repeats, whitespaces_any, block > {};
            struct group_statement : pegtl::seq< keyword, whitespaces, mode, whitespaces_any, block, pegtl::star< whitespaces_any, with_keyword, whitespaces_any, block > > {};
        }
        struct parallel : pegtl::sor< Parallel::block_statement, Parallel::group_statement > {};
        struct expression_bracket : pegtl::seq< pegtl::one< '(' >, whitespaces_any, expression, whitespaces_any, pegtl::one< ')' > > {};
        struct expression_atomic : pegtl::seq< pegtl::opt< Operators::operation_prefix >, whitespaces_any, pegtl::sor< expression_bracket, value >, pegtl::opt< whitespaces_any, Operators::operation_suffix >, pegtl::opt< cast_suffix > > {};
        struct expression : pegtl::seq< expression_atomic, pegtl::star< whitespaces_any, Operators::operation, whitespaces_any, expression_atomic > > {};
        struct expression_statement : pegtl::seq< expression, whitespaces_any, semicolons > {};
        struct isc_inlined_statement : pegtl::seq< pegtl::string< 'i', 's', 'c' >, pegtl::plus< whitespaces_any, string >, whitespaces_any, semicolons > {};
        struct statement : pegtl::sor< comment, block, namespace_block, parallel, using_namespace_statement, alias_statement, object_destroy_statement, variable_statement, ControlFlow::while_statement, ControlFlow::for_statement, ControlFlow::foreach_statement, ControlFlow::condition_statement, ControlFlow::return_statement, ControlFlow::continue_statement, ControlFlow::break_statement, Function::call_statement, Function::definition_statement, Function::definition_operator_statement, Enumeration::definition_statement, Class::definition_statement, isc_inlined_statement, expression_statement > {};
        struct statements : pegtl::plus< pegtl::seq< whitespaces_any, statement, whitespaces_any > > {};
        struct grammar : pegtl::must< pegtl::opt< statements >, pegtl::eof > {};

    }
}

#endif

main.ast

[1]()
[2]-(statement)
[3]--(namespace_block)
[4]---(identifier)Some
[5]---(access_struct)
[6]----(identifier)Test
[7]---(access_struct)
[8]----(identifier)Namespace
[9]---(block)
[10]----(statement)
[11]-----(class.definition_statement)
[12]------(meta_attribute.definition)
[13]-------(meta_attribute.meta_instance)
[14]--------(identifier)MetaAttribute
[15]------(identifier)Something
[16]------(class.body)
[17]-------(class.constructor)
[18]--------(identifier)Something
[19]--------(function.definition.arguments)
[20]---------(function.definition.argument_list)
[21]----------(variable.declaration)
[22]-----------(identifier)n
[23]-----------(type_specifier)
[24]------------(type_object)
[25]-------------(class.type)
[26]--------------(identifier)string
[27]--------(block)
[28]---------(statement)
[29]----------(variable_statement)
[30]-----------(variable)
[31]------------(variable.assignment)
[32]-------------(identifier)name
[33]-------------(operators.assignment)
[34]--------------(operators.assign)=
[35]-------------(variable.assignment_expression)
[36]--------------(expression)
[37]---------------(expression_atomic)
[38]----------------(value)
[39]-----------------(identifier)n
[40]-------(variable_statement)
[41]--------(variable)
[42]---------(variable.declaration_assignment)
[43]----------(variable.declaration)
[44]-----------(identifier)name
[45]-----------(type_specifier)
[46]------------(type_object)
[47]-------------(class.type)
[48]--------------(identifier)string
[49]----------(operators.assign)=
[50]----------(variable.assignment_expression)
[51]-----------(expression)
[52]------------(expression_atomic)
[53]-------------(value)
[54]--------------(identifier)null
[55]----(statement)
[56]-----(class.definition_statement)
[57]------(meta_attribute.definition)
[58]-------(meta_attribute.meta_instance)
[59]--------(identifier)Something
[60]--------(function.call.arguments)
[61]---------(function.call.argument_list)
[62]----------(expression)
[63]-----------(expression_atomic)
[64]------------(value)
[65]-------------(string)"string automatically wrapped in managed object"
[66]------(meta_attribute.definition)
[67]-------(meta_attribute.meta_instance)
[68]--------(identifier)Fuckin
[69]--------(access_struct)
[70]---------(identifier)Amazin
[71]--------(access_struct)
[72]---------(identifier)Attribute
[73]-------(meta_attribute.meta_instance)
[74]--------(identifier)And
[75]--------(access_struct)
[76]---------(identifier)Another
[77]--------(access_struct)
[78]---------(identifier)Attribute
[79]------(access_mode)
[80]-------(internal_keyword)internal
[81]------(identifier)Test
[82]------(class.body)
[83]-------(variable_statement)
[84]--------(variable)
[85]---------(variable.declaration_assignment)
[86]----------(variable.declaration)
[87]-----------(static_keyword)static
[88]-----------(identifier)default
[89]-----------(type_specifier)
[90]------------(type_data)
[91]-------------(class.type)
[92]--------------(identifier)Test
[93]----------(operators.assign)=
[94]----------(variable.assignment_expression)
[95]-----------(expression)
[96]------------(expression_atomic)
[97]-------------(value)
[98]--------------(function.call)
[99]---------------(identifier)Test
[100]---------------(function.call.arguments)
[101]----------------(function.call.argument_list)
[102]-----------------(expression)
[103]------------------(expression_atomic)
[104]-------------------(value)
[105]--------------------(number)
[106]---------------------(number.integer_literal)0
[107]-------(class.constructor)
[108]--------(access_mode)
[109]---------(public_keyword)public
[110]--------(identifier)Test
[111]--------(function.definition.arguments)
[112]---------(function.definition.argument_list)
[113]----------(variable.declaration)
[114]-----------(identifier)v
[115]-----------(type_specifier)
[116]------------(type_data)
[117]-------------(class.type)
[118]--------------(identifier)int
[119]--------(block)
[120]---------(statement)
[121]----------(variable_statement)
[122]-----------(variable)
[123]------------(variable.assignment)
[124]-------------(identifier)V
[125]-------------(operators.assignment)
[126]--------------(operators.assign)=
[127]-------------(variable.assignment_expression)
[128]--------------(expression)
[129]---------------(expression_atomic)
[130]----------------(value)
[131]-----------------(identifier)v
[132]-------(class.destructor)
[133]--------(access_mode)
[134]---------(private_keyword)private
[135]--------(identifier)Test
[136]--------(function.definition.arguments)
[137]---------(function.definition.argument_list)
[138]--------(block)
[139]---------(statement)
[140]----------(variable_statement)
[141]-----------(variable)
[142]------------(variable.assignment)
[143]-------------(identifier)V
[144]-------------(operators.assignment)
[145]--------------(operators.assign)=
[146]-------------(variable.assignment_expression)
[147]--------------(expression)
[148]---------------(expression_atomic)
[149]----------------(value)
[150]-----------------(number)
[151]------------------(number.integer_literal)0
[152]-------(function.definition_operator_statement)
[153]--------(meta_attribute.definition)
[154]---------(meta_attribute.meta_instance)
[155]----------(identifier)ShittyOperator
[156]--------(access_mode)
[157]---------(public_keyword)public
[158]--------(static_keyword)static
[159]--------(operators.operation)
[160]---------(operators.binary_operation)
[161]----------(operators.add)+
[162]--------(function.definition.arguments)
[163]---------(function.definition.argument_list)
[164]----------(variable.declaration)
[165]-----------(identifier)a
[166]-----------(type_specifier)
[167]------------(type_data)
[168]-------------(class.type)
[169]--------------(identifier)Test
[170]----------(variable.declaration)
[171]-----------(identifier)b
[172]-----------(type_specifier)
[173]------------(type_data)
[174]-------------(class.type)
[175]--------------(identifier)Test
[176]--------(type_specifier)
[177]---------(type_data)
[178]----------(class.type)
[179]-----------(identifier)Test
[180]--------(block)
[181]---------(statement)
[182]----------(control_flow.return_statement)
[183]-----------(control_flow.return_keyword)return
[184]-----------(expression)
[185]------------(expression_atomic)
[186]-------------(value)
[187]--------------(function.call)
[188]---------------(identifier)Test
[189]---------------(function.call.arguments)
[190]----------------(function.call.argument_list)
[191]-----------------(expression)
[192]------------------(expression_atomic)
[193]-------------------(value)
[194]--------------------(identifier)a
[195]--------------------(access)
[196]---------------------(access_struct)
[197]----------------------(identifier)V
[198]------------------(operators.operation)
[199]-------------------(operators.binary_operation)
[200]--------------------(operators.add)+
[201]------------------(expression_atomic)
[202]-------------------(value)
[203]--------------------(identifier)b
[204]--------------------(access)
[205]---------------------(access_struct)
[206]----------------------(identifier)V
[207]-------(class.property)
[208]--------(meta_attribute.definition)
[209]---------(meta_attribute.meta_instance)
[210]----------(identifier)DunnoWhyImFor
[211]--------(access_mode)
[212]---------(public_keyword)public
[213]--------(variable.declaration)
[214]---------(identifier)V
[215]---------(type_specifier)
[216]----------(type_data)
[217]-----------(class.type)
[218]------------(identifier)int
[219]--------(class.property_getter)
[220]---------(block)
[221]----------(statement)
[222]-----------(control_flow.return_statement)
[223]------------(control_flow.return_keyword)return
[224]------------(expression)
[225]-------------(expression_atomic)
[226]--------------(value)
[227]---------------(identifier)m_v
[228]--------(class.property_setter)
[229]---------(access_mode)
[230]----------(internal_keyword)internal
[231]---------(block)
[232]----------(statement)
[233]-----------(variable_statement)
[234]------------(variable)
[235]-------------(variable.assignment)
[236]--------------(identifier)m_v
[237]--------------(operators.assignment)
[238]---------------(operators.assign)=
[239]--------------(variable.assignment_expression)
[240]---------------(expression)
[241]----------------(expression_atomic)
[242]-----------------(value)
[243]------------------(identifier)value
[244]-------(variable_statement)
[245]--------(variable)
[246]---------(variable.declaration_assignment)
[247]----------(variable.declaration)
[248]-----------(access_mode)
[249]------------(protected_keyword)protected
[250]-----------(identifier)m_v
[251]-----------(type_specifier)
[252]------------(type_data)
[253]-------------(class.type)
[254]--------------(identifier)int
[255]----------(operators.assign)=
[256]----------(variable.assignment_expression)
[257]-----------(expression)
[258]------------(expression_atomic)
[259]-------------(value)
[260]--------------(number)
[261]---------------(number.integer_literal)0
[262]-(statement)
[263]--(class.definition_statement)
[264]---(identifier)Array
[265]---(class.template_parameters)
[266]----(class.type)
[267]-----(identifier)T
[268]---(class.body)
[269]----(class.constructor)
[270]-----(identifier)Array
[271]-----(function.definition.arguments)
[272]------(function.definition.argument_list)
[273]-------(variable.declaration)
[274]--------(identifier)c
[275]--------(type_specifier)
[276]---------(type_data)
[277]----------(class.type)
[278]-----------(identifier)int
[279]-----(block)
[280]------(statement)
[281]-------(variable_statement)
[282]--------(variable)
[283]---------(variable.assignment)
[284]----------(identifier)values
[285]----------(operators.assignment)
[286]-----------(operators.assign)=
[287]----------(variable.assignment_expression)
[288]-----------(expression)
[289]------------(expression_atomic)
[290]-------------(value)
[291]--------------(object_create)
[292]---------------(new_keyword)new
[293]---------------(function.call)
[294]----------------(identifier)T
[295]----------------(function.call.arguments)
[296]-----------------(function.call.argument_list)
[297]------------------(expression)
[298]-------------------(expression_atomic)
[299]--------------------(value)
[300]---------------------(default_value)
[301]----------------------(default_keyword)default
[302]----------------------(class.type)
[303]-----------------------(identifier)T
[304]---------------(array_specifier)
[305]----------------(expression)
[306]-----------------(expression_atomic)
[307]------------------(value)
[308]-------------------(identifier)c
[309]------(statement)
[310]-------(variable_statement)
[311]--------(variable)
[312]---------(variable.assignment)
[313]----------(identifier)count
[314]----------(operators.assignment)
[315]-----------(operators.assign)=
[316]----------(variable.assignment_expression)
[317]-----------(expression)
[318]------------(expression_atomic)
[319]-------------(value)
[320]--------------(identifier)c
[321]----(class.destructor)
[322]-----(identifier)Array
[323]-----(function.definition.arguments)
[324]------(function.definition.argument_list)
[325]-----(block)
[326]------(statement)
[327]-------(object_destroy_statement)
[328]--------(delete_keyword)delete
[329]--------(expression)
[330]---------(expression_atomic)
[331]----------(value)
[332]-----------(identifier)values
[333]------(statement)
[334]-------(variable_statement)
[335]--------(variable)
[336]---------(variable.assignment)
[337]----------(identifier)values
[338]----------(operators.assignment)
[339]-----------(operators.assign)=
[340]----------(variable.assignment_expression)
[341]-----------(expression)
[342]------------(expression_atomic)
[343]-------------(value)
[344]--------------(identifier)null
[345]----(function.definition_operator_statement)
[346]-----(operators.array_access_operator)[]
[347]-----(function.definition.arguments)
[348]------(function.definition.argument_list)
[349]-------(variable.declaration)
[350]--------(identifier)v
[351]--------(type_specifier)
[352]---------(type_data)
[353]----------(class.type)
[354]-----------(identifier)int
[355]-----(type_specifier)
[356]------(type_data)
[357]-------(class.type)
[358]--------(identifier)T
[359]-----(block)
[360]------(statement)
[361]-------(control_flow.return_statement)
[362]--------(control_flow.return_keyword)return
[363]--------(expression)
[364]---------(expression_atomic)
[365]----------(value)
[366]-----------(identifier)values
[367]-----------(access)
[368]------------(access_array)
[369]-------------(expression)
[370]--------------(expression_atomic)
[371]---------------(value)
[372]----------------(identifier)v
[373]----(class.property)
[374]-----(meta_attribute.definition)
[375]------(meta_attribute.meta_instance)
[376]-------(identifier)IterationStart
[377]-----(variable.declaration)
[378]------(identifier)Start
[379]------(type_specifier)
[380]-------(type_data)
[381]--------(class.type)
[382]---------(identifier)int
[383]-----(class.property_getter)
[384]------(block)
[385]-------(statement)
[386]--------(control_flow.return_statement)
[387]---------(control_flow.return_keyword)return
[388]---------(expression)
[389]----------(expression_atomic)
[390]-----------(value)
[391]------------(number)
[392]-------------(number.integer_literal)0
[393]----(class.property)
[394]-----(meta_attribute.definition)
[395]------(meta_attribute.meta_instance)
[396]-------(identifier)IterationStop
[397]-----(variable.declaration)
[398]------(identifier)Stop
[399]------(type_specifier)
[400]-------(type_data)
[401]--------(class.type)
[402]---------(identifier)int
[403]-----(class.property_getter)
[404]------(block)
[405]-------(statement)
[406]--------(control_flow.return_statement)
[407]---------(control_flow.return_keyword)return
[408]---------(expression)
[409]----------(expression_atomic)
[410]-----------(value)
[411]------------(identifier)count
[412]----(variable_statement)
[413]-----(variable)
[414]------(variable.declaration_assignment)
[415]-------(variable.declaration)
[416]--------(identifier)values
[417]--------(type_specifier)
[418]---------(type_pointer)
[419]----------(class.type)
[420]-----------(identifier)T
[421]-------(operators.assign)=
[422]-------(variable.assignment_expression)
[423]--------(expression)
[424]---------(expression_atomic)
[425]----------(value)
[426]-----------(identifier)null
[427]----(variable_statement)
[428]-----(variable)
[429]------(variable.declaration_assignment)
[430]-------(variable.declaration)
[431]--------(identifier)count
[432]--------(type_specifier)
[433]---------(type_data)
[434]----------(class.type)
[435]-----------(identifier)int
[436]-------(operators.assign)=
[437]-------(variable.assignment_expression)
[438]--------(expression)
[439]---------(expression_atomic)
[440]----------(value)
[441]-----------(number)
[442]------------(number.integer_literal)0
[443]-(statement)
[444]--(alias_statement)
[445]---(alias_keyword)alias
[446]---(identifier)TestArray
[447]---(type_specifier)
[448]----(type_data)
[449]-----(class.type)
[450]------(identifier)Template
[451]------(class.template_parameters)
[452]-------(class.type)
[453]--------(identifier)Test
[454]-(statement)
[455]--(variable_statement)
[456]---(variable)
[457]----(variable.declaration_assignment)
[458]-----(variable.declaration)
[459]------(identifier)t1
[460]------(type_specifier)
[461]-------(type_data)
[462]--------(class.type)
[463]---------(identifier)TestArray
[464]-----(operators.assign)=
[465]-----(variable.assignment_expression)
[466]------(expression)
[467]-------(expression_atomic)
[468]--------(value)
[469]---------(function.call)
[470]----------(identifier)TestArray
[471]----------(function.call.arguments)
[472]-----------(function.call.argument_list)
[473]------------(expression)
[474]-------------(expression_atomic)
[475]--------------(value)
[476]---------------(number)
[477]----------------(number.integer_literal)1
[478]-(statement)
[479]--(variable_statement)
[480]---(variable)
[481]----(variable.declaration_assignment)
[482]-----(variable.declaration)
[483]------(identifier)t2
[484]------(type_specifier)
[485]-------(type_data)
[486]--------(class.type)
[487]---------(identifier)TestArray
[488]-----(operators.assign)=
[489]-----(variable.assignment_expression)
[490]------(expression)
[491]-------(expression_atomic)
[492]--------(value)
[493]---------(function.call)
[494]----------(identifier)TestArray
[495]----------(function.call.arguments)
[496]-----------(function.call.argument_list)
[497]------------(expression)
[498]-------------(expression_atomic)
[499]--------------(value)
[500]---------------(number)
[501]----------------(number.integer_literal)1
[502]-(statement)
[503]--(variable_statement)
[504]---(variable)
[505]----(variable.assignment)
[506]-----(identifier)t1
[507]-----(access)
[508]------(access_array)
[509]-------(expression)
[510]--------(expression_atomic)
[511]---------(value)
[512]----------(number)
[513]-----------(number.integer_literal)0
[514]-----(operators.assignment)
[515]------(operators.add_assign)+=
[516]-----(variable.assignment_expression)
[517]------(expression)
[518]-------(expression_atomic)
[519]--------(value)
[520]---------(identifier)t2
[521]---------(access)
[522]----------(access_array)
[523]-----------(expression)
[524]------------(expression_atomic)
[525]-------------(value)
[526]--------------(number)
[527]---------------(number.integer_literal)0
[528]-(statement)
[529]--(class.definition_statement)
[530]---(identifier)MutableArray
[531]---(class.template_parameters)
[532]----(class.type)
[533]-----(identifier)T
[534]---(class.inheritance)
[535]----(class.type)
[536]-----(identifier)Array
[537]-----(class.template_parameters)
[538]------(class.type)
[539]-------(identifier)T
[540]---(class.body)
[541]----(class.constructor)
[542]-----(identifier)MutableArray
[543]-----(function.definition.arguments)
[544]------(function.definition.argument_list)
[545]-------(variable.declaration)
[546]--------(identifier)c
[547]--------(type_specifier)
[548]---------(type_data)
[549]----------(class.type)
[550]-----------(identifier)int
[551]-----(block)
[552]------(statement)
[553]-------(function.call_statement)
[554]--------(function.call)
[555]---------(identifier)Array
[556]---------(function.call.arguments)
[557]----------(function.call.argument_list)
[558]-----------(expression)
[559]------------(expression_atomic)
[560]-------------(value)
[561]--------------(identifier)c
[562]----(function.definition_statement)
[563]-----(identifier)resize
[564]-----(function.definition.arguments)
[565]------(function.definition.argument_list)
[566]-------(variable.declaration)
[567]--------(identifier)c
[568]--------(type_specifier)
[569]---------(type_data)
[570]----------(class.type)
[571]-----------(identifier)int
[572]-----(type_specifier)
[573]------(type_data)
[574]-------(class.type)
[575]--------(identifier)void
[576]-----(block)
[577]------(statement)
[578]-------(function.call_statement)
[579]--------(function.call)
[580]---------(identifier)clear
[581]---------(function.call.arguments)
[582]----------(function.call.argument_list)
[583]------(statement)
[584]-------(variable_statement)
[585]--------(variable)
[586]---------(variable.assignment)
[587]----------(identifier)values
[588]----------(operators.assignment)
[589]-----------(operators.assign)=
[590]----------(variable.assignment_expression)
[591]-----------(expression)
[592]------------(expression_atomic)
[593]-------------(value)
[594]--------------(object_create)
[595]---------------(new_keyword)new
[596]---------------(function.call)
[597]----------------(identifier)T
[598]----------------(function.call.arguments)
[599]-----------------(function.call.argument_list)
[600]------------------(expression)
[601]-------------------(expression_atomic)
[602]--------------------(value)
[603]---------------------(default_value)
[604]----------------------(default_keyword)default
[605]----------------------(class.type)
[606]-----------------------(identifier)T
[607]---------------(array_specifier)
[608]----------------(expression)
[609]-----------------(expression_atomic)
[610]------------------(value)
[611]-------------------(identifier)c
[612]------(statement)
[613]-------(variable_statement)
[614]--------(variable)
[615]---------(variable.assignment)
[616]----------(identifier)count
[617]----------(operators.assignment)
[618]-----------(operators.assign)=
[619]----------(variable.assignment_expression)
[620]-----------(expression)
[621]------------(expression_atomic)
[622]-------------(value)
[623]--------------(identifier)c
[624]----(function.definition_statement)
[625]-----(identifier)clear
[626]-----(function.definition.arguments)
[627]------(function.definition.argument_list)
[628]-----(type_specifier)
[629]------(type_data)
[630]-------(class.type)
[631]--------(identifier)void
[632]-----(block)
[633]------(statement)
[634]-------(object_destroy_statement)
[635]--------(delete_keyword)delete
[636]--------(expression)
[637]---------(expression_atomic)
[638]----------(value)
[639]-----------(identifier)values
[640]------(statement)
[641]-------(variable_statement)
[642]--------(variable)
[643]---------(variable.assignment)
[644]----------(identifier)values
[645]----------(operators.assignment)
[646]-----------(operators.assign)=
[647]----------(variable.assignment_expression)
[648]-----------(expression)
[649]------------(expression_atomic)
[650]-------------(value)
[651]--------------(identifier)null
[652]-(statement)
[653]--(enum.definition_statement)
[654]---(identifier)DefaultEnum
[655]---(enum.body)
[656]----(enum.field)
[657]-----(identifier)E0
[658]----(enum.field)
[659]-----(identifier)E2
[660]-----(operators.assign)=
[661]-----(value)
[662]------(number)
[663]-------(number.integer_literal)2
[664]----(enum.field)
[665]-----(identifier)E3
[666]-(statement)
[667]--(enum.definition_statement)
[668]---(identifier)StringEnum
[669]---(type_specifier)
[670]----(type_data)
[671]-----(class.type)
[672]------(identifier)string
[673]---(enum.body)
[674]----(enum.field)
[675]-----(identifier)SOME
[676]-----(operators.assign)=
[677]-----(value)
[678]------(string)"some"
[679]----(enum.field)
[680]-----(identifier)PRETTY
[681]-----(operators.assign)=
[682]-----(value)
[683]------(string)"pretty"
[684]----(enum.field)
[685]-----(identifier)SHIT
[686]-----(operators.assign)=
[687]-----(value)
[688]------(string)"shit"
[689]-(statement)
[690]--(variable_statement)
[691]---(variable)
[692]----(variable.declaration)
[693]-----(identifier)a1
[694]-----(type_specifier)
[695]------(type_data)
[696]-------(class.type)
[697]--------(identifier)int
[698]-(statement)
[699]--(variable_statement)
[700]---(variable)
[701]----(variable.declaration_assignment)
[702]-----(variable.declaration)
[703]------(identifier)b2
[704]------(type_specifier)
[705]-------(type_data)
[706]--------(class.type)
[707]---------(identifier)float
[708]-----(operators.assign)=
[709]-----(variable.assignment_expression)
[710]------(expression)
[711]-------(expression_atomic)
[712]--------(value)
[713]---------(number)
[714]----------(number.float_literal)2.3
[715]-(statement)
[716]--(variable_statement)
[717]---(variable)
[718]----(variable.declaration_assignment)
[719]-----(variable.declaration)
[720]------(identifier)d
[721]------(type_specifier)
[722]-------(type_pointer)
[723]--------(class.type)
[724]---------(identifier)byte
[725]-----(operators.assign)=
[726]-----(variable.assignment_expression)
[727]------(expression)
[728]-------(expression_atomic)
[729]--------(value)
[730]---------(object_create)
[731]----------(new_keyword)new
[732]----------(identifier)byte
[733]----------(array_specifier)
[734]-----------(expression)
[735]------------(expression_atomic)
[736]-------------(value)
[737]--------------(number)
[738]---------------(number.integer_literal)2
[739]-(statement)
[740]--(variable_statement)
[741]---(variable)
[742]----(variable.assignment)
[743]-----(identifier)d
[744]-----(access)
[745]------(access_array)
[746]-------(expression)
[747]--------(expression_atomic)
[748]---------(value)
[749]----------(number)
[750]-----------(number.integer_literal)0
[751]-----(operators.assignment)
[752]------(operators.assign)=
[753]-----(variable.assignment_expression)
[754]------(expression)
[755]-------(expression_atomic)
[756]--------(value)
[757]---------(identifier)d
[758]---------(access)
[759]----------(access_array)
[760]-----------(expression)
[761]------------(expression_atomic)
[762]-------------(value)
[763]--------------(number)
[764]---------------(number.integer_literal)1
[765]-(statement)
[766]--(object_destroy_statement)
[767]---(delete_keyword)delete
[768]---(expression)
[769]----(expression_atomic)
[770]-----(value)
[771]------(identifier)d
[772]-(statement)
[773]--(variable_statement)
[774]---(variable)
[775]----(variable.assignment)
[776]-----(identifier)d
[777]-----(operators.assignment)
[778]------(operators.assign)=
[779]-----(variable.assignment_expression)
[780]------(expression)
[781]-------(expression_atomic)
[782]--------(value)
[783]---------(identifier)null
[784]-(statement)
[785]--(using_namespace_statement)
[786]---(identifier)Some
[787]---(access_struct)
[788]----(identifier)Test
[789]-(statement)
[790]--(variable_statement)
[791]---(variable)
[792]----(variable.declaration_assignment)
[793]-----(variable.declaration)
[794]------(identifier)test1
[795]------(type_specifier)
[796]-------(type_pointer)
[797]--------(class.type)
[798]---------(identifier)Namespace
[799]--------(access_type)
[800]---------(class.type)
[801]----------(identifier)Test
[802]-----(operators.assign)=
[803]-----(variable.assignment_expression)
[804]------(expression)
[805]-------(expression_atomic)
[806]--------(value)
[807]---------(object_create)
[808]----------(new_keyword)new
[809]----------(identifier)Namespace
[810]----------(access_struct)
[811]-----------(identifier)Test
[812]-(statement)
[813]--(variable_statement)
[814]---(variable)
[815]----(variable.declaration_assignment)
[816]-----(variable.declaration)
[817]------(identifier)test2
[818]------(type_specifier)
[819]-------(type_pointer)
[820]--------(class.type)
[821]---------(identifier)Some
[822]--------(access_type)
[823]---------(class.type)
[824]----------(identifier)Test
[825]--------(access_type)
[826]---------(class.type)
[827]----------(identifier)Namespace
[828]--------(access_type)
[829]---------(class.type)
[830]----------(identifier)Test
[831]-----(operators.assign)=
[832]-----(variable.assignment_expression)
[833]------(expression)
[834]-------(expression_atomic)
[835]--------(value)
[836]---------(object_create)
[837]----------(new_keyword)new
[838]----------(identifier)Some
[839]----------(access_struct)
[840]-----------(identifier)Test
[841]----------(access_struct)
[842]-----------(identifier)Namespace
[843]----------(access_struct)
[844]-----------(identifier)Test
[845]-(statement)
[846]--(variable_statement)
[847]---(variable)
[848]----(variable.assignment)
[849]-----(identifier)test1
[850]-----(cast_suffix)
[851]-----(operators.assignment)
[852]------(operators.add_assign)+=
[853]-----(variable.assignment_expression)
[854]------(expression)
[855]-------(expression_atomic)
[856]--------(value)
[857]---------(identifier)test2
[858]---------(cast_suffix)
[859]-(statement)
[860]--(object_destroy_statement)
[861]---(delete_keyword)delete
[862]---(expression)
[863]----(expression_atomic)
[864]-----(value)
[865]------(identifier)test1
[866]-(statement)
[867]--(variable_statement)
[868]---(variable)
[869]----(variable.assignment)
[870]-----(identifier)test1
[871]-----(operators.assignment)
[872]------(operators.assign)=
[873]-----(variable.assignment_expression)
[874]------(expression)
[875]-------(expression_atomic)
[876]--------(value)
[877]---------(identifier)null
[878]-(statement)
[879]--(object_destroy_statement)
[880]---(delete_keyword)delete
[881]---(expression)
[882]----(expression_atomic)
[883]-----(value)
[884]------(identifier)test2
[885]-(statement)
[886]--(variable_statement)
[887]---(variable)
[888]----(variable.assignment)
[889]-----(identifier)test2
[890]-----(operators.assignment)
[891]------(operators.assign)=
[892]-----(variable.assignment_expression)
[893]------(expression)
[894]-------(expression_atomic)
[895]--------(value)
[896]---------(identifier)null
[897]-(statement)
[898]--(variable_statement)
[899]---(variable)
[900]----(variable.declaration_assignment)
[901]-----(variable.declaration)
[902]------(identifier)wat
[903]------(type_specifier)
[904]-------(type_data)
[905]--------(class.type)
[906]---------(identifier)bool
[907]-----(operators.assign)=
[908]-----(variable.assignment_expression)
[909]------(expression)
[910]-------(expression_atomic)
[911]--------(value)
[912]---------(control_flow.inlined_condition)
[913]----------(control_flow.inlined_condition_test)
[914]-----------(expression)
[915]------------(expression_atomic)
[916]-------------(value)
[917]--------------(identifier)t1
[918]--------------(access)
[919]---------------(access_array)
[920]----------------(expression)
[921]-----------------(expression_atomic)
[922]------------------(value)
[923]-------------------(number)
[924]--------------------(number.integer_literal)0
[925]------------(operators.operation)
[926]-------------(operators.conditional_operation)
[927]--------------(operators.conditional_greater)>
[928]------------(expression_atomic)
[929]-------------(value)
[930]--------------(identifier)t2
[931]--------------(access)
[932]---------------(access_array)
[933]----------------(expression)
[934]-----------------(expression_atomic)
[935]------------------(value)
[936]-------------------(number)
[937]--------------------(number.integer_literal)0
[938]----------(control_flow.inlined_condition_true)
[939]-----------(expression)
[940]------------(expression_atomic)
[941]-------------(value)
[942]--------------(identifier)true
[943]----------(control_flow.inlined_condition_false)
[944]-----------(expression)
[945]------------(expression_atomic)
[946]-------------(value)
[947]--------------(identifier)false
[948]-(statement)
[949]--(function.definition_statement)
[950]---(identifier)main
[951]---(function.definition.arguments)
[952]----(function.definition.argument_list)
[953]-----(variable.declaration)
[954]------(identifier)argv
[955]------(type_specifier)
[956]-------(type_pointer)
[957]--------(class.type)
[958]---------(identifier)string
[959]-----(variable.declaration)
[960]------(identifier)argc
[961]------(type_specifier)
[962]-------(type_data)
[963]--------(class.type)
[964]---------(identifier)int
[965]---(type_specifier)
[966]----(type_data)
[967]-----(class.type)
[968]------(identifier)int
[969]---(block)
[970]----(statement)
[971]-----(function.definition_statement)
[972]------(identifier)sum
[973]------(function.definition.arguments)
[974]-------(function.definition.argument_list)
[975]--------(variable.declaration)
[976]---------(identifier)a
[977]---------(type_specifier)
[978]----------(type_data)
[979]-----------(class.type)
[980]------------(identifier)int
[981]--------(variable.declaration)
[982]---------(identifier)b
[983]---------(type_specifier)
[984]----------(type_data)
[985]-----------(class.type)
[986]------------(identifier)int
[987]------(type_specifier)
[988]-------(type_data)
[989]--------(class.type)
[990]---------(identifier)int
[991]------(block)
[992]-------(statement)
[993]--------(control_flow.return_statement)
[994]---------(control_flow.return_keyword)return
[995]---------(expression)
[996]----------(expression_atomic)
[997]-----------(value)
[998]------------(identifier)a
[999]----------(operators.operation)
[1000]-----------(operators.binary_operation)
[1001]------------(operators.add)+
[1002]----------(expression_atomic)
[1003]-----------(value)
[1004]------------(identifier)b
[1005]----(statement)
[1006]-----(variable_statement)
[1007]------(variable)
[1008]-------(variable.declaration_assignment)
[1009]--------(variable.declaration)
[1010]---------(identifier)a2
[1011]---------(type_specifier)
[1012]----------(type_data)
[1013]-----------(class.type)
[1014]------------(identifier)int
[1015]--------(operators.assign)=
[1016]--------(variable.assignment_expression)
[1017]---------(expression)
[1018]----------(expression_atomic)
[1019]-----------(value)
[1020]------------(number)
[1021]-------------(number.integer_literal)1
[1022]----(statement)
[1023]-----(variable_statement)
[1024]------(variable)
[1025]-------(variable.declaration_assignment)
[1026]--------(variable.declaration)
[1027]---------(identifier)a3
[1028]---------(type_specifier)
[1029]----------(type_data)
[1030]-----------(class.type)
[1031]------------(identifier)int
[1032]--------(operators.assign)=
[1033]--------(variable.assignment_expression)
[1034]---------(expression)
[1035]----------(expression_atomic)
[1036]-----------(value)
[1037]------------(identifier)a2
[1038]----(statement)
[1039]-----(variable_statement)
[1040]------(variable)
[1041]-------(variable.declaration)
[1042]--------(identifier)b1
[1043]--------(type_specifier)
[1044]---------(type_data)
[1045]----------(class.type)
[1046]-----------(identifier)float
[1047]----(statement)
[1048]-----(variable_statement)
[1049]------(variable)
[1050]-------(variable.declaration_assignment)
[1051]--------(variable.declaration)
[1052]---------(identifier)b3
[1053]---------(type_specifier)
[1054]----------(type_data)
[1055]-----------(class.type)
[1056]------------(identifier)float
[1057]--------(operators.assign)=
[1058]--------(variable.assignment_expression)
[1059]---------(expression)
[1060]----------(expression_atomic)
[1061]-----------(value)
[1062]------------(identifier)b2
[1063]----(statement)
[1064]-----(block)
[1065]------(statement)
[1066]-------(variable_statement)
[1067]--------(variable)
[1068]---------(variable.declaration)
[1069]----------(identifier)c1
[1070]----------(type_specifier)
[1071]-----------(type_data)
[1072]------------(class.type)
[1073]-------------(identifier)string
[1074]------(statement)
[1075]-------(variable_statement)
[1076]--------(variable)
[1077]---------(variable.declaration_assignment)
[1078]----------(variable.declaration)
[1079]-----------(identifier)c2
[1080]-----------(type_specifier)
[1081]------------(type_data)
[1082]-------------(class.type)
[1083]--------------(identifier)string
[1084]----------(operators.assign)=
[1085]----------(variable.assignment_expression)
[1086]-----------(expression)
[1087]------------(expression_atomic)
[1088]-------------(value)
[1089]--------------(string)"test string"
[1090]------(statement)
[1091]-------(variable_statement)
[1092]--------(variable)
[1093]---------(variable.declaration_assignment)
[1094]----------(variable.declaration)
[1095]-----------(identifier)c3
[1096]-----------(type_specifier)
[1097]------------(type_data)
[1098]-------------(class.type)
[1099]--------------(identifier)string
[1100]----------(operators.assign)=
[1101]----------(variable.assignment_expression)
[1102]-----------(expression)
[1103]------------(expression_atomic)
[1104]-------------(value)
[1105]--------------(identifier)c2
[1106]------(statement)
[1107]-------(variable_statement)
[1108]--------(variable)
[1109]---------(variable.assignment)
[1110]----------(identifier)c3
[1111]----------(operators.assignment)
[1112]-----------(operators.assign)=
[1113]----------(variable.assignment_expression)
[1114]-----------(expression)
[1115]------------(expression_atomic)
[1116]-------------(value)
[1117]--------------(identifier)c2
[1118]----(statement)
[1119]-----(variable_statement)
[1120]------(variable)
[1121]-------(variable.declaration_assignment)
[1122]--------(variable.declaration)
[1123]---------(identifier)sum2
[1124]---------(type_specifier)
[1125]----------(type_data)
[1126]-----------(class.type)
[1127]------------(identifier)function
[1128]--------(operators.assign)=
[1129]--------(variable.assignment_expression)
[1130]---------(expression)
[1131]----------(expression_atomic)
[1132]-----------(value)
[1133]------------(function.definition_anonymous)
[1134]-------------(function.definition.arguments)
[1135]--------------(function.definition.argument_list)
[1136]---------------(variable.declaration)
[1137]----------------(identifier)v
[1138]----------------(type_specifier)
[1139]-----------------(type_data)
[1140]------------------(class.type)
[1141]-------------------(identifier)int
[1142]-------------(type_specifier)
[1143]--------------(type_data)
[1144]---------------(class.type)
[1145]----------------(identifier)int
[1146]-------------(block)
[1147]--------------(statement)
[1148]---------------(control_flow.return_statement)
[1149]----------------(control_flow.return_keyword)return
[1150]----------------(expression)
[1151]-----------------(expression_atomic)
[1152]------------------(value)
[1153]-------------------(function.call)
[1154]--------------------(identifier)sum
[1155]--------------------(function.call.arguments)
[1156]---------------------(function.call.argument_list)
[1157]----------------------(expression)
[1158]-----------------------(expression_atomic)
[1159]------------------------(value)
[1160]-------------------------(identifier)v
[1161]----------------------(expression)
[1162]-----------------------(expression_atomic)
[1163]------------------------(value)
[1164]-------------------------(identifier)v
[1165]----(statement)
[1166]-----(variable_statement)
[1167]------(variable)
[1168]-------(variable.assignment)
[1169]--------(identifier)a3
[1170]--------(operators.assignment)
[1171]---------(operators.assign)=
[1172]--------(variable.assignment_expression)
[1173]---------(variable.assignment)
[1174]----------(identifier)a1
[1175]----------(operators.assignment)
[1176]-----------(operators.assign)=
[1177]----------(variable.assignment_expression)
[1178]-----------(expression)
[1179]------------(expression_atomic)
[1180]-------------(operators.operation_prefix)
[1181]--------------(operators.subtract)-
[1182]-------------(value)
[1183]--------------(number)
[1184]---------------(number.integer_literal)1
[1185]------------(operators.operation)
[1186]-------------(operators.binary_operation)
[1187]--------------(operators.add)+
[1188]------------(expression_atomic)
[1189]-------------(expression_bracket)
[1190]--------------(expression)
[1191]---------------(expression_atomic)
[1192]----------------(expression_bracket)
[1193]-----------------(expression)
[1194]------------------(expression_atomic)
[1195]-------------------(operators.operation_prefix)
[1196]--------------------(operators.subtract)-
[1197]-------------------(value)
[1198]--------------------(identifier)a2
[1199]------------------(operators.operation)
[1200]-------------------(operators.binary_operation)
[1201]--------------------(operators.multiply)*
[1202]------------------(expression_atomic)
[1203]-------------------(value)
[1204]--------------------(identifier)b1
[1205]---------------(operators.operation)
[1206]----------------(operators.binary_operation)
[1207]-----------------(operators.subtract)-
[1208]---------------(expression_atomic)
[1209]----------------(value)
[1210]-----------------(number)
[1211]------------------(number.integer_literal)2
[1212]------------(operators.operation)
[1213]-------------(operators.binary_operation)
[1214]--------------(operators.divide)/
[1215]------------(expression_atomic)
[1216]-------------(value)
[1217]--------------(identifier)b3
[1218]----(statement)
[1219]-----(variable_statement)
[1220]------(variable)
[1221]-------(variable.assignment)
[1222]--------(identifier)a2
[1223]--------(operators.assignment)
[1224]---------(operators.add_assign)+=
[1225]--------(variable.assignment_expression)
[1226]---------(expression)
[1227]----------(expression_atomic)
[1228]-----------(value)
[1229]------------(function.call)
[1230]-------------(identifier)sum2
[1231]-------------(function.call.arguments)
[1232]--------------(function.call.argument_list)
[1233]---------------(expression)
[1234]----------------(expression_atomic)
[1235]-----------------(value)
[1236]------------------(identifier)a1
[1237]----------(operators.operation)
[1238]-----------(operators.binary_operation)
[1239]------------(operators.subtract)-
[1240]----------(expression_atomic)
[1241]-----------(value)
[1242]------------(identifier)a3
[1243]----(statement)
[1244]-----(variable_statement)
[1245]------(variable)
[1246]-------(variable.assignment)
[1247]--------(identifier)a3
[1248]--------(operators.assignment)
[1249]---------(operators.assign)=
[1250]--------(variable.assignment_expression)
[1251]---------(expression)
[1252]----------(expression_atomic)
[1253]-----------(value)
[1254]------------(function.call)
[1255]-------------(identifier)sum
[1256]-------------(function.call.arguments)
[1257]--------------(function.call.argument_list)
[1258]---------------(expression)
[1259]----------------(expression_atomic)
[1260]-----------------(value)
[1261]------------------(identifier)a1
[1262]---------------(expression)
[1263]----------------(expression_atomic)
[1264]-----------------(value)
[1265]------------------(identifier)a2
[1266]----(statement)
[1267]-----(control_flow.condition_statement)
[1268]------(control_flow.if_statement)
[1269]-------(control_flow.if_keyword)if
[1270]-------(expression)
[1271]--------(expression_atomic)
[1272]---------(expression_bracket)
[1273]----------(expression)
[1274]-----------(expression_atomic)
[1275]------------(value)
[1276]-------------(identifier)a1
[1277]-----------(operators.operation)
[1278]------------(operators.conditional_operation)
[1279]-------------(operators.conditional_greater)>
[1280]-----------(expression_atomic)
[1281]------------(value)
[1282]-------------(identifier)a2
[1283]-------(statement)
[1284]--------(variable_statement)
[1285]---------(variable)
[1286]----------(variable.assignment)
[1287]-----------(identifier)a1
[1288]-----------(operators.assignment)
[1289]------------(operators.assign)=
[1290]-----------(variable.assignment_expression)
[1291]------------(expression)
[1292]-------------(expression_atomic)
[1293]--------------(value)
[1294]---------------(identifier)a2
[1295]------(control_flow.else_if_statement)
[1296]-------(control_flow.else_keyword)else
[1297]-------(control_flow.if_statement)
[1298]--------(control_flow.if_keyword)if
[1299]--------(expression)
[1300]---------(expression_atomic)
[1301]----------(expression_bracket)
[1302]-----------(expression)
[1303]------------(expression_atomic)
[1304]-------------(value)
[1305]--------------(identifier)a2
[1306]------------(operators.operation)
[1307]-------------(operators.conditional_operation)
[1308]--------------(operators.conditional_equal)==
[1309]------------(expression_atomic)
[1310]-------------(value)
[1311]--------------(identifier)a3
[1312]--------(statement)
[1313]---------(variable_statement)
[1314]----------(variable)
[1315]-----------(variable.assignment)
[1316]------------(identifier)a2
[1317]------------(operators.assignment)
[1318]-------------(operators.assign)=
[1319]------------(variable.assignment_expression)
[1320]-------------(expression)
[1321]--------------(expression_atomic)
[1322]---------------(value)
[1323]----------------(function.call)
[1324]-----------------(identifier)sum2
[1325]-----------------(function.call.arguments)
[1326]------------------(function.call.argument_list)
[1327]-------------------(expression)
[1328]--------------------(expression_atomic)
[1329]---------------------(value)
[1330]----------------------(identifier)a3
[1331]------(control_flow.else_statement)
[1332]-------(control_flow.else_keyword)else
[1333]-------(statement)
[1334]--------(variable_statement)
[1335]---------(variable)
[1336]----------(variable.assignment)
[1337]-----------(identifier)a3
[1338]-----------(operators.assignment)
[1339]------------(operators.assign)=
[1340]-----------(variable.assignment_expression)
[1341]------------(expression)
[1342]-------------(expression_atomic)
[1343]--------------(value)
[1344]---------------(function.call)
[1345]----------------(identifier)sum
[1346]----------------(function.call.arguments)
[1347]-----------------(function.call.argument_list)
[1348]------------------(expression)
[1349]-------------------(expression_atomic)
[1350]--------------------(value)
[1351]---------------------(identifier)a2
[1352]------------------(expression)
[1353]-------------------(expression_atomic)
[1354]--------------------(value)
[1355]---------------------(identifier)a1
[1356]----(statement)
[1357]-----(variable_statement)
[1358]------(variable)
[1359]-------(variable.assignment)
[1360]--------(identifier)a1
[1361]--------(operators.assignment)
[1362]---------(operators.assign)=
[1363]--------(variable.assignment_expression)
[1364]---------(expression)
[1365]----------(expression_atomic)
[1366]-----------(value)
[1367]------------(number)
[1368]-------------(number.integer_literal)1
[1369]----(statement)
[1370]-----(control_flow.for_statement)
[1371]------(control_flow.for_keyword)for
[1372]------(control_flow.for_stages)
[1373]-------(control_flow.for_stage_init)
[1374]--------(variable)
[1375]---------(variable.declaration_assignment)
[1376]----------(variable.declaration)
[1377]-----------(identifier)i
[1378]-----------(type_specifier)
[1379]------------(type_data)
[1380]-------------(class.type)
[1381]--------------(identifier)int
[1382]----------(operators.assign)=
[1383]----------(variable.assignment_expression)
[1384]-----------(expression)
[1385]------------(expression_atomic)
[1386]-------------(value)
[1387]--------------(number)
[1388]---------------(number.integer_literal)1
[1389]-------(control_flow.for_stage_condition)
[1390]--------(expression)
[1391]---------(expression_atomic)
[1392]----------(value)
[1393]-----------(identifier)i
[1394]---------(operators.operation)
[1395]----------(operators.conditional_operation)
[1396]-----------(operators.conditional_less_or_equal)<=
[1397]---------(expression_atomic)
[1398]----------(value)
[1399]-----------(number)
[1400]------------(number.integer_literal)10
[1401]-------(control_flow.for_stage_iteration)
[1402]--------(expression)
[1403]---------(expression_atomic)
[1404]----------(operators.operation_prefix)
[1405]-----------(operators.increment)++
[1406]----------(value)
[1407]-----------(identifier)i
[1408]------(block)
[1409]-------(statement)
[1410]--------(control_flow.condition_statement)
[1411]---------(control_flow.if_statement)
[1412]----------(control_flow.if_keyword)if
[1413]----------(expression)
[1414]-----------(expression_atomic)
[1415]------------(expression_bracket)
[1416]-------------(expression)
[1417]--------------(expression_atomic)
[1418]---------------(value)
[1419]----------------(identifier)i
[1420]--------------(operators.operation)
[1421]---------------(operators.conditional_operation)
[1422]----------------(operators.conditional_greater)>
[1423]--------------(expression_atomic)
[1424]---------------(value)
[1425]----------------(number)
[1426]-----------------(number.integer_literal)5
[1427]----------(statement)
[1428]-----------(control_flow.continue_statement)
[1429]------------(control_flow.continue_keyword)continue
[1430]-------(statement)
[1431]--------(variable_statement)
[1432]---------(variable)
[1433]----------(variable.assignment)
[1434]-----------(identifier)a1
[1435]-----------(operators.assignment)
[1436]------------(operators.multiply_assign)*=
[1437]-----------(variable.assignment_expression)
[1438]------------(expression)
[1439]-------------(expression_atomic)
[1440]--------------(value)
[1441]---------------(identifier)i
[1442]----(statement)
[1443]-----(variable_statement)
[1444]------(variable)
[1445]-------(variable.declaration_instantiation)
[1446]--------(variable.declaration)
[1447]---------(identifier)data
[1448]---------(type_specifier)
[1449]----------(type_data)
[1450]-----------(class.type)
[1451]------------(identifier)Array
[1452]------------(class.template_parameters)
[1453]-------------(class.type)
[1454]--------------(identifier)int
[1455]--------(function.call.arguments)
[1456]---------(function.call.argument_list)
[1457]----------(expression)
[1458]-----------(expression_atomic)
[1459]------------(value)
[1460]-------------(number)
[1461]--------------(number.integer_literal)1000
[1462]----(statement)
[1463]-----(variable_statement)
[1464]------(variable)
[1465]-------(variable.assignment)
[1466]--------(identifier)a1
[1467]--------(operators.assignment)
[1468]---------(operators.assign)=
[1469]--------(variable.assignment_expression)
[1470]---------(expression)
[1471]----------(expression_atomic)
[1472]-----------(value)
[1473]------------(number)
[1474]-------------(number.integer_literal)0
[1475]----(statement)
[1476]-----(control_flow.foreach_statement)
[1477]------(control_flow.foreach_keyword)foreach
[1478]------(control_flow.foreach_stage)
[1479]-------(variable)
[1480]--------(variable.declaration)
[1481]---------(identifier)v
[1482]---------(type_specifier)
[1483]----------(type_data)
[1484]-----------(class.type)
[1485]------------(identifier)int
[1486]-------(value)
[1487]--------(identifier)data
[1488]------(statement)
[1489]-------(variable_statement)
[1490]--------(variable)
[1491]---------(variable.assignment)
[1492]----------(identifier)a1
[1493]----------(operators.assignment)
[1494]-----------(operators.multiply_assign)*=
[1495]----------(variable.assignment_expression)
[1496]-----------(expression)
[1497]------------(expression_atomic)
[1498]-------------(value)
[1499]--------------(identifier)v
[1500]----(statement)
[1501]-----(control_flow.while_statement)
[1502]------(control_flow.while_keyword)while
[1503]------(expression)
[1504]-------(expression_atomic)
[1505]--------(expression_bracket)
[1506]---------(expression)
[1507]----------(expression_atomic)
[1508]-----------(value)
[1509]------------(identifier)true
[1510]------(block)
[1511]-------(statement)
[1512]--------(control_flow.condition_statement)
[1513]---------(control_flow.if_statement)
[1514]----------(control_flow.if_keyword)if
[1515]----------(expression)
[1516]-----------(expression_atomic)
[1517]------------(expression_bracket)
[1518]-------------(expression)
[1519]--------------(expression_atomic)
[1520]---------------(value)
[1521]----------------(identifier)a1
[1522]--------------(operators.operation)
[1523]---------------(operators.conditional_operation)
[1524]----------------(operators.conditional_less)<
[1525]--------------(expression_atomic)
[1526]---------------(value)
[1527]----------------(number)
[1528]-----------------(number.integer_literal)0
[1529]----------(statement)
[1530]-----------(control_flow.break_statement)
[1531]------------(control_flow.break_keyword)break
[1532]-------(statement)
[1533]--------(expression)
[1534]---------(expression_atomic)
[1535]----------(value)
[1536]-----------(identifier)a1
[1537]----------(operators.operation_suffix)
[1538]-----------(operators.decrement)--
[1539]----(statement)
[1540]-----(parallel)
[1541]------(parallel.block_statement)
[1542]-------(parallel.mode)
[1543]--------(parallel.local_mode)local
[1544]-------(parallel.repeats)
[1545]--------(parallel.hardware_repeats)hardware
[1546]-------(block)
[1547]--------(statement)
[1548]---------(variable_statement)
[1549]----------(variable)
[1550]-----------(variable.declaration)
[1551]------------(identifier)index
[1552]------------(type_specifier)
[1553]-------------(type_data)
[1554]--------------(class.type)
[1555]---------------(identifier)int
[1556]--------(statement)
[1557]---------(isc_inlined_statement)
[1558]----------(string)"pidx $index"
[1559]--------(statement)
[1560]---------(variable_statement)
[1561]----------(variable)
[1562]-----------(variable.declaration_assignment)
[1563]------------(variable.declaration)
[1564]-------------(identifier)size
[1565]-------------(type_specifier)
[1566]--------------(type_data)
[1567]---------------(class.type)
[1568]----------------(identifier)int
[1569]------------(operators.assign)=
[1570]------------(variable.assignment_expression)
[1571]-------------(expression)
[1572]--------------(expression_atomic)
[1573]---------------(value)
[1574]----------------(number)
[1575]-----------------(number.integer_literal)1000
[1576]--------(statement)
[1577]---------(variable_statement)
[1578]----------(variable)
[1579]-----------(variable.declaration_assignment)
[1580]------------(variable.declaration)
[1581]-------------(identifier)start
[1582]-------------(type_specifier)
[1583]--------------(type_data)
[1584]---------------(class.type)
[1585]----------------(identifier)int
[1586]------------(operators.assign)=
[1587]------------(variable.assignment_expression)
[1588]-------------(expression)
[1589]--------------(expression_atomic)
[1590]---------------(value)
[1591]----------------(identifier)index
[1592]--------------(operators.operation)
[1593]---------------(operators.binary_operation)
[1594]----------------(operators.multiply)*
[1595]--------------(expression_atomic)
[1596]---------------(value)
[1597]----------------(identifier)size
[1598]--------(statement)
[1599]---------(variable_statement)
[1600]----------(variable)
[1601]-----------(variable.declaration_assignment)
[1602]------------(variable.declaration)
[1603]-------------(identifier)result
[1604]-------------(type_specifier)
[1605]--------------(type_data)
[1606]---------------(class.type)
[1607]----------------(identifier)int
[1608]------------(operators.assign)=
[1609]------------(variable.assignment_expression)
[1610]-------------(expression)
[1611]--------------(expression_atomic)
[1612]---------------(value)
[1613]----------------(number)
[1614]-----------------(number.integer_literal)0
[1615]--------(statement)
[1616]---------(control_flow.for_statement)
[1617]----------(control_flow.for_keyword)for
[1618]----------(control_flow.for_stages)
[1619]-----------(control_flow.for_stage_init)
[1620]------------(variable)
[1621]-------------(variable.declaration_assignment)
[1622]--------------(variable.declaration)
[1623]---------------(identifier)i
[1624]---------------(type_specifier)
[1625]----------------(type_data)
[1626]-----------------(class.type)
[1627]------------------(identifier)int
[1628]--------------(operators.assign)=
[1629]--------------(variable.assignment_expression)
[1630]---------------(expression)
[1631]----------------(expression_atomic)
[1632]-----------------(value)
[1633]------------------(identifier)start
[1634]-----------(control_flow.for_stage_condition)
[1635]------------(expression)
[1636]-------------(expression_atomic)
[1637]--------------(value)
[1638]---------------(identifier)i
[1639]-------------(operators.operation)
[1640]--------------(operators.conditional_operation)
[1641]---------------(operators.conditional_less)<
[1642]-------------(expression_atomic)
[1643]--------------(value)
[1644]---------------(identifier)start
[1645]-------------(operators.operation)
[1646]--------------(operators.binary_operation)
[1647]---------------(operators.add)+
[1648]-------------(expression_atomic)
[1649]--------------(value)
[1650]---------------(identifier)size
[1651]-----------(control_flow.for_stage_iteration)
[1652]------------(expression)
[1653]-------------(expression_atomic)
[1654]--------------(operators.operation_prefix)
[1655]---------------(operators.increment)++
[1656]--------------(value)
[1657]---------------(identifier)i
[1658]----------(statement)
[1659]-----------(variable_statement)
[1660]------------(variable)
[1661]-------------(variable.assignment)
[1662]--------------(identifier)result
[1663]--------------(operators.assignment)
[1664]---------------(operators.assign)=
[1665]--------------(variable.assignment_expression)
[1666]---------------(expression)
[1667]----------------(expression_atomic)
[1668]-----------------(value)
[1669]------------------(identifier)result
[1670]----------------(operators.operation)
[1671]-----------------(operators.binary_operation)
[1672]------------------(operators.add)+
[1673]----------------(expression_atomic)
[1674]-----------------(value)
[1675]------------------(identifier)i
[1676]----(statement)
[1677]-----(parallel)
[1678]------(parallel.group_statement)
[1679]-------(parallel.mode)
[1680]--------(parallel.local_mode)local
[1681]-------(block)
[1682]--------(statement)
[1683]---------(variable_statement)
[1684]----------(variable)
[1685]-----------(variable.declaration_assignment)
[1686]------------(variable.declaration)
[1687]-------------(identifier)result
[1688]-------------(type_specifier)
[1689]--------------(type_data)
[1690]---------------(class.type)
[1691]----------------(identifier)int
[1692]------------(operators.assign)=
[1693]------------(variable.assignment_expression)
[1694]-------------(expression)
[1695]--------------(expression_atomic)
[1696]---------------(value)
[1697]----------------(number)
[1698]-----------------(number.integer_literal)0
[1699]--------(statement)
[1700]---------(control_flow.for_statement)
[1701]----------(control_flow.for_keyword)for
[1702]----------(control_flow.for_stages)
[1703]-----------(control_flow.for_stage_init)
[1704]------------(variable)
[1705]-------------(variable.declaration_assignment)
[1706]--------------(variable.declaration)
[1707]---------------(identifier)i
[1708]---------------(type_specifier)
[1709]----------------(type_data)
[1710]-----------------(class.type)
[1711]------------------(identifier)int
[1712]--------------(operators.assign)=
[1713]--------------(variable.assignment_expression)
[1714]---------------(expression)
[1715]----------------(expression_atomic)
[1716]-----------------(value)
[1717]------------------(number)
[1718]-------------------(number.integer_literal)0
[1719]-----------(control_flow.for_stage_condition)
[1720]------------(expression)
[1721]-------------(expression_atomic)
[1722]--------------(value)
[1723]---------------(identifier)i
[1724]-------------(operators.operation)
[1725]--------------(operators.conditional_operation)
[1726]---------------(operators.conditional_less)<
[1727]-------------(expression_atomic)
[1728]--------------(value)
[1729]---------------(number)
[1730]----------------(number.integer_literal)1000
[1731]-----------(control_flow.for_stage_iteration)
[1732]------------(expression)
[1733]-------------(expression_atomic)
[1734]--------------(operators.operation_prefix)
[1735]---------------(operators.increment)++
[1736]--------------(value)
[1737]---------------(identifier)i
[1738]----------(statement)
[1739]-----------(variable_statement)
[1740]------------(variable)
[1741]-------------(variable.assignment)
[1742]--------------(identifier)result
[1743]--------------(operators.assignment)
[1744]---------------(operators.assign)=
[1745]--------------(variable.assignment_expression)
[1746]---------------(expression)
[1747]----------------(expression_atomic)
[1748]-----------------(value)
[1749]------------------(identifier)result
[1750]----------------(operators.operation)
[1751]-----------------(operators.binary_operation)
[1752]------------------(operators.subtract)-
[1753]----------------(expression_atomic)
[1754]-----------------(value)
[1755]------------------(identifier)i
[1756]-------(block)
[1757]--------(statement)
[1758]---------(variable_statement)
[1759]----------(variable)
[1760]-----------(variable.declaration_assignment)
[1761]------------(variable.declaration)
[1762]-------------(identifier)result
[1763]-------------(type_specifier)
[1764]--------------(type_data)
[1765]---------------(class.type)
[1766]----------------(identifier)int
[1767]------------(operators.assign)=
[1768]------------(variable.assignment_expression)
[1769]-------------(expression)
[1770]--------------(expression_atomic)
[1771]---------------(value)
[1772]----------------(number)
[1773]-----------------(number.integer_literal)0
[1774]--------(statement)
[1775]---------(control_flow.for_statement)
[1776]----------(control_flow.for_keyword)for
[1777]----------(control_flow.for_stages)
[1778]-----------(control_flow.for_stage_init)
[1779]------------(variable)
[1780]-------------(variable.declaration_assignment)
[1781]--------------(variable.declaration)
[1782]---------------(identifier)i
[1783]---------------(type_specifier)
[1784]----------------(type_data)
[1785]-----------------(class.type)
[1786]------------------(identifier)int
[1787]--------------(operators.assign)=
[1788]--------------(variable.assignment_expression)
[1789]---------------(expression)
[1790]----------------(expression_atomic)
[1791]-----------------(value)
[1792]------------------(number)
[1793]-------------------(number.integer_literal)1000
[1794]-----------(control_flow.for_stage_condition)
[1795]------------(expression)
[1796]-------------(expression_atomic)
[1797]--------------(value)
[1798]---------------(identifier)i
[1799]-------------(operators.operation)
[1800]--------------(operators.conditional_operation)
[1801]---------------(operators.conditional_less)<
[1802]-------------(expression_atomic)
[1803]--------------(value)
[1804]---------------(number)
[1805]----------------(number.integer_literal)2000
[1806]-----------(control_flow.for_stage_iteration)
[1807]------------(expression)
[1808]-------------(expression_atomic)
[1809]--------------(operators.operation_prefix)
[1810]---------------(operators.increment)++
[1811]--------------(value)
[1812]---------------(identifier)i
[1813]----------(statement)
[1814]-----------(variable_statement)
[1815]------------(variable)
[1816]-------------(variable.assignment)
[1817]--------------(identifier)result
[1818]--------------(operators.assignment)
[1819]---------------(operators.assign)=
[1820]--------------(variable.assignment_expression)
[1821]---------------(expression)
[1822]----------------(expression_atomic)
[1823]-----------------(value)
[1824]------------------(identifier)result
[1825]----------------(operators.operation)
[1826]-----------------(operators.binary_operation)
[1827]------------------(operators.add)+
[1828]----------------(expression_atomic)
[1829]-----------------(value)
[1830]------------------(identifier)i

main.ipp

// namespaces keeps identifiers in named scopes.
namespace Some.Test.Namespace
{
	// class with MetaAttribute attribute instance will be available as meta-attribute.
	[MetaAttribute]
	class Something
	{
		// constructor is called on meta-attribute instantiation.
		Something(n:^string)
		{
			name = n;
		}

		// name variable of managed string type.
		// managed object is just reference counted wrapper of any type.
		// (managed objects works with smart pointers behind the scene).
		name:^string = null;
	}

	// meta-attributes can be instantiated with one or more meta-info blocks.
	[Something("string automatically wrapped in managed object")]
	[Fuckin.Amazin.Attribute, And.Another.Attribute]
	// internal class is visible only in whole module, it's not public.
	internal class Test // class definition.
	{
		// default access mode is: public.
		// static variable named 'default' will be marked as default type value.
		// if static 'default' variable is not specified, parameterless constructor
		// will be used.
		static default:Test = Test(0);

		// public is visible for whole application.
		public Test(v:int)
		{
			V = v;
		}

		// private member is visible only in instance scope.
		private ~Test()
		{
			V = 0;
		}

		[ShittyOperator]
		// this is static operator method definition.
		public static +(a:Test, b:Test):Test
		{
			return Test(a.V + b.V); // access to structure fields is done by dot.
		}

		// meta-attributes can be applied to: classes, methods, properties and functions.
		[DunnoWhyImFor]
		// properties are defined like variables but have specified getter and setter.
		public V:int
		{
			get { return m_v; }
			internal set { m_v = value; }
		}

		// protected member is visible for class and inheritance scope.
		protected m_v:int = 0;
	}
}

// class template (not a generic!).
class Array<T>
{
	Array(c:int)
	{
		values = new T(default T)[c];
		count = c;
	}

	~Array()
	{
		delete values;
		values = null;
	}

	[](v:int):T
	{
		return values[v];
	}

	// meta-attribute to mark property as for-each-loop iteration (by index) start index.
	[IterationStart]
	Start:int
	{
		get { return 0; }
	}

	// meta-attribute to mark property as for-each-loop iteration (by index) stop index.
	[IterationStop]
	Stop:int
	{
		get { return count; }
	}

	values:*T = null;
	count:int = 0;
}

// TestArray is alias for Template<Test>.
alias TestArray:Template<Test>;

// some template usage.
t1:TestArray = TestArray(1);
t2:TestArray = TestArray(1);
t1[0] += t2[0];

// class inheritance.
class MutableArray<T> : Array<T>
{
	MutableArray(c:int)
	{
		Array(c);
	}

	resize(c:int):void
	{
		clear();
		values = new T(default T)[c];
		count = c;
	}

	clear():void
	{
		delete values;
		values = null;
	}
}

// enumeration (default values type is: int).
enum DefaultEnum
{
	E0, // it's the same as: E0 = default int.
	E2 = 2,
	E3
}

// enumeration can have specified values type.
enum StringEnum:string
{
	SOME = "some",
	PRETTY = "pretty",
	SHIT = "shit"
}

// variables in global scope.
a1:int;
b2:float = 2.3;

d:*byte = new byte[2]; // create new object with specified items count as pointer.
d[0] = d[1]; // array access.
delete d; // delete object at pointer location.
d = null;

// from here we will use Some.Test namespace.
using namespace Some.Test;

test1:*Namespace.Test = new Namespace.Test;
test2:*Some.Test.Namespace.Test = new Some.Test.Namespace.Test;
// casting to another type is done by '->' operator, after which you specify target type.
// if you does not specify target type, it will cast to value (from pointer or object).
test1-> += test2->;
delete test1; test1 = null;
delete test2; test2 = null;

// inlined condition.
// i know: this is very ugly syntax, but hey - at least it's works and it's simple :>
wat:bool = ?(t1[0] > t2[0]; true; false);

// entry point.
main(argv:*string, argc:int):int
{
	// functions (can be defined inside another function).
	sum(a:int, b:int):int
	{
		return a + b;
	}

	// variables.
	a2:int = 1;
	a3:int = a2;
	b1:float;
	b3:float = b2;
	{ // scope block.
		c1: // inlined comments.
			string;
		c2:string = "test string";
		c3:string = c2;
		c3 = c2;
	}

	// delegates (anonymous functions).
	sum2:function = @(v:int):int { return sum(v, v); };

	// arithmetics.
	a3 = a1 = -1 + /* ignored */ ((-a2 * b1) - 2) / b3;
	a2 += sum2(a1) - a3;

	// function call.
	a3 = sum(a1, a2);

	// control flow: conditions.
	if(a1 > a2)
		a1 = a2;
	else if(a2 == a3)
		a2 = sum2(a3);
	else
		a3 = sum(a2, a1);

	// control flow: for-loop.
	a1 = 1;
	for(i:int = 1; i <= 10; ++i)
	{
		if(i > 5) continue;
		a1 *= i;
	}

	// control flow: for-each-loop.
	data:Array<int>(1000);
	a1 = 0;
	foreach(v:int in data)
		a1 *= v;

	// control flow: while-loop.
	while(true)
	{
		if(a1 < 0) break;
		a1--;
	}

	// parallel block.
	// you specify jumping scope mode (local, parent, global)
	// and threads count (hardware or any integer).
	// local jumping scope: there cannot be any function/method calls.
	// parent jumping scope: there can be calls to function/method in parent thread code scope.
	// global jumping scope: there can be any function/method calls.
	// this code block will be executed on every hardware thread.
	// while parallel code is executed, main thread is paused. 
	parallel local hardware
	{
		index:int;
		isc "pidx $index"; // inlined intuicio assembler code.
		size:int = 1000;
		start:int = index * size;
		result:int = 0;
		for(i:int = start; i < start + size; ++i)
			result = result + i;
	}

	// parallel group.
	// group is specified by separated code blocks delimited by 'with' keyword.
	// this code blocks will be executed on separated threads.
	parallel local
	{
		result:int = 0;
		for(i:int = 0; i < 1000; ++i)
			result = result - i;
	}
	with
	{
		result:int = 0;
		for(i:int = 1000; i < 2000; ++i)
			result = result + i;
	}
}