// Auto generated on 11th April 2003
// Generator parameters: csharp syntactic_grammar
// Generator author: Jon Jagger, {JSL}
// URL   http://www.jaggersoft.com
// email jon@jaggersoft.com

#include "csharp/syntactic_grammar.hpp"
#include "csharp/syntactic_grammar_visitor.hpp"

#include "array/end_of.hpp"
#include "grammar/infinity.hpp"
#include "grammar/qualified_symbol_definition.hpp"

namespace
{
    template<typename iterator_type>
    const ::grammar::non_terminal_symbol_definition *
    extract(iterator_type position, iterator_type end)
    {
        return (position != end) ? position->second : 0;
    }
}

namespace csharp // syntactic_grammar - associative look up
{
    const ::grammar::non_terminal_symbol_definition *
    syntactic_grammar::operator[](const char * name) const
    {
        return extract(::grammar::base::symbols.find(name), ::grammar::base::symbols.end());
    }
}

namespace csharp // syntactic_grammar - configuration
{

    void syntactic_grammar::Configure_namespace_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_or_type_name, 1, 1),
            };
            namespace_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_name.name] = &namespace_name;
    }

    void syntactic_grammar::Configure_type_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_or_type_name, 1, 1),
            };
            type_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[type_name.name] = &type_name;
    }

    void syntactic_grammar::Configure_namespace_or_type_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(qualified_identifier, 1, 1),
            };
            namespace_or_type_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_or_type_name.name] = &namespace_or_type_name;
    }

    void syntactic_grammar::Configure_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_type, 1, 1),
            };
            type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(reference_type, 1, 1),
            };
            type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(value_type, 1, 1),
            };
            type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[type.name] = &type;
    }

    void syntactic_grammar::Configure_value_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(struct_type, 1, 1),
            };
            value_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(enum_type, 1, 1),
            };
            value_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[value_type.name] = &value_type;
    }

    void syntactic_grammar::Configure_struct_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            struct_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_type, 1, 1),
            };
            struct_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[struct_type.name] = &struct_type;
    }

    void syntactic_grammar::Configure_simple_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(numeric_type, 1, 1),
            };
            simple_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("bool"), 1, 1),
            };
            simple_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[simple_type.name] = &simple_type;
    }

    void syntactic_grammar::Configure_numeric_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(integral_type, 1, 1),
            };
            numeric_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(floating_point_type, 1, 1),
            };
            numeric_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("decimal"), 1, 1),
            };
            numeric_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[numeric_type.name] = &numeric_type;
    }

    void syntactic_grammar::Configure_integral_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sbyte"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("byte"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("short"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ushort"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("int"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("uint"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("long"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ulong"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("char"), 1, 1),
            };
            integral_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[integral_type.name] = &integral_type;
    }

    void syntactic_grammar::Configure_floating_point_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("float"), 1, 1),
            };
            floating_point_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("double"), 1, 1),
            };
            floating_point_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[floating_point_type.name] = &floating_point_type;
    }

    void syntactic_grammar::Configure_enum_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            enum_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[enum_type.name] = &enum_type;
    }

    void syntactic_grammar::Configure_reference_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_type, 1, 1),
            };
            reference_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[reference_type.name] = &reference_type;
    }

    void syntactic_grammar::Configure_class_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            class_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            class_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("string"), 1, 1),
            };
            class_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_type.name] = &class_type;
    }

    void syntactic_grammar::Configure_interface_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            interface_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_type.name] = &interface_type;
    }

    void syntactic_grammar::Configure_delegate_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            delegate_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_type.name] = &delegate_type;
    }

    void syntactic_grammar::Configure_variable_reference()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            variable_reference.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[variable_reference.name] = &variable_reference;
    }

    void syntactic_grammar::Configure_argument_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(argument, 1, 1),
                ::grammar::base::create(arguments, 0, 1),
            };
            argument_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[argument_list.name] = &argument_list;
    }

    void syntactic_grammar::Configure_arguments()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(argument_list, 1, 1),
            };
            arguments.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[arguments.name] = &arguments;
    }

    void syntactic_grammar::Configure_argument()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ref"), 1, 1),
                ::grammar::base::create(variable_reference, 1, 1),
            };
            argument.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("out"), 1, 1),
                ::grammar::base::create(variable_reference, 1, 1),
            };
            argument.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            argument.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[argument.name] = &argument;
    }

    void syntactic_grammar::Configure_primary_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_creation_expression, 1, 1),
            };
            primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(primary_no_array_creation_expression, 1, 1),
            };
            primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[primary_expression.name] = &primary_expression;
    }

    void syntactic_grammar::Configure_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(literal, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_creation_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(typeof_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(checked_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unchecked_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(sizeof_expression, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(predefined_type, 1, 1),
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[primary_no_array_creation_expression.name] = &primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(primary_suffix, 0, 1),
            };
            primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[primary_suffix.name] = &primary_suffix;
    }

    void syntactic_grammar::Configure_member_access_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            member_access_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[member_access_suffix.name] = &member_access_suffix;
    }

    void syntactic_grammar::Configure_invocation_expression_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            invocation_expression_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[invocation_expression_suffix.name] = &invocation_expression_suffix;
    }

    void syntactic_grammar::Configure_element_access_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            element_access_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[element_access_suffix.name] = &element_access_suffix;
    }

    void syntactic_grammar::Configure_post_increment_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("++"), 1, 1),
            };
            post_increment_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_increment_suffix.name] = &post_increment_suffix;
    }

    void syntactic_grammar::Configure_post_decrement_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("--"), 1, 1),
            };
            post_decrement_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_decrement_suffix.name] = &post_decrement_suffix;
    }

    void syntactic_grammar::Configure_expression_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(expressions, 0, 1),
            };
            expression_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expression_list.name] = &expression_list;
    }

    void syntactic_grammar::Configure_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
            };
            expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expressions.name] = &expressions;
    }

    void syntactic_grammar::Configure_simple_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
            };
            simple_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[simple_name.name] = &simple_name;
    }

    void syntactic_grammar::Configure_parenthesized_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            parenthesized_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[parenthesized_expression.name] = &parenthesized_expression;
    }

    void syntactic_grammar::Configure_predefined_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("bool"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("byte"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("char"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("decimal"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("double"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("float"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("int"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("long"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sbyte"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("short"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("string"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("uint"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ulong"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ushort"), 1, 1),
            };
            predefined_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[predefined_type.name] = &predefined_type;
    }

    void syntactic_grammar::Configure_invocation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(ie_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(invocation_expression_suffix, 1, ::grammar::infinity()),
            };
            invocation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[invocation_expression.name] = &invocation_expression;
    }

    void syntactic_grammar::Configure_ie_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(literal, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_creation_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(typeof_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(checked_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unchecked_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(sizeof_expression, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(predefined_type, 1, 1),
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[ie_primary_no_array_creation_expression.name] = &ie_primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_ie_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 1, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(ie_primary_suffix, 0, 1),
            };
            ie_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[ie_primary_suffix.name] = &ie_primary_suffix;
    }

    void syntactic_grammar::Configure_post_increment_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pide_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(post_increment_suffix, 1, 1),
            };
            post_increment_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_increment_expression.name] = &post_increment_expression;
    }

    void syntactic_grammar::Configure_post_decrement_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pide_primary_no_array_creation_expression, 1, 1),
                ::grammar::base::create(post_decrement_suffix, 1, 1),
            };
            post_decrement_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[post_decrement_expression.name] = &post_decrement_expression;
    }

    void syntactic_grammar::Configure_pide_primary_no_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_name, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(parenthesized_expression, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(this_access, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(base_access, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_no_array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pide_primary_no_array_creation_expression.name] = &pide_primary_no_array_creation_expression;
    }

    void syntactic_grammar::Configure_pide_primary_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(member_access_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(element_access_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_member_access_suffix, 1, 1),
                ::grammar::base::create(pide_primary_suffix, 0, 1),
            };
            pide_primary_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pide_primary_suffix.name] = &pide_primary_suffix;
    }

    void syntactic_grammar::Configure_this_access()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
            };
            this_access.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[this_access.name] = &this_access;
    }

    void syntactic_grammar::Configure_base_access()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("base"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
            };
            base_access.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("base"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            base_access.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[base_access.name] = &base_access;
    }

    void syntactic_grammar::Configure_object_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(argument_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            object_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[object_creation_expression.name] = &object_creation_expression;
    }

    void syntactic_grammar::Configure_array_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(non_array_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
                ::grammar::base::create(expression_list, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
                ::grammar::base::create(rank_specifiers, 0, 1),
                ::grammar::base::create(array_initializer, 0, 1),
            };
            array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(array_type, 1, 1),
                ::grammar::base::create(array_initializer, 1, 1),
            };
            array_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[array_creation_expression.name] = &array_creation_expression;
    }

    void syntactic_grammar::Configure_delegate_creation_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
                ::grammar::base::create(delegate_type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            delegate_creation_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delegate_creation_expression.name] = &delegate_creation_expression;
    }

    void syntactic_grammar::Configure_typeof_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("typeof"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            typeof_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("typeof"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("void"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            typeof_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[typeof_expression.name] = &typeof_expression;
    }

    void syntactic_grammar::Configure_checked_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("checked"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            checked_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[checked_expression.name] = &checked_expression;
    }

    void syntactic_grammar::Configure_unchecked_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unchecked"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            unchecked_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unchecked_expression.name] = &unchecked_expression;
    }

    void syntactic_grammar::Configure_unary_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("~"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_increment_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_decrement_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(cast_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pointer_indirection_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(addressof_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(primary_expression, 1, 1),
            };
            unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unary_expression.name] = &unary_expression;
    }

    void syntactic_grammar::Configure_pre_increment_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("++"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            pre_increment_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pre_increment_expression.name] = &pre_increment_expression;
    }

    void syntactic_grammar::Configure_pre_decrement_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("--"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            pre_decrement_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pre_decrement_expression.name] = &pre_decrement_expression;
    }

    void syntactic_grammar::Configure_cast_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(unary_expression, 1, 1),
            };
            cast_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[cast_expression.name] = &cast_expression;
    }

    void syntactic_grammar::Configure_multiplicative_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unary_expression, 1, 1),
                ::grammar::base::create(multiplicative_expressions, 0, 1),
            };
            multiplicative_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[multiplicative_expression.name] = &multiplicative_expression;
    }

    void syntactic_grammar::Configure_multiplicative_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
                ::grammar::base::create(multiplicative_expression, 1, 1),
            };
            multiplicative_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/"), 1, 1),
                ::grammar::base::create(multiplicative_expression, 1, 1),
            };
            multiplicative_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%"), 1, 1),
                ::grammar::base::create(multiplicative_expression, 1, 1),
            };
            multiplicative_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[multiplicative_expressions.name] = &multiplicative_expressions;
    }

    void syntactic_grammar::Configure_additive_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(multiplicative_expression, 1, 1),
                ::grammar::base::create(additive_expressions, 0, 1),
            };
            additive_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[additive_expression.name] = &additive_expression;
    }

    void syntactic_grammar::Configure_additive_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
                ::grammar::base::create(additive_expression, 1, 1),
            };
            additive_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
                ::grammar::base::create(additive_expression, 1, 1),
            };
            additive_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[additive_expressions.name] = &additive_expressions;
    }

    void syntactic_grammar::Configure_shift_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(additive_expression, 1, 1),
                ::grammar::base::create(shift_expressions, 0, 1),
            };
            shift_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[shift_expression.name] = &shift_expression;
    }

    void syntactic_grammar::Configure_shift_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<"), 1, 1),
                ::grammar::base::create(shift_expression, 1, 1),
            };
            shift_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">>"), 1, 1),
                ::grammar::base::create(shift_expression, 1, 1),
            };
            shift_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[shift_expressions.name] = &shift_expressions;
    }

    void syntactic_grammar::Configure_relational_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(shift_expression, 1, 1),
                ::grammar::base::create(relational_expressions, 0, 1),
            };
            relational_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[relational_expression.name] = &relational_expression;
    }

    void syntactic_grammar::Configure_relational_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<"), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">"), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<="), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">="), 1, 1),
                ::grammar::base::create(relational_expression, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("is"), 1, 1),
                ::grammar::base::create(type, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("as"), 1, 1),
                ::grammar::base::create(type, 1, 1),
            };
            relational_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[relational_expressions.name] = &relational_expressions;
    }

    void syntactic_grammar::Configure_equality_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(relational_expression, 1, 1),
                ::grammar::base::create(equality_expressions, 0, 1),
            };
            equality_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[equality_expression.name] = &equality_expression;
    }

    void syntactic_grammar::Configure_equality_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("=="), 1, 1),
                ::grammar::base::create(equality_expression, 1, 1),
            };
            equality_expressions.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!="), 1, 1),
                ::grammar::base::create(equality_expression, 1, 1),
            };
            equality_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[equality_expressions.name] = &equality_expressions;
    }

    void syntactic_grammar::Configure_and_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(equality_expression, 1, 1),
                ::grammar::base::create(and_expressions, 0, 1),
            };
            and_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[and_expression.name] = &and_expression;
    }

    void syntactic_grammar::Configure_and_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
                ::grammar::base::create(and_expression, 1, 1),
            };
            and_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[and_expressions.name] = &and_expressions;
    }

    void syntactic_grammar::Configure_exclusive_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(and_expression, 1, 1),
                ::grammar::base::create(exclusive_or_expressions, 0, 1),
            };
            exclusive_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[exclusive_or_expression.name] = &exclusive_or_expression;
    }

    void syntactic_grammar::Configure_exclusive_or_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^"), 1, 1),
                ::grammar::base::create(exclusive_or_expression, 1, 1),
            };
            exclusive_or_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[exclusive_or_expressions.name] = &exclusive_or_expressions;
    }

    void syntactic_grammar::Configure_inclusive_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(exclusive_or_expression, 1, 1),
                ::grammar::base::create(inclusive_or_expressions, 0, 1),
            };
            inclusive_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[inclusive_or_expression.name] = &inclusive_or_expression;
    }

    void syntactic_grammar::Configure_inclusive_or_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|"), 1, 1),
                ::grammar::base::create(inclusive_or_expression, 1, 1),
            };
            inclusive_or_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[inclusive_or_expressions.name] = &inclusive_or_expressions;
    }

    void syntactic_grammar::Configure_conditional_and_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(inclusive_or_expression, 1, 1),
                ::grammar::base::create(conditional_and_expressions, 0, 1),
            };
            conditional_and_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_and_expression.name] = &conditional_and_expression;
    }

    void syntactic_grammar::Configure_conditional_and_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&&"), 1, 1),
                ::grammar::base::create(conditional_and_expression, 1, 1),
            };
            conditional_and_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_and_expressions.name] = &conditional_and_expressions;
    }

    void syntactic_grammar::Configure_conditional_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_and_expression, 1, 1),
                ::grammar::base::create(conditional_or_expressions, 0, 1),
            };
            conditional_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_or_expression.name] = &conditional_or_expression;
    }

    void syntactic_grammar::Configure_conditional_or_expressions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("||"), 1, 1),
                ::grammar::base::create(conditional_or_expression, 1, 1),
            };
            conditional_or_expressions.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_or_expressions.name] = &conditional_or_expressions;
    }

    void syntactic_grammar::Configure_conditional_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_or_expression, 1, 1),
            };
            conditional_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_or_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("?"), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(expression, 1, 1),
            };
            conditional_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[conditional_expression.name] = &conditional_expression;
    }

    void syntactic_grammar::Configure_assignment()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unary_expression, 1, 1),
                ::grammar::base::create(assignment_operator, 1, 1),
                ::grammar::base::create(expression, 1, 1),
            };
            assignment.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[assignment.name] = &assignment;
    }

    void syntactic_grammar::Configure_assignment_operator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">>="), 1, 1),
            };
            assignment_operator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[assignment_operator.name] = &assignment_operator;
    }

    void syntactic_grammar::Configure_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(assignment, 1, 1),
            };
            expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_expression, 1, 1),
            };
            expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expression.name] = &expression;
    }

    void syntactic_grammar::Configure_constant_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            constant_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[constant_expression.name] = &constant_expression;
    }

    void syntactic_grammar::Configure_boolean_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            boolean_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[boolean_expression.name] = &boolean_expression;
    }

    void syntactic_grammar::Configure_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(labeled_statement, 1, 1),
            };
            statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(declaration_statement, 1, 1),
            };
            statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement.name] = &statement;
    }

    void syntactic_grammar::Configure_embedded_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(block, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(empty_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(selection_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(iteration_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(jump_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(try_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(checked_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unchecked_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(lock_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unsafe_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(fixed_statement, 1, 1),
            };
            embedded_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[embedded_statement.name] = &embedded_statement;
    }

    void syntactic_grammar::Configure_block()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(statement_list, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            block.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[block.name] = &block;
    }

    void syntactic_grammar::Configure_statement_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement, 1, ::grammar::infinity()),
            };
            statement_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement_list.name] = &statement_list;
    }

    void syntactic_grammar::Configure_empty_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            empty_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[empty_statement.name] = &empty_statement;
    }

    void syntactic_grammar::Configure_labeled_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(statement, 1, 1),
            };
            labeled_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[labeled_statement.name] = &labeled_statement;
    }

    void syntactic_grammar::Configure_declaration_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declaration, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            declaration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_constant_declaration, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            declaration_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[declaration_statement.name] = &declaration_statement;
    }

    void syntactic_grammar::Configure_local_variable_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(local_variable_declarators, 1, 1),
            };
            local_variable_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_declaration.name] = &local_variable_declaration;
    }

    void syntactic_grammar::Configure_local_variable_declarators()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declarator, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(local_variable_declarators, 1, 1),
            };
            local_variable_declarators.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declarator, 1, 1),
            };
            local_variable_declarators.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_declarators.name] = &local_variable_declarators;
    }

    void syntactic_grammar::Configure_local_variable_declarator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(local_variable_initializer, 1, 1),
            };
            local_variable_declarator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
            };
            local_variable_declarator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_declarator.name] = &local_variable_declarator;
    }

    void syntactic_grammar::Configure_local_variable_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            local_variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(array_initializer, 1, 1),
            };
            local_variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(stackalloc_initializer, 1, 1),
            };
            local_variable_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_variable_initializer.name] = &local_variable_initializer;
    }

    void syntactic_grammar::Configure_local_constant_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("const"), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(constant_declarators, 1, 1),
            };
            local_constant_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[local_constant_declaration.name] = &local_constant_declaration;
    }

    void syntactic_grammar::Configure_expression_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            expression_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[expression_statement.name] = &expression_statement;
    }

    void syntactic_grammar::Configure_statement_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(invocation_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(object_creation_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(assignment, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_increment_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(post_decrement_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_increment_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pre_decrement_expression, 1, 1),
            };
            statement_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement_expression.name] = &statement_expression;
    }

    void syntactic_grammar::Configure_selection_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(if_statement, 1, 1),
            };
            selection_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_statement, 1, 1),
            };
            selection_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[selection_statement.name] = &selection_statement;
    }

    void syntactic_grammar::Configure_if_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("if"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("else"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            if_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("if"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            if_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[if_statement.name] = &if_statement;
    }

    void syntactic_grammar::Configure_switch_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("switch"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(switch_block, 1, 1),
            };
            switch_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_statement.name] = &switch_statement;
    }

    void syntactic_grammar::Configure_switch_block()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(switch_sections, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            switch_block.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_block.name] = &switch_block;
    }

    void syntactic_grammar::Configure_switch_sections()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_section, 1, ::grammar::infinity()),
            };
            switch_sections.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_sections.name] = &switch_sections;
    }

    void syntactic_grammar::Configure_switch_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_labels, 1, 1),
                ::grammar::base::create(statement_list, 1, 1),
            };
            switch_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_section.name] = &switch_section;
    }

    void syntactic_grammar::Configure_switch_labels()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(switch_label, 1, ::grammar::infinity()),
            };
            switch_labels.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_labels.name] = &switch_labels;
    }

    void syntactic_grammar::Configure_switch_label()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("case"), 1, 1),
                ::grammar::base::create(constant_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            switch_label.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("default"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            switch_label.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[switch_label.name] = &switch_label;
    }

    void syntactic_grammar::Configure_iteration_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(while_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(do_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(for_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(foreach_statement, 1, 1),
            };
            iteration_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[iteration_statement.name] = &iteration_statement;
    }

    void syntactic_grammar::Configure_while_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("while"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            while_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[while_statement.name] = &while_statement;
    }

    void syntactic_grammar::Configure_do_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("do"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("while"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(boolean_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            do_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[do_statement.name] = &do_statement;
    }

    void syntactic_grammar::Configure_for_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("for"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(for_initializer, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
                ::grammar::base::create(for_condition, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
                ::grammar::base::create(for_iterator, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            for_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_statement.name] = &for_statement;
    }

    void syntactic_grammar::Configure_for_initializer()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declaration, 1, 1),
            };
            for_initializer.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression_list, 1, 1),
            };
            for_initializer.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_initializer.name] = &for_initializer;
    }

    void syntactic_grammar::Configure_for_condition()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(boolean_expression, 1, 1),
            };
            for_condition.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_condition.name] = &for_condition;
    }

    void syntactic_grammar::Configure_for_iterator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression_list, 1, 1),
            };
            for_iterator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[for_iterator.name] = &for_iterator;
    }

    void syntactic_grammar::Configure_statement_expression_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(statement_expression_list, 1, 1),
            };
            statement_expression_list.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(statement_expression, 1, 1),
            };
            statement_expression_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[statement_expression_list.name] = &statement_expression_list;
    }

    void syntactic_grammar::Configure_foreach_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("foreach"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(type, 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("in"), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            foreach_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[foreach_statement.name] = &foreach_statement;
    }

    void syntactic_grammar::Configure_jump_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(break_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(continue_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(goto_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(return_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(throw_statement, 1, 1),
            };
            jump_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[jump_statement.name] = &jump_statement;
    }

    void syntactic_grammar::Configure_break_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("break"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            break_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[break_statement.name] = &break_statement;
    }

    void syntactic_grammar::Configure_continue_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("continue"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            continue_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[continue_statement.name] = &continue_statement;
    }

    void syntactic_grammar::Configure_goto_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            goto_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("case"), 1, 1),
                ::grammar::base::create(constant_expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            goto_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("default"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            goto_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[goto_statement.name] = &goto_statement;
    }

    void syntactic_grammar::Configure_return_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("return"), 1, 1),
                ::grammar::base::create(expression, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            return_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[return_statement.name] = &return_statement;
    }

    void syntactic_grammar::Configure_throw_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("throw"), 1, 1),
                ::grammar::base::create(expression, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            throw_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[throw_statement.name] = &throw_statement;
    }

    void syntactic_grammar::Configure_try_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("try"), 1, 1),
                ::grammar::base::create(block, 1, 1),
                ::grammar::base::create(catch_clauses, 1, 1),
                ::grammar::base::create(finally_clause, 0, 1),
            };
            try_statement.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("try"), 1, 1),
                ::grammar::base::create(block, 1, 1),
                ::grammar::base::create(finally_clause, 1, 1),
            };
            try_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[try_statement.name] = &try_statement;
    }

    void syntactic_grammar::Configure_catch_clauses()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(specific_catch_clauses, 1, 1),
                ::grammar::base::create(general_catch_clause, 0, 1),
            };
            catch_clauses.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(specific_catch_clauses, 0, 1),
                ::grammar::base::create(general_catch_clause, 1, 1),
            };
            catch_clauses.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[catch_clauses.name] = &catch_clauses;
    }

    void syntactic_grammar::Configure_specific_catch_clauses()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(specific_catch_clause, 1, ::grammar::infinity()),
            };
            specific_catch_clauses.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[specific_catch_clauses.name] = &specific_catch_clauses;
    }

    void syntactic_grammar::Configure_specific_catch_clause()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("catch"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(class_type, 1, 1),
                ::grammar::base::create(identifier, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            specific_catch_clause.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[specific_catch_clause.name] = &specific_catch_clause;
    }

    void syntactic_grammar::Configure_general_catch_clause()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("catch"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            general_catch_clause.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[general_catch_clause.name] = &general_catch_clause;
    }

    void syntactic_grammar::Configure_finally_clause()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("finally"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            finally_clause.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[finally_clause.name] = &finally_clause;
    }

    void syntactic_grammar::Configure_checked_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("checked"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            checked_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[checked_statement.name] = &checked_statement;
    }

    void syntactic_grammar::Configure_unchecked_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unchecked"), 1, 1),
                ::grammar::base::create(block, 1, 1),
            };
            unchecked_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unchecked_statement.name] = &unchecked_statement;
    }

    void syntactic_grammar::Configure_lock_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("lock"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(expression, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            lock_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[lock_statement.name] = &lock_statement;
    }

    void syntactic_grammar::Configure_using_statement()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
                ::grammar::base::create(resource_acquisition, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
                ::grammar::base::create(embedded_statement, 1, 1),
            };
            using_statement.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_statement.name] = &using_statement;
    }

    void syntactic_grammar::Configure_resource_acquisition()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(local_variable_declaration, 1, 1),
            };
            resource_acquisition.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(expression, 1, 1),
            };
            resource_acquisition.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[resource_acquisition.name] = &resource_acquisition;
    }

    void syntactic_grammar::Configure_compilation_unit()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_directives, 0, 1),
                ::grammar::base::create(global_attributes, 0, 1),
                ::grammar::base::create(namespace_member_declarations, 0, 1),
            };
            compilation_unit.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[compilation_unit.name] = &compilation_unit;
    }

    void syntactic_grammar::Configure_namespace_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("namespace"), 1, 1),
                ::grammar::base::create(qualified_identifier, 1, 1),
                ::grammar::base::create(namespace_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            namespace_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_declaration.name] = &namespace_declaration;
    }

    void syntactic_grammar::Configure_qualified_identifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(identifiers, 0, 1),
            };
            qualified_identifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[qualified_identifier.name] = &qualified_identifier;
    }

    void syntactic_grammar::Configure_identifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(qualified_identifier, 1, 1),
            };
            identifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifiers.name] = &identifiers;
    }

    void syntactic_grammar::Configure_namespace_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(using_directives, 0, 1),
                ::grammar::base::create(namespace_member_declarations, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            namespace_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_body.name] = &namespace_body;
    }

    void syntactic_grammar::Configure_using_directives()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_directive, 1, ::grammar::infinity()),
            };
            using_directives.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_directives.name] = &using_directives;
    }

    void syntactic_grammar::Configure_using_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_alias_directive, 1, 1),
            };
            using_directive.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(using_namespace_directive, 1, 1),
            };
            using_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_directive.name] = &using_directive;
    }

    void syntactic_grammar::Configure_using_alias_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
                ::grammar::base::create(namespace_or_type_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            using_alias_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_alias_directive.name] = &using_alias_directive;
    }

    void syntactic_grammar::Configure_using_namespace_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
                ::grammar::base::create(namespace_name, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            using_namespace_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[using_namespace_directive.name] = &using_namespace_directive;
    }

    void syntactic_grammar::Configure_namespace_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_member_declaration, 1, ::grammar::infinity()),
            };
            namespace_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_member_declarations.name] = &namespace_member_declarations;
    }

    void syntactic_grammar::Configure_namespace_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(namespace_declaration, 1, 1),
            };
            namespace_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_declaration, 1, 1),
            };
            namespace_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[namespace_member_declaration.name] = &namespace_member_declaration;
    }

    void syntactic_grammar::Configure_type_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(struct_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(interface_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(enum_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delegate_declaration, 1, 1),
            };
            type_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[type_declaration.name] = &type_declaration;
    }

    void syntactic_grammar::Configure_class_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(class_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("class"), 1, 1),
                ::grammar::base::create(identifier, 1, 1),
                ::grammar::base::create(class_base, 0, 1),
                ::grammar::base::create(class_body, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(";"), 0, 1),
            };
            class_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_declaration.name] = &class_declaration;
    }

    void syntactic_grammar::Configure_class_modifiers()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_modifier, 1, ::grammar::infinity()),
            };
            class_modifiers.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_modifiers.name] = &class_modifiers;
    }

    void syntactic_grammar::Configure_class_modifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            class_modifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_modifier.name] = &class_modifier;
    }

    void syntactic_grammar::Configure_class_base()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(base_type, 1, 1),
                ::grammar::base::create(interface_type_list, 0, ::grammar::infinity()),
            };
            class_base.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_base.name] = &class_base;
    }

    void syntactic_grammar::Configure_base_type()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            base_type.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_name, 1, 1),
            };
            base_type.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[base_type.name] = &base_type;
    }

    void syntactic_grammar::Configure_interface_type_list()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(interface_type, 1, 1),
            };
            interface_type_list.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[interface_type_list.name] = &interface_type_list;
    }

    void syntactic_grammar::Configure_class_body()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
                ::grammar::base::create(class_member_declarations, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            class_body.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_body.name] = &class_body;
    }

    void syntactic_grammar::Configure_class_member_declarations()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(class_member_declaration, 1, ::grammar::infinity()),
            };
            class_member_declarations.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_member_declarations.name] = &class_member_declarations;
    }

    void syntactic_grammar::Configure_class_member_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constant_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(field_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(method_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(property_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(event_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(indexer_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(operator_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(constructor_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(destructor_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(static_constructor_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(type_declaration, 1, 1),
            };
            class_member_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[class_member_declaration.name] = &class_member_declaration;
    }

    void syntactic_grammar::Configure_constant_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(attributes, 0, 1),
                ::grammar::base::create(constant_modifiers, 0, 1),
                ::grammar::base::create(::grammar::base::term