ss_expression.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/visitor.v.g.hh>
#include <lestes/lang/cplus/lex/token_value.hh>
#include <lestes/lang/cplus/sem/ss_misc.g.hh>
#include <lestes/lang/cplus/sem/ss_type.g.hh>
#include <lestes/backend_v2/intercode/pi.g.hh>
#include <lestes/lang/cplus/sem/as_decl.g.hh>
#include <lestes/lang/cplus/sem/ss_declaration.g.hh>
#include <lestes/lang/cplus/sem/ss_literal_info.g.hh>

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

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

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


// ------------- Class ss_expression follows. -------------

/*!
   \returns The value of ss_expression::type.
   \author lsg
 */
ptr< ss_type > ss_expression::type_get() const
{
        return type;
}

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

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

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

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

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

/*!
   Generated constructor for class ss_expression.
   \author lsg
 */
ss_expression::ss_expression (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp)
        : ss_base_with_location(a__ss_base_with_location__location), type(checked(a__ss_expression__type)), psp(checked(a__ss_expression__psp)), nsp(checked(a__ss_expression__nsp))
{}

ptr< object::reflection_list > ss_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( "type", "ss_type" ) );
                mdl->push_back( md::create( "psp", "ss_sp" ) );
                mdl->push_back( md::create( "nsp", "ss_sp" ) );
                reflection = reflection_list::create( ::lestes::intercode::ss_base_with_location::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_expression::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->type );
        result->push_back( value_list::create() );
        result->back()->push_back( this->psp );
        result->push_back( value_list::create() );
        result->back()->push_back( this->nsp );
        return result;
}


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

// End of class ss_expression.

// ------------- Class ss_this_expr follows. -------------

void ss_this_expr::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_this_expr( this );
}

/*!
   This factory method for class ss_this_expr takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_this_expr > ss_this_expr::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp)
{
        return ptr< ss_this_expr > ( new ss_this_expr(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp) );
}

/*!
   Generated constructor for class ss_this_expr.
   \author lsg
 */
ss_this_expr::ss_this_expr (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp)
{}

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

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


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

// End of class ss_this_expr.

// ------------- Class ss_literal follows. -------------

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

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

void ss_literal::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_literal( this );
}

/*!
   This factory method for class ss_literal takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_literal > ss_literal::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_literal_info > a__ss_literal__value)
{
        return ptr< ss_literal > ( new ss_literal(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_literal__value) );
}

/*!
   Generated constructor for class ss_literal.
   \author lsg
 */
ss_literal::ss_literal (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_literal_info > a__ss_literal__value)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), value(checked(a__ss_literal__value))
{}

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

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

// End of class ss_literal.

// ------------- Class ss_ternary follows. -------------

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

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

/*!
   \returns The value of ss_ternary::true_expr.
   \author lsg
 */
ptr< ss_expression > ss_ternary::true_expr_get() const
{
        return true_expr;
}

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

/*!
   \returns The value of ss_ternary::false_expr.
   \author lsg
 */
ptr< ss_expression > ss_ternary::false_expr_get() const
{
        return false_expr;
}

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

void ss_ternary::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_ternary( this );
}

/*!
   This factory method for class ss_ternary takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_ternary > ss_ternary::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_ternary__condition,
                ptr< ss_expression > a__ss_ternary__true_expr,
                ptr< ss_expression > a__ss_ternary__false_expr)
{
        return ptr< ss_ternary > ( new ss_ternary(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_ternary__condition,
                a__ss_ternary__true_expr,
                a__ss_ternary__false_expr) );
}

/*!
   Generated constructor for class ss_ternary.
   \author lsg
 */
ss_ternary::ss_ternary (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_ternary__condition,
                ptr< ss_expression > a__ss_ternary__true_expr,
                ptr< ss_expression > a__ss_ternary__false_expr)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), condition(checked(a__ss_ternary__condition)), true_expr(checked(a__ss_ternary__true_expr)), false_expr(checked(a__ss_ternary__false_expr))
{}

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

ptr< object::field_list_list > ss_ternary::field_values_get() const
{
        ptr < field_list_list > result = ss_expression::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->true_expr );
        result->push_back( value_list::create() );
        result->back()->push_back( this->false_expr );
        return result;
}


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

// End of class ss_ternary.

// ------------- Class ss_var_ref_abstract follows. -------------

/*!
   Generated constructor for class ss_var_ref_abstract.
   \author lsg
 */
