as_statements.g.cc

Go to the documentation of this file.

// This file is automatically generated, do not edit.

#include <lestes/lang/cplus/sem/as_decl.g.hh>
#include <lestes/lang/cplus/sem/as_expr.g.hh>
#include <lestes/lang/cplus/sem/as_visitor.v.g.hh>

#include <lestes/std/list.hh>
#include <lestes/std/pair.hh>
#include <lestes/std/reflect.hh>

#include <lestes/lang/cplus/sem/as_statements.g.hh>

package(lestes);
package(lang);
package(cplus);
package(sem);


// ------------- Class as_statement follows. -------------

/*!
   Generated constructor for class as_statement.
   \author lsg
 */
as_statement::as_statement (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_base(a__as_base__location)
{}

ptr< object::reflection_list > as_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_statement::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_statement::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_statement.

// ------------- Class as_dummy_statement follows. -------------

void as_dummy_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_dummy_statement( this );
}

/*!
   This factory method for class as_dummy_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_dummy_statement > as_dummy_statement::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_dummy_statement > ( new as_dummy_statement(a__as_base__location) );
}

/*!
   Generated constructor for class as_dummy_statement.
   \author lsg
 */
as_dummy_statement::as_dummy_statement (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_statement(a__as_base__location)
{}

ptr< object::reflection_list > as_dummy_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_dummy_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_dummy_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_dummy_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_dummy_statement.

// ------------- Class as_labeled_statement follows. -------------

/*!
   \returns The value of as_labeled_statement::statement.
   \author lsg
 */
ptr< as_statement > as_labeled_statement::statement_get() const
{
        return statement;
}

/*!
   \param[in] x The new value to set as_labeled_statement::statement to.
   \author lsg
 */
void as_labeled_statement::statement_set(const ptr< as_statement > & x)
{
        as_labeled_statement::statement = x;
}

/*!
   Generated constructor for class as_labeled_statement.
   \author lsg
 */
as_labeled_statement::as_labeled_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement)
        : as_statement(a__as_base__location), statement(checked(a__as_labeled_statement__statement))
{}

ptr< object::reflection_list > as_labeled_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "statement", "as_statement" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_labeled_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_labeled_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->statement );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_labeled_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_labeled_statement.

// ------------- Class as_default_labeled_statement follows. -------------

void as_default_labeled_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_default_labeled_statement( this );
}

/*!
   This factory method for class as_default_labeled_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_default_labeled_statement > as_default_labeled_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement)
{
        return ptr< as_default_labeled_statement > ( new as_default_labeled_statement(a__as_base__location,
                a__as_labeled_statement__statement) );
}

/*!
   Generated constructor for class as_default_labeled_statement.
   \author lsg
 */
as_default_labeled_statement::as_default_labeled_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement)
        : as_labeled_statement(a__as_base__location,
                a__as_labeled_statement__statement)
{}

ptr< object::reflection_list > as_default_labeled_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_labeled_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_default_labeled_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_default_labeled_statement::field_values_get() const
{
        ptr < field_list_list > result = as_labeled_statement::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_default_labeled_statement::gc_mark()
{
        as_labeled_statement::gc_mark();
}

// End of class as_default_labeled_statement.

// ------------- Class as_case_labeled_statement follows. -------------

/*!
   \returns The value of as_case_labeled_statement::case_value.
   \author lsg
 */
ptr< as_constant_expression > as_case_labeled_statement::case_value_get() const
{
        return case_value;
}

/*!
   \param[in] x The new value to set as_case_labeled_statement::case_value to.
   \author lsg
 */
void as_case_labeled_statement::case_value_set(const ptr< as_constant_expression > & x)
{
        as_case_labeled_statement::case_value = x;
}

void as_case_labeled_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_case_labeled_statement( this );
}

/*!
   This factory method for class as_case_labeled_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_case_labeled_statement > as_case_labeled_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement,
                ptr< as_constant_expression > a__as_case_labeled_statement__case_value)
{
        return ptr< as_case_labeled_statement > ( new as_case_labeled_statement(a__as_base__location,
                a__as_labeled_statement__statement,
                a__as_case_labeled_statement__case_value) );
}

/*!
   Generated constructor for class as_case_labeled_statement.
   \author lsg
 */
as_case_labeled_statement::as_case_labeled_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement,
                ptr< as_constant_expression > a__as_case_labeled_statement__case_value)
        : as_labeled_statement(a__as_base__location,
                a__as_labeled_statement__statement), case_value(checked(a__as_case_labeled_statement__case_value))
{}

ptr< object::reflection_list > as_case_labeled_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "case_value", "as_constant_expression" ) );
                reflection = reflection_list::create( as_labeled_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_case_labeled_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_case_labeled_statement::field_values_get() const
{
        ptr < field_list_list > result = as_labeled_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->case_value );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_case_labeled_statement::gc_mark()
{
        as_labeled_statement::gc_mark();
}

// End of class as_case_labeled_statement.

// ------------- Class as_identifier_labeled_statement follows. -------------

/*!
   \returns The value of as_identifier_labeled_statement::identifier.
   \author lsg
 */
ptr< as_identifier > as_identifier_labeled_statement::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_identifier_labeled_statement::identifier to.
   \author lsg
 */
void as_identifier_labeled_statement::identifier_set(const ptr< as_identifier > & x)
{
        as_identifier_labeled_statement::identifier = x;
}

void as_identifier_labeled_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_identifier_labeled_statement( this );
}

/*!
   This factory method for class as_identifier_labeled_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_identifier_labeled_statement > as_identifier_labeled_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement,
                ptr< as_identifier > a__as_identifier_labeled_statement__identifier)
{
        return ptr< as_identifier_labeled_statement > ( new as_identifier_labeled_statement(a__as_base__location,
                a__as_labeled_statement__statement,
                a__as_identifier_labeled_statement__identifier) );
}

/*!
   Generated constructor for class as_identifier_labeled_statement.
   \author lsg
 */
