
// Auto generated on 11th April 2003
// Generator parameters: csharp lexical_grammar
// Generator author: Jon Jagger, {JSL}
// URL   http://www.jaggersoft.com
// email jon@jaggersoft.com

#include "csharp/lexical_grammar.hpp"
#include "csharp/lexical_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 // lexical_grammar - associative look up
{
    const ::grammar::non_terminal_symbol_definition *
    lexical_grammar::operator[](const char * name) const
    {
        return extract(::grammar::base::symbols.find(name), ::grammar::base::symbols.end());
    }
}

namespace csharp // lexical_grammar - configuration
{

    void lexical_grammar::Configure_input()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(input_section, 0, 1),
            };
            input.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[input.name] = &input;
    }

    void lexical_grammar::Configure_input_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(input_section_part, 1, ::grammar::infinity()),
            };
            input_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[input_section.name] = &input_section;
    }

    void lexical_grammar::Configure_input_section_part()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(input_elements, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
            };
            input_section_part.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_directive, 1, 1),
            };
            input_section_part.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[input_section_part.name] = &input_section_part;
    }

    void lexical_grammar::Configure_input_elements()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(input_element, 1, ::grammar::infinity()),
            };
            input_elements.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[input_elements.name] = &input_elements;
    }

    void lexical_grammar::Configure_input_element()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
            };
            input_element.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(comment, 1, 1),
            };
            input_element.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(token, 1, 1),
            };
            input_element.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[input_element.name] = &input_element;
    }

    void lexical_grammar::Configure_new_line()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\r"), 1, 1),
                ::grammar::base::create(::grammar::base::terminal("\n"), 0, 1),
            };
            new_line.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\n"), 1, 1),
            };
            new_line.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[new_line.name] = &new_line;
    }

    void lexical_grammar::Configure_comment()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(single_line_comment, 1, 1),
            };
            comment.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delimited_comment, 1, 1),
            };
            comment.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[comment.name] = &comment;
    }

    void lexical_grammar::Configure_single_line_comment()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("//"), 1, 1),
                ::grammar::base::create(input_characters, 0, 1),
            };
            single_line_comment.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[single_line_comment.name] = &single_line_comment;
    }

    void lexical_grammar::Configure_input_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of("\r\n"), 1, ::grammar::infinity()),
            };
            input_characters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[input_characters.name] = &input_characters;
    }

    void lexical_grammar::Configure_delimited_comment()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/*"), 1, 1),
                ::grammar::base::create(delimited_comment_text, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("*/"), 1, 1),
            };
            delimited_comment.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delimited_comment.name] = &delimited_comment;
    }

    void lexical_grammar::Configure_delimited_comment_text()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(delimited_comment_section, 1, ::grammar::infinity()),
            };
            delimited_comment_text.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delimited_comment_text.name] = &delimited_comment_text;
    }

    void lexical_grammar::Configure_delimited_comment_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of("*"), 1, 1),
            };
            delimited_comment_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, ::grammar::infinity()),
                ::grammar::base::create(::grammar::base::none_of("/"), 1, 1),
            };
            delimited_comment_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[delimited_comment_section.name] = &delimited_comment_section;
    }

    void lexical_grammar::Configure_whitespace()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of(" \t\v\f"), 1, ::grammar::infinity()),
            };
            whitespace.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[whitespace.name] = &whitespace;
    }

    void lexical_grammar::Configure_token()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(keyword, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(real_literal, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(integer_literal, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(character_literal, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(string_literal, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(operator_or_punctuator, 1, 1),
            };
            token.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[token.name] = &token;
    }

    void lexical_grammar::Configure_unicode_escape_sequence()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\\u"), 1, 1),
                ::grammar::base::create(hex_digit, 4, 4),
            };
            unicode_escape_sequence.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\\U"), 1, 1),
                ::grammar::base::create(hex_digit, 8, 8),
            };
            unicode_escape_sequence.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[unicode_escape_sequence.name] = &unicode_escape_sequence;
    }

    void lexical_grammar::Configure_identifier()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(available_identifier, 1, 1),
            };
            identifier.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(identifier_or_keyword, 1, 1),
            };
            identifier.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifier.name] = &identifier;
    }

    void lexical_grammar::Configure_identifier_or_keyword()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier_start_character, 1, 1),
                ::grammar::base::create(identifier_part_characters, 0, 1),
            };
            identifier_or_keyword.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifier_or_keyword.name] = &identifier_or_keyword;
    }

    void lexical_grammar::Configure_identifier_start_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(letter_character, 1, 1),
            };
            identifier_start_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("_"), 1, 1),
            };
            identifier_start_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifier_start_character.name] = &identifier_start_character;
    }

    void lexical_grammar::Configure_identifier_part_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(identifier_part_character, 1, ::grammar::infinity()),
            };
            identifier_part_characters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifier_part_characters.name] = &identifier_part_characters;
    }

    void lexical_grammar::Configure_identifier_part_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(letter_character, 1, 1),
            };
            identifier_part_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digit_character, 1, 1),
            };
            identifier_part_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(connecting_character, 1, 1),
            };
            identifier_part_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(combining_character, 1, 1),
            };
            identifier_part_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(formatting_character, 1, 1),
            };
            identifier_part_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[identifier_part_character.name] = &identifier_part_character;
    }

    void lexical_grammar::Configure_keyword()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("abstract"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("as"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("base"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("bool"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("break"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("byte"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("case"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("catch"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("char"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("checked"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("class"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("const"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("continue"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("decimal"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("default"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("delegate"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("double"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("do"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("else"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("enum"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("event"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("explicit"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("extern"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("false"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("finally"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("fixed"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("float"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("foreach"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("for"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("goto"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("if"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("implicit"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("interface"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("internal"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("int"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("in"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("is"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("lock"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("long"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("namespace"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("new"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("null"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("object"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("operator"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("out"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("override"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("params"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("private"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("protected"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("public"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("readonly"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ref"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("return"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sbyte"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sealed"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("short"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("sizeof"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("stackalloc"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("static"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("string"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("struct"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("switch"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("this"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("throw"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("true"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("try"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("typeof"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("uint"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ulong"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unchecked"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("unsafe"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ushort"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("using"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("virtual"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("void"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("volatile"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("while"), 1, 1),
            };
            keyword.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[keyword.name] = &keyword;
    }

    void lexical_grammar::Configure_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(boolean_literal, 1, 1),
            };
            literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(real_literal, 1, 1),
            };
            literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(integer_literal, 1, 1),
            };
            literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(character_literal, 1, 1),
            };
            literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(string_literal, 1, 1),
            };
            literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(null_literal, 1, 1),
            };
            literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[literal.name] = &literal;
    }

    void lexical_grammar::Configure_boolean_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("true"), 1, 1),
            };
            boolean_literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("false"), 1, 1),
            };
            boolean_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[boolean_literal.name] = &boolean_literal;
    }

    void lexical_grammar::Configure_integer_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(hexadecimal_integer_literal, 1, 1),
            };
            integer_literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_integer_literal, 1, 1),
            };
            integer_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[integer_literal.name] = &integer_literal;
    }

    void lexical_grammar::Configure_decimal_integer_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(integer_type_suffix, 0, 1),
            };
            decimal_integer_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[decimal_integer_literal.name] = &decimal_integer_literal;
    }

    void lexical_grammar::Configure_decimal_digits()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("0123456789"), 1, ::grammar::infinity()),
            };
            decimal_digits.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[decimal_digits.name] = &decimal_digits;
    }

    void lexical_grammar::Configure_integer_type_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("Uu"), 1, 1),
                ::grammar::base::create(::grammar::base::one_of("Ll"), 0, 1),
            };
            integer_type_suffix.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("Ll"), 1, 1),
                ::grammar::base::create(::grammar::base::one_of("Uu"), 0, 1),
            };
            integer_type_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[integer_type_suffix.name] = &integer_type_suffix;
    }

    void lexical_grammar::Configure_hexadecimal_integer_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("0"), 1, 1),
                ::grammar::base::create(::grammar::base::one_of("xX"), 1, 1),
                ::grammar::base::create(hex_digits, 1, 1),
                ::grammar::base::create(integer_type_suffix, 0, 1),
            };
            hexadecimal_integer_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[hexadecimal_integer_literal.name] = &hexadecimal_integer_literal;
    }

    void lexical_grammar::Configure_hex_digits()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(hex_digit, 1, ::grammar::infinity()),
            };
            hex_digits.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[hex_digits.name] = &hex_digits;
    }

    void lexical_grammar::Configure_hex_digit()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("0123456789ABCDEFabcdef"), 1, 1),
            };
            hex_digit.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[hex_digit.name] = &hex_digit;
    }

    void lexical_grammar::Configure_real_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(exponent_part, 0, 1),
                ::grammar::base::create(real_type_suffix, 0, 1),
            };
            real_literal.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(decimal_digits, 1, 1),
                ::grammar::base::create(exponent_part, 0, 1),
                ::grammar::base::create(real_type_suffix, 0, 1),
            };
            real_literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(exponent_part, 1, 1),
                ::grammar::base::create(real_type_suffix, 0, 1),
            };
            real_literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(real_type_suffix, 1, 1),
            };
            real_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[real_literal.name] = &real_literal;
    }

    void lexical_grammar::Configure_exponent_part()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("eE"), 1, 1),
                ::grammar::base::create(sign, 0, 1),
                ::grammar::base::create(decimal_digits, 1, 1),
            };
            exponent_part.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[exponent_part.name] = &exponent_part;
    }

    void lexical_grammar::Configure_sign()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("+-"), 1, 1),
            };
            sign.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[sign.name] = &sign;
    }

    void lexical_grammar::Configure_real_type_suffix()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("FfDdMm"), 1, 1),
            };
            real_type_suffix.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[real_type_suffix.name] = &real_type_suffix;
    }

    void lexical_grammar::Configure_character_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("'"), 1, 1),
                ::grammar::base::create(character, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("'"), 1, 1),
            };
            character_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[character_literal.name] = &character_literal;
    }

    void lexical_grammar::Configure_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(single_character, 1, 1),
            };
            character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_escape_sequence, 1, 1),
            };
            character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(hexadecimal_escape_sequence, 1, 1),
            };
            character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unicode_escape_sequence, 1, 1),
            };
            character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[character.name] = &character;
    }

    void lexical_grammar::Configure_single_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of("'\\\r\n"), 1, 1),
            };
            single_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[single_character.name] = &single_character;
    }

    void lexical_grammar::Configure_simple_escape_sequence()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\\"), 1, 1),
                ::grammar::base::create(::grammar::base::one_of("'\"\\0abfnrtv"), 1, 1),
            };
            simple_escape_sequence.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[simple_escape_sequence.name] = &simple_escape_sequence;
    }

    void lexical_grammar::Configure_hexadecimal_escape_sequence()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\\x"), 1, 1),
                ::grammar::base::create(hex_digit, 1, 4),
            };
            hexadecimal_escape_sequence.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[hexadecimal_escape_sequence.name] = &hexadecimal_escape_sequence;
    }

    void lexical_grammar::Configure_string_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(regular_string_literal, 1, 1),
            };
            string_literal.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(verbatim_string_literal, 1, 1),
            };
            string_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[string_literal.name] = &string_literal;
    }

    void lexical_grammar::Configure_regular_string_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\""), 1, 1),
                ::grammar::base::create(regular_string_literal_characters, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("\""), 1, 1),
            };
            regular_string_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[regular_string_literal.name] = &regular_string_literal;
    }

    void lexical_grammar::Configure_regular_string_literal_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(regular_string_literal_character, 1, ::grammar::infinity()),
            };
            regular_string_literal_characters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[regular_string_literal_characters.name] = &regular_string_literal_characters;
    }

    void lexical_grammar::Configure_regular_string_literal_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(single_regular_string_literal_character, 1, 1),
            };
            regular_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(simple_escape_sequence, 1, 1),
            };
            regular_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(hexadecimal_escape_sequence, 1, 1),
            };
            regular_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(unicode_escape_sequence, 1, 1),
            };
            regular_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[regular_string_literal_character.name] = &regular_string_literal_character;
    }

    void lexical_grammar::Configure_single_regular_string_literal_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of("\"\\\r\n"), 1, 1),
            };
            single_regular_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[single_regular_string_literal_character.name] = &single_regular_string_literal_character;
    }

    void lexical_grammar::Configure_verbatim_string_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("@\""), 1, 1),
                ::grammar::base::create(verbatim_string_literal_characters, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("\""), 1, 1),
            };
            verbatim_string_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[verbatim_string_literal.name] = &verbatim_string_literal;
    }

    void lexical_grammar::Configure_verbatim_string_literal_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(verbatim_string_literal_character, 1, ::grammar::infinity()),
            };
            verbatim_string_literal_characters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[verbatim_string_literal_characters.name] = &verbatim_string_literal_characters;
    }

    void lexical_grammar::Configure_verbatim_string_literal_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(single_verbatim_string_literal_character, 1, 1),
            };
            verbatim_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(quote_escape_sequence, 1, 1),
            };
            verbatim_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[verbatim_string_literal_character.name] = &verbatim_string_literal_character;
    }

    void lexical_grammar::Configure_single_verbatim_string_literal_character()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of("\""), 1, 1),
            };
            single_verbatim_string_literal_character.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[single_verbatim_string_literal_character.name] = &single_verbatim_string_literal_character;
    }

    void lexical_grammar::Configure_quote_escape_sequence()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\"\""), 1, 1),
            };
            quote_escape_sequence.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[quote_escape_sequence.name] = &quote_escape_sequence;
    }

    void lexical_grammar::Configure_null_literal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("null"), 1, 1),
            };
            null_literal.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[null_literal.name] = &null_literal;
    }

    void lexical_grammar::Configure_operator_or_punctuator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("{"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("["), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("]"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("("), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("."), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(","), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(";"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("++"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("+"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("--"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("->"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("-"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("*"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("/="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("%"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&&"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("&"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("||"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("|"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("^"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("!"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("~"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("=="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<<"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("<"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">>="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">="), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(">"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("?"), 1, 1),
            };
            operator_or_punctuator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[operator_or_punctuator.name] = &operator_or_punctuator;
    }

    void lexical_grammar::Configure_pp_directive()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_declaration, 1, 1),
            };
            pp_directive.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_conditional, 1, 1),
            };
            pp_directive.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_line, 1, 1),
            };
            pp_directive.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_diagnostic, 1, 1),
            };
            pp_directive.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_region, 1, 1),
            };
            pp_directive.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_directive.name] = &pp_directive;
    }

    void lexical_grammar::Configure_pp_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(pp_or_expression, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
            };
            pp_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_expression.name] = &pp_expression;
    }

    void lexical_grammar::Configure_pp_or_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_and_expression, 1, 1),
            };
            pp_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_or_expression, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("||"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(pp_and_expression, 1, 1),
            };
            pp_or_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_or_expression.name] = &pp_or_expression;
    }

    void lexical_grammar::Configure_pp_and_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_equality_expression, 1, 1),
            };
            pp_and_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_and_expression, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("&&"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(pp_equality_expression, 1, 1),
            };
            pp_and_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_and_expression.name] = &pp_and_expression;
    }

    void lexical_grammar::Configure_pp_equality_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_unary_expression, 1, 1),
            };
            pp_equality_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_equality_expression, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("=="), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(pp_unary_expression, 1, 1),
            };
            pp_equality_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_equality_expression, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("!="), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(pp_unary_expression, 1, 1),
            };
            pp_equality_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_equality_expression.name] = &pp_equality_expression;
    }

    void lexical_grammar::Configure_pp_unary_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_primary_expression, 1, 1),
            };
            pp_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(whitespace, 0, 1),
                ::grammar::base::create(pp_unary_expression, 1, 1),
            };
            pp_unary_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_unary_expression.name] = &pp_unary_expression;
    }

    void lexical_grammar::Configure_pp_primary_expression()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("true"), 1, 1),
            };
            pp_primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("false"), 1, 1),
            };
            pp_primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(conditional_symbol, 1, 1),
            };
            pp_primary_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(whitespace, 0, 1),
                ::grammar::base::create(pp_expression, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            pp_primary_expression.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_primary_expression.name] = &pp_primary_expression;
    }

    void lexical_grammar::Configure_pp_declaration()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("define"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(conditional_symbol, 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
            };
            pp_declaration.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("undef"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(conditional_symbol, 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
            };
            pp_declaration.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_declaration.name] = &pp_declaration;
    }

    void lexical_grammar::Configure_pp_new_line()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(single_line_comment, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
            };
            pp_new_line.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_new_line.name] = &pp_new_line;
    }

    void lexical_grammar::Configure_pp_conditional()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_if_section, 1, 1),
                ::grammar::base::create(pp_elif_section, 0, 1),
                ::grammar::base::create(pp_else_section, 0, 1),
                ::grammar::base::create(pp_endif, 1, 1),
            };
            pp_conditional.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_conditional.name] = &pp_conditional;
    }

    void lexical_grammar::Configure_pp_if_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("if"), 1, 1),
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(pp_expression, 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
                ::grammar::base::create(conditional_section, 0, 1),
            };
            pp_if_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_if_section.name] = &pp_if_section;
    }

    void lexical_grammar::Configure_pp_elif_sections()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_elif_section, 1, ::grammar::infinity()),
            };
            pp_elif_sections.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_elif_sections.name] = &pp_elif_sections;
    }

    void lexical_grammar::Configure_pp_elif_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("elif"), 1, 1),
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(pp_expression, 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
                ::grammar::base::create(conditional_section, 0, 1),
            };
            pp_elif_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_elif_section.name] = &pp_elif_section;
    }

    void lexical_grammar::Configure_pp_else_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("else"), 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
                ::grammar::base::create(conditional_section, 0, 1),
            };
            pp_else_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_else_section.name] = &pp_else_section;
    }

    void lexical_grammar::Configure_pp_endif()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("endif"), 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
            };
            pp_endif.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_endif.name] = &pp_endif;
    }

    void lexical_grammar::Configure_skipped_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(skipped_section_part, 1, ::grammar::infinity()),
            };
            skipped_section.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[skipped_section.name] = &skipped_section;
    }

    void lexical_grammar::Configure_skipped_section_part()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(skipped_characters, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
            };
            skipped_section_part.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_directive, 1, 1),
            };
            skipped_section_part.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[skipped_section_part.name] = &skipped_section_part;
    }

    void lexical_grammar::Configure_skipped_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::none_of("#"), 1, 1),
                ::grammar::base::create(input_characters, 0, 1),
            };
            skipped_characters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[skipped_characters.name] = &skipped_characters;
    }

    void lexical_grammar::Configure_pp_diagnostic()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("error"), 1, 1),
                ::grammar::base::create(pp_message, 1, 1),
            };
            pp_diagnostic.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("warning"), 1, 1),
                ::grammar::base::create(pp_message, 1, 1),
            };
            pp_diagnostic.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_diagnostic.name] = &pp_diagnostic;
    }

    void lexical_grammar::Configure_pp_message()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(new_line, 1, 1),
            };
            pp_message.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(input_characters, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
            };
            pp_message.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_message.name] = &pp_message;
    }

    void lexical_grammar::Configure_pp_region()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(pp_start_region, 1, 1),
                ::grammar::base::create(conditional_section, 0, 1),
                ::grammar::base::create(pp_end_region, 1, 1),
            };
            pp_region.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_region.name] = &pp_region;
    }

    void lexical_grammar::Configure_pp_start_region()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("region"), 1, 1),
                ::grammar::base::create(pp_message, 1, 1),
            };
            pp_start_region.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_start_region.name] = &pp_start_region;
    }

    void lexical_grammar::Configure_pp_end_region()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("endregion"), 1, 1),
                ::grammar::base::create(pp_message, 1, 1),
            };
            pp_end_region.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_end_region.name] = &pp_end_region;
    }

    void lexical_grammar::Configure_pp_line()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("#"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(::grammar::base::terminal("line"), 1, 1),
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(line_indicator, 1, 1),
                ::grammar::base::create(pp_new_line, 1, 1),
            };
            pp_line.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[pp_line.name] = &pp_line;
    }

    void lexical_grammar::Configure_line_indicator()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(file_name, 1, 1),
            };
            line_indicator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(decimal_digits, 1, 1),
            };
            line_indicator.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("default"), 1, 1),
            };
            line_indicator.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[line_indicator.name] = &line_indicator;
    }

    void lexical_grammar::Configure_file_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("\""), 1, 1),
                ::grammar::base::create(file_name_characters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("\""), 1, 1),
            };
            file_name.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[file_name.name] = &file_name;
    }

    void lexical_grammar::Configure_file_name_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of("\"\r\n"), 1, ::grammar::infinity()),
            };
            file_name_characters.push_back(key(), rhs, array::end_of(rhs));
        }

        ::grammar::base::symbols[file_name_characters.name] = &file_name_characters;
    }
}

