as_visitor.v.cc

Go to the documentation of this file.

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

#include <lestes/lang/cplus/sem/as_decl.g.hh>
#include <lestes/lang/cplus/sem/as_expr.g.hh>
#include <lestes/lang/cplus/sem/as_other.g.hh>
#include <lestes/lang/cplus/sem/as_statements.g.hh>
#include <lestes/lang/cplus/sem/ss_type.g.hh>
#include <lestes/lang/cplus/sem/ss_type_builtin.g.hh>
#include <lestes/lang/cplus/sem/ss_expression.g.hh>
#include <lestes/lang/cplus/sem/ss_expr_binary_op.g.hh>
#include <lestes/lang/cplus/sem/ss_expr_unary_op.g.hh>
#include <lestes/lang/cplus/sem/ss_expr_funcall.g.hh>

#include "as_visitor.v.g.hh"

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

void abstract_sa_expression_converter::visit_as_empty_expression( ptr< as_empty_expression > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_qmark( ptr< as_expression_qmark > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_comma( ptr< as_expression_comma > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_equal( ptr< as_expression_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_plus_equal( ptr< as_expression_plus_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_minus_equal( ptr< as_expression_minus_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_star_equal( ptr< as_expression_star_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_slash_equal( ptr< as_expression_slash_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_percent_equal( ptr< as_expression_percent_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_hat_equal( ptr< as_expression_hat_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_amp_equal( ptr< as_expression_amp_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_vbar_equal( ptr< as_expression_vbar_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_less_less_equal( ptr< as_expression_less_less_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_greater_greater_equal( ptr< as_expression_greater_greater_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_equal_equal( ptr< as_expression_equal_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_exclam_equal( ptr< as_expression_exclam_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_less_equal( ptr< as_expression_less_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_greater_equal( ptr< as_expression_greater_equal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_less( ptr< as_expression_less > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_greater( ptr< as_expression_greater > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_vbar_vbar( ptr< as_expression_vbar_vbar > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_amp_amp( ptr< as_expression_amp_amp > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_vbar( ptr< as_expression_vbar > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_amp( ptr< as_expression_amp > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_hat( ptr< as_expression_hat > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_less_less( ptr< as_expression_less_less > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_greater_greater( ptr< as_expression_greater_greater > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_plus( ptr< as_expression_plus > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_minus( ptr< as_expression_minus > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_star( ptr< as_expression_star > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_slash( ptr< as_expression_slash > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_percent( ptr< as_expression_percent > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_dot_star( ptr< as_expression_dot_star > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_minus_greater_star( ptr< as_expression_minus_greater_star > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_brackets( ptr< as_expression_brackets > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_plus_plus_pre( ptr< as_expression_plus_plus_pre > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_plus_plus_post( ptr< as_expression_plus_plus_post > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_minus_minus_pre( ptr< as_expression_minus_minus_pre > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_minus_minus_post( ptr< as_expression_minus_minus_post > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_unary_amp( ptr< as_expression_unary_amp > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_unary_plus( ptr< as_expression_unary_plus > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_unary_minus( ptr< as_expression_unary_minus > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_unary_star( ptr< as_expression_unary_star > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_tilde( ptr< as_expression_tilde > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_exclam( ptr< as_expression_exclam > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_sizeof_expr( ptr< as_expression_sizeof_expr > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_typeid_expr( ptr< as_expression_typeid_expr > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_delete_base( ptr< as_expression_delete_base > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_delete( ptr< as_expression_delete > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_delete_array( ptr< as_expression_delete_array > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_throw( ptr< as_expression_throw > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_sizeof_type( ptr< as_expression_sizeof_type > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_typeid_type( ptr< as_expression_typeid_type > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_new( ptr< as_expression_new > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_this_expression( ptr< as_this_expression > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_literal( ptr< as_literal > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_name_expression( ptr< as_name_expression > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_reinterpret_cast( ptr< as_expression_reinterpret_cast > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_dynamic_cast( ptr< as_expression_dynamic_cast > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_static_cast( ptr< as_expression_static_cast > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_const_cast( ptr< as_expression_const_cast > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_old_style_cast( ptr< as_expression_old_style_cast > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_functional_style_cast( ptr< as_expression_functional_style_cast > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_member_access_dot( ptr< as_expression_member_access_dot > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_member_access_arrow( ptr< as_expression_member_access_arrow > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_pseudo_destruct_dot( ptr< as_expression_pseudo_destruct_dot > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_pseudo_destruct_arrow( ptr< as_expression_pseudo_destruct_arrow > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_expression_function_call( ptr< as_expression_function_call > a )
{
        return convert( a );
}

void abstract_sa_expression_converter::visit_as_constant_expression( ptr< as_constant_expression > a )
{
        return convert( a );
}

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

---