ss_ss2pi_base.g.hh

Go to the documentation of this file.

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

#ifndef lestes__lang__cplus__sem__ss_ss2pi_base_g_hh__included
#define lestes__lang__cplus__sem__ss_ss2pi_base_g_hh__included

#include <lestes/common.hh>
#include <lestes/lang/cplus/sem/ss_statement.g.hh>
#include <lestes/lang/cplus/sem/ss_type_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/visitor.v.g.hh>
#include <lestes/lang/cplus/sem/ss_declaration_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/ss_ss2pi_typedefs.hh>

#include <lestes/std/objectize_macros.hh>
package(lestes);
package(std);
class object;
end_package(std);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_pi;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_mem;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_mem_ptr_deref;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_preg;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_sp;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_operand;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(backend_v2);
package(intercode);
class pi_mem_factory;
end_package(intercode);
end_package(backend_v2);
end_package(lestes);

package(lestes);
package(md);
package(literals);
class literal_info_base;
end_package(literals);
end_package(md);
end_package(lestes);

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


class ss_function_declaration;
class ss_declaration;
class ss_stmt2pi_base;
class ss_compound_stmt;
class ss_type;
class ss_sp;
class ss_expression;
class ss_decl_stmt;
class ss_stmt2pi;
class ss_decl2pi;
class ss_decl2mem;
class ss_type2destructor;
class ss_expr2destination;
class ss_expr2pi;
class ss_destructor_table;
class ss_destructor_tables;
class ss_destructor_tables_stack;
class ss_linfo2pi_linfo;


//! Visitor responsible for converting statements into pseudoinstructions
class ss_stmt2pi : public ss_statement_visitor {
public:
        //! The method current_function_get returns the value of the field ss_stmt2pi::current_function.
        ptr< ss_function_declaration > current_function_get() const;

        //! The method current_function_set sets the field ss_stmt2pi::current_function to the given value.
        void current_function_set(const ptr< ss_function_declaration > &);

        //! The method local_variable_map_get returns the value of the field ss_stmt2pi::local_variable_map.
        ptr< variable_map_type > local_variable_map_get() const;

        //! The method local_variable_map_set sets the field ss_stmt2pi::local_variable_map to the given value.
        void local_variable_map_set(const ptr< variable_map_type > &);

        //! The method namespace_variable_map_get returns the value of the field ss_stmt2pi::namespace_variable_map.
        ptr< variable_map_type > namespace_variable_map_get() const;

        //! The method namespace_variable_map_set sets the field ss_stmt2pi::namespace_variable_map to the given value.
        void namespace_variable_map_set(const ptr< variable_map_type > &);

        //! API to store record of memmory placeholder for variable. It automaticaly distinguishes between global scope and local scope, where record shall be added (according to "current_function" member).
        void mem_variable_set(ptr< ss_declaration > , ptr< ::lestes::backend_v2::intercode::pi_mem_factory > );

        //! API to look-up memory placeholder, which was allocated for variable. It searches in both local and global scope. It also automaticaly inserts new record for alias and function parameter declarations.
        ptr< ::lestes::backend_v2::intercode::pi_mem_factory > mem_variable_get(ptr< ss_declaration > );

        virtual void visit_ss_compound_stmt(ptr< ::lestes::lang::cplus::sem::ss_compound_stmt > );

        virtual void visit_ss_decl_stmt(ptr< ::lestes::lang::cplus::sem::ss_decl_stmt > );

        virtual void visit_ss_try(ptr< ::lestes::lang::cplus::sem::ss_try > );

        virtual void visit_ss_break(ptr< ::lestes::lang::cplus::sem::ss_break > );

        virtual void visit_ss_return(ptr< ::lestes::lang::cplus::sem::ss_return > );

        virtual void visit_ss_goto(ptr< ::lestes::lang::cplus::sem::ss_goto > );

        virtual void visit_ss_expr_stmt(ptr< ::lestes::lang::cplus::sem::ss_expr_stmt > );

        virtual void visit_ss_continue(ptr< ::lestes::lang::cplus::sem::ss_continue > );

        virtual void visit_ss_if_stmt(ptr< ::lestes::lang::cplus::sem::ss_if_stmt > );

        virtual void visit_ss_catch(ptr< ::lestes::lang::cplus::sem::ss_catch > );