as_identifier_labeled_statement::as_identifier_labeled_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_labeled_statement__statement,
                ptr< as_identifier > a__as_identifier_labeled_statement__identifier)
        : as_labeled_statement(a__as_base__location,
                a__as_labeled_statement__statement), identifier(checked(a__as_identifier_labeled_statement__identifier))
{}

ptr< object::reflection_list > as_identifier_labeled_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "identifier", "as_identifier" ) );
                reflection = reflection_list::create( as_labeled_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_identifier_labeled_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_identifier_labeled_statement::field_values_get() const
{
        ptr < field_list_list > result = as_labeled_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_identifier_labeled_statement::gc_mark()
{
        as_labeled_statement::gc_mark();
}

// End of class as_identifier_labeled_statement.

// ------------- Class as_compound_statement follows. -------------

/*!
   \returns The value of as_compound_statement::statements.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_statement > > > as_compound_statement::statements_get() const
{
        return statements;
}

/*!
   \param[in] x The new value to set as_compound_statement::statements to.
   \author lsg
 */
void as_compound_statement::statements_set(const ptr< ::lestes::std::list< srp< as_statement > > > & x)
{
        as_compound_statement::statements = x;
}

void as_compound_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_compound_statement( this );
}

/*!
   This factory method for class as_compound_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_compound_statement > as_compound_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_statement > > > a__as_compound_statement__statements)
{
        return ptr< as_compound_statement > ( new as_compound_statement(a__as_base__location,
                a__as_compound_statement__statements) );
}

/*!
   Generated constructor for class as_compound_statement.
   \author lsg
 */
as_compound_statement::as_compound_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_statement > > > a__as_compound_statement__statements)
        : as_statement(a__as_base__location), statements(checked(a__as_compound_statement__statements))
{}

ptr< object::reflection_list > as_compound_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "statements", "list&lt; srp&lt; as_statement &gt; &gt;" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_compound_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_compound_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->statements );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_compound_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_compound_statement.

// ------------- Class as_expression_statement follows. -------------

/*!
   \returns The value of as_expression_statement::expression.
   \author lsg
 */
ptr< as_expression > as_expression_statement::expression_get() const
{
        return expression;
}

/*!
   \param[in] x The new value to set as_expression_statement::expression to.
   \author lsg
 */
void as_expression_statement::expression_set(const ptr< as_expression > & x)
{
        as_expression_statement::expression = x;
}

void as_expression_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_expression_statement( this );
}

/*!
   This factory method for class as_expression_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_statement > as_expression_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_statement__expression)
{
        return ptr< as_expression_statement > ( new as_expression_statement(a__as_base__location,
                a__as_expression_statement__expression) );
}

/*!
   Generated constructor for class as_expression_statement.
   \author lsg
 */
as_expression_statement::as_expression_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_statement__expression)
        : as_statement(a__as_base__location), expression(checked(a__as_expression_statement__expression))
{}

ptr< object::reflection_list > as_expression_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "expression", "as_expression" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_expression_statement.

// ------------- Class as_selection_statement follows. -------------

/*!
   \returns The value of as_selection_statement::condition.
   \author lsg
 */
ptr< as_condition > as_selection_statement::condition_get() const
{
        return condition;
}

/*!
   \param[in] x The new value to set as_selection_statement::condition to.
   \author lsg
 */
void as_selection_statement::condition_set(const ptr< as_condition > & x)
{
        as_selection_statement::condition = x;
}

/*!
   Generated constructor for class as_selection_statement.
   \author lsg
 */
as_selection_statement::as_selection_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_condition > a__as_selection_statement__condition)
        : as_statement(a__as_base__location), condition(checked(a__as_selection_statement__condition))
{}

ptr< object::reflection_list > as_selection_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "condition", "as_condition" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_selection_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_selection_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->condition );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_selection_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_selection_statement.

// ------------- Class as_if_statement follows. -------------

/*!
   \returns The value of as_if_statement::then_statement.
   \author lsg
 */
ptr< as_statement > as_if_statement::then_statement_get() const
{
        return then_statement;
}

/*!
   \param[in] x The new value to set as_if_statement::then_statement to.
   \author lsg
 */
void as_if_statement::then_statement_set(const ptr< as_statement > & x)
{
        as_if_statement::then_statement = x;
}

/*!
   \returns The value of as_if_statement::else_statement.
   \author lsg
 */
ptr< as_statement > as_if_statement::else_statement_get() const
{
        return else_statement;
}

/*!
   \param[in] x The new value to set as_if_statement::else_statement to.
   \author lsg
 */
void as_if_statement::else_statement_set(const ptr< as_statement > & x)
{
        as_if_statement::else_statement = x;
}

void as_if_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_if_statement( this );
}

/*!
   This factory method for class as_if_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_if_statement > as_if_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_condition > a__as_selection_statement__condition,
                ptr< as_statement > a__as_if_statement__then_statement,
                ptr< as_statement > a__as_if_statement__else_statement)
{
        return ptr< as_if_statement > ( new as_if_statement(a__as_base__location,
                a__as_selection_statement__condition,
                a__as_if_statement__then_statement,
                a__as_if_statement__else_statement) );
}

/*!
   Generated constructor for class as_if_statement.
   \author lsg
 */
as_if_statement::as_if_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_condition > a__as_selection_statement__condition,
                ptr< as_statement > a__as_if_statement__then_statement,
                ptr< as_statement > a__as_if_statement__else_statement)
        : as_selection_statement(a__as_base__location,
                a__as_selection_statement__condition), then_statement(checked(a__as_if_statement__then_statement)), else_statement(a__as_if_statement__else_statement)
{}