namespace csharp // lexical_grammar - 'tor
{
    lexical_grammar::lexical_grammar()
        : ::grammar::base()
        , input(key(), "input", 1)
        , input_section(key(), "input-section", 1)
        , input_section_part(key(), "input-section-part", 2)
        , input_elements(key(), "input-elements", 1)
        , input_element(key(), "input-element", 3)
        , new_line(key(), "new-line", 2)
        , comment(key(), "comment", 2)
        , single_line_comment(key(), "single-line-comment", 1)
        , input_characters(key(), "input-characters", 1)
        , delimited_comment(key(), "delimited-comment", 1)
        , delimited_comment_text(key(), "delimited-comment-text", 1)
        , delimited_comment_section(key(), "delimited-comment-section", 2)
        , whitespace(key(), "whitespace", 1)
        , token(key(), "token", 7)
        , unicode_escape_sequence(key(), "unicode-escape-sequence", 2)
        , identifier(key(), "identifier", 2)
        , identifier_or_keyword(key(), "identifier-or-keyword", 1)
        , identifier_start_character(key(), "identifier-start-character", 2)
        , identifier_part_characters(key(), "identifier-part-characters", 1)
        , identifier_part_character(key(), "identifier-part-character", 5)
        , keyword(key(), "keyword", 77)
        , literal(key(), "literal", 6)
        , boolean_literal(key(), "boolean-literal", 2)
        , integer_literal(key(), "integer-literal", 2)
        , decimal_integer_literal(key(), "decimal-integer-literal", 1)
        , decimal_digits(key(), "decimal-digits", 1)
        , integer_type_suffix(key(), "integer-type-suffix", 2)
        , hexadecimal_integer_literal(key(), "hexadecimal-integer-literal", 1)
        , hex_digits(key(), "hex-digits", 1)
        , hex_digit(key(), "hex-digit", 1)
        , real_literal(key(), "real-literal", 4)
        , exponent_part(key(), "exponent-part", 1)
        , sign(key(), "sign", 1)
        , real_type_suffix(key(), "real-type-suffix", 1)
        , character_literal(key(), "character-literal", 1)
        , character(key(), "character", 4)
        , single_character(key(), "single-character", 1)
        , simple_escape_sequence(key(), "simple-escape-sequence", 1)
        , hexadecimal_escape_sequence(key(), "hexadecimal-escape-sequence", 1)
        , string_literal(key(), "string-literal", 2)
        , regular_string_literal(key(), "regular-string-literal", 1)
        , regular_string_literal_characters(key(), "regular-string-literal-characters", 1)
        , regular_string_literal_character(key(), "regular-string-literal-character", 4)
        , single_regular_string_literal_character(key(), "single-regular-string-literal-character", 1)
        , verbatim_string_literal(key(), "verbatim-string-literal", 1)
        , verbatim_string_literal_characters(key(), "verbatim-string-literal-characters", 1)
        , verbatim_string_literal_character(key(), "verbatim-string-literal-character", 2)
        , single_verbatim_string_literal_character(key(), "single-verbatim-string-literal-character", 1)
        , quote_escape_sequence(key(), "quote-escape-sequence", 1)
        , null_literal(key(), "null-literal", 1)
        , operator_or_punctuator(key(), "operator-or-punctuator", 44)
        , pp_directive(key(), "pp-directive", 5)
        , pp_expression(key(), "pp-expression", 1)
        , pp_or_expression(key(), "pp-or-expression", 2)
        , pp_and_expression(key(), "pp-and-expression", 2)
        , pp_equality_expression(key(), "pp-equality-expression", 3)
        , pp_unary_expression(key(), "pp-unary-expression", 2)
        , pp_primary_expression(key(), "pp-primary-expression", 4)
        , pp_declaration(key(), "pp-declaration", 2)
        , pp_new_line(key(), "pp-new-line", 1)
        , pp_conditional(key(), "pp-conditional", 1)
        , pp_if_section(key(), "pp-if-section", 1)
        , pp_elif_sections(key(), "pp-elif-sections", 1)
        , pp_elif_section(key(), "pp-elif-section", 1)
        , pp_else_section(key(), "pp-else-section", 1)
        , pp_endif(key(), "pp-endif", 1)
        , skipped_section(key(), "skipped-section", 1)
        , skipped_section_part(key(), "skipped-section-part", 2)
        , skipped_characters(key(), "skipped-characters", 1)
        , pp_diagnostic(key(), "pp-diagnostic", 2)
        , pp_message(key(), "pp-message", 2)
        , pp_region(key(), "pp-region", 1)
        , pp_start_region(key(), "pp-start-region", 1)
        , pp_end_region(key(), "pp-end-region", 1)
        , pp_line(key(), "pp-line", 1)
        , line_indicator(key(), "line-indicator", 3)
        , file_name(key(), "file-name", 1)
        , file_name_characters(key(), "file-name-characters", 1)
        , available_identifier(key(), "available-identifier", &lexical_grammar_visitor::available_identifier)
        , letter_character(key(), "letter-character", &lexical_grammar_visitor::letter_character)
        , decimal_digit_character(key(), "decimal-digit-character", &lexical_grammar_visitor::decimal_digit_character)
        , connecting_character(key(), "connecting-character", &lexical_grammar_visitor::connecting_character)
        , combining_character(key(), "combining-character", &lexical_grammar_visitor::combining_character)
        , formatting_character(key(), "formatting-character", &lexical_grammar_visitor::formatting_character)
        , conditional_symbol(key(), "conditional-symbol", &lexical_grammar_visitor::conditional_symbol)
        , conditional_section(key(), "conditional-section", &lexical_grammar_visitor::conditional_section)
    {
        Configure_input();
        Configure_input_section();
        Configure_input_section_part();
        Configure_input_elements();
        Configure_input_element();
        Configure_new_line();
        Configure_comment();
        Configure_single_line_comment();
        Configure_input_characters();
        Configure_delimited_comment();
        Configure_delimited_comment_text();
        Configure_delimited_comment_section();
        Configure_whitespace();
        Configure_token();
        Configure_unicode_escape_sequence();
        Configure_identifier();
        Configure_identifier_or_keyword();
        Configure_identifier_start_character();
        Configure_identifier_part_characters();
        Configure_identifier_part_character();
        Configure_keyword();
        Configure_literal();
        Configure_boolean_literal();
        Configure_integer_literal();
        Configure_decimal_integer_literal();
        Configure_decimal_digits();
        Configure_integer_type_suffix();
        Configure_hexadecimal_integer_literal();
        Configure_hex_digits();
        Configure_hex_digit();
        Configure_real_literal();
        Configure_exponent_part();
        Configure_sign();
        Configure_real_type_suffix();
        Configure_character_literal();
        Configure_character();
        Configure_single_character();
        Configure_simple_escape_sequence();
        Configure_hexadecimal_escape_sequence();
        Configure_string_literal();
        Configure_regular_string_literal();
        Configure_regular_string_literal_characters();
        Configure_regular_string_literal_character();
        Configure_single_regular_string_literal_character();
        Configure_verbatim_string_literal();
        Configure_verbatim_string_literal_characters();
        Configure_verbatim_string_literal_character();
        Configure_single_verbatim_string_literal_character();
        Configure_quote_escape_sequence();
        Configure_null_literal();
        Configure_operator_or_punctuator();
        Configure_pp_directive();
        Configure_pp_expression();
        Configure_pp_or_expression();
        Configure_pp_and_expression();
        Configure_pp_equality_expression();
        Configure_pp_unary_expression();
        Configure_pp_primary_expression();
        Configure_pp_declaration();
        Configure_pp_new_line();
        Configure_pp_conditional();
        Configure_pp_if_section();
        Configure_pp_elif_sections();
        Configure_pp_elif_section();
        Configure_pp_else_section();
        Configure_pp_endif();
        Configure_skipped_section();
        Configure_skipped_section_part();
        Configure_skipped_characters();
        Configure_pp_diagnostic();
        Configure_pp_message();
        Configure_pp_region();
        Configure_pp_start_region();
        Configure_pp_end_region();
        Configure_pp_line();
        Configure_line_indicator();
        Configure_file_name();
        Configure_file_name_characters();
    }
}
namespace csharp // lexical_grammar - instance
{
    const lexical_grammar & lexical_grammar::instance()
    {
        static const lexical_grammar the_instance;
        return the_instance;
    }
}