        virtual void visit_ss_switch_stmt(ptr< ::lestes::lang::cplus::sem::ss_switch_stmt > );

        virtual void visit_ss_do(ptr< ::lestes::lang::cplus::sem::ss_do > );

        virtual void visit_ss_while(ptr< ::lestes::lang::cplus::sem::ss_while > );

        virtual void visit_ss_for(ptr< ::lestes::lang::cplus::sem::ss_for > );

        
        //! First generated factory method for class ss_stmt2pi.
        static ptr< ss_stmt2pi > create (
                ptr< ss_function_declaration > a__ss_stmt2pi__current_function,
                ptr< variable_map_type > a__ss_stmt2pi__local_variable_map,
                ptr< variable_map_type > a__ss_stmt2pi__namespace_variable_map);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_stmt2pi.
        ss_stmt2pi (
                ptr< ss_function_declaration > a__ss_stmt2pi__current_function,
                ptr< variable_map_type > a__ss_stmt2pi__local_variable_map,
                ptr< variable_map_type > a__ss_stmt2pi__namespace_variable_map);

        //! Marking routine for class ss_stmt2pi. 
        virtual void gc_mark();

private:
        //! Current function, in which we are transforming to pi. Needed for expression tranformation. When on global scope, current function is set to NULL.
        srp< ss_function_declaration > current_function;
        /*! \brief      Map of variables in current function. 

         
                                        We distinguish these variables, from global, because after transformation
                                        of the current function, they are of no use.
                                
        */
        srp< variable_map_type > local_variable_map;
        //! Map of variables on namespace scope.
        srp< variable_map_type > namespace_variable_map;
        static ptr<reflection_list> reflection;
        
}; // ss_stmt2pi


//! Visitor responsible for converting declarations into pseudoinstructions
class ss_decl2pi : public ss_decl2pi_default {
public:
        //! The method caller_get returns the value of the field ss_decl2pi::caller.
        ptr< ss_stmt2pi > caller_get() const;

        //! The method caller_set sets the field ss_decl2pi::caller to the given value.
        void caller_set(const ptr< ss_stmt2pi > &);

        //! The method statement_get returns the value of the field ss_decl2pi::statement.
        ptr< ss_decl_stmt > statement_get() const;

        //! The method statement_set sets the field ss_decl2pi::statement to the given value.
        void statement_set(const ptr< ss_decl_stmt > &);

        virtual void default_action(ptr< ::lestes::lang::cplus::sem::ss_declaration > );

        virtual void visit_ss_function_declaration(ptr< ::lestes::lang::cplus::sem::ss_function_declaration > );

        virtual void visit_ss_object_declaration(ptr< ::lestes::lang::cplus::sem::ss_object_declaration > );

        virtual void visit_ss_structure_declaration(ptr< ::lestes::lang::cplus::sem::ss_structure_declaration > );

        
        //! First generated factory method for class ss_decl2pi.
        static ptr< ss_decl2pi > create (
                ptr< ss_stmt2pi > a__ss_decl2pi__caller,
                ptr< ss_decl_stmt > a__ss_decl2pi__statement);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_decl2pi.
        ss_decl2pi (
                ptr< ss_stmt2pi > a__ss_decl2pi__caller,
                ptr< ss_decl_stmt > a__ss_decl2pi__statement);

        //! Marking routine for class ss_decl2pi. 
        virtual void gc_mark();

private:
        //! Each declaration visitor is called from statement visitor.
        srp< ss_stmt2pi > caller;
        //! Statement containing current declaration. Used for initializations.
        srp< ss_decl_stmt > statement;
        static ptr<reflection_list> reflection;
        
}; // ss_decl2pi


/*! \brief Visitor responsible for getting correct pi_mem_factory for a given declaration


                                Used for lookup for declarations, which are not declared through ordinary ss_decl_stmt,
                                such as fake declarations, function parameter declarations.
                        
*/
class ss_decl2mem : public ss_decl2pi_default {
public:
        //! The method caller_get returns the value of the field ss_decl2mem::caller.
        ptr< ss_stmt2pi > caller_get() const;

        //! The method caller_set sets the field ss_decl2mem::caller to the given value.
        void caller_set(const ptr< ss_stmt2pi > &);