ptr< object::reflection_list > as_if_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "then_statement", "as_statement" ) );
                mdl->push_back( md::create( "else_statement", "as_statement" ) );
                reflection = reflection_list::create( as_selection_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_if_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_if_statement::field_values_get() const
{
        ptr < field_list_list > result = as_selection_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->then_statement );
        result->push_back( value_list::create() );
        result->back()->push_back( this->else_statement );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_if_statement::gc_mark()
{
        as_selection_statement::gc_mark();
}

// End of class as_if_statement.

// ------------- Class as_switch_statement follows. -------------

/*!
   \returns The value of as_switch_statement::controlled_statement.
   \author lsg
 */
ptr< as_statement > as_switch_statement::controlled_statement_get() const
{
        return controlled_statement;
}

/*!
   \param[in] x The new value to set as_switch_statement::controlled_statement to.
   \author lsg
 */
void as_switch_statement::controlled_statement_set(const ptr< as_statement > & x)
{
        as_switch_statement::controlled_statement = x;
}

void as_switch_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_switch_statement( this );
}

/*!
   This factory method for class as_switch_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_switch_statement > as_switch_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_condition > a__as_selection_statement__condition,
                ptr< as_statement > a__as_switch_statement__controlled_statement)
{
        return ptr< as_switch_statement > ( new as_switch_statement(a__as_base__location,
                a__as_selection_statement__condition,
                a__as_switch_statement__controlled_statement) );
}

/*!
   Generated constructor for class as_switch_statement.
   \author lsg
 */
as_switch_statement::as_switch_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_condition > a__as_selection_statement__condition,
                ptr< as_statement > a__as_switch_statement__controlled_statement)
        : as_selection_statement(a__as_base__location,
                a__as_selection_statement__condition), controlled_statement(checked(a__as_switch_statement__controlled_statement))
{}

ptr< object::reflection_list > as_switch_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "controlled_statement", "as_statement" ) );
                reflection = reflection_list::create( as_selection_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_switch_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_switch_statement::field_values_get() const
{
        ptr < field_list_list > result = as_selection_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->controlled_statement );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_switch_statement::gc_mark()
{
        as_selection_statement::gc_mark();
}

// End of class as_switch_statement.

// ------------- Class as_iteration_statement follows. -------------

/*!
   \returns The value of as_iteration_statement::controlled_statement.
   \author lsg
 */
ptr< as_statement > as_iteration_statement::controlled_statement_get() const
{
        return controlled_statement;
}

/*!
   \param[in] x The new value to set as_iteration_statement::controlled_statement to.
   \author lsg
 */
void as_iteration_statement::controlled_statement_set(const ptr< as_statement > & x)
{
        as_iteration_statement::controlled_statement = x;
}

/*!
   Generated constructor for class as_iteration_statement.
   \author lsg
 */
as_iteration_statement::as_iteration_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement)
        : as_statement(a__as_base__location), controlled_statement(checked(a__as_iteration_statement__controlled_statement))
{}

ptr< object::reflection_list > as_iteration_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "controlled_statement", "as_statement" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_iteration_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_iteration_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->controlled_statement );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_iteration_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_iteration_statement.

// ------------- Class as_do_statement follows. -------------

/*!
   \returns The value of as_do_statement::condition.
   \author lsg
 */
ptr< as_expression > as_do_statement::condition_get() const
{
        return condition;
}

/*!
   \param[in] x The new value to set as_do_statement::condition to.
   \author lsg
 */
void as_do_statement::condition_set(const ptr< as_expression > & x)
{
        as_do_statement::condition = x;
}

void as_do_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_do_statement( this );
}

/*!
   This factory method for class as_do_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_do_statement > as_do_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement,
                ptr< as_expression > a__as_do_statement__condition)
{
        return ptr< as_do_statement > ( new as_do_statement(a__as_base__location,
                a__as_iteration_statement__controlled_statement,
                a__as_do_statement__condition) );
}

/*!
   Generated constructor for class as_do_statement.
   \author lsg
 */
as_do_statement::as_do_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement,
                ptr< as_expression > a__as_do_statement__condition)
        : as_iteration_statement(a__as_base__location,
                a__as_iteration_statement__controlled_statement), condition(checked(a__as_do_statement__condition))
{}

ptr< object::reflection_list > as_do_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "condition", "as_expression" ) );
                reflection = reflection_list::create( as_iteration_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_do_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_do_statement::field_values_get() const
{
        ptr < field_list_list > result = as_iteration_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->condition );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_do_statement::gc_mark()
{
        as_iteration_statement::gc_mark();
}

// End of class as_do_statement.

// ------------- Class as_while_statement follows. -------------

/*!
   \returns The value of as_while_statement::condition.
   \author lsg
 */
ptr< as_condition > as_while_statement::condition_get() const
{
        return condition;
}

/*!
   \param[in] x The new value to set as_while_statement::condition to.
   \author lsg
 */
void as_while_statement::condition_set(const ptr< as_condition > & x)
{
        as_while_statement::condition = x;
}

void as_while_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_while_statement( this );
}

/*!
   This factory method for class as_while_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_while_statement > as_while_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement,
                ptr< as_condition > a__as_while_statement__condition)
{
        return ptr< as_while_statement > ( new as_while_statement(a__as_base__location,
                a__as_iteration_statement__controlled_statement,
                a__as_while_statement__condition) );
}

/*!
   Generated constructor for class as_while_statement.
   \author lsg
 */
as_while_statement::as_while_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement,
                ptr< as_condition > a__as_while_statement__condition)
        : as_iteration_statement(a__as_base__location,
                a__as_iteration_statement__controlled_statement), condition(checked(a__as_while_statement__condition))
{}

ptr< object::reflection_list > as_while_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "condition", "as_condition" ) );
                reflection = reflection_list::create( as_iteration_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_while_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_while_statement::field_values_get() const
{
        ptr < field_list_list > result = as_iteration_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->condition );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_while_statement::gc_mark()
{
        as_iteration_statement::gc_mark();
}

// End of class as_while_statement.

// ------------- Class as_for_statement follows. -------------

/*!
   \returns The value of as_for_statement::for_init.
   \author lsg
 */
ptr< as_for_init_statement > as_for_statement::for_init_get() const
{
        return for_init;
}

/*!
   \param[in] x The new value to set as_for_statement::for_init to.
   \author lsg
 */
void as_for_statement::for_init_set(const ptr< as_for_init_statement > & x)
{
        as_for_statement::for_init = x;
}

/*!
   \returns The value of as_for_statement::condition.
   \author lsg
 */
ptr< as_condition > as_for_statement::condition_get() const
{
        return condition;
}

/*!
   \param[in] x The new value to set as_for_statement::condition to.
   \author lsg
 */
void as_for_statement::condition_set(const ptr< as_condition > & x)
{
        as_for_statement::condition = x;
}

/*!
   \returns The value of as_for_statement::increment.
   \author lsg
 */
ptr< as_expression > as_for_statement::increment_get() const
{
        return increment;
}

/*!
   \param[in] x The new value to set as_for_statement::increment to.
   \author lsg
 */
void as_for_statement::increment_set(const ptr< as_expression > & x)
{
        as_for_statement::increment = x;
}

void as_for_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_for_statement( this );
}