ss_var_ref_abstract::ss_var_ref_abstract (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp)
{}

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

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


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

// End of class ss_var_ref_abstract.

// ------------- Class ss_var_ref_by_qname follows. -------------

/*!
   \returns The value of ss_var_ref_by_qname::contained_in.
   \author lsg
 */
ptr< ss_decl_seq > ss_var_ref_by_qname::contained_in_get() const
{
        return contained_in;
}

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

/*!
   \returns The value of ss_var_ref_by_qname::decl_time.
   \author lsg
 */
ptr< ss_declaration_time > ss_var_ref_by_qname::decl_time_get() const
{
        return decl_time;
}

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

/*!
   \returns The value of ss_var_ref_by_qname::qualified_name.
   \author lsg
 */
ptr< as_name > ss_var_ref_by_qname::qualified_name_get() const
{
        return qualified_name;
}

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

void ss_var_ref_by_qname::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_var_ref_by_qname( this );
}

/*!
   This factory method for class ss_var_ref_by_qname takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_var_ref_by_qname > ss_var_ref_by_qname::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_decl_seq > a__ss_var_ref_by_qname__contained_in,
                ptr< ss_declaration_time > a__ss_var_ref_by_qname__decl_time,
                ptr< as_name > a__ss_var_ref_by_qname__qualified_name)
{
        return ptr< ss_var_ref_by_qname > ( new ss_var_ref_by_qname(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_var_ref_by_qname__contained_in,
                a__ss_var_ref_by_qname__decl_time,
                a__ss_var_ref_by_qname__qualified_name) );
}

/*!
   Generated constructor for class ss_var_ref_by_qname.
   \author lsg
 */
ss_var_ref_by_qname::ss_var_ref_by_qname (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_decl_seq > a__ss_var_ref_by_qname__contained_in,
                ptr< ss_declaration_time > a__ss_var_ref_by_qname__decl_time,
                ptr< as_name > a__ss_var_ref_by_qname__qualified_name)
        : ss_var_ref_abstract(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), contained_in(checked(a__ss_var_ref_by_qname__contained_in)), decl_time(checked(a__ss_var_ref_by_qname__decl_time)), qualified_name(checked(a__ss_var_ref_by_qname__qualified_name))
{}

ptr< object::reflection_list > ss_var_ref_by_qname::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( "contained_in", "ss_decl_seq" ) );
                mdl->push_back( md::create( "decl_time", "ss_declaration_time" ) );
                mdl->push_back( md::create( "qualified_name", "as_name" ) );
                reflection = reflection_list::create( ss_var_ref_abstract::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_var_ref_by_qname", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_var_ref_by_qname::field_values_get() const
{
        ptr < field_list_list > result = ss_var_ref_abstract::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->contained_in );
        result->push_back( value_list::create() );
        result->back()->push_back( this->decl_time );
        result->push_back( value_list::create() );
        result->back()->push_back( this->qualified_name );
        return result;
}


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

// End of class ss_var_ref_by_qname.

// ------------- Class ss_var_ref follows. -------------

/*!
   \returns The value of ss_var_ref::var_decl.
   \author lsg
 */
ptr< ss_declaration > ss_var_ref::var_decl_get() const
{
        return var_decl;
}

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

void ss_var_ref::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_var_ref( this );
}

/*!
   This factory method for class ss_var_ref takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_var_ref > ss_var_ref::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_declaration > a__ss_var_ref__var_decl)
{
        return ptr< ss_var_ref > ( new ss_var_ref(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_var_ref__var_decl) );
}

/*!
   Generated constructor for class ss_var_ref.
   \author lsg
 */
ss_var_ref::ss_var_ref (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_declaration > a__ss_var_ref__var_decl)
        : ss_var_ref_abstract(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), var_decl(checked(a__ss_var_ref__var_decl))
{}

ptr< object::reflection_list > ss_var_ref::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( "var_decl", "ss_declaration" ) );
                reflection = reflection_list::create( ss_var_ref_abstract::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_var_ref", mdl ) );
        }
        return reflection;
}

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


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

// End of class ss_var_ref.

// ------------- Class ss_throw follows. -------------

/*!
   \returns The value of ss_throw::type.
   \author lsg
 */
ptr< ss_type > ss_throw::type_get() const
{
        return type;
}

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

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

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

void ss_throw::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_throw( this );
}