        //! The method result_get returns the value of the field ss_decl2mem::result.
        ptr< ::lestes::backend_v2::intercode::pi_mem_factory > result_get() const;

        //! The method result_set sets the field ss_decl2mem::result to the given value.
        void result_set(const ptr< ::lestes::backend_v2::intercode::pi_mem_factory > &);

        virtual void default_action(ptr< ::lestes::lang::cplus::sem::ss_declaration > );

        virtual void visit_ss_parameter_declaration(ptr< ::lestes::lang::cplus::sem::ss_parameter_declaration > );

        virtual void visit_ss_fake_declaration(ptr< ::lestes::lang::cplus::sem::ss_fake_declaration > );

        virtual void visit_ss_object_declaration(ptr< ::lestes::lang::cplus::sem::ss_object_declaration > );

        
        //! First generated factory method for class ss_decl2mem.
        static ptr< ss_decl2mem > create (
                ptr< ss_stmt2pi > a__ss_decl2mem__caller,
                ptr< ::lestes::backend_v2::intercode::pi_mem_factory > a__ss_decl2mem__result);

        //! Second generated factory method for class ss_decl2mem.
        static ptr< ss_decl2mem > create (
                ptr< ss_stmt2pi > a__ss_decl2mem__caller);

        
        //! "visit-return" method
        ptr< ::lestes::backend_v2::intercode::pi_mem_factory > get_real_decl_mem( const ptr< ::lestes::lang::cplus::sem::ss_declaration > & );

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_decl2mem.
        ss_decl2mem (
                ptr< ss_stmt2pi > a__ss_decl2mem__caller,
                ptr< ::lestes::backend_v2::intercode::pi_mem_factory > a__ss_decl2mem__result);

        //! Marking routine for class ss_decl2mem. 
        virtual void gc_mark();

private:
        //! Statement visitor caller - we need to know current function and variable maps.
        srp< ss_stmt2pi > caller;
        //! Returned pi_mem_factory for a given declaration.
        srp< ::lestes::backend_v2::intercode::pi_mem_factory > result;
        static ptr<reflection_list> reflection;
        
}; // ss_decl2mem


class ss_type2destructor : public ss_type2destructor_base {
public:
        //! The method destructor_get returns the value of the field ss_type2destructor::destructor.
        ptr< ss_function_declaration > destructor_get() const;

        //! The method destructor_set sets the field ss_type2destructor::destructor to the given value.
        void destructor_set(const ptr< ss_function_declaration > &);

        virtual void default_destructor(ptr< ::lestes::lang::cplus::sem::ss_type > );

        virtual void visit_ss_class(ptr< ::lestes::lang::cplus::sem::ss_class > );

        virtual void visit_ss_union(ptr< ::lestes::lang::cplus::sem::ss_union > );

        
        //! First generated factory method for class ss_type2destructor.
        static ptr< ss_type2destructor > create (
                ptr< ss_function_declaration > a__ss_type2destructor__destructor);

        //! Second generated factory method for class ss_type2destructor.
        static ptr< ss_type2destructor > create (
                );

        
        //! "visit-return" method
        ptr< ss_function_declaration > find_destructor( const ptr< ::lestes::lang::cplus::sem::ss_type > & );

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_type2destructor.
        ss_type2destructor (
                ptr< ss_function_declaration > a__ss_type2destructor__destructor);

        //! Marking routine for class ss_type2destructor. 
        virtual void gc_mark();

private:
        /*! \brief Destructor for a given type.

        For types with no destructor NULL is set.
        */
        srp< ss_function_declaration > destructor;
        static ptr<reflection_list> reflection;
        
}; // ss_type2destructor


//! Visitor for determination destination of sideeffect expression. Used for origin computation.
class ss_expr2destination : public ss_expr2destination_base {
public:
        //! The method destination_get returns the value of the field ss_expr2destination::destination.
        ptr< ss_expression > destination_get() const;

        //! The method destination_set sets the field ss_expr2destination::destination to the given value.
        void destination_set(const ptr< ss_expression > &);

        virtual void default_destination(ptr< ::lestes::lang::cplus::sem::ss_expression > );

        virtual void visit_ss_funcall(ptr< ::lestes::lang::cplus::sem::ss_funcall > );

