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

#include "bootstrap/meta_grammar.hpp"
#include "bootstrap/meta_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 bootstrap // meta_grammar - associative look up
{
    const ::grammar::non_terminal_symbol_definition *
    meta_grammar::operator[](const char * name) const
    {
        return extract(::grammar::base::symbols.find(name), ::grammar::base::symbols.end());
    }
}

namespace bootstrap // meta_grammar - configuration
{

    void meta_grammar::Configure_grammar()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(grammar_section, 1, ::grammar::infinity()),
            };
            grammar.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_grammar_section()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(non_terminal, 1, 1),
                ::grammar::base::create(new_line, 0, 1),
            };
            grammar_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(predicate, 1, 1),
                ::grammar::base::create(new_line, 0, 1),
            };
            grammar_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(comment, 1, 1),
                ::grammar::base::create(new_line, 0, 1),
            };
            grammar_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
            };
            grammar_section.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
            };
            grammar_section.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_comment()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("//"), 1, 1),
                ::grammar::base::create(::grammar::base::none_of("\r\n"), 0, ::grammar::infinity()),
            };
            comment.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_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 meta_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 meta_grammar::Configure_non_terminal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(name_characters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(":"), 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
                ::grammar::base::create(productions, 1, 1),
            };
            non_terminal.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_productions()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(production, 1, ::grammar::infinity()),
            };
            productions.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_production()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(qualified_symbols, 1, 1),
                ::grammar::base::create(whitespace, 0, 1),
                ::grammar::base::create(new_line, 1, 1),
            };
            production.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_qualified_symbols()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(qualified_symbol, 1, ::grammar::infinity()),
            };
            qualified_symbols.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_qualified_symbol()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(symbol_name, 1, 1),
                ::grammar::base::create(multiplicity, 0, 1),
            };
            qualified_symbol.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(terminal, 1, 1),
                ::grammar::base::create(multiplicity, 0, 1),
            };
            qualified_symbol.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(none_of, 1, 1),
                ::grammar::base::create(multiplicity, 0, 1),
            };
            qualified_symbol.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(whitespace, 1, 1),
                ::grammar::base::create(one_of, 1, 1),
                ::grammar::base::create(multiplicity, 0, 1),
            };
            qualified_symbol.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_multiplicity()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("?+*"), 1, 1),
            };
            multiplicity.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(::grammar::base::terminal("}"), 1, 1),
            };
            multiplicity.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(::grammar::base::terminal(","), 1, 1),
                ::grammar::base::create(decimal_digits, 1, 1),
                ::grammar::base::create(::grammar::base::terminal("}"), 1, 1),
            };
            multiplicity.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_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 meta_grammar::Configure_symbol_name()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(name_characters, 1, 1),
            };
            symbol_name.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_terminal()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("TERMINAL("), 1, 1),
                ::grammar::base::create(terminal_characters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            terminal.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_none_of()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("NONE_OF("), 1, 1),
                ::grammar::base::create(terminal_characters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            none_of.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_one_of()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("ONE_OF("), 1, 1),
                ::grammar::base::create(terminal_characters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            one_of.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_predicate()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal("PREDICATE("), 1, 1),
                ::grammar::base::create(name_characters, 1, 1),
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            predicate.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_terminal_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::terminal(")"), 1, 1),
            };
            terminal_characters.push_back(key(), rhs, array::end_of(rhs));
        }
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::none_of(")"), 1, ::grammar::infinity()),
            };
            terminal_characters.push_back(key(), rhs, array::end_of(rhs));
        }

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

    void meta_grammar::Configure_name_characters()
    {
        {
            const ::grammar::qualified_symbol_definition rhs[] =
            {
                ::grammar::base::create(::grammar::base::one_of("abcdefghijklmnopqrstuvwxyz-"), 1, ::grammar::infinity()),
            };
            name_characters.push_back(key(), rhs, array::end_of(rhs));
        }

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

namespace bootstrap // meta_grammar - 'tor
{
    meta_grammar::meta_grammar()
        : ::grammar::base()
        , grammar(key(), "grammar", 1)
        , grammar_section(key(), "grammar-section", 5)
        , comment(key(), "comment", 1)
        , whitespace(key(), "whitespace", 1)
        , new_line(key(), "new-line", 2)
        , non_terminal(key(), "non-terminal", 1)
        , productions(key(), "productions", 1)
        , production(key(), "production", 1)
        , qualified_symbols(key(), "qualified-symbols", 1)
        , qualified_symbol(key(), "qualified-symbol", 4)
        , multiplicity(key(), "multiplicity", 3)
        , decimal_digits(key(), "decimal-digits", 1)
        , symbol_name(key(), "symbol-name", 1)
        , terminal(key(), "terminal", 1)
        , none_of(key(), "none-of", 1)
        , one_of(key(), "one-of", 1)
        , predicate(key(), "predicate", 1)
        , terminal_characters(key(), "terminal-characters", 2)
        , name_characters(key(), "name-characters", 1)
    {
        Configure_grammar();
        Configure_grammar_section();
        Configure_comment();
        Configure_whitespace();
        Configure_new_line();
        Configure_non_terminal();
        Configure_productions();
        Configure_production();
        Configure_qualified_symbols();
        Configure_qualified_symbol();
        Configure_multiplicity();
        Configure_decimal_digits();
        Configure_symbol_name();
        Configure_terminal();
        Configure_none_of();
        Configure_one_of();
        Configure_predicate();
        Configure_terminal_characters();
        Configure_name_characters();
    }
}
namespace bootstrap // meta_grammar - instance
{
    const meta_grammar & meta_grammar::instance()
    {
        static const meta_grammar the_instance;
        return the_instance;
    }
}