/*!
   This factory method for class ss_throw takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_throw > ss_throw::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_type > a__ss_throw__type,
                ptr< ss_expression > a__ss_throw__value)
{
        return ptr< ss_throw > ( new ss_throw(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_throw__type,
                a__ss_throw__value) );
}

/*!
   Generated constructor for class ss_throw.
   \author lsg
 */
ss_throw::ss_throw (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_type > a__ss_throw__type,
                ptr< ss_expression > a__ss_throw__value)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), type(checked(a__ss_throw__type)), value(checked(a__ss_throw__value))
{}

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

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


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

// End of class ss_throw.

// ------------- Class ss_member_ptr follows. -------------

/*!
   \returns The value of ss_member_ptr::object.
   \author lsg
 */
ptr< ss_expression > ss_member_ptr::object_get() const
{
        return object;
}

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

/*!
   \returns The value of ss_member_ptr::member_ptr.
   \author lsg
 */
ptr< ss_expression > ss_member_ptr::member_ptr_get() const
{
        return member_ptr;
}

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

void ss_member_ptr::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_member_ptr( this );
}

/*!
   This factory method for class ss_member_ptr takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_member_ptr > ss_member_ptr::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_member_ptr__object,
                ptr< ss_expression > a__ss_member_ptr__member_ptr)
{
        return ptr< ss_member_ptr > ( new ss_member_ptr(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_member_ptr__object,
                a__ss_member_ptr__member_ptr) );
}

/*!
   Generated constructor for class ss_member_ptr.
   \author lsg
 */
ss_member_ptr::ss_member_ptr (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_member_ptr__object,
                ptr< ss_expression > a__ss_member_ptr__member_ptr)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), object(checked(a__ss_member_ptr__object)), member_ptr(checked(a__ss_member_ptr__member_ptr))
{}

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

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


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

// End of class ss_member_ptr.

// ------------- Class ss_ptr_member_ptr follows. -------------

/*!
   \returns The value of ss_ptr_member_ptr::object_ptr.
   \author lsg
 */
ptr< ss_expression > ss_ptr_member_ptr::object_ptr_get() const
{
        return object_ptr;
}

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

/*!
   \returns The value of ss_ptr_member_ptr::member_ptr.
   \author lsg
 */
ptr< ss_expression > ss_ptr_member_ptr::member_ptr_get() const
{
        return member_ptr;
}

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

void ss_ptr_member_ptr::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_ptr_member_ptr( this );
}

/*!
   This factory method for class ss_ptr_member_ptr takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_ptr_member_ptr > ss_ptr_member_ptr::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_ptr_member_ptr__object_ptr,
                ptr< ss_expression > a__ss_ptr_member_ptr__member_ptr)
{
        return ptr< ss_ptr_member_ptr > ( new ss_ptr_member_ptr(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_ptr_member_ptr__object_ptr,
                a__ss_ptr_member_ptr__member_ptr) );
}

/*!
   Generated constructor for class ss_ptr_member_ptr.
   \author lsg
 */
ss_ptr_member_ptr::ss_ptr_member_ptr (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_ptr_member_ptr__object_ptr,
                ptr< ss_expression > a__ss_ptr_member_ptr__member_ptr)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), object_ptr(checked(a__ss_ptr_member_ptr__object_ptr)), member_ptr(checked(a__ss_ptr_member_ptr__member_ptr))
{}

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

ptr< object::field_list_list > ss_ptr_member_ptr::field_values_get() const
{
        ptr < field_list_list > result = ss_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->object_ptr );
        result->push_back( value_list::create() );
        result->back()->push_back( this->member_ptr );
        return result;
}


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

// End of class ss_ptr_member_ptr.

// ------------- Class ss_access follows. -------------

/*!
   \returns The value of ss_access::object.
   \author lsg
 */
ptr< ss_expression > ss_access::object_get() const
{
        return object;
}

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

/*!
   \returns The value of ss_access::member.
   \author lsg
 */
ptr< ss_declaration > ss_access::member_get() const
{
        return member;
}

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

void ss_access::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_access( this );
}

/*!
   This factory method for class ss_access takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_access > ss_access::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_access__object,
                ptr< ss_declaration > a__ss_access__member)
{
        return ptr< ss_access > ( new ss_access(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_access__object,
                a__ss_access__member) );
}

/*!
   Generated constructor for class ss_access.
   \author lsg
 */