        virtual void visit_ss_assign(ptr< ::lestes::lang::cplus::sem::ss_assign > );

        virtual void visit_ss_vol_get(ptr< ::lestes::lang::cplus::sem::ss_vol_get > );

        
        //! First generated factory method for class ss_expr2destination.
        static ptr< ss_expr2destination > create (
                ptr< ss_expression > a__ss_expr2destination__destination);

        //! Second generated factory method for class ss_expr2destination.
        static ptr< ss_expr2destination > create (
                );

        
        //! "visit-return" method
        ptr< ss_expression > get_destination( const ptr< ::lestes::lang::cplus::sem::ss_expression > & );

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_expr2destination.
        ss_expr2destination (
                ptr< ss_expression > a__ss_expr2destination__destination);

        //! Marking routine for class ss_expr2destination. 
        virtual void gc_mark();

private:
        /*! \brief      Field for storing result.

                
                                        In case of sideeffect expression without destination(funcall)
                                        is set to NULL.
                                        
                                
        */
        srp< ss_expression > destination;
        static ptr<reflection_list> reflection;
        
}; // ss_expr2destination


//! Visitor for converting expressions into pseudoinstructions.
class ss_expr2pi : public ss_expression_visitor {
public:
        //! The method caller_get returns the value of the field ss_expr2pi::caller.
        ptr< ss_stmt2pi > caller_get() const;

        //! The method caller_set sets the field ss_expr2pi::caller to the given value.
        void caller_set(const ptr< ss_stmt2pi > &);

        //! The method result_get returns the value of the field ss_expr2pi::result.
        ptr< ::lestes::backend_v2::intercode::pi_operand > result_get() const;

        //! The method result_set sets the field ss_expr2pi::result to the given value.
        void result_set(const ptr< ::lestes::backend_v2::intercode::pi_operand > &);

        //! The method psp_get returns the value of the field ss_expr2pi::psp.
        ptr< ss_sp > psp_get() const;

        //! The method psp_set sets the field ss_expr2pi::psp to the given value.
        void psp_set(const ptr< ss_sp > &);

        //! The method temporaries_get returns the value of the field ss_expr2pi::temporaries.
        ptr< ss_destructor_table > temporaries_get() const;

        //! The method temporaries_set sets the field ss_expr2pi::temporaries to the given value.
        void temporaries_set(const ptr< ss_destructor_table > &);

        //! The method expr2operand_map_get returns the value of the field ss_expr2pi::expr2operand_map.
        ptr< expression_results_map_type > expr2operand_map_get() const;

        //! The method expr2operand_map_set sets the field ss_expr2pi::expr2operand_map to the given value.
        void expr2operand_map_set(const ptr< expression_results_map_type > &);

        //! The method returned_pointer_get returns the value of the field ss_expr2pi::returned_pointer.
        bool returned_pointer_get() const;

        //! The method returned_pointer_set sets the field ss_expr2pi::returned_pointer to the given value.
        void returned_pointer_set(bool);

        //! Check whether given expression was yet transformed.
        bool evaluated(ptr< ss_expression > );

        //! Computes an origin of a given pi_mem_factory inside fullexpression settled bye ss_sp
        ptr< ::lestes::backend_v2::intercode::pi_pi > compute_origin(ptr< ::lestes::backend_v2::intercode::pi_mem_factory > , ptr< ss_sp > );

        //! 
        ptr< ::lestes::backend_v2::intercode::pi_preg > returns_preg(const ptr < ss_expression > & );

        ptr< ::lestes::backend_v2::intercode::pi_mem > returns_mem(const ptr < ss_expression > & );

        ptr< ::lestes::backend_v2::intercode::pi_mem_ptr_deref > returns_mem_pointer(const ptr < ss_expression > & );

        bool is_returned_pointer(ptr< ss_expression > );

        virtual void visit_ss_assign(ptr< ::lestes::lang::cplus::sem::ss_assign > );

        virtual void visit_ss_add(ptr< ::lestes::lang::cplus::sem::ss_add > );

        virtual void visit_ss_sub(ptr< ::lestes::lang::cplus::sem::ss_sub > );

        virtual void visit_ss_mul(ptr< ::lestes::lang::cplus::sem::ss_mul > );