/*!
   This factory method for class as_for_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_for_statement > as_for_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement,
                ptr< as_for_init_statement > a__as_for_statement__for_init,
                ptr< as_condition > a__as_for_statement__condition,
                ptr< as_expression > a__as_for_statement__increment)
{
        return ptr< as_for_statement > ( new as_for_statement(a__as_base__location,
                a__as_iteration_statement__controlled_statement,
                a__as_for_statement__for_init,
                a__as_for_statement__condition,
                a__as_for_statement__increment) );
}

/*!
   Generated constructor for class as_for_statement.
   \author lsg
 */
as_for_statement::as_for_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_statement > a__as_iteration_statement__controlled_statement,
                ptr< as_for_init_statement > a__as_for_statement__for_init,
                ptr< as_condition > a__as_for_statement__condition,
                ptr< as_expression > a__as_for_statement__increment)
        : as_iteration_statement(a__as_base__location,
                a__as_iteration_statement__controlled_statement), for_init(checked(a__as_for_statement__for_init)), condition(checked(a__as_for_statement__condition)), increment(checked(a__as_for_statement__increment))
{}

ptr< object::reflection_list > as_for_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "for_init", "as_for_init_statement" ) );
                mdl->push_back( md::create( "condition", "as_condition" ) );
                mdl->push_back( md::create( "increment", "as_expression" ) );
                reflection = reflection_list::create( as_iteration_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_for_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_for_statement::field_values_get() const
{
        ptr < field_list_list > result = as_iteration_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->for_init );
        result->push_back( value_list::create() );
        result->back()->push_back( this->condition );
        result->push_back( value_list::create() );
        result->back()->push_back( this->increment );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_for_statement::gc_mark()
{
        as_iteration_statement::gc_mark();
}

// End of class as_for_statement.

// ------------- Class as_for_init_statement follows. -------------

/*!
   Generated constructor for class as_for_init_statement.
   \author lsg
 */
as_for_init_statement::as_for_init_statement (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_base(a__as_base__location)
{}

ptr< object::reflection_list > as_for_init_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_for_init_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_for_init_statement::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_for_init_statement::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_for_init_statement.

// ------------- Class as_for_init_statement_expression follows. -------------

/*!
   \returns The value of as_for_init_statement_expression::expression_statement.
   \author lsg
 */
ptr< as_expression_statement > as_for_init_statement_expression::expression_statement_get() const
{
        return expression_statement;
}

/*!
   \param[in] x The new value to set as_for_init_statement_expression::expression_statement to.
   \author lsg
 */
void as_for_init_statement_expression::expression_statement_set(const ptr< as_expression_statement > & x)
{
        as_for_init_statement_expression::expression_statement = x;
}

/*!
   This factory method for class as_for_init_statement_expression takes values of all fields as arguments.
   \author lsg
 */
ptr< as_for_init_statement_expression > as_for_init_statement_expression::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression_statement > a__as_for_init_statement_expression__expression_statement)
{
        return ptr< as_for_init_statement_expression > ( new as_for_init_statement_expression(a__as_base__location,
                a__as_for_init_statement_expression__expression_statement) );
}

/*!
   Generated constructor for class as_for_init_statement_expression.
   \author lsg
 */
as_for_init_statement_expression::as_for_init_statement_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression_statement > a__as_for_init_statement_expression__expression_statement)
        : as_for_init_statement(a__as_base__location), expression_statement(checked(a__as_for_init_statement_expression__expression_statement))
{}

ptr< object::reflection_list > as_for_init_statement_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "expression_statement", "as_expression_statement" ) );
                reflection = reflection_list::create( as_for_init_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_for_init_statement_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_for_init_statement_expression::field_values_get() const
{
        ptr < field_list_list > result = as_for_init_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression_statement );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_for_init_statement_expression::gc_mark()
{
        as_for_init_statement::gc_mark();
}

// End of class as_for_init_statement_expression.

// ------------- Class as_for_init_statement_declaration follows. -------------

/*!
   \returns The value of as_for_init_statement_declaration::declaration.
   \author lsg
 */
ptr< as_declaration > as_for_init_statement_declaration::declaration_get() const
{
        return declaration;
}

/*!
   \param[in] x The new value to set as_for_init_statement_declaration::declaration to.
   \author lsg
 */
void as_for_init_statement_declaration::declaration_set(const ptr< as_declaration > & x)
{
        as_for_init_statement_declaration::declaration = x;
}

/*!
   This factory method for class as_for_init_statement_declaration takes values of all fields as arguments.
   \author lsg
 */
ptr< as_for_init_statement_declaration > as_for_init_statement_declaration::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declaration > a__as_for_init_statement_declaration__declaration)
{
        return ptr< as_for_init_statement_declaration > ( new as_for_init_statement_declaration(a__as_base__location,
                a__as_for_init_statement_declaration__declaration) );
}

/*!
   Generated constructor for class as_for_init_statement_declaration.
   \author lsg
 */
as_for_init_statement_declaration::as_for_init_statement_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declaration > a__as_for_init_statement_declaration__declaration)
        : as_for_init_statement(a__as_base__location), declaration(checked(a__as_for_init_statement_declaration__declaration))
{}

ptr< object::reflection_list > as_for_init_statement_declaration::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "declaration", "as_declaration" ) );
                reflection = reflection_list::create( as_for_init_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_for_init_statement_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_for_init_statement_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_for_init_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_for_init_statement_declaration::gc_mark()
{
        as_for_init_statement::gc_mark();
}

// End of class as_for_init_statement_declaration.

// ------------- Class as_condition follows. -------------

/*!
   Generated constructor for class as_condition.
   \author lsg
 */
as_condition::as_condition (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_base(a__as_base__location)
{}

ptr< object::reflection_list > as_condition::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_condition", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_condition::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_condition::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_condition.

// ------------- Class as_empty_condition follows. -------------

void as_empty_condition::accept_as_condition_visitor( ptr< as_condition_visitor > v )
{
        return v->visit_as_empty_condition( this );
}

/*!
   This factory method for class as_empty_condition takes values of all fields as arguments.
   \author lsg
 */
ptr< as_empty_condition > as_empty_condition::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_empty_condition > ( new as_empty_condition(a__as_base__location) );
}

/*!
   Generated constructor for class as_empty_condition.
   \author lsg
 */
as_empty_condition::as_empty_condition (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_condition(a__as_base__location)
{}

ptr< object::reflection_list > as_empty_condition::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_condition::reflection_get() );
                reflection->push_back( class_reflection::create( "as_empty_condition", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_empty_condition::field_values_get() const
{
        ptr < field_list_list > result = as_condition::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_empty_condition::gc_mark()
{
        as_condition::gc_mark();
}

// End of class as_empty_condition.

// ------------- Class as_condition_expression follows. -------------

/*!
   \returns The value of as_condition_expression::expression.
   \author lsg
 */
ptr< as_expression > as_condition_expression::expression_get() const
{
        return expression;
}

/*!
   \param[in] x The new value to set as_condition_expression::expression to.
   \author lsg
 */
void as_condition_expression::expression_set(const ptr< as_expression > & x)
{
        as_condition_expression::expression = x;
}

void as_condition_expression::accept_as_condition_visitor( ptr< as_condition_visitor > v )
{
        return v->visit_as_condition_expression( this );
}

/*!
   This factory method for class as_condition_expression takes values of all fields as arguments.
   \author lsg
 */
ptr< as_condition_expression > as_condition_expression::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_condition_expression__expression)
{
        return ptr< as_condition_expression > ( new as_condition_expression(a__as_base__location,
                a__as_condition_expression__expression) );
}

/*!
   Generated constructor for class as_condition_expression.
   \author lsg
 */
as_condition_expression::as_condition_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_condition_expression__expression)
        : as_condition(a__as_base__location), expression(checked(a__as_condition_expression__expression))
{}

ptr< object::reflection_list > as_condition_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "expression", "as_expression" ) );
                reflection = reflection_list::create( as_condition::reflection_get() );
                reflection->push_back( class_reflection::create( "as_condition_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_condition_expression::field_values_get() const
{
        ptr < field_list_list > result = as_condition::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_condition_expression::gc_mark()
{
        as_condition::gc_mark();
}

// End of class as_condition_expression.

// ------------- Class as_condition_declaration follows. -------------

/*!
   \returns The value of as_condition_declaration::type_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_type_specifier > > > as_condition_declaration::type_specifiers_get() const
{
        return type_specifiers;
}

/*!
   \param[in] x The new value to set as_condition_declaration::type_specifiers to.
   \author lsg
 */
void as_condition_declaration::type_specifiers_set(const ptr< ::lestes::std::list< srp< as_type_specifier > > > & x)
{
        as_condition_declaration::type_specifiers = x;
}

/*!
   \returns The value of as_condition_declaration::declarator.
   \author lsg
 */
ptr< as_declarator > as_condition_declaration::declarator_get() const
{
        return declarator;
}

/*!
   \param[in] x The new value to set as_condition_declaration::declarator to.
   \author lsg
 */
void as_condition_declaration::declarator_set(const ptr< as_declarator > & x)
{
        as_condition_declaration::declarator = x;
}

/*!
   \returns The value of as_condition_declaration::initializer.
   \author lsg
 */
ptr< as_expression > as_condition_declaration::initializer_get() const
{
        return initializer;
}

/*!
   \param[in] x The new value to set as_condition_declaration::initializer to.
   \author lsg
 */
void as_condition_declaration::initializer_set(const ptr< as_expression > & x)
{
        as_condition_declaration::initializer = x;
}

void as_condition_declaration::accept_as_condition_visitor( ptr< as_condition_visitor > v )
{
        return v->visit_as_condition_declaration( this );
}

/*!
   This factory method for class as_condition_declaration takes values of all fields as arguments.
   \author lsg
 */
ptr< as_condition_declaration > as_condition_declaration::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_condition_declaration__type_specifiers,
                ptr< as_declarator > a__as_condition_declaration__declarator,
                ptr< as_expression > a__as_condition_declaration__initializer)
{
        return ptr< as_condition_declaration > ( new as_condition_declaration(a__as_base__location,
                a__as_condition_declaration__type_specifiers,
                a__as_condition_declaration__declarator,
                a__as_condition_declaration__initializer) );
}

/*!
   Generated constructor for class as_condition_declaration.
   \author lsg
 */
as_condition_declaration::as_condition_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_condition_declaration__type_specifiers,
                ptr< as_declarator > a__as_condition_declaration__declarator,
                ptr< as_expression > a__as_condition_declaration__initializer)
        : as_condition(a__as_base__location), type_specifiers(checked(a__as_condition_declaration__type_specifiers)), declarator(checked(a__as_condition_declaration__declarator)), initializer(checked(a__as_condition_declaration__initializer))
{}

ptr< object::reflection_list > as_condition_declaration::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "type_specifiers", "list&lt; srp&lt; as_type_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "declarator", "as_declarator" ) );
                mdl->push_back( md::create( "initializer", "as_expression" ) );
                reflection = reflection_list::create( as_condition::reflection_get() );
                reflection->push_back( class_reflection::create( "as_condition_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_condition_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_condition::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        result->push_back( value_list::create() );
        result->back()->push_back( this->initializer );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_condition_declaration::gc_mark()
{
        as_condition::gc_mark();
}

// End of class as_condition_declaration.

// ------------- Class as_jump_statement follows. -------------

/*!
   Generated constructor for class as_jump_statement.
   \author lsg
 */
as_jump_statement::as_jump_statement (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_statement(a__as_base__location)
{}

ptr< object::reflection_list > as_jump_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_jump_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_jump_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_jump_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_jump_statement.

// ------------- Class as_break_statement follows. -------------

void as_break_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_break_statement( this );
}

/*!
   This factory method for class as_break_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_break_statement > as_break_statement::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_break_statement > ( new as_break_statement(a__as_base__location) );
}

/*!
   Generated constructor for class as_break_statement.
   \author lsg
 */
as_break_statement::as_break_statement (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_jump_statement(a__as_base__location)
{}

ptr< object::reflection_list > as_break_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_jump_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_break_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_break_statement::field_values_get() const
{
        ptr < field_list_list > result = as_jump_statement::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_break_statement::gc_mark()
{
        as_jump_statement::gc_mark();
}

// End of class as_break_statement.

// ------------- Class as_continue_statement follows. -------------

void as_continue_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_continue_statement( this );
}

/*!
   This factory method for class as_continue_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_continue_statement > as_continue_statement::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_continue_statement > ( new as_continue_statement(a__as_base__location) );
}

/*!
   Generated constructor for class as_continue_statement.
   \author lsg
 */
as_continue_statement::as_continue_statement (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_statement(a__as_base__location)
{}

ptr< object::reflection_list > as_continue_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_continue_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_continue_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_continue_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_continue_statement.

// ------------- Class as_return_statement follows. -------------

/*!
   \returns The value of as_return_statement::value.
   \author lsg
 */
ptr< as_expression > as_return_statement::value_get() const
{
        return value;
}

/*!
   \param[in] x The new value to set as_return_statement::value to.
   \author lsg
 */
void as_return_statement::value_set(const ptr< as_expression > & x)
{
        as_return_statement::value = x;
}

void as_return_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_return_statement( this );
}

/*!
   This factory method for class as_return_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_return_statement > as_return_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_return_statement__value)
{
        return ptr< as_return_statement > ( new as_return_statement(a__as_base__location,
                a__as_return_statement__value) );
}

/*!
   Generated constructor for class as_return_statement.
   \author lsg
 */
as_return_statement::as_return_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_return_statement__value)
        : as_jump_statement(a__as_base__location), value(checked(a__as_return_statement__value))
{}

ptr< object::reflection_list > as_return_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "value", "as_expression" ) );
                reflection = reflection_list::create( as_jump_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_return_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_return_statement::field_values_get() const
{
        ptr < field_list_list > result = as_jump_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->value );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_return_statement::gc_mark()
{
        as_jump_statement::gc_mark();
}

// End of class as_return_statement.

// ------------- Class as_goto_statement follows. -------------

/*!
   \returns The value of as_goto_statement::identifier.
   \author lsg
 */
ptr< as_identifier > as_goto_statement::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_goto_statement::identifier to.
   \author lsg
 */
void as_goto_statement::identifier_set(const ptr< as_identifier > & x)
{
        as_goto_statement::identifier = x;
}

void as_goto_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_goto_statement( this );
}

/*!
   This factory method for class as_goto_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_goto_statement > as_goto_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_identifier > a__as_goto_statement__identifier)
{
        return ptr< as_goto_statement > ( new as_goto_statement(a__as_base__location,
                a__as_goto_statement__identifier) );
}

/*!
   Generated constructor for class as_goto_statement.
   \author lsg
 */
as_goto_statement::as_goto_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_identifier > a__as_goto_statement__identifier)
        : as_jump_statement(a__as_base__location), identifier(checked(a__as_goto_statement__identifier))
{}

ptr< object::reflection_list > as_goto_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "identifier", "as_identifier" ) );
                reflection = reflection_list::create( as_jump_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_goto_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_goto_statement::field_values_get() const
{
        ptr < field_list_list > result = as_jump_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_goto_statement::gc_mark()
{
        as_jump_statement::gc_mark();
}

// End of class as_goto_statement.

// ------------- Class as_declaration_statement follows. -------------

/*!
   \returns The value of as_declaration_statement::declaration.
   \author lsg
 */
ptr< as_declaration > as_declaration_statement::declaration_get() const
{
        return declaration;
}

/*!
   \param[in] x The new value to set as_declaration_statement::declaration to.
   \author lsg
 */
void as_declaration_statement::declaration_set(const ptr< as_declaration > & x)
{
        as_declaration_statement::declaration = x;
}

void as_declaration_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_declaration_statement( this );
}

/*!
   This factory method for class as_declaration_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_declaration_statement > as_declaration_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declaration > a__as_declaration_statement__declaration)
{
        return ptr< as_declaration_statement > ( new as_declaration_statement(a__as_base__location,
                a__as_declaration_statement__declaration) );
}

/*!
   Generated constructor for class as_declaration_statement.
   \author lsg
 */
as_declaration_statement::as_declaration_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declaration > a__as_declaration_statement__declaration)
        : as_statement(a__as_base__location), declaration(checked(a__as_declaration_statement__declaration))
{}

ptr< object::reflection_list > as_declaration_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "declaration", "as_declaration" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_declaration_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declaration_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_declaration_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_declaration_statement.

// ------------- Class as_try_block_statement follows. -------------

/*!
   \returns The value of as_try_block_statement::statement.
   \author lsg
 */
ptr< as_compound_statement > as_try_block_statement::statement_get() const
{
        return statement;
}

/*!
   \param[in] x The new value to set as_try_block_statement::statement to.
   \author lsg
 */
void as_try_block_statement::statement_set(const ptr< as_compound_statement > & x)
{
        as_try_block_statement::statement = x;
}

/*!
   \returns The value of as_try_block_statement::handlers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_handler > > > as_try_block_statement::handlers_get() const
{
        return handlers;
}

/*!
   \param[in] x The new value to set as_try_block_statement::handlers to.
   \author lsg
 */
void as_try_block_statement::handlers_set(const ptr< ::lestes::std::list< srp< as_handler > > > & x)
{
        as_try_block_statement::handlers = x;
}

void as_try_block_statement::accept_as_statement_visitor( ptr< as_statement_visitor > v )
{
        return v->visit_as_try_block_statement( this );
}

/*!
   This factory method for class as_try_block_statement takes values of all fields as arguments.
   \author lsg
 */
ptr< as_try_block_statement > as_try_block_statement::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_compound_statement > a__as_try_block_statement__statement,
                ptr< ::lestes::std::list< srp< as_handler > > > a__as_try_block_statement__handlers)
{
        return ptr< as_try_block_statement > ( new as_try_block_statement(a__as_base__location,
                a__as_try_block_statement__statement,
                a__as_try_block_statement__handlers) );
}

/*!
   Generated constructor for class as_try_block_statement.
   \author lsg
 */
as_try_block_statement::as_try_block_statement (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_compound_statement > a__as_try_block_statement__statement,
                ptr< ::lestes::std::list< srp< as_handler > > > a__as_try_block_statement__handlers)
        : as_statement(a__as_base__location), statement(checked(a__as_try_block_statement__statement)), handlers(checked(a__as_try_block_statement__handlers))
{}

ptr< object::reflection_list > as_try_block_statement::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "statement", "as_compound_statement" ) );
                mdl->push_back( md::create( "handlers", "list&lt; srp&lt; as_handler &gt; &gt;" ) );
                reflection = reflection_list::create( as_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "as_try_block_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_try_block_statement::field_values_get() const
{
        ptr < field_list_list > result = as_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->statement );
        result->push_back( value_list::create() );
        result->back()->push_back( this->handlers );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_try_block_statement::gc_mark()
{
        as_statement::gc_mark();
}

// End of class as_try_block_statement.

// ------------- Class as_handler follows. -------------

/*!
   \returns The value of as_handler::exception_declaration.
   \author lsg
 */
ptr< as_exception_declaration > as_handler::exception_declaration_get() const
{
        return exception_declaration;
}

/*!
   \param[in] x The new value to set as_handler::exception_declaration to.
   \author lsg
 */
void as_handler::exception_declaration_set(const ptr< as_exception_declaration > & x)
{
        as_handler::exception_declaration = x;
}

/*!
   \returns The value of as_handler::compound_statement.
   \author lsg
 */
ptr< as_compound_statement > as_handler::compound_statement_get() const
{
        return compound_statement;
}

/*!
   \param[in] x The new value to set as_handler::compound_statement to.
   \author lsg
 */
void as_handler::compound_statement_set(const ptr< as_compound_statement > & x)
{
        as_handler::compound_statement = x;
}

/*!
   This factory method for class as_handler takes values of all fields as arguments.
   \author lsg
 */
ptr< as_handler > as_handler::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_exception_declaration > a__as_handler__exception_declaration,
                ptr< as_compound_statement > a__as_handler__compound_statement)
{
        return ptr< as_handler > ( new as_handler(a__as_base__location,
                a__as_handler__exception_declaration,
                a__as_handler__compound_statement) );
}

/*!
   Generated constructor for class as_handler.
   \author lsg
 */
as_handler::as_handler (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_exception_declaration > a__as_handler__exception_declaration,
                ptr< as_compound_statement > a__as_handler__compound_statement)
        : as_base(a__as_base__location), exception_declaration(checked(a__as_handler__exception_declaration)), compound_statement(checked(a__as_handler__compound_statement))
{}

ptr< object::reflection_list > as_handler::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "exception_declaration", "as_exception_declaration" ) );
                mdl->push_back( md::create( "compound_statement", "as_compound_statement" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_handler", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_handler::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->exception_declaration );
        result->push_back( value_list::create() );
        result->back()->push_back( this->compound_statement );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_handler::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_handler.

// ------------- Class as_exception_declaration follows. -------------

/*!
   Generated constructor for class as_exception_declaration.
   \author lsg
 */
as_exception_declaration::as_exception_declaration (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_base(a__as_base__location)
{}

ptr< object::reflection_list > as_exception_declaration::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_exception_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_exception_declaration::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_exception_declaration::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_exception_declaration.

// ------------- Class as_exception_declaration_any_type follows. -------------

/*!
   This factory method for class as_exception_declaration_any_type takes values of all fields as arguments.
   \author lsg
 */
ptr< as_exception_declaration_any_type > as_exception_declaration_any_type::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_exception_declaration_any_type > ( new as_exception_declaration_any_type(a__as_base__location) );
}

/*!
   Generated constructor for class as_exception_declaration_any_type.
   \author lsg
 */
as_exception_declaration_any_type::as_exception_declaration_any_type (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_exception_declaration(a__as_base__location)
{}

ptr< object::reflection_list > as_exception_declaration_any_type::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_exception_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_exception_declaration_any_type", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_exception_declaration_any_type::field_values_get() const
{
        ptr < field_list_list > result = as_exception_declaration::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_exception_declaration_any_type::gc_mark()
{
        as_exception_declaration::gc_mark();
}

// End of class as_exception_declaration_any_type.

// ------------- Class as_exception_declaration_single_type follows. -------------

/*!
   \returns The value of as_exception_declaration_single_type::type_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_type_specifier > > > as_exception_declaration_single_type::type_specifiers_get() const
{
        return type_specifiers;
}

/*!
   \param[in] x The new value to set as_exception_declaration_single_type::type_specifiers to.
   \author lsg
 */
void as_exception_declaration_single_type::type_specifiers_set(const ptr< ::lestes::std::list< srp< as_type_specifier > > > & x)
{
        as_exception_declaration_single_type::type_specifiers = x;
}

/*!
   This factory method for class as_exception_declaration_single_type takes values of all fields as arguments.
   \author lsg
 */
ptr< as_exception_declaration_single_type > as_exception_declaration_single_type::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_exception_declaration_single_type__type_specifiers)
{
        return ptr< as_exception_declaration_single_type > ( new as_exception_declaration_single_type(a__as_base__location,
                a__as_exception_declaration_single_type__type_specifiers) );
}

/*!
   Generated constructor for class as_exception_declaration_single_type.
   \author lsg
 */
as_exception_declaration_single_type::as_exception_declaration_single_type (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_exception_declaration_single_type__type_specifiers)
        : as_exception_declaration(a__as_base__location), type_specifiers(checked(a__as_exception_declaration_single_type__type_specifiers))
{}

ptr< object::reflection_list > as_exception_declaration_single_type::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "type_specifiers", "list&lt; srp&lt; as_type_specifier &gt; &gt;" ) );
                reflection = reflection_list::create( as_exception_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_exception_declaration_single_type", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_exception_declaration_single_type::field_values_get() const
{
        ptr < field_list_list > result = as_exception_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_specifiers );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_exception_declaration_single_type::gc_mark()
{
        as_exception_declaration::gc_mark();
}

// End of class as_exception_declaration_single_type.

// ------------- Class as_exception_declaration_single_type_with_variable follows. -------------

/*!
   \returns The value of as_exception_declaration_single_type_with_variable::declarator.
   \author lsg
 */
ptr< as_declarator > as_exception_declaration_single_type_with_variable::declarator_get() const
{
        return declarator;
}

/*!
   \param[in] x The new value to set as_exception_declaration_single_type_with_variable::declarator to.
   \author lsg
 */
void as_exception_declaration_single_type_with_variable::declarator_set(const ptr< as_declarator > & x)
{
        as_exception_declaration_single_type_with_variable::declarator = x;
}

/*!
   This factory method for class as_exception_declaration_single_type_with_variable takes values of all fields as arguments.
   \author lsg
 */
ptr< as_exception_declaration_single_type_with_variable > as_exception_declaration_single_type_with_variable::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_exception_declaration_single_type__type_specifiers,
                ptr< as_declarator > a__as_exception_declaration_single_type_with_variable__declarator)
{
        return ptr< as_exception_declaration_single_type_with_variable > ( new as_exception_declaration_single_type_with_variable(a__as_base__location,
                a__as_exception_declaration_single_type__type_specifiers,
                a__as_exception_declaration_single_type_with_variable__declarator) );
}

/*!
   Generated constructor for class as_exception_declaration_single_type_with_variable.
   \author lsg
 */
as_exception_declaration_single_type_with_variable::as_exception_declaration_single_type_with_variable (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_exception_declaration_single_type__type_specifiers,
                ptr< as_declarator > a__as_exception_declaration_single_type_with_variable__declarator)
        : as_exception_declaration_single_type(a__as_base__location,
                a__as_exception_declaration_single_type__type_specifiers), declarator(checked(a__as_exception_declaration_single_type_with_variable__declarator))
{}

ptr< object::reflection_list > as_exception_declaration_single_type_with_variable::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "declarator", "as_declarator" ) );
                reflection = reflection_list::create( as_exception_declaration_single_type::reflection_get() );
                reflection->push_back( class_reflection::create( "as_exception_declaration_single_type_with_variable", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_exception_declaration_single_type_with_variable::field_values_get() const
{
        ptr < field_list_list > result = as_exception_declaration_single_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_exception_declaration_single_type_with_variable::gc_mark()
{
        as_exception_declaration_single_type::gc_mark();
}

// End of class as_exception_declaration_single_type_with_variable.


// static data members follow 
ptr<object::reflection_list> as_statement::reflection = reflection;
ptr<object::reflection_list> as_dummy_statement::reflection = reflection;
ptr<object::reflection_list> as_labeled_statement::reflection = reflection;
ptr<object::reflection_list> as_default_labeled_statement::reflection = reflection;
ptr<object::reflection_list> as_case_labeled_statement::reflection = reflection;
ptr<object::reflection_list> as_identifier_labeled_statement::reflection = reflection;
ptr<object::reflection_list> as_compound_statement::reflection = reflection;
ptr<object::reflection_list> as_expression_statement::reflection = reflection;
ptr<object::reflection_list> as_selection_statement::reflection = reflection;
ptr<object::reflection_list> as_if_statement::reflection = reflection;
ptr<object::reflection_list> as_switch_statement::reflection = reflection;
ptr<object::reflection_list> as_iteration_statement::reflection = reflection;
ptr<object::reflection_list> as_do_statement::reflection = reflection;
ptr<object::reflection_list> as_while_statement::reflection = reflection;
ptr<object::reflection_list> as_for_statement::reflection = reflection;
ptr<object::reflection_list> as_for_init_statement::reflection = reflection;
ptr<object::reflection_list> as_for_init_statement_expression::reflection = reflection;
ptr<object::reflection_list> as_for_init_statement_declaration::reflection = reflection;
ptr<object::reflection_list> as_condition::reflection = reflection;
ptr<object::reflection_list> as_empty_condition::reflection = reflection;
ptr<object::reflection_list> as_condition_expression::reflection = reflection;
ptr<object::reflection_list> as_condition_declaration::reflection = reflection;
ptr<object::reflection_list> as_jump_statement::reflection = reflection;
ptr<object::reflection_list> as_break_statement::reflection = reflection;
ptr<object::reflection_list> as_continue_statement::reflection = reflection;
ptr<object::reflection_list> as_return_statement::reflection = reflection;
ptr<object::reflection_list> as_goto_statement::reflection = reflection;
ptr<object::reflection_list> as_declaration_statement::reflection = reflection;
ptr<object::reflection_list> as_try_block_statement::reflection = reflection;
ptr<object::reflection_list> as_handler::reflection = reflection;
ptr<object::reflection_list> as_exception_declaration::reflection = reflection;
ptr<object::reflection_list> as_exception_declaration_any_type::reflection = reflection;
ptr<object::reflection_list> as_exception_declaration_single_type::reflection = reflection;
ptr<object::reflection_list> as_exception_declaration_single_type_with_variable::reflection = reflection;

end_package(sem);
end_package(cplus);
end_package(lang);
end_package(lestes);

---