ss_access::ss_access (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_access__object,
                ptr< ss_declaration > a__ss_access__member)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), object(checked(a__ss_access__object)), member(checked(a__ss_access__member))
{}

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

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


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

// End of class ss_access.

// ------------- Class ss_ptr_access follows. -------------

/*!
   \returns The value of ss_ptr_access::object_ptr.
   \author lsg
 */
ptr< ss_expression > ss_ptr_access::object_ptr_get() const
{
        return object_ptr;
}

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

/*!
   \returns The value of ss_ptr_access::member.
   \author lsg
 */
ptr< ss_declaration > ss_ptr_access::member_get() const
{
        return member;
}

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

void ss_ptr_access::accept_ss_expression_visitor( ptr< ss_expression_visitor > v )
{
        return v->visit_ss_ptr_access( this );
}

/*!
   This factory method for class ss_ptr_access takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_ptr_access > ss_ptr_access::create(ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_ptr_access__object_ptr,
                ptr< ss_declaration > a__ss_ptr_access__member)
{
        return ptr< ss_ptr_access > ( new ss_ptr_access(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp,
                a__ss_ptr_access__object_ptr,
                a__ss_ptr_access__member) );
}

/*!
   Generated constructor for class ss_ptr_access.
   \author lsg
 */
ss_ptr_access::ss_ptr_access (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_ptr_access__object_ptr,
                ptr< ss_declaration > a__ss_ptr_access__member)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), object_ptr(checked(a__ss_ptr_access__object_ptr)), member(checked(a__ss_ptr_access__member))
{}

ptr< object::reflection_list > ss_ptr_access::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( "object_ptr", "ss_expression" ) );
                mdl->push_back( md::create( "member", "ss_declaration" ) );
                reflection = reflection_list::create( ss_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_ptr_access", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_ptr_access::field_values_get() const
{
        ptr < field_list_list > result = ss_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->object_ptr );
        result->push_back( value_list::create() );
        result->back()->push_back( this->member );
        return result;
}


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

// End of class ss_ptr_access.

// ------------- Class ss_binary_expr follows. -------------

/*!
   \returns The value of ss_binary_expr::left.
   \author lsg
 */
ptr< ss_expression > ss_binary_expr::left_get() const
{
        return left;
}

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

/*!
   \returns The value of ss_binary_expr::right.
   \author lsg
 */
ptr< ss_expression > ss_binary_expr::right_get() const
{
        return right;
}

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

/*!
   Generated constructor for class ss_binary_expr.
   \author lsg
 */
ss_binary_expr::ss_binary_expr (ptr< ::lestes::std::source_location > a__ss_base_with_location__location,
                ptr< ss_type > a__ss_expression__type,
                ptr< ss_sp > a__ss_expression__psp,
                ptr< ss_sp > a__ss_expression__nsp,
                ptr< ss_expression > a__ss_binary_expr__left,
                ptr< ss_expression > a__ss_binary_expr__right)
        : ss_expression(a__ss_base_with_location__location,
                a__ss_expression__type,
                a__ss_expression__psp,
                a__ss_expression__nsp), left(checked(a__ss_binary_expr__left)), right(checked(a__ss_binary_expr__right))
{}

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

ptr< object::field_list_list > ss_binary_expr::field_values_get() const
{
        ptr < field_list_list > result = ss_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->left );
        result->push_back( value_list::create() );
        result->back()->push_back( this->right );
        return result;
}


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

// End of class ss_binary_expr.


// static data members follow 
ptr<object::reflection_list> ss_expression::reflection = reflection;
ptr<object::reflection_list> ss_this_expr::reflection = reflection;
ptr<object::reflection_list> ss_literal::reflection = reflection;
ptr<object::reflection_list> ss_ternary::reflection = reflection;
ptr<object::reflection_list> ss_var_ref_abstract::reflection = reflection;
ptr<object::reflection_list> ss_var_ref_by_qname::reflection = reflection;
ptr<object::reflection_list> ss_var_ref::reflection = reflection;
ptr<object::reflection_list> ss_throw::reflection = reflection;
ptr<object::reflection_list> ss_member_ptr::reflection = reflection;
ptr<object::reflection_list> ss_ptr_member_ptr::reflection = reflection;
ptr<object::reflection_list> ss_access::reflection = reflection;
ptr<object::reflection_list> ss_ptr_access::reflection = reflection;
ptr<object::reflection_list> ss_binary_expr::reflection = reflection;

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

---