        virtual void visit_ss_div(ptr< ::lestes::lang::cplus::sem::ss_div > );

        virtual void visit_ss_mod(ptr< ::lestes::lang::cplus::sem::ss_mod > );

        virtual void visit_ss_shr(ptr< ::lestes::lang::cplus::sem::ss_shr > );

        virtual void visit_ss_shl(ptr< ::lestes::lang::cplus::sem::ss_shl > );

        virtual void visit_ss_sbg(ptr< ::lestes::lang::cplus::sem::ss_sbg > );

        virtual void visit_ss_sbl(ptr< ::lestes::lang::cplus::sem::ss_sbl > );

        virtual void visit_ss_sbng(ptr< ::lestes::lang::cplus::sem::ss_sbng > );

        virtual void visit_ss_sbnl(ptr< ::lestes::lang::cplus::sem::ss_sbnl > );

        virtual void visit_ss_sbne(ptr< ::lestes::lang::cplus::sem::ss_sbne > );

        virtual void visit_ss_sbe(ptr< ::lestes::lang::cplus::sem::ss_sbe > );

        virtual void visit_ss_band(ptr< ::lestes::lang::cplus::sem::ss_band > );

        virtual void visit_ss_bor(ptr< ::lestes::lang::cplus::sem::ss_bor > );

        virtual void visit_ss_bxor(ptr< ::lestes::lang::cplus::sem::ss_bxor > );

        virtual void visit_ss_land(ptr< ::lestes::lang::cplus::sem::ss_land > );

        virtual void visit_ss_lor(ptr< ::lestes::lang::cplus::sem::ss_lor > );

        virtual void visit_ss_arr_acc(ptr< ::lestes::lang::cplus::sem::ss_arr_acc > );

        virtual void visit_ss_pfuncall(ptr< ::lestes::lang::cplus::sem::ss_pfuncall > );

        virtual void visit_ss_funcall(ptr< ::lestes::lang::cplus::sem::ss_funcall > );

        virtual void visit_ss_ifuncall(ptr< ::lestes::lang::cplus::sem::ss_ifuncall > );

        virtual void visit_ss_mfuncall(ptr< ::lestes::lang::cplus::sem::ss_mfuncall > );

        virtual void visit_ss_vfuncall(ptr< ::lestes::lang::cplus::sem::ss_vfuncall > );

        virtual void visit_ss_dereference(ptr< ::lestes::lang::cplus::sem::ss_dereference > );

        virtual void visit_ss_conversion(ptr< ::lestes::lang::cplus::sem::ss_conversion > );

        virtual void visit_ss_array_to_pointer(ptr< ::lestes::lang::cplus::sem::ss_array_to_pointer > );

        virtual void visit_ss_bind_reference(ptr< ::lestes::lang::cplus::sem::ss_bind_reference > );

        virtual void visit_ss_bind_to_temporary(ptr< ::lestes::lang::cplus::sem::ss_bind_to_temporary > );

        virtual void visit_ss_get(ptr< ::lestes::lang::cplus::sem::ss_get > );

        virtual void visit_ss_vol_get(ptr< ::lestes::lang::cplus::sem::ss_vol_get > );

        virtual void visit_ss_gat(ptr< ::lestes::lang::cplus::sem::ss_gat > );

        virtual void visit_ss_neg(ptr< ::lestes::lang::cplus::sem::ss_neg > );

        virtual void visit_ss_lnot(ptr< ::lestes::lang::cplus::sem::ss_lnot > );

        virtual void visit_ss_bnot(ptr< ::lestes::lang::cplus::sem::ss_bnot > );

        virtual void visit_ss_address_of(ptr< ::lestes::lang::cplus::sem::ss_address_of > );

        virtual void visit_ss_this_expr(ptr< ::lestes::lang::cplus::sem::ss_this_expr > );

        virtual void visit_ss_literal(ptr< ::lestes::lang::cplus::sem::ss_literal > );

        virtual void visit_ss_ternary(ptr< ::lestes::lang::cplus::sem::ss_ternary > );

        virtual void visit_ss_var_ref_by_qname(ptr< ::lestes::lang::cplus::sem::ss_var_ref_by_qname > );

        virtual void visit_ss_var_ref(ptr< ::lestes::lang::cplus::sem::ss_var_ref > );

        virtual void visit_ss_throw(ptr< ::lestes::lang::cplus::sem::ss_throw > );

        virtual void visit_ss_member_ptr(ptr< ::lestes::lang::cplus::sem::ss_member_ptr > );

        virtual void visit_ss_ptr_member_ptr(ptr< ::lestes::lang::cplus::sem::ss_ptr_member_ptr > );

        virtual void visit_ss_access(ptr< ::lestes::lang::cplus::sem::ss_access > );

        virtual void visit_ss_ptr_access(ptr< ::lestes::lang::cplus::sem::ss_ptr_access > );

        
        //! First generated factory method for class ss_expr2pi.
        static ptr< ss_expr2pi > create (
                ptr< ss_stmt2pi > a__ss_expr2pi__caller,
                ptr< ::lestes::backend_v2::intercode::pi_operand > a__ss_expr2pi__result,
                ptr< ss_sp > a__ss_expr2pi__psp,
                ptr< ss_destructor_table > a__ss_expr2pi__temporaries,
                ptr< expression_results_map_type > a__ss_expr2pi__expr2operand_map,
                bool a__ss_expr2pi__returned_pointer);

        //! Second generated factory method for class ss_expr2pi.
        static ptr< ss_expr2pi > create (
                ptr< ss_stmt2pi > a__ss_expr2pi__caller,
                ptr< ss_sp > a__ss_expr2pi__psp,
                ptr< ss_destructor_table > a__ss_expr2pi__temporaries,
                ptr< expression_results_map_type > a__ss_expr2pi__expr2operand_map);

        
        //! "visit-return" method
        ptr< ::lestes::backend_v2::intercode::pi_operand > returns( const ptr< ::lestes::lang::cplus::sem::ss_expression > & );

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_expr2pi.
        ss_expr2pi (
                ptr< ss_stmt2pi > a__ss_expr2pi__caller,
                ptr< ::lestes::backend_v2::intercode::pi_operand > a__ss_expr2pi__result,
                ptr< ss_sp > a__ss_expr2pi__psp,
                ptr< ss_destructor_table > a__ss_expr2pi__temporaries,
                ptr< expression_results_map_type > a__ss_expr2pi__expr2operand_map,
                bool a__ss_expr2pi__returned_pointer);

        //! Marking routine for class ss_expr2pi. 
        virtual void gc_mark();

private:
        //! Nearest statement visitor caller(needed for variable access).
        srp< ss_stmt2pi > caller;
        /*! \brief      Result of evaluating current expression

        
                                        Usually pseudoregister, where the result is stored.
                                        For lvalues appropriate memory placeholder(pi_mem) is stored.
                                        For void funcalls NULL is stored.
                                
        */
        srp< ::lestes::backend_v2::intercode::pi_operand > result;
        /*! \brief      Previous full-expression sequence point

        
                                        It points to the psp of the fullexpression (or the whole expression of the initializer).
                                        Used for stop mark of pi_mem origin computation - only side effects
                                        inside the whole expression are significant.
                                
        */
        srp< ss_sp > psp;
        /*! \brief      Destructor table for temporary variables

        
                                        Temporaries which rise, when evaluating exression.
                                        They will be destructed, after evaluating the whole expression(i.e. the whole statement)
                                
        */
        srp< ss_destructor_table > temporaries;
        /*! \brief      Map for result of subexpressions inside fullexpression

        
                                        It prevents of reevaluation of already evaluated subexpressions.
                                        Used also for determination of memory destination of side effects.
                                
        */
        srp< expression_results_map_type > expr2operand_map;
        //! Temporary variable used by is_returned_pointer method
        bool returned_pointer;
        static ptr<reflection_list> reflection;
        
}; // ss_expr2pi


class ss_destructor_table : public ::lestes::std::object {
public:
        //! The method compound_stmt_get returns the value of the field ss_destructor_table::compound_stmt.
        ptr< ss_compound_stmt > compound_stmt_get() const;

        //! The method compound_stmt_set sets the field ss_destructor_table::compound_stmt to the given value.
        void compound_stmt_set(const ptr< ss_compound_stmt > &);

        //! The method destructors_get returns the value of the field ss_destructor_table::destructors.
        ptr< ::lestes::std::list< srp< destructor_entry_type > > > destructors_get() const;

        //! The method destructors_set sets the field ss_destructor_table::destructors to the given value.
        void destructors_set(const ptr< ::lestes::std::list< srp< destructor_entry_type > > > & );

        void destructor_add(ptr< ss_function_declaration > , ptr< ::lestes::backend_v2::intercode::pi_mem_factory > );

        //! Implements back rolling of a destructor table (i.e.compound statement).
        virtual ptr< ::lestes::backend_v2::intercode::pi_sp > back_roll_table(ptr< ::lestes::backend_v2::intercode::pi_sp > psp, ptr< ::lestes::backend_v2::intercode::pi_sp > nsp);

        
        //! First generated factory method for class ss_destructor_table.
        static ptr< ss_destructor_table > create (
                ptr< ss_compound_stmt > a__ss_destructor_table__compound_stmt,
                ptr< ::lestes::std::list< srp< destructor_entry_type > > > a__ss_destructor_table__destructors);

        //! Second generated factory method for class ss_destructor_table.
        static ptr< ss_destructor_table > create (
                ptr< ss_compound_stmt > a__ss_destructor_table__compound_stmt);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_destructor_table.
        ss_destructor_table (
                ptr< ss_compound_stmt > a__ss_destructor_table__compound_stmt,
                ptr< ::lestes::std::list< srp< destructor_entry_type > > > a__ss_destructor_table__destructors);

        //! Marking routine for class ss_destructor_table. 
        virtual void gc_mark();

private:
        //! Compound statement, where variable (destructor) takes place.
        srp< ss_compound_stmt > compound_stmt;
        /*! 
        For types, which have no destructors, destructor set to NULL.
        */
        srp< ::lestes::std::list< srp< destructor_entry_type > > >  destructors;
        static ptr<reflection_list> reflection;
        
}; // ss_destructor_table


class ss_destructor_tables : public ::lestes::std::object {
public:
        //! The method singleton_instance_get returns the value of the field ss_destructor_tables::singleton_instance.
        static ptr< ss_destructor_tables > singleton_instance_get();

        //! The method singleton_instance_set sets the field ss_destructor_tables::singleton_instance to the given value.
        static void singleton_instance_set(const ptr< ss_destructor_tables > &);

        static ptr< ss_destructor_tables > instance();

        //! Returns DT corresponding to newly entered compound statement, where to add destructors
        virtual ptr< ss_destructor_table > open_compound_stmt(ptr< ss_compound_stmt > ) abstract;

        //! Returns DT corresponding to parent compound statement, where to continue adding destructors
        virtual ptr< ss_destructor_table > close_compound_stmt() abstract;

        //! Find and record destructor for ss type, which destructs appropriate memory placeholder
        virtual void destructor_add(ptr< ss_type > , ptr< ::lestes::backend_v2::intercode::pi_mem_factory > ) abstract;

        //! Find and record destructor for ss type, which destructs appropriate memory placeholder
        virtual void destructor_add_to_destr(ptr< ss_destructor_table > , ptr< ss_type > , ptr< ::lestes::backend_v2::intercode::pi_mem_factory > ) abstract;

        //! Normal end of compound statement
        virtual void back_roll_from_current_compound_stmt() abstract;

        //! Abnormal end of compound statement;psp,nsp shall be taken from current statement(e.g. break, continue, goto)
        virtual void back_roll_to_compound_stmt(ptr< ss_compound_stmt > , bool , ptr< ::lestes::backend_v2::intercode::pi_sp > psp, ptr< ::lestes::backend_v2::intercode::pi_sp > nsp) abstract;

        //! Abnormal end of compound statement; psp,nsp shall be taken from current return statement
        virtual void back_roll_from_function(ptr< ::lestes::backend_v2::intercode::pi_sp > psp, ptr< ::lestes::backend_v2::intercode::pi_sp > nsp) abstract;

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_destructor_tables.
        ss_destructor_tables (
                );

        //! Marking routine for class ss_destructor_tables. 
        virtual void gc_mark();

private:
        static ptr< ss_destructor_tables > singleton_instance;
        static ptr<reflection_list> reflection;
        
}; // ss_destructor_tables


class ss_destructor_tables_stack : public ss_destructor_tables {
public:
        //! The method current_get returns the value of the field ss_destructor_tables_stack::current.
        static ptr< ss_destructor_table > current_get();

        //! The method current_set sets the field ss_destructor_tables_stack::current to the given value.
        static void current_set(const ptr< ss_destructor_table > &);

        //! The method tables_get returns the value of the field ss_destructor_tables_stack::tables.
        static ptr< ::lestes::std::list< srp< ss_destructor_table > > > tables_get();

        //! The method tables_set sets the field ss_destructor_tables_stack::tables to the given value.
        static void tables_set(const ptr< ::lestes::std::list< srp< ss_destructor_table > > > & );

        virtual ptr< ss_destructor_table > open_compound_stmt(ptr< ss_compound_stmt > );

        virtual ptr< ss_destructor_table > close_compound_stmt();

        virtual void destructor_add(ptr< ss_type > , ptr< ::lestes::backend_v2::intercode::pi_mem_factory > );

        virtual void destructor_add_to_destr(ptr< ss_destructor_table > , ptr< ss_type > , ptr< ::lestes::backend_v2::intercode::pi_mem_factory > );

        virtual void back_roll_from_current_compound_stmt();

        virtual void back_roll_to_compound_stmt(ptr< ss_compound_stmt > , bool , ptr< ::lestes::backend_v2::intercode::pi_sp > psp, ptr< ::lestes::backend_v2::intercode::pi_sp > nsp);

        virtual void back_roll_from_function(ptr< ::lestes::backend_v2::intercode::pi_sp > psp, ptr< ::lestes::backend_v2::intercode::pi_sp > nsp);

        
        //! First generated factory method for class ss_destructor_tables_stack.
        static ptr< ss_destructor_tables_stack > create (
                );

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_destructor_tables_stack.
        ss_destructor_tables_stack (
                );

        //! Marking routine for class ss_destructor_tables_stack. 
        virtual void gc_mark();

private:
        //! Current destructor table.
        static ptr< ss_destructor_table > current;
        //! Destructor table for each compound statement
        static ptr< ::lestes::std::list< srp< ss_destructor_table > > >  tables;
        static ptr<reflection_list> reflection;
        
}; // ss_destructor_tables_stack


//! Visitor for converting literal info to pi layer literal info.
class ss_linfo2pi_linfo : public ss_literal_info_visitor {
public:
        //! The method pinfo_get returns the value of the field ss_linfo2pi_linfo::pinfo.
        ptr< ::lestes::md::literals::literal_info_base > pinfo_get() const;

        //! The method pinfo_set sets the field ss_linfo2pi_linfo::pinfo to the given value.
        void pinfo_set(const ptr< ::lestes::md::literals::literal_info_base > &);

        virtual void visit_ss_integral_literal_info(ptr< ::lestes::lang::cplus::sem::ss_integral_literal_info > );

        virtual void visit_ss_floating_literal_info(ptr< ::lestes::lang::cplus::sem::ss_floating_literal_info > );

        virtual void visit_ss_compound_literal_info(ptr< ::lestes::lang::cplus::sem::ss_compound_literal_info > );

        
        //! First generated factory method for class ss_linfo2pi_linfo.
        static ptr< ss_linfo2pi_linfo > create (
                ptr< ::lestes::md::literals::literal_info_base > a__ss_linfo2pi_linfo__pinfo);

        //! Second generated factory method for class ss_linfo2pi_linfo.
        static ptr< ss_linfo2pi_linfo > create (
                );

        
        //! "visit-return" method
        ptr< ::lestes::md::literals::literal_info_base > get_pinfo( const ptr< ::lestes::lang::cplus::sem::ss_literal_info > & );

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_linfo2pi_linfo.
        ss_linfo2pi_linfo (
                ptr< ::lestes::md::literals::literal_info_base > a__ss_linfo2pi_linfo__pinfo);

        //! Marking routine for class ss_linfo2pi_linfo. 
        virtual void gc_mark();

private:
        //! Field for storing result.
        srp< ::lestes::md::literals::literal_info_base > pinfo;
        static ptr<reflection_list> reflection;
        
}; // ss_linfo2pi_linfo


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

#endif // lestes__lang__cplus__sem__ss_ss2pi_base_g_hh__included

---