ss_statement.g.cc

Go to the documentation of this file.

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

/*!
        \file
        \brief Intercode structure for project Lestes
        
                        This file describes a set of classes and data types used for intercode layer -ss-.
                        It is an output from a XSLT template which generates C++ code.
                
*/

#include <lestes/lang/cplus/sem/ss_ss2pi_base.g.hh>
#include <lestes/lang/cplus/sem/ss_declaration.g.hh>
#include <lestes/lang/cplus/sem/visitor.v.g.hh>

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

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

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


// ------------- Class ss_statement follows. -------------

/*!
   \returns The value of ss_statement::labels.
   \author lsg
 */
ptr< ::lestes::std::list< srp< ss_label > > > ss_statement::labels_get() const
{
        return labels;
}

/*!
   \returns The value of ss_statement::parent.
   \author lsg
 */
ptr< ss_compound_stmt > ss_statement::parent_get() const
{
        return parent;
}

/*!
   \returns The value of ss_statement::psp.
   \author lsg
 */
ptr< ss_sp > ss_statement::psp_get() const
{
        return psp;
}

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

/*!
   \returns The value of ss_statement::nsp.
   \author lsg
 */
ptr< ss_sp > ss_statement::nsp_get() const
{
        return nsp;
}

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

/*!
   \returns The value of ss_statement::sequence_points.
   \author lsg
 */
ptr< ::lestes::std::list< srp< ss_sp > > > ss_statement::sequence_points_get() const
{
        return sequence_points;
}

/*!
   Generated constructor for class ss_statement.
   \author lsg
 */
ss_statement::ss_statement (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points)
        : ss_base_with_location(a__ss_base_with_location__location), labels(checked(a__ss_statement__labels)), parent(check__ss_statement__parent(a__ss_statement__parent)), psp(checked(a__ss_statement__psp)), nsp(checked(a__ss_statement__nsp)), sequence_points(checked(a__ss_statement__sequence_points))
{}

ptr< object::reflection_list > ss_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( "labels", "list&lt; srp&lt; ss_label &gt; &gt;" ) );
                mdl->push_back( md::create( "parent", "ss_compound_stmt" ) );
                mdl->push_back( md::create( "psp", "ss_sp" ) );
                mdl->push_back( md::create( "nsp", "ss_sp" ) );
                mdl->push_back( md::create( "sequence_points", "list&lt; srp&lt; ss_sp &gt; &gt;" ) );
                mdl->push_back( md::create( "parent_set_ward", "bool" ) );
                reflection = reflection_list::create( ::lestes::intercode::ss_base_with_location::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_statement", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_statement::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::ss_base_with_location::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->labels );
        result->push_back( value_list::create() );
        result->back()->push_back( this->parent );
        result->push_back( value_list::create() );
        result->back()->push_back( this->psp );
        result->push_back( value_list::create() );
        result->back()->push_back( this->nsp );
        result->push_back( value_list::create() );
        result->back()->push_back( this->sequence_points );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< bool > ::create( this->parent_set_ward ) );
        return result;
}


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

// End of class ss_statement.

// ------------- Class ss_compound_stmt follows. -------------

/*!
   \returns The value of ss_compound_stmt::decl_seq.
   \author lsg
 */
ptr< ss_decl_seq > ss_compound_stmt::decl_seq_get() const
{
        return decl_seq;
}

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

/*!
   \returns The value of ss_compound_stmt::destructor_sp.
   \author lsg
 */
ptr< ss_sp > ss_compound_stmt::destructor_sp_get() const
{
        return destructor_sp;
}

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

/*!
   \returns The value of ss_compound_stmt::behavior.
   \author lsg
 */
ss_compound_stmt::behavior_type ss_compound_stmt::behavior_get() const
{
        return behavior;
}

/*!
   \param[in] x The new value to set ss_compound_stmt::behavior to.
   \author lsg
 */
void ss_compound_stmt::behavior_set(behavior_type x)
{
        ss_compound_stmt::behavior = x;
}

void ss_compound_stmt::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_compound_stmt( this );
}

/*!
   This factory method for class ss_compound_stmt takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_compound_stmt > ss_compound_stmt::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_decl_seq > a__ss_compound_stmt__decl_seq,
                ptr< ::lestes::std::list< srp< ss_statement > > > a__ss_compound_stmt__statements,
                ptr< ss_sp > a__ss_compound_stmt__destructor_sp,
                behavior_type a__ss_compound_stmt__behavior)
{
        return ptr< ss_compound_stmt > ( new ss_compound_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_compound_stmt__decl_seq,
                a__ss_compound_stmt__statements,
                a__ss_compound_stmt__destructor_sp,
                a__ss_compound_stmt__behavior) );
}

/*!
   This factory method for class ss_compound_stmt uses initializers.
   \author lsg
 */
ptr< ss_compound_stmt > ss_compound_stmt::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_decl_seq > a__ss_compound_stmt__decl_seq,
                ptr< ::lestes::std::list< srp< ss_statement > > > a__ss_compound_stmt__statements,
                ptr< ss_sp > a__ss_compound_stmt__destructor_sp)
{
        return ptr< ss_compound_stmt > ( new ss_compound_stmt(a__ss_base_with_location__location, a__ss_statement__labels, a__ss_statement__parent, a__ss_statement__psp, a__ss_statement__nsp, a__ss_statement__sequence_points, a__ss_compound_stmt__decl_seq, a__ss_compound_stmt__statements, a__ss_compound_stmt__destructor_sp, NORMAL) );
}

/*!
   Generated constructor for class ss_compound_stmt.
   \author lsg
 */
ss_compound_stmt::ss_compound_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_decl_seq > a__ss_compound_stmt__decl_seq,
                ptr< ::lestes::std::list< srp< ss_statement > > > a__ss_compound_stmt__statements,
                ptr< ss_sp > a__ss_compound_stmt__destructor_sp,
                behavior_type a__ss_compound_stmt__behavior)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), decl_seq(checked(a__ss_compound_stmt__decl_seq)), statements(checked(a__ss_compound_stmt__statements)), destructor_sp(checked(a__ss_compound_stmt__destructor_sp)), behavior(a__ss_compound_stmt__behavior)
{}

ptr< object::reflection_list > ss_compound_stmt::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( "decl_seq", "ss_decl_seq" ) );
                mdl->push_back( md::create( "statements", "list&lt; srp&lt; ss_statement &gt; &gt;" ) );
                mdl->push_back( md::create( "destructor_sp", "ss_sp" ) );
                mdl->push_back( md::create( "the_root_instance", "ss_compound_stmt" ) );
                mdl->push_back( md::create( "behavior", "behavior_type" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_compound_stmt", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_compound_stmt::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->decl_seq );
        result->push_back( value_list::create() );
        result->back()->push_back( this->statements );
        result->push_back( value_list::create() );
        result->back()->push_back( this->destructor_sp );
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_root_instance );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< behavior_type > ::create( this->behavior ) );
        return result;
}


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

// End of class ss_compound_stmt.

// ------------- Class ss_decl_stmt follows. -------------

/*!
   \returns The value of ss_decl_stmt::decl.
   \author lsg
 */
ptr< ss_declaration > ss_decl_stmt::decl_get() const
{
        return decl;
}

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

/*!
   \returns The value of ss_decl_stmt::args.
   \author lsg
 */
ptr< ::lestes::std::list< srp< ss_expression > > > ss_decl_stmt::args_get() const
{
        return args;
}

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

/*!
   \returns The value of ss_decl_stmt::initializer_kind.
   \author lsg
 */
ss_decl_stmt::initializer_kind_enum ss_decl_stmt::initializer_kind_get() const
{
        return initializer_kind;
}

/*!
   \param[in] x The new value to set ss_decl_stmt::initializer_kind to.
   \author lsg
 */
void ss_decl_stmt::initializer_kind_set(initializer_kind_enum x)
{
        ss_decl_stmt::initializer_kind = x;
}

void ss_decl_stmt::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_decl_stmt( this );
}

/*!
   This factory method for class ss_decl_stmt takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_decl_stmt > ss_decl_stmt::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_declaration > a__ss_decl_stmt__decl,
                ptr< ::lestes::std::list< srp< ss_expression > > > a__ss_decl_stmt__args,
                initializer_kind_enum a__ss_decl_stmt__initializer_kind)
{
        return ptr< ss_decl_stmt > ( new ss_decl_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_decl_stmt__decl,
                a__ss_decl_stmt__args,
                a__ss_decl_stmt__initializer_kind) );
}

/*!
   Generated constructor for class ss_decl_stmt.
   \author lsg
 */
ss_decl_stmt::ss_decl_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_declaration > a__ss_decl_stmt__decl,
                ptr< ::lestes::std::list< srp< ss_expression > > > a__ss_decl_stmt__args,
                initializer_kind_enum a__ss_decl_stmt__initializer_kind)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), decl(checked(a__ss_decl_stmt__decl)), args(checked(a__ss_decl_stmt__args)), initializer_kind(a__ss_decl_stmt__initializer_kind)
{}

ptr< object::reflection_list > ss_decl_stmt::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( "decl", "ss_declaration" ) );
                mdl->push_back( md::create( "args", "list&lt; srp&lt; ss_expression &gt; &gt;" ) );
                mdl->push_back( md::create( "initializer_kind", "initializer_kind_enum" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_decl_stmt", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_decl_stmt::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->decl );
        result->push_back( value_list::create() );
        result->back()->push_back( this->args );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< initializer_kind_enum > ::create( this->initializer_kind ) );
        return result;
}


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

// End of class ss_decl_stmt.

// ------------- Class ss_try follows. -------------

/*!
   \returns The value of ss_try::block.
   \author lsg
 */
ptr< ss_compound_stmt > ss_try::block_get() const
{
        return block;
}

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

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

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

void ss_try::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_try( this );
}

/*!
   This factory method for class ss_try takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_try > ss_try::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_try__block,
                ptr< ::lestes::std::list< srp< ss_catch > > > a__ss_try__handlers)
{
        return ptr< ss_try > ( new ss_try(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_try__block,
                a__ss_try__handlers) );
}

/*!
   Generated constructor for class ss_try.
   \author lsg
 */
ss_try::ss_try (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_try__block,
                ptr< ::lestes::std::list< srp< ss_catch > > > a__ss_try__handlers)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), block(checked(a__ss_try__block)), handlers(checked(a__ss_try__handlers))
{}

ptr< object::reflection_list > ss_try::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( "block", "ss_compound_stmt" ) );
                mdl->push_back( md::create( "handlers", "list&lt; srp&lt; ss_catch &gt; &gt;" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_try", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_try::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->block );
        result->push_back( value_list::create() );
        result->back()->push_back( this->handlers );
        return result;
}


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

// End of class ss_try.

// ------------- Class ss_break follows. -------------

/*!
   \returns The value of ss_break::from.
   \author lsg
 */
ptr< ss_breakable_stmt > ss_break::from_get() const
{
        return from;
}

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

void ss_break::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_break( this );
}

/*!
   This factory method for class ss_break takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_break > ss_break::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_breakable_stmt > a__ss_break__from)
{
        return ptr< ss_break > ( new ss_break(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_break__from) );
}

/*!
   Generated constructor for class ss_break.
   \author lsg
 */
ss_break::ss_break (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_breakable_stmt > a__ss_break__from)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), from(checked(a__ss_break__from))
{}

ptr< object::reflection_list > ss_break::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( "from", "ss_breakable_stmt" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_break", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_break::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->from );
        return result;
}


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

// End of class ss_break.

// ------------- Class ss_return follows. -------------

/*!
   \returns The value of ss_return::result.
   \author lsg
 */
ptr< ss_expression > ss_return::result_get() const
{
        return result;
}

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

void ss_return::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_return( this );
}

/*!
   This factory method for class ss_return takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_return > ss_return::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_expression > a__ss_return__result)
{
        return ptr< ss_return > ( new ss_return(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_return__result) );
}

/*!
   Generated constructor for class ss_return.
   \author lsg
 */
ss_return::ss_return (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_expression > a__ss_return__result)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), result(a__ss_return__result)
{}

ptr< object::reflection_list > ss_return::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( "result", "ss_expression" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_return", mdl ) );
        }
        return reflection;
}

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


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

// End of class ss_return.

// ------------- Class ss_goto follows. -------------

/*!
   \returns The value of ss_goto::label.
   \author lsg
 */
ptr< ss_label > ss_goto::label_get() const
{
        return label;
}

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

void ss_goto::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_goto( this );
}

/*!
   This factory method for class ss_goto takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_goto > ss_goto::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_label > a__ss_goto__label)
{
        return ptr< ss_goto > ( new ss_goto(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_goto__label) );
}

/*!
   Generated constructor for class ss_goto.
   \author lsg
 */
ss_goto::ss_goto (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_label > a__ss_goto__label)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), label(checked(a__ss_goto__label))
{}

ptr< object::reflection_list > ss_goto::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( "label", "ss_label" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_goto", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_goto::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->label );
        return result;
}


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

// End of class ss_goto.

// ------------- Class ss_expr_stmt follows. -------------

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

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

void ss_expr_stmt::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_expr_stmt( this );
}

/*!
   This factory method for class ss_expr_stmt takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_expr_stmt > ss_expr_stmt::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_expression > a__ss_expr_stmt__expression)
{
        return ptr< ss_expr_stmt > ( new ss_expr_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_expr_stmt__expression) );
}

/*!
   Generated constructor for class ss_expr_stmt.
   \author lsg
 */
ss_expr_stmt::ss_expr_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_expression > a__ss_expr_stmt__expression)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), expression(checked(a__ss_expr_stmt__expression))
{}

ptr< object::reflection_list > ss_expr_stmt::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", "ss_expression" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_expr_stmt", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_expr_stmt::field_values_get() const
{
        ptr < field_list_list > result = ss_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 ss_expr_stmt::gc_mark()
{
        ss_statement::gc_mark();
}

// End of class ss_expr_stmt.

// ------------- Class ss_continue follows. -------------

/*!
   \returns The value of ss_continue::from.
   \author lsg
 */
ptr< ss_iteration_stmt > ss_continue::from_get() const
{
        return from;
}

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

void ss_continue::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_continue( this );
}

/*!
   This factory method for class ss_continue takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_continue > ss_continue::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_iteration_stmt > a__ss_continue__from)
{
        return ptr< ss_continue > ( new ss_continue(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_continue__from) );
}

/*!
   Generated constructor for class ss_continue.
   \author lsg
 */
ss_continue::ss_continue (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_iteration_stmt > a__ss_continue__from)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), from(checked(a__ss_continue__from))
{}

ptr< object::reflection_list > ss_continue::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( "from", "ss_iteration_stmt" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_continue", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_continue::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->from );
        return result;
}


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

// End of class ss_continue.

// ------------- Class ss_if_stmt follows. -------------

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

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

/*!
   \returns The value of ss_if_stmt::cthen.
   \author lsg
 */
ptr< ss_compound_stmt > ss_if_stmt::cthen_get() const
{
        return cthen;
}

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

/*!
   \returns The value of ss_if_stmt::celse.
   \author lsg
 */
ptr< ss_compound_stmt > ss_if_stmt::celse_get() const
{
        return celse;
}

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

void ss_if_stmt::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_if_stmt( this );
}

/*!
   This factory method for class ss_if_stmt takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_if_stmt > ss_if_stmt::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_expression > a__ss_if_stmt__condition,
                ptr< ss_compound_stmt > a__ss_if_stmt__cthen,
                ptr< ss_compound_stmt > a__ss_if_stmt__celse)
{
        return ptr< ss_if_stmt > ( new ss_if_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_if_stmt__condition,
                a__ss_if_stmt__cthen,
                a__ss_if_stmt__celse) );
}

/*!
   Generated constructor for class ss_if_stmt.
   \author lsg
 */
ss_if_stmt::ss_if_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_expression > a__ss_if_stmt__condition,
                ptr< ss_compound_stmt > a__ss_if_stmt__cthen,
                ptr< ss_compound_stmt > a__ss_if_stmt__celse)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), condition(checked(a__ss_if_stmt__condition)), cthen(checked(a__ss_if_stmt__cthen)), celse(checked(a__ss_if_stmt__celse))
{}

ptr< object::reflection_list > ss_if_stmt::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", "ss_expression" ) );
                mdl->push_back( md::create( "cthen", "ss_compound_stmt" ) );
                mdl->push_back( md::create( "celse", "ss_compound_stmt" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_if_stmt", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_if_stmt::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->condition );
        result->push_back( value_list::create() );
        result->back()->push_back( this->cthen );
        result->push_back( value_list::create() );
        result->back()->push_back( this->celse );
        return result;
}


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

// End of class ss_if_stmt.

// ------------- Class ss_catch follows. -------------

/*!
   \returns The value of ss_catch::body.
   \author lsg
 */
ptr< ss_compound_stmt > ss_catch::body_get() const
{
        return body;
}

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

/*!
   \returns The value of ss_catch::decl.
   \author lsg
 */
ptr< ss_declaration > ss_catch::decl_get() const
{
        return decl;
}

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

void ss_catch::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_catch( this );
}

/*!
   This factory method for class ss_catch takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_catch > ss_catch::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_catch__body,
                ptr< ss_declaration > a__ss_catch__decl)
{
        return ptr< ss_catch > ( new ss_catch(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_catch__body,
                a__ss_catch__decl) );
}

/*!
   Generated constructor for class ss_catch.
   \author lsg
 */
ss_catch::ss_catch (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_catch__body,
                ptr< ss_declaration > a__ss_catch__decl)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), body(checked(a__ss_catch__body)), decl(checked(a__ss_catch__decl))
{}

ptr< object::reflection_list > ss_catch::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( "body", "ss_compound_stmt" ) );
                mdl->push_back( md::create( "decl", "ss_declaration" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_catch", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_catch::field_values_get() const
{
        ptr < field_list_list > result = ss_statement::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->body );
        result->push_back( value_list::create() );
        result->back()->push_back( this->decl );
        return result;
}


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

// End of class ss_catch.

// ------------- Class ss_breakable_stmt follows. -------------

/*!
   \returns The value of ss_breakable_stmt::body.
   \author lsg
 */
ptr< ss_compound_stmt > ss_breakable_stmt::body_get() const
{
        return body;
}

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

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

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

/*!
   Generated constructor for class ss_breakable_stmt.
   \author lsg
 */
ss_breakable_stmt::ss_breakable_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition)
        : ss_statement(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points), body(checked(a__ss_breakable_stmt__body)), condition(checked(a__ss_breakable_stmt__condition))
{}

ptr< object::reflection_list > ss_breakable_stmt::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( "body", "ss_compound_stmt" ) );
                mdl->push_back( md::create( "condition", "ss_expression" ) );
                reflection = reflection_list::create( ss_statement::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_breakable_stmt", mdl ) );
        }
        return reflection;
}

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


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

// End of class ss_breakable_stmt.

// ------------- Class ss_switch_stmt follows. -------------

/*!
   \returns The value of ss_switch_stmt::case_labels.
   \author lsg
 */
ptr< ::lestes::std::list< srp< ss_case_label > > > ss_switch_stmt::case_labels_get() const
{
        return case_labels;
}

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

/*!
   \returns The value of ss_switch_stmt::default_label.
   \author lsg
 */
ptr< ss_default_label > ss_switch_stmt::default_label_get() const
{
        return default_label;
}

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

void ss_switch_stmt::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_switch_stmt( this );
}

/*!
   This factory method for class ss_switch_stmt takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_switch_stmt > ss_switch_stmt::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition,
                ptr< ::lestes::std::list< srp< ss_case_label > > > a__ss_switch_stmt__case_labels,
                ptr< ss_default_label > a__ss_switch_stmt__default_label)
{
        return ptr< ss_switch_stmt > ( new ss_switch_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition,
                a__ss_switch_stmt__case_labels,
                a__ss_switch_stmt__default_label) );
}

/*!
   Generated constructor for class ss_switch_stmt.
   \author lsg
 */
ss_switch_stmt::ss_switch_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition,
                ptr< ::lestes::std::list< srp< ss_case_label > > > a__ss_switch_stmt__case_labels,
                ptr< ss_default_label > a__ss_switch_stmt__default_label)
        : ss_breakable_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition), case_labels(checked(a__ss_switch_stmt__case_labels)), default_label(checked(a__ss_switch_stmt__default_label))
{}

ptr< object::reflection_list > ss_switch_stmt::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_labels", "list&lt; srp&lt; ss_case_label &gt; &gt;" ) );
                mdl->push_back( md::create( "default_label", "ss_default_label" ) );
                reflection = reflection_list::create( ss_breakable_stmt::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_switch_stmt", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_switch_stmt::field_values_get() const
{
        ptr < field_list_list > result = ss_breakable_stmt::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->case_labels );
        result->push_back( value_list::create() );
        result->back()->push_back( this->default_label );
        return result;
}


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

// End of class ss_switch_stmt.

// ------------- Class ss_iteration_stmt follows. -------------

/*!
   Generated constructor for class ss_iteration_stmt.
   \author lsg
 */
ss_iteration_stmt::ss_iteration_stmt (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition)
        : ss_breakable_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition)
{}

ptr< object::reflection_list > ss_iteration_stmt::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( ss_breakable_stmt::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_iteration_stmt", mdl ) );
        }
        return reflection;
}

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


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

// End of class ss_iteration_stmt.

// ------------- Class ss_do follows. -------------

void ss_do::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_do( this );
}

/*!
   This factory method for class ss_do takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_do > ss_do::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition)
{
        return ptr< ss_do > ( new ss_do(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition) );
}

/*!
   Generated constructor for class ss_do.
   \author lsg
 */
ss_do::ss_do (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition)
        : ss_iteration_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition)
{}

ptr< object::reflection_list > ss_do::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( ss_iteration_stmt::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_do", mdl ) );
        }
        return reflection;
}

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


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

// End of class ss_do.

// ------------- Class ss_while follows. -------------

void ss_while::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_while( this );
}

/*!
   This factory method for class ss_while takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_while > ss_while::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition)
{
        return ptr< ss_while > ( new ss_while(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition) );
}

/*!
   Generated constructor for class ss_while.
   \author lsg
 */
ss_while::ss_while (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition)
        : ss_iteration_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition)
{}

ptr< object::reflection_list > ss_while::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( ss_iteration_stmt::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_while", mdl ) );
        }
        return reflection;
}

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


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

// End of class ss_while.

// ------------- Class ss_for follows. -------------

/*!
   \returns The value of ss_for::iteration.
   \author lsg
 */
ptr< ss_expr_stmt > ss_for::iteration_get() const
{
        return iteration;
}

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

void ss_for::accept_ss_statement_visitor( ptr< ss_statement_visitor > v )
{
        return v->visit_ss_for( this );
}

/*!
   This factory method for class ss_for takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_for > ss_for::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition,
                ptr< ss_expr_stmt > a__ss_for__iteration)
{
        return ptr< ss_for > ( new ss_for(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition,
                a__ss_for__iteration) );
}

/*!
   Generated constructor for class ss_for.
   \author lsg
 */
ss_for::ss_for (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ::lestes::std::list< srp< ss_label > > > a__ss_statement__labels,
                ptr< ss_compound_stmt > a__ss_statement__parent,
                ptr< ss_sp > a__ss_statement__psp,
                ptr< ss_sp > a__ss_statement__nsp,
                ptr< ::lestes::std::list< srp< ss_sp > > > a__ss_statement__sequence_points,
                ptr< ss_compound_stmt > a__ss_breakable_stmt__body,
                ptr< ss_expression > a__ss_breakable_stmt__condition,
                ptr< ss_expr_stmt > a__ss_for__iteration)
        : ss_iteration_stmt(a__ss_base_with_location__location,
                a__ss_statement__labels,
                a__ss_statement__parent,
                a__ss_statement__psp,
                a__ss_statement__nsp,
                a__ss_statement__sequence_points,
                a__ss_breakable_stmt__body,
                a__ss_breakable_stmt__condition), iteration(a__ss_for__iteration)
{}

ptr< object::reflection_list > ss_for::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( "iteration", "ss_expr_stmt" ) );
                reflection = reflection_list::create( ss_iteration_stmt::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_for", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_for::field_values_get() const
{
        ptr < field_list_list > result = ss_iteration_stmt::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->iteration );
        return result;
}


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

// End of class ss_for.


// static data members follow 
bool ss_statement::parent_set_ward = false;
ptr<object::reflection_list> ss_statement::reflection = reflection;
ptr< ss_compound_stmt > ss_compound_stmt::the_root_instance = the_root_instance;
ptr<object::reflection_list> ss_compound_stmt::reflection = reflection;
ptr<object::reflection_list> ss_decl_stmt::reflection = reflection;
ptr<object::reflection_list> ss_try::reflection = reflection;
ptr<object::reflection_list> ss_break::reflection = reflection;
ptr<object::reflection_list> ss_return::reflection = reflection;
ptr<object::reflection_list> ss_goto::reflection = reflection;
ptr<object::reflection_list> ss_expr_stmt::reflection = reflection;
ptr<object::reflection_list> ss_continue::reflection = reflection;
ptr<object::reflection_list> ss_if_stmt::reflection = reflection;
ptr<object::reflection_list> ss_catch::reflection = reflection;
ptr<object::reflection_list> ss_breakable_stmt::reflection = reflection;
ptr<object::reflection_list> ss_switch_stmt::reflection = reflection;
ptr<object::reflection_list> ss_iteration_stmt::reflection = reflection;
ptr<object::reflection_list> ss_do::reflection = reflection;
ptr<object::reflection_list> ss_while::reflection = reflection;
ptr<object::reflection_list> ss_for::reflection = reflection;

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

---