lestes::lang::cplus::sem Namespace Reference

Classes
class	as_access_specifier_to_ss_access_specifier
	FIXME Base abstract class for functionals, representing function call. More...
class	as_access_specifier_visitor
class	as_base_specifier_to_ss_base_specifier
	FIXME Base abstract class for functionals, representing function call. More...
class	as_class_key_to_ss_access_specifier
	FIXME Base abstract class for functionals, representing function call. More...
class	as_class_key_to_ss_struct_base
	FIXME Base abstract class for functionals, representing function call. More...
class	as_class_key_visitor
class	as_cv_qualifier2ss_type
	CV qualification for ss_type. More...
class	as_cv_qualifier_visitor
class	as_string_literal
class	as_declaration
class	as_block_declaration
class	as_simple_declaration
class	as_init_declarator
class	as_initializer
class	as_initializer_expression_list
class	as_initializer_clause
class	as_initializer_clause_expression
class	as_initializer_clause_braced
class	as_function_definition
class	as_template_declaration
class	as_template_param
class	as_template_type_param
class	as_template_type_param_type
class	as_template_type_param_template
class	as_template_nontype_param
class	as_mem_initializer
class	as_explicit_instantiation
class	as_explicit_specialization
class	as_linkage_specification
class	as_id
class	as_template_id
	FIXME. More...
class	as_identifier
class	as_destructor_id
class	as_destructor_id_token
class	as_destructor_id_template
class	as_constructor_id
	Id for constructors. More...
class	as_op_function_id
class	as_conv_function_id
class	as_empty_id
	Used in as_name in name-less classes, for example. More...
class	as_global_namespace_fake_id
class	as_name
	The class as_name represents an occurence of name in the C++ program. More...
class	as_base_specifier
class	as_asm_declaration
class	as_gnu_asm_declaration
class	as_gnu_asm_specification
class	as_namespace_alias_declaration
class	as_namespace_definition
class	as_using
class	as_using_declaration
class	as_using_declaration_with_typename
class	as_access_declaration
	Access declaration, [11.3]. More...
class	as_using_directive
class	as_enumerator_definition
class	as_param_declaration
class	as_access_specifier
class	as_access_specifier_public
class	as_access_specifier_protected
class	as_access_specifier_private
class	as_param_decl_clause
class	as_declaration_specifier
	Abstract base for declaration specifiers. More...
class	as_function_specifier
class	as_function_specifier_inline
class	as_function_specifier_virtual
class	as_function_specifier_explicit
class	as_friend_specifier
class	as_typedef_specifier
class	as_storage_class_specifier
class	as_storage_class_specifier_auto
class	as_storage_class_specifier_register
class	as_storage_class_specifier_static
class	as_storage_class_specifier_extern
class	as_storage_class_specifier_mutable
class	as_type_specifier
	Abstract base class for type specifiers. More...
class	as_enumeration_specifier
class	as_simple_type_specifier
	Abstract base class for simple type specifiers. More...
class	as_builtin_simple_type_specifier
class	as_char_simple_type_specifier
	Simple type specifier class representing the keyword char. More...
class	as_wchar_t_simple_type_specifier
	Simple type specifier class representing the keyword wchar_t. More...
class	as_bool_simple_type_specifier
	Simple type specifier class representing the keyword bool. More...
class	as_short_simple_type_specifier
	Simple type specifier class representing the keyword short. More...
class	as_int_simple_type_specifier
	Simple type specifier class representing the keyword int. More...
class	as_long_simple_type_specifier
	Simple type specifier class representing the keyword long. More...
class	as_signed_simple_type_specifier
	Simple type specifier class representing the keyword signed. More...
class	as_unsigned_simple_type_specifier
	Simple type specifier class representing the keyword unsigned. More...
class	as_float_simple_type_specifier
	Simple type specifier class representing the keyword float. More...
class	as_double_simple_type_specifier
	Simple type specifier class representing the keyword double. More...
class	as_void_simple_type_specifier
	Simple type specifier class representing the keyword void. More...
class	as_cv_qualifier
	Abstract base for cv-qualifiers. More...
class	as_cv_qualifier_const
class	as_cv_qualifier_volatile
class	as_cv_qualifier_restrict
	Restrict qualifier -- C99 specific. More...
class	as_elaborated_type_specifier
class	as_named_simple_type_specifier
class	as_exception_specification
class	as_elaborated_type_specifier_typename
class	as_elaborated_type_specifier_tagged
class	as_elaborated_type_specifier_class_key
class	as_elaborated_type_specifier_enum
class	as_template_argument
class	as_non_type_template_argument
class	as_type_template_argument
class	as_declarator
class	as_dummy_declarator
	Dummy node, used when creating as_function_definition that just bears the data for later use (eg. in _func_try_block). More...
class	as_declarator_op
class	as_declarator_op_ptr
class	as_ptr_op_star
class	as_ptr_op_amp
class	as_ptr_op_member_ptr
class	as_declarator_op_func
class	as_declarator_op_array
class	as_declarator_op_non_constant_array
class	as_type_id
class	as_class_key
class	as_class_key_class
class	as_class_key_struct
class	as_class_key_union
class	as_member_declaration
class	as_member_using_declaration
class	as_member_template_declaration
class	as_member_function_definition
class	as_member_declaration_ordinary
class	as_member_declarator
class	as_bitfield_member_declarator
class	as_ordinary_member_declarator
class	as_initialized_member_declarator
class	as_pure_member_declarator
class	as_class_specifier
class	as_class_forward_member_declaration
class	as_class_forward_declaration
class	as_declaration_specifier2is_void
	Tests void specifier. More...
class	as_declaration_specifier2properties
	Declaration specifier visitor. More...
class	as_declaration_specifier_visitor
class	as_declaration_specifier2is_void_base
class	as_declarator_op2op_func
	Function declarator operator recognition. More...
class	as_declarator_op2ss_type
	Declarator operator visitor. More...
class	as_declarator_op_visitor
class	as_declarator_op_default_visitor
class	as_expression
class	as_empty_expression
class	as_binary_expression
class	as_unary_expression
class	as_ternary_expression
class	as_expression_qmark
class	as_expression_comma
class	as_expression_equal
class	as_expression_plus_equal
class	as_expression_minus_equal
class	as_expression_star_equal
class	as_expression_slash_equal
class	as_expression_percent_equal
class	as_expression_hat_equal
class	as_expression_amp_equal
class	as_expression_vbar_equal
class	as_expression_less_less_equal
class	as_expression_greater_greater_equal
class	as_expression_equal_equal
class	as_expression_exclam_equal
class	as_expression_less_equal
class	as_expression_greater_equal
class	as_expression_less
class	as_expression_greater
class	as_expression_vbar_vbar
class	as_expression_amp_amp
class	as_expression_vbar
class	as_expression_amp
class	as_expression_hat
class	as_expression_less_less
class	as_expression_greater_greater
class	as_expression_plus
class	as_expression_minus
class	as_expression_star
class	as_expression_slash
class	as_expression_percent
class	as_expression_dot_star
class	as_expression_minus_greater_star
class	as_expression_brackets
class	as_expression_plus_plus_pre
class	as_expression_plus_plus_post
class	as_expression_minus_minus_pre
class	as_expression_minus_minus_post
class	as_expression_unary_amp
class	as_expression_unary_plus
class	as_expression_unary_minus
class	as_expression_unary_star
class	as_expression_tilde
class	as_expression_exclam
class	as_expression_sizeof_expr
class	as_expression_typeid_expr
class	as_expression_delete_base
class	as_expression_delete
class	as_expression_delete_array
class	as_expression_throw
	The expression is set to empty expression when lone 'throw' is found. More...
class	as_expression_sizeof_type
class	as_expression_typeid_type
class	as_expression_new
class	as_this_expression
class	as_literal
class	as_name_expression
	corresponds to id_expr in the grammar/norm More...
class	as_expression_cast_base
class	as_expression_cast_base_one
class	as_expression_cast_base_list
class	as_expression_reinterpret_cast
class	as_expression_dynamic_cast
class	as_expression_static_cast
class	as_expression_const_cast
class	as_expression_old_style_cast
class	as_expression_functional_style_cast
class	as_postfix_expression
class	as_expression_member_access
class	as_expression_member_access_dot
class	as_expression_member_access_arrow
class	as_expression_pseudo_destruct_dot
class	as_expression_pseudo_destruct_arrow
class	as_expression_function_call
class	as_constant_expression
class	as_id_to_declaration_set
	Extractor of ss_declaration set from as_id. More...
class	as_id_to_ss_decl_name
	Convertor from as_id to ss_decl_name. More...
class	as_id_visitor
class	as_no_token
class	as_statement_seq
class	as_expression_list
class	as_declarator_op_seq
class	as_mem_initializer_list
class	as_cv_qualifier_seq
class	as_enumerator_list
class	as_base_specifier_list
class	as_template_param_list
class	as_init_declarator_list
class	as_param_declaration_list
class	as_initializer_list
class	as_handler_seq
class	as_type_id_list
class	as_template_argument_list
class	as_declaration_seq
class	as_member_declarator_list
class	as_declaration_specifier_seq
class	as_type_specifier_seq
class	as_member_specification
class	as_anyid_opt_bearer
class	as_excptn_spec_opt_bearer
class	as_virtual_opt_bearer
class	as_access_spec_opt_bearer
class	as_statement
class	as_dummy_statement
class	as_labeled_statement
class	as_default_labeled_statement
class	as_case_labeled_statement
class	as_identifier_labeled_statement
class	as_compound_statement
class	as_expression_statement
class	as_selection_statement
class	as_if_statement
class	as_switch_statement
class	as_iteration_statement
class	as_do_statement
class	as_while_statement
class	as_for_statement
class	as_for_init_statement
class	as_for_init_statement_expression
class	as_for_init_statement_declaration
class	as_condition
class	as_empty_condition
class	as_condition_expression
class	as_condition_declaration
class	as_jump_statement
class	as_break_statement
class	as_continue_statement
class	as_return_statement
class	as_goto_statement
class	as_declaration_statement
class	as_try_block_statement
class	as_handler
class	as_exception_declaration
class	as_exception_declaration_any_type
class	as_exception_declaration_single_type
class	as_exception_declaration_single_type_with_variable
class	as_expr_visitor
class	abstract_sa_expression_converter
class	as_statement_visitor
class	as_initializer_clause_visitor
	Used to convert as_initializer_clause to ss_expression list. More...
class	as_condition_visitor
	Used to convert as_condition to ss_expression. More...
class	lex_literal_to_ss_literal_info
	FIXME Base abstract class for functionals, representing function call. More...
class	li_by_name_in_single_scope
	Lookup of name in single scope. More...
class	li_class_by_name_in_single_scope
	FIXME. More...
class	li_func_by_name
	This is for purpose of searching for function/method by name in all scopes (current + parents). More...
class	li_func_by_name_in_single_scope
	This is for purpose of searching for function/method by name in all scopes (current + parents). More...
class	li_non_secu_by_name_in_single_scope
	Lookup of non-secu name in single scope. More...
class	lu_filter
class	lu_multi_filter
class	lu_yes_cont_filter
class	lu_yes_filter
class	lu_struct_filter
class	lu_namespace_filter
class	lu_elaborated_filter
class	lu_qual_filter
	[3.4.3/1] More...
class	lu_func_cont_filter
class	lu_name_filter
class	lu_visible_filter
class	lu_secu_filter
	Filters class-like and enum declaration. More...
class	lu_inversion_filter
	Inversion filter. More...
class	lu_params
class	lu_lookup
class	lu_lookup_in_type
class	or_builtin_operator_declaration_creator
	Singleton class for purposes of creation of buitltin operator delcarations. More...
class	or_or_functional_to_enum
class	or_ics_functional
	Base abstract class for functionals, representing conversion sequences. More...
class	or_ics_functional_for_std_conversion
class	or_ics_functional_for_arr_ptr_conversion
class	or_ics_functional_for_reference_bind_conversion
class	or_ics_functional_for_bind_to_temporary_conversion
class	or_ics_functional_for_lval_rval_conversion
class	or_ics_functional_for_user_conversion_by_constructor
class	or_ics_functional_for_user_conversion_by_conversion_function
class	or_ics_functional_for_compound_conversion
class	or_ics_functional_visitor
class	or_ics_visitor_cv
class	or_ics_visitor_tgts
class	or_or_functional
	Base abstract class for functionals, representing function call. More...
class	or_or_functional_concrete
	This is the concrete implementation of functional creating the ss_expression for the non-ambiguous case. More...
class	or_or_functional_comma
	This is the concrete implementation of functional creating the ss_expression for the comma case (this has to be handled separately, as comma can be used for infinitely many types. More...
class	or_or_functional_addrof
	This is the concrete implementation of functional creating the ss_expression for the address_of case (this has to be handled separately, as unary and can be used for infinitely many types. More...
class	or_or_functional_literal
	This is the concrete implementation of functional creating the ss_expression for the literal case. More...
class	or_or_functional_func_decl_set
	This functional holds list of function declarations, from which later the correct one, for creation ss_?funcall is chosen (this is used in sa_deconstruct_spse::visit_as_name_expression(). More...
class	or_or_functional_decl
	This is the functional resembling the or_or_functional_func_decl_set. The difference is that this is for the case where only one (but we generally don't know what is the declaration of) declaration is returned. (this is used in sa_deconstruct_spse::visit_as_name_expression() and then for decission in sa_deconstruct_spse::visit_as_expression_function_call(). More...
class	or_or_functional_ambiguous
	This is the concrete implementation of functional creating the ss_expression for the ambiguous case. More...
class	or_or_functional_noviable
	This is the concrete implementation of functional creating the ss_expression for the no-viables-found case. More...
class	or_or_functional_this
	This is the concrete implementation of functional creating the ss_expression for the case of operator 'this'. More...
class	or_declaration_helper
	This is declaration over ss_declaration, which helps us distinguish in which case we are (function/method/builtin operator). More...
class	or_builtin_operator_expression_creator
	This class contains methods for the actual creation of ss_expression for builtin operator. More...
class	or_funcall_creator
	This class contains methods for the actual creation of ss_expression for function call. More...
class	or_funcall_creator_context
	TODO: does this have any use?? More...
class	or_ics_base
class	or_ics_base_cv
class	or_ics_functional_base
class	or_or_functional_visitor
class	sa_class_declaration
	FIXME Base abstract class for functionals, representing function call. More...
class	declaration_context
	Declaration context enumeration wrapper. More...
class	sa_context_stack_marker
class	sa_context_manager
	The context manager for sa. More...
class	sa_context_manager_concrete
class	sa_context
	The context for sa. More...
class	sa_as_context
	The as context. More...
class	sa_ss_context
	The ss context. More...
class	sa_sa_context
	The ss context. More...
class	sa_decl_seq_compound_pair_creator
	FIXME Base abstract class for functionals, representing function call. More...
class	sa_declaration_specifier_list
	Declaration specifier list structural analyser. More...
class	sa_declaration_specifiers
	Analysed declaration specifiers. More...
class	sa_declarator_type
	Declarator structural analyser. More...
class	ss_decl_to_enum
class	sa_deconstruct_spse
class	sa_namespace_definition
class	sa_param_declaration
	Parameter declaration structural analyser. More...
class	sa_param_declaration_empty
	Empty parameter declaration checker. More...
class	sa_param_declaration_type
	Parameter declaration structural analyser. More...
class	sa_scope_of_as_name
	Extracts information about a name's scope. More...
class	sa_simple_declaration
	Simple declaration analyser. More...
class	sa_statements
	Main visitor for statements SA. More...
class	decl_stmt_listener
class	last_declaration_memorizer
class	initializer_clause_converter
class	condition_to_expression
class	sa_expression_converter
	Visitor to transform AS expressions to SS and convert them to given type. More...
class	get_real_declaration
	If the declaration is a fake declaration, this visitor gets a real declaration from it. Otherwise it returns its input. More...
class	sa_usings
	FIXME Base abstract class for functionals, representing function call. More...
class	ss_decl2mangled_name
	Visitor that returns string representation of ss_declaration as defined by GNU GCC mangling rules. More...
class	ss_decl2id
	Visitor that returns identification of a descandant of ss_declaration. More...
class	ss_decl_name
	Abstract class for declaration names. More...
class	ss_ordinary_name
	Class for ordinary name declaration. More...
class	ss_conversion_name
	Class for ordinary name declaration. More...
class	ss_operator
	Class for operators. More...
class	ss_dummy_name
	Dummy name, used in ss_dummy_declaration. More...
class	ss_operator_new
	This class represents the name of operator new . More...
class	ss_operator_delete
	This class represents the name of operator delete . More...
class	ss_operator_new_array
	This class represents the name of operator new[] . More...
class	ss_operator_delete_array
	This class represents the name of operator delete[] . More...
class	ss_operator_add
	This class represents the name of operator + . More...
class	ss_operator_sub
	This class represents the name of operator - . More...
class	ss_operator_mul
	This class represents the name of operator * . More...
class	ss_operator_div
	This class represents the name of operator / . More...
class	ss_operator_mod
	This class represents the name of operator %% . More...
class	ss_operator_bxor
	This class represents the name of operator ^ . More...
class	ss_operator_band
	This class represents the name of operator & . More...
class	ss_operator_bor
	This class represents the name of operator | . More...
class	ss_operator_bnot
	This class represents the name of operator ~ . More...
class	ss_operator_lnot
	This class represents the name of operator ! . More...
class	ss_operator_assign
	This class represents the name of operator = . More...
class	ss_operator_assign_add
	This class represents the name of operator += . More...
class	ss_operator_assign_sub
	This class represents the name of operator -= . More...
class	ss_operator_assign_mul
	This class represents the name of operator *= . More...
class	ss_operator_assign_div
	This class represents the name of operator /= . More...
class	ss_operator_assign_mod
	This class represents the name of operator %= . More...
class	ss_operator_assign_bxor
	This class represents the name of operator ^= . More...
class	ss_operator_assign_band
	This class represents the name of operator &= . More...
class	ss_operator_assign_bor
	This class represents the name of operator |= . More...
class	ss_operator_assign_shl
	This class represents the name of operator <<= . More...
class	ss_operator_assign_shr
	This class represents the name of operator >>= . More...
class	ss_operator_shr
	This class represents the name of operator >> . More...
class	ss_operator_shl
	This class represents the name of operator << . More...
class	ss_operator_sbl
	This class represents the name of operator < . More...
class	ss_operator_sbg
	This class represents the name of operator > . More...
class	ss_operator_sbng
	This class represents the name of operator <= . More...
class	ss_operator_sbnl
	This class represents the name of operator >= . More...
class	ss_operator_sbe
	This class represents the name of operator == . More...
class	ss_operator_sbne
	This class represents the name of operator != . More...
class	ss_operator_land
	This class represents the name of operator && . More...
class	ss_operator_lor
	This class represents the name of operator || . More...
class	ss_operator_inc
	This class represents the name of operator ++ . More...
class	ss_operator_dec
	This class represents the name of operator -- . More...
class	ss_operator_comma
	This class represents the name of operator , . More...
class	ss_operator_access
	This class represents the name of operator -> . More...
class	ss_operator_access_member
	This class represents the name of operator ->* . More...
class	ss_operator_function_call
	This class represents the name of operator () . More...
class	ss_operator_array
	This class represents the name of operator [] . More...
class	ss_operator_ternary
	This class represents the name of operator ?: . More...
class	ss_decl_name2mangled_name
	Returns string representation of a ss_decl_name. More...
class	ss_decl_name_matcher
class	ss_decl_name_visitor
class	ss_decl_name2lstring_base
class	ss_declaration
	Class for declarations. More...
class	ss_namespace_definition
class	ss_declaration_with_access_specifier
class	ss_object_declaration
	A variable is an object in the terms of the norm. More...
class	ss_bitfield_declaration
class	ss_parameter_declaration
class	ss_fake_declaration
	Fake declaration is used to prohibit redeclaration of an object. More...
class	ss_injected_class_declaration
	The injected class name declaration. More...
class	ss_enum_definition
class	ss_typedef_definition
class	ss_enumerator_declaration
class	ss_befriendable_declaration
	Class for declarations that can be friends of a class. More...
class	ss_structure_declaration
	Class for declarations that can be friends of a class. More...
class	ss_function_declaration
	Class for function definition. More...
class	ss_method_declaration
	Method declaration for a class. More...
class	ss_using_declaration
class	ss_dummy_declaration
class	ss_compound_stmt_declaration
	Dummy declaration of compound statement. More...
class	ss_builtin_operator_declaration
	This class represents concieved declaration for builtin operators. More...
class	ss_linkage
class	ss_declaration2ss_function_declaration
	Declaration convertor. More...
class	ss_declaration2ss_namespace_definition
	Declaration convertor. More...
class	ss_declaration2ss_object_declaration
	Declaration convertor. More...
class	ss_declaration2ss_structure_declaration
	Declaration convertor. More...
class	ss_declaration2ss_typedef_definition
	Declaration convertor. More...
class	ss_declaration_to_ss_decl_seq
class	ss_declaration_visitor
class	ss_declaration_default_visitor
class	ss_decl2pi_default
class	ss_decl2ulint_base
class	ss_decl2lstring_base
class	ss_access_specifier
	Access specifier enumeration wrapper. More...
class	ss_storage_class
	Storage class enumeration wrapper. More...
class	ss_assign
	Class for assignement binary operator (=). More...
class	ss_add
	Class for addition binary operator (+). More...
class	ss_sub
	Class for subtraction binary operator (-). More...
class	ss_mul
	Class for multiplication binary operator (*). More...
class	ss_div
	Class for division binary operator (/). More...
class	ss_mod
	Class for modulo/reminder binary operator (%%). More...
class	ss_shr
	Class for right shift binary operator (>>). More...
class	ss_shl
	Class for left shift binary operator (<<). More...
class	ss_sbg
	Class for "greater than" binary operator (>). More...
class	ss_sbl
	Class for "less than" binary operator (<). More...
class	ss_sbng
	Class for "not greater than" binary operator (<=). More...
class	ss_sbnl
	Class for "not less than" binary operator (>=). More...
class	ss_sbne
	Class for "not equal" binary operator (!=). More...
class	ss_sbe
	Class for equality binary operator (==). More...
class	ss_band
	Class for bitwise and binary operator (&). More...
class	ss_bor
	Class for bitwise or binary operator (|). More...
class	ss_bxor
	Class for bitwise xor binary operator (^). More...
class	ss_land
	Class for logical and binary operator (&&). More...
class	ss_lor
	Class for logical or binary operator (||). More...
class	ss_arr_acc
	Class for accessing array ([]). More...
class	ss_funcall_abstr
	Base class for function call expressions. More...
class	ss_pfuncall
	Class for member pointer call. More...
class	ss_funcall
	Class for ordinary function call. More...
class	ss_ifuncall
	Class for indirect ordinary global function call. More...
class	ss_mfuncall
	Class for method call. More...
class	ss_vfuncall
	Class for virtual method call. More...
class	ss_unary_expr
	Base class for function call expressions. More...
class	ss_dereference
	Class for dereference operator (*). More...
class	ss_conversion
	Class for conversion operator. More...
class	ss_array_to_pointer
	Class for conversion operator for the array to pointer case. More...
class	ss_bind_reference
	Class for reference binding. More...
class	ss_bind_to_temporary
	Class for pruposes of reference binding. More...
class	ss_get
	Class representing lvalue to rvalue conversion. More...
class	ss_vol_get
	Class representing lvalue to rvalue conversion (from volatile variable object). More...
class	ss_gat
	Class for unary operator plus/gation (+). More...
class	ss_neg
	Class for unary operator minus/negation (-). More...
class	ss_lnot
	Class for unary operator of logical negation (!). More...
class	ss_bnot
	Class for unary operator of binary negation/complement (~). More...
class	ss_address_of
	Class for reference operator (&). More...
class	ss_expression
	Base class for expressions. More...
class	ss_this_expr
	Class for this pointer. More...
class	ss_literal
	Class for literal value. More...
class	ss_ternary
	Class for ternary ?: operator expression. More...
class	ss_var_ref_abstract
	Abstract class for variable references. More...
class	ss_var_ref_by_qname
	Class for variable references by qualified name. More...
class	ss_var_ref
	Class for variable reference. More...
class	ss_throw
	Class for throw expression. More...
class	ss_member_ptr
	Class for pointer to member operator .*. More...
class	ss_ptr_member_ptr
	Class for pointer to member operator ->*. More...
class	ss_access
	Class for member access (.). More...
class	ss_ptr_access
	Class for member access via pointer (->). More...
class	ss_binary_expr
	Base class for built-in binary operators. More...
class	ss_constructor_finder
	Finds a proper constructor (set) for a given class. More...
class	ss_constructor_find
class	ss_destructor_finder
	Finds a proper destructor for a given class. More...
class	ss_destructor_find
class	ss_literal_info
	Base class for literal information. More...
class	ss_integral_literal_info
class	ss_floating_literal_info
class	ss_compound_literal_info
	Represents compound literal. More...
class	ss_declaration_time
	Declaration time. More...
class	ss_decl_seq
	Class for declaration sequence. More...
class	ss_using_directive
	Class for using directive. More...
class	ss_label
	Base class for labels. More...
class	ss_breakable_stmt_label
	Class for labels created from breakable statements(i.e. do,while,for,switch). More...
class	ss_case_label
	Class for "case" label inside the switch. More...
class	ss_default_label
	Class for the default case inside the switch. More...
class	ss_continue_label
	Class for the continue label in loops. More...
class	ss_break_label
	Class for the break label in loops and switch. More...
class	ss_targetted_label
	Class for labels, which target is known at ceration time of label(i.e. label for goto). More...
class	ss_internal_label
	Class for internally generated label. More...
class	ss_id_label
	Class for label associated with identifier (from goto). More...
class	ss_se
	Class representing side effect. More...
class	ss_sp
	Class representing sequence point. More...
class	ss_translation_unit
class	ss_base_specifier
	Class-base specifier. More...
class	ss_stmt2pi
	Visitor responsible for converting statements into pseudoinstructions. More...
class	ss_decl2pi
	Visitor responsible for converting declarations into pseudoinstructions. More...
class	ss_decl2mem
	Visitor responsible for getting correct pi_mem_factory for a given declaration. More...
class	ss_type2destructor
class	ss_expr2destination
	Visitor for determination destination of sideeffect expression. Used for origin computation. More...
class	ss_expr2pi
	Visitor for converting expressions into pseudoinstructions. More...
class	ss_destructor_table
class	ss_destructor_tables
class	ss_destructor_tables_stack
class	ss_linfo2pi_linfo
	Visitor for converting literal info to pi layer literal info. More...
class	ss_statement
	Base class for statements. More...
class	ss_compound_stmt
	Class for compound statement. More...
class	ss_decl_stmt
	Class for declaration statement. More...
class	ss_try
	Class for try-block. More...
class	ss_break
	Class for break statement. More...
class	ss_return
	Class for return statement. More...
class	ss_goto
	Class for goto statement. More...
class	ss_expr_stmt
	Class for expression statement. More...
class	ss_continue
	Class for continue statement. More...
class	ss_if_stmt
	Class for if statement. More...
class	ss_catch
	Class for catch handler for try block. More...
class	ss_breakable_stmt
	Base class for breakable statements. More...
class	ss_switch_stmt
	Class for switch block. More...
class	ss_iteration_stmt
	Base class for iteration statements. More...
class	ss_do
	Class for "do" iteration statement. More...
class	ss_while
	Class for "while" iteration statement. More...
class	ss_for
	Class for "for" iteration statement. More...
class	ss_type
	Base class for intercode types. More...
class	ss_builtin_type
	Class for built-in types. More...
class	ss_const
	Class for const types. More...
class	ss_volatile
	Class for volatile types. More...
class	ss_const_volatile
	Class for volatile types. More...
class	ss_referential
	Class for references. More...
class	ss_reference
	Class for referenced types via &. More...
class	ss_pseudoreference
	Class for pseudo-referenced types. More...
class	ss_pointer
	Class for pointered types. More...
class	ss_enum
	Class for enumeration type. More...
class	ss_array
	Class for array type. More...
class	ss_member_pointer
	Class for member pointer (8.3.3). More...
class	ss_function
	Class for function type. More...
class	ss_member_function
	Class for member function type. More...
class	ss_struct_base
	Base class for structurated objects. More...
class	ss_class
	Class for struct-class types. More...
class	ss_union
	Class for union type. More...
class	ss_typename_type
	Class for template typename types. More...
class	ss_function_comparator
	Comparator for ss_function. More...
class	ss_type2cv_unqualified
	CV qualifiers remover. More...
class	ss_type2id
	Visitor that returns identification of a descendant of ss_type. More...
class	ss_type2info
	Visitor providing lightweight type info for certain SS type classes. More...
class	ss_type2mangled_id
	Visitor that returns string representation of ss_type as defined by GNU GCC mangling rules. More...
class	ss_type2param_type
	Normalizes types of parameters. More...
class	ss_bool
	Base class for built-in bool type. More...
class	ss_void
	Base class for built-in void type. More...
class	ss_integral
	Base class for built-in integral types. More...
class	ss_type_int
	Base class for built-in integer types. More...
class	ss_type_sint
	Base class for built-in signed integer type. More...
class	ss_type_uint
	Base class for built-in unsigned integer type. More...
class	ss_type_long
	Base class for built-in long types. More...
class	ss_type_slong
	Base class for built-in signed long type. More...
class	ss_type_ulong
	Base class for built-in unsigned long type. More...
class	ss_type_short
	Base class for built-in short types. More...
class	ss_type_sshort
	Base class for built-in signed short type. More...
class	ss_type_ushort
	Base class for built-in unsigned short type. More...
class	ss_type_char
	Base class for built-in char types. More...
class	ss_type_wchar_t
	Base class for built-in wchar-t type. More...
class	ss_type_schar
	Base class for built-in signed char type. More...
class	ss_type_uchar
	Base class for built-in unsigned char type. More...
class	ss_type_pchar
	Base class for built-in plain char type. More...
class	ss_floating
	Base class for built-in floating types. More...
class	ss_type_float
	Base class for built-in float type. More...
class	ss_type_double
	Base class for built-in double type. More...
class	ss_type_ldouble
	Base class for built-in long double type. More...
class	ss_type_visitor
class	ss_type2param_type_base
class	ss_type2info_base
class	ss_type2cv_unqualified_base
class	ss_type2destructor_base
class	ss_type_default_visitor
class	ss_type2tm_type_gen_base
class	ss_using_target
class	ss_expression_visitor
class	ss_expr2destination_base
class	ss_statement_visitor
class	ss_statement_visitor_cut_at_top
class	ss_literal_info_visitor
Typedefs
typedef broadcast_listener< ss_declaration >	declaration_broadcast_listener
typedef broadcaster< ss_declaration >	declaration_broadcaster
typedef set< srp< ss_declaration > >	ss_structure_declaration_set_type
	Defines set with ss_structure declaration.
typedef list< srp< ss_base_specifier > >	bases_type
typedef set< srp< ss_declaration > >	declaration_set_type
typedef set< srp< ss_decl_seq > >	decl_seq_set_type
typedef ::lestes::std::set< srp< ss_function_declaration > >	func_decl_set
typedef ::lestes::std::list< srp< ss_declaration > >	decl_list
typedef ::lestes::std::list< srp< or_or_functional > >	exprlist
typedef ::lestes::std::set< srp< ss_function_declaration > >	func_decl_set
typedef list< srp< ss_sp > >	sp_list
typedef list< srp< as_declaration_specifier > >	as_declaration_specifier_list_type
typedef list< srp< as_declarator_op > >	as_declarator_op_list_type
typedef ::lestes::std::list< srp< or_or_functional > >	exprlist
typedef ::lestes::std::set< srp< ss_function_declaration > >	func_decl_set
typedef list< srp< as_declarator_op > >	as_declarator_op_list_type
	Type of list of as_declarator_op elements.
typedef ::lestes::std::set< srp< ss_declaration > >	ss_declaration_set_type
	Type of set of ss_declaration elements.
typedef ::lestes::std::list< srp< ss_sp > >	sp_list
typedef ::lestes::std::list< srp< ss_label > >	label_list
typedef ::lestes::std::list< srp< ss_expression > >	expr_list
typedef ::lestes::std::list< srp< ss_statement > >	stmt_list
typedef ::lestes::std::list< srp< ss_declaration > >	decl_list
typedef ::lestes::std::source_location	location
typedef ::lestes::std::list< srp< ss_expression > >	expr_list
typedef list< srp< ss_declaration > >	decl_list_type
typedef ::lestes::std::list< srp< ::lestes::backend_v2::intercode::pi_mem > >	list_mem_type
typedef ::lestes::std::map< srp< ss_declaration >, srp< ::lestes::backend_v2::intercode::pi_mem_factory > >	variable_map_type
typedef ::lestes::std::pair< srp< ss_function_declaration >, srp< ::lestes::backend_v2::intercode::pi_mem_factory > >	destructor_entry_type
typedef ::lestes::std::map< srp< ss_expression >, srp< ::lestes::backend_v2::intercode::pi_operand > >	expression_results_map_type
Enumerations
enum	or_or_functional_enum {   OR_OR_FUNCTIONAL_CONCRETE, OR_OR_FUNCTIONAL_COMMA, OR_OR_FUNCTIONAL_ADDROF, OR_OR_FUNCTIONAL_LITERAL,   OR_OR_FUNCTIONAL_THIS, OR_OR_FUNCTIONAL_AMBIGUOUS, OR_OR_FUNCTIONAL_NOVIABLE, OR_OR_FUNCTIONAL_FUNC_DECL_SET,   OR_OR_FUNCTIONAL_DECL }
enum	rank_type { RANK_EXACT, RANK_PROMOTION, RANK_CONVERSION, RANK_USER }
enum	or_cv_enum {   OR_CV_CONST, OR_CV_VOLATILE, OR_CV_CONST_VOLATILE, OR_CV_MEMBER_PTR,   OR_CV_PTR, OR_CV_BOOL, OR_CV_VOID, OR_CV_CLASS,   OR_CV_PSEUDOREFERENCE, OR_CV_REFERENCE, OR_CV_SINT, OR_CV_NONE }
enum	ss_decl_enum {   INJECTED_CLASS_DECLARATION, STRUCTURE_DECLARATION, NAMESPACE_DEFINITION, OBJECT_DECLARATION,   BITFIELD_DECLARATION, PARAMETER_DECLARATION, ENUMERATOR_DECLARATION, ENUM_DEFINITION,   TYPEDEF_DEFINITION, USING_DECLARATION, COMPOUND_STMT_DECLARATION, FAKE_DECLARATION,   FUNCTION_DECLARATION, METHOD_DECLARATION, BUILTIN_OPERATOR_DECLARATION }
Functions
void	ss2pi_start (ptr< ss_translation_unit >)
void	summary_seq_points (ptr< ss_sp > x)
int	man ()
ptr< ::lestes::msg::message_stencil1< ucn_string > >	integer_literal_cannot_be_represented (::lestes::msg::message_stencil1< ucn_string >::create("integer literal %0 cannot be represented by any of the allowed types",::lestes::msg::message::FLG_ERROR,::lestes::msg::formatter< ucn_string >::instance()))
	initialize_logger (lu_logger,"lu", sem_logger)
	declare_logger (lu_logger)
	declare_logger (lookup_log)
	initialize_logger (lookup_log,"lookup", lu_logger)
static ptr< declaration_set_type >	unify (const ptr< declaration_set_type > &s1, const ptr< declaration_set_type > &s2)
	Computes union of two given sets of declarations.
	declare_logger (or_log)
	initialize_logger (or_log,"overload", or_logger)
ptr< or_ics_functional >	or_find_ics (ptr< or_or_functional > source, ptr< ss_type > target)
bool	is_not_worse_conv_seq (ptr< or_ics_functional > r1, ptr< or_or_functional > e1, ptr< or_ics_functional > r2, ptr< or_or_functional > e2)
bool	is_better_conv_seq (ptr< or_ics_functional > r1, ptr< or_or_functional > e1, ptr< or_ics_functional > r2, ptr< or_or_functional > e2)
bool	exists_ics_conversion (ptr< ss_function_declaration > candidate, ptr< exprlist > exprs)
ptr< func_decl_set >	filter_ics_existence (ptr< func_decl_set > candidates, ptr< exprlist > exprs)
ptr< func_decl_set >	filter_num_args (ptr< func_decl_set > candidates, decl_list::size_type num_args)
ptr< func_decl_set >	select_viable (ptr< func_decl_set > candidates, ptr< exprlist > exprs)
bool	is_better_function (ptr< ss_function_declaration > f, ptr< ss_function_declaration > g, ptr< exprlist > exprs)
ptr< or_or_functional >	best_selection (ptr< func_decl_set > viables, ptr< exprlist > exprs)
ptr< func_decl_set >	collect_candidates (ptr< ss_operator> func_name, ptr< ss_decl_seq > ctxt)
ptr< or_or_functional >	overload_resolution (ptr< exprlist > exprs, ptr< ss_operator> func_name)
ptr< or_or_functional >	overload_resolution (ptr< exprlist > exprs, ptr< func_decl_set > candidates)
	declare_logger (or_ics_log)
	initialize_logger (or_ics_log,"or_ics_finder", or_ics_logger)
ptr< ::lestes::std::list< srp< or_ics_functional > > >	filter_type (ptr< ::lestes::std::list< srp< or_ics_functional > > > lst, ptr< ss_type > tgt)
ptr< or_ics_functional >	get_best_conversion (ptr< ::lestes::std::list< srp< or_ics_functional > > > lst, ptr< or_or_functional > e)
ptr< ss_expression >	convert_ptr_to_cv (ptr< or_or_functional > source)
	initialize_logger (or_ics_logger,"or_ics", sem_logger)
	declare_logger (or_ics_logger)
	initialize_logger (or_logger,"or", sem_logger)
	declare_logger (or_logger)
ptr< ::lestes::msg::message_stencil0< bool > >	non_lval_crement (::lestes::msg::message_stencil0< bool >::create("Non-lvalue used in increment/decrement.",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	non_lval_assign (::lestes::msg::message_stencil0< bool >::create("Non-lvalue used in assign.",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	incompatible_types_conversion (::lestes::msg::message_stencil0< bool >::create("Conversion between incompatible types requested.",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	assign_incompatible_types (::lestes::msg::message_stencil0< bool >::create("Asignment of incompatible types.",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	ambiguous_result (::lestes::msg::message_stencil0< bool >::create("The overload resolution returned ambigous result.",::lestes::msg::message::FLG_ERROR))
void	run ()
ptr< ::lestes::msg::message_stencil0< bool > >	union_shall_not_have_bases (::lestes::msg::message_stencil0< bool >::create("base classes cannot be specified in a union declaration",::lestes::msg::message::FLG_ERROR))
void	sa_decl_spec_test (void)
	Tests sa_decl_spec class.
ptr< ::lestes::msg::message_stencil0< bool > >	declaration_without_type (::lestes::msg::message_stencil0< bool >::create("declaration with no type",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_char_specifier (::lestes::msg::message_stencil0< bool >::create("short or long invalid for char",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_double_specifier (::lestes::msg::message_stencil0< bool >::create("signed, unsigned or short invalid for double",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_type_specifier (::lestes::msg::message_stencil0< bool >::create("signed, unsigned, short or long invalid for the type",::lestes::msg::message::FLG_ERROR))
void	sa_declarator_test (void)
	Tests sa_declarator class.
ptr< ::lestes::std::list< srp< as_declaration_specifier > > >	ts2ds (ptr< ::lestes::std::list< srp< as_type_specifier > > > tsl)
ptr< ::lestes::msg::message_stencil0< bool > >	no_viable_found (::lestes::msg::message_stencil0< bool >::create("Found no viable function to call",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	non_lvalue_in_unary_amp (::lestes::msg::message_stencil0< bool >::create("Non-lvalue used in unary &",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	ambiguous_function_prefix (::lestes::msg::message_stencil0< bool >::create("Ambiguous function prefix.",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	unrecognized_identifier (::lestes::msg::message_stencil0< bool >::create("Unrecognized identifier.",::lestes::msg::message::FLG_ERROR))
	initialize_logger (sa_logger,"sa", sem_logger)
	initialize_logger (sa_parser_action_logger,"sa_parser_action", sa_logger)
	initialize_logger (sa_class_logger,"sa_class", sa_logger)
	initialize_logger (sa_class_type_logger,"sa_class_type", sa_class_logger)
	initialize_logger (sa_class_base_logger,"sa_class_base", sa_class_logger)
	initialize_logger (sa_class_declaration_logger,"sa_class_declaration", sa_class_logger)
	initialize_logger (sa_simple_declaration_logger,"sa_simple_declaration", sa_logger)
	initialize_logger (sa_declarator_type_logger,"sa_declarator_type", sa_simple_declaration_logger)
	initialize_logger (sa_param_declaration_type_logger,"sa_param_declaration_type", sa_simple_declaration_logger)
	initialize_logger (sa_param_declaration_empty_logger,"sa_param_declaration_empty", sa_simple_declaration_logger)
	initialize_logger (sa_param_declaration_logger,"sa_param_declaration", sa_simple_declaration_logger)
	initialize_logger (sa_statements_logger,"sa_statements", sa_logger)
	declare_logger (sa_logger)
	declare_logger (sa_parser_action_logger)
	declare_logger (sa_class_logger)
	declare_logger (sa_class_type_logger)
	declare_logger (sa_class_base_logger)
	declare_logger (sa_class_declaration_logger)
	declare_logger (sa_simple_declaration_logger)
	declare_logger (sa_declarator_type_logger)
	declare_logger (sa_statements_logger)
	declare_logger (sa_param_declaration_type_logger)
	declare_logger (sa_param_declaration_empty_logger)
	declare_logger (sa_param_declaration_logger)
ptr< ::lestes::msg::message_stencil1< ptr< as_id > > >	name_already_declared (::lestes::msg::message_stencil1< ptr< as_id > >::create("name already declared when trying to define namespace '%0'",::lestes::msg::message::FLG_ERROR,::lestes::msg::formatter< ptr< as_id > >::instance()))
ptr< ::lestes::msg::message_stencil0< bool > >	declared_here (::lestes::msg::message_stencil0< bool >::create("declared here",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	unnamed_not_yet (::lestes::msg::message_stencil0< bool >::create("unnamed namespaces are not implemented yet",::lestes::msg::message::FLG_WARNING))
void	process_friend_function_declaration (ptr< sa_context > ctx, ptr< sa_declaration_specifiers > specifiers, ptr< as_declarator > declarator)
ptr< ::lestes::msg::message_stencil0< bool > >	redefinition (::lestes::msg::message_stencil0< bool >::create("redefinition of object",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_storage_specifier (::lestes::msg::message_stencil0< bool >::create("invalid storage specifier in declaration",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_specifier_function (::lestes::msg::message_stencil0< bool >::create("invalid specifier in function declaration",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_specifier_object (::lestes::msg::message_stencil0< bool >::create("invalid specifier in object declaration",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_specifier_typedef (::lestes::msg::message_stencil0< bool >::create("invalid specifier in typedef",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	different_return_types (::lestes::msg::message_stencil0< bool >::create("the return types are different",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	conflicting_types (::lestes::msg::message_stencil0< bool >::create("conflict types for declaration",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	previous_declaration (::lestes::msg::message_stencil0< bool >::create("previously declared here",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	redeclaration_different (::lestes::msg::message_stencil0< bool >::create("redeclaration as different kind of symbol",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	field_storage_specifier (::lestes::msg::message_stencil0< bool >::create("storage specifier for field",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	field_redefinition (::lestes::msg::message_stencil0< bool >::create("field redefined",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	static_and_extern (::lestes::msg::message_stencil0< bool >::create("declaration is both static and extern",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	methods_not_implemented (::lestes::msg::message_stencil0< bool >::create("method declarations are not implemented",::lestes::msg::message::FLG_ERROR))
ptr< ::lestes::msg::message_stencil0< bool > >	conversion_not_found (::lestes::msg::message_stencil0< bool >::create("Type conversion does not exist.",::lestes::msg::message::FLG_ERROR))
	initialize_logger (sem_logger,"sem", cplus_logger)
	declare_logger (sem_logger)
int	run_test ()
	declare_logger (dtl)
	declare_logger (fll)
	declare_logger (spl)
	declare_logger (gnl)
	initialize_logger (dtl,"destr_tab", sem_logger)
	initialize_logger (fll,"flow", sem_logger)
	initialize_logger (spl,"SP", sem_logger)
	initialize_logger (gnl,"ss2pi", sem_logger)
int	log_indent (ptr< ::lestes::msg::logger > flow, int ind)
void	dump (ptr< object >x)
void	dumb (ptr< object >x)
template<typename X>
ptr< X >	dung (ptr< X >x)
ptr< pi_mem >	pi_operand2pi_mem (ptr< pi_operand > x)
ptr< pi_mem_ptr_deref >	pi_operand2pi_mem_pointer (ptr< pi_operand > x)
ptr< pi_preg >	pi_operand2pi_preg (ptr< pi_operand > x)
ptr< pi_sp >	ss_sp2pi_sp (ptr< ss_sp > sp)
	BIND_EQUAL_SS_PI (add)
	BIND_EQUAL_SS_PI (sub)
	BIND_EQUAL_SS_PI (mul)
	BIND_EQUAL_SS_PI (div)
	BIND_EQUAL_SS_PI (mod)
	BIND_EQUAL_SS_PI (shr)
	BIND_EQUAL_SS_PI (shl)
	BIND_EQUAL_SS_PI (band)
	BIND_EQUAL_SS_PI (bor)
	BIND_EQUAL_SS_PI (bxor)
void	ss_type2info_test (void)
	Tests ss_type2info class.
Variables
ptr< declaration_broadcaster >	declaration_finished = declaration_broadcaster::create()
ptr< declaration_broadcaster >	declaration_finished
ptr< ::lestes::msg::message_stencil1< ucn_string > >	integer_literal_cannot_be_represented
	Integer literal cannot be represented by any type error.
static ptr< ss_decl_seq >	seq_param
ptr< ::lestes::msg::message_stencil0< bool > >	non_lval_crement
	Non-lvalue was used increment/decrement.
ptr< ::lestes::msg::message_stencil0< bool > >	non_lval_assign
	Non-lvalue was used in assign.
ptr< ::lestes::msg::message_stencil0< bool > >	incompatible_types_conversion
	Conversion between incompatible types was requested.
ptr< ::lestes::msg::message_stencil0< bool > >	assign_incompatible_types
	Assignment for incompatible types was requested.
ptr< ::lestes::msg::message_stencil0< bool > >	ambiguous_result
	Overload resolution was ambiguous.
ptr< ::lestes::msg::message_stencil0< bool > >	union_shall_not_have_bases
	Union shall not have bases.
ptr< ::lestes::msg::message_stencil0< bool > >	declaration_without_type
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_char_specifier
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_double_specifier
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_type_specifier
ptr< ::lestes::msg::message_stencil0< bool > >	no_viable_found
	No viable function found.
ptr< ::lestes::msg::message_stencil0< bool > >	non_lvalue_in_unary_amp
	rvalue used in unary amp.
ptr< ::lestes::msg::message_stencil0< bool > >	ambiguous_function_prefix
	The function prefix is ambiguous.
ptr< ::lestes::msg::message_stencil0< bool > >	unrecognized_identifier
	Identifier was not found.
ptr< ::lestes::msg::message_stencil1< ptr< as_id > > >	name_already_declared
ptr< ::lestes::msg::message_stencil0< bool > >	declared_here
ptr< ::lestes::msg::message_stencil0< bool > >	unnamed_not_yet
ptr< ::lestes::msg::message_stencil0< bool > >	redefinition
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_storage_specifier
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_specifier_function
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_specifier_object
ptr< ::lestes::msg::message_stencil0< bool > >	invalid_specifier_typedef
ptr< ::lestes::msg::message_stencil0< bool > >	different_return_types
ptr< ::lestes::msg::message_stencil0< bool > >	conflicting_types
ptr< ::lestes::msg::message_stencil0< bool > >	previous_declaration
ptr< ::lestes::msg::message_stencil0< bool > >	redeclaration_different
ptr< ::lestes::msg::message_stencil0< bool > >	field_storage_specifier
ptr< ::lestes::msg::message_stencil0< bool > >	field_redefinition
ptr< ::lestes::msg::message_stencil0< bool > >	static_and_extern
ptr< ::lestes::msg::message_stencil0< bool > >	methods_not_implemented
ptr< ::lestes::msg::message_stencil0< bool > >	conversion_not_found
	or_find_ics returned NULL - the conversion sequence could not be found.
int	log_count = 0
static bool	hack_used = false

---

Typedef Documentation

typedef list< srp< as_declaration_specifier > > lestes::lang::cplus::sem::as_declaration_specifier_list_type

Definition at line 50 of file sa_declaration_specifier_list.g.hh.

typedef list< srp<as_declarator_op> > lestes::lang::cplus::sem::as_declarator_op_list_type

Type of list of as_declarator_op elements.

Definition at line 123 of file sa_simple_declaration.cc.

typedef list< srp< as_declarator_op > > lestes::lang::cplus::sem::as_declarator_op_list_type

Definition at line 60 of file sa_declarator_type.cc.

typedef list< srp<ss_base_specifier> > lestes::lang::cplus::sem::bases_type

Definition at line 68 of file lu_lu.cc.

typedef ::lestes::std::list< srp< ss_declaration > > lestes::lang::cplus::sem::decl_list

Definition at line 74 of file sa_statements.cc.

typedef ::lestes::std::list< srp< ss_declaration > > lestes::lang::cplus::sem::decl_list

Definition at line 63 of file or.cc.

typedef list<srp<ss_declaration> > lestes::lang::cplus::sem::decl_list_type

Definition at line 52 of file ss_decl2lstring_base.cc.

typedef set< srp< ss_decl_seq > > lestes::lang::cplus::sem::decl_seq_set_type

Definition at line 38 of file lu_typedef.hh.

typedef broadcast_listener< ss_declaration > lestes::lang::cplus::sem::declaration_broadcast_listener

Definition at line 38 of file declaration_broadcasting.hh.

typedef broadcaster< ss_declaration > lestes::lang::cplus::sem::declaration_broadcaster

Definition at line 41 of file declaration_broadcasting.hh.

typedef set< srp< ss_declaration > > lestes::lang::cplus::sem::declaration_set_type

Definition at line 36 of file lu_typedef.hh.

typedef ::lestes::std::pair< srp< ss_function_declaration >, srp< ::lestes::backend_v2::intercode::pi_mem_factory > > lestes::lang::cplus::sem::destructor_entry_type

Definition at line 63 of file ss_ss2pi_typedefs.hh.

typedef ::lestes::std::list< srp < ss_expression > > lestes::lang::cplus::sem::expr_list

Definition at line 40 of file sa_statements.g.hh.

typedef ::lestes::std::list< srp< ss_expression > > lestes::lang::cplus::sem::expr_list

Definition at line 72 of file sa_statements.cc.

typedef ::lestes::std::map< srp< ss_expression >, srp< ::lestes::backend_v2::intercode::pi_operand > > lestes::lang::cplus::sem::expression_results_map_type

Definition at line 64 of file ss_ss2pi_typedefs.hh.

typedef ::lestes::std::list< srp< or_or_functional > > lestes::lang::cplus::sem::exprlist

Definition at line 74 of file sa_deconstruct_spse.cc.

typedef ::lestes::std::list< srp< or_or_functional > > lestes::lang::cplus::sem::exprlist

Definition at line 38 of file or.hh.

typedef ::lestes::std::set< srp< ss_function_declaration > > lestes::lang::cplus::sem::func_decl_set

Definition at line 75 of file sa_deconstruct_spse.cc.

typedef ::lestes::std::set< srp< ss_function_declaration > > lestes::lang::cplus::sem::func_decl_set

Definition at line 41 of file or.hh.

typedef ::lestes::std::set< srp< ss_function_declaration > > lestes::lang::cplus::sem::func_decl_set

Definition at line 62 of file or.cc.

typedef ::lestes::std::list< srp< ss_label > > lestes::lang::cplus::sem::label_list

Definition at line 71 of file sa_statements.cc.

typedef ::lestes::std::list< srp< ::lestes::backend_v2::intercode::pi_mem > > lestes::lang::cplus::sem::list_mem_type

Definition at line 61 of file ss_ss2pi_typedefs.hh.

typedef ::lestes::std::source_location lestes::lang::cplus::sem::location

Definition at line 75 of file sa_statements.cc.

typedef ::lestes::std::list< srp< ss_sp > > lestes::lang::cplus::sem::sp_list

Definition at line 68 of file sa_statements.cc.

typedef list< srp < ss_sp > > lestes::lang::cplus::sem::sp_list

Definition at line 49 of file sa_decl_seq_compound_pair_creator.cc.

typedef ::lestes::std::set< srp<ss_declaration> > lestes::lang::cplus::sem::ss_declaration_set_type

Type of set of ss_declaration elements.

Definition at line 126 of file sa_simple_declaration.cc.

typedef set< srp<ss_declaration> > lestes::lang::cplus::sem::ss_structure_declaration_set_type

Defines set with ss_structure declaration.

Definition at line 50 of file li_non_secu_by_name_in_single_scope.cc.

typedef ::lestes::std::list< srp< ss_statement > > lestes::lang::cplus::sem::stmt_list

Definition at line 73 of file sa_statements.cc.

typedef ::lestes::std::map< srp< ss_declaration >, srp< ::lestes::backend_v2::intercode::pi_mem_factory> > lestes::lang::cplus::sem::variable_map_type

Definition at line 62 of file ss_ss2pi_typedefs.hh.

---

Enumeration Type Documentation

enum lestes::lang::cplus::sem::or_cv_enum

Enumerator:

OR_CV_CONST
OR_CV_VOLATILE
OR_CV_CONST_VOLATILE
OR_CV_MEMBER_PTR
OR_CV_PTR
OR_CV_BOOL
OR_CV_VOID
OR_CV_CLASS
OR_CV_PSEUDOREFERENCE
OR_CV_REFERENCE
OR_CV_SINT
OR_CV_NONE

Definition at line 40 of file or_ics.hh.

             {
        OR_CV_CONST,
        OR_CV_VOLATILE,
        OR_CV_CONST_VOLATILE,
        OR_CV_MEMBER_PTR,
        OR_CV_PTR,
        OR_CV_BOOL,
        OR_CV_VOID,
        OR_CV_CLASS,
        OR_CV_PSEUDOREFERENCE,
        OR_CV_REFERENCE,
        OR_CV_SINT,
        OR_CV_NONE,
} or_cv_enum;

enum lestes::lang::cplus::sem::or_or_functional_enum

Enumerator:

OR_OR_FUNCTIONAL_CONCRETE
OR_OR_FUNCTIONAL_COMMA
OR_OR_FUNCTIONAL_ADDROF
OR_OR_FUNCTIONAL_LITERAL
OR_OR_FUNCTIONAL_THIS
OR_OR_FUNCTIONAL_AMBIGUOUS
OR_OR_FUNCTIONAL_NOVIABLE
OR_OR_FUNCTIONAL_FUNC_DECL_SET
OR_OR_FUNCTIONAL_DECL

Definition at line 16 of file or_actual_visitors.g.hh.

                           {
        OR_OR_FUNCTIONAL_CONCRETE,
        OR_OR_FUNCTIONAL_COMMA,
        OR_OR_FUNCTIONAL_ADDROF,
        OR_OR_FUNCTIONAL_LITERAL,
        OR_OR_FUNCTIONAL_THIS,
        OR_OR_FUNCTIONAL_AMBIGUOUS,
        OR_OR_FUNCTIONAL_NOVIABLE,
        OR_OR_FUNCTIONAL_FUNC_DECL_SET,
        OR_OR_FUNCTIONAL_DECL
};

enum lestes::lang::cplus::sem::rank_type

Enumerator:

RANK_EXACT
RANK_PROMOTION
RANK_CONVERSION
RANK_USER

Definition at line 23 of file or_ics.g.hh.

               {
        RANK_EXACT,
        RANK_PROMOTION,
        RANK_CONVERSION,
        RANK_USER
};

enum lestes::lang::cplus::sem::ss_decl_enum

Enumerator:

INJECTED_CLASS_DECLARATION
STRUCTURE_DECLARATION
NAMESPACE_DEFINITION
OBJECT_DECLARATION
BITFIELD_DECLARATION
PARAMETER_DECLARATION
ENUMERATOR_DECLARATION
ENUM_DEFINITION
TYPEDEF_DEFINITION
USING_DECLARATION
COMPOUND_STMT_DECLARATION
FAKE_DECLARATION
FUNCTION_DECLARATION
METHOD_DECLARATION
BUILTIN_OPERATOR_DECLARATION

Definition at line 17 of file sa_deconstruct_spse.g.hh.

                  {
        INJECTED_CLASS_DECLARATION,
        STRUCTURE_DECLARATION,
        NAMESPACE_DEFINITION,
        OBJECT_DECLARATION,
        BITFIELD_DECLARATION,
        PARAMETER_DECLARATION,
        ENUMERATOR_DECLARATION,
        ENUM_DEFINITION,
        TYPEDEF_DEFINITION,
        USING_DECLARATION,
        COMPOUND_STMT_DECLARATION,
        FAKE_DECLARATION,
        FUNCTION_DECLARATION,
        METHOD_DECLARATION,
        BUILTIN_OPERATOR_DECLARATION
};

---

Function Documentation

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::ambiguous_function_prefix

(

::lestes::msg::message_stencil0< bool >::

create("Ambiguous function prefix.",::lestes::msg::message::FLG_ERROR)

)

Issued when there are more than one "meanings" for function prefix.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::ambiguous_result

(

::lestes::msg::message_stencil0< bool >::

create("The overload resolution returned ambigous result.",::lestes::msg::message::FLG_ERROR)

)

Issued when the overload resolution process can't chose one best viable function.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::assign_incompatible_types

(

::lestes::msg::message_stencil0< bool >::

create("Asignment of incompatible types.",::lestes::msg::message::FLG_ERROR)

)

Issued when the arguments of assignment are not compatible.

ptr< or_or_functional > lestes::lang::cplus::sem::best_selection	(	ptr< func_decl_set >	viables,
		ptr< exprlist >	exprs
	)

This function selects the best function from set of viable functions.

Returns:

The functional, which represents the corresponding funcall, for the selected function.

Definition at line 232 of file or.cc.

References is_better_function(), and llog.

Referenced by overload_resolution().

{
        func_decl_set::iterator it = viables->begin();
        ptr< ss_function_declaration > best = *it;
        bool was_better = true;

        if (viables->size() == 0) {
                /* there are no candidates */
                return or_or_functional_noviable::create(ss_void::instance());
        }
        for(++it; it != viables->end(); ++it) {
                if(is_better_function(best, *it, exprs)) {
                        llog(or_logger) << "1: true\n";
                        was_better = true;
                } else if (is_better_function(*it, best, exprs)) {
                        llog(or_logger) << "2: true\n";
                        was_better = true;
                        best = *it; 
                } else {
                        llog(or_logger) << "3: false\n";
                        was_better = false;
                }
        }

        it = viables->begin();
        for(++it; it != viables->end(); ++it) {
                if(!((*it)->equals(best)) && !is_better_function(*it, best, exprs) && !is_better_function(best, *it, exprs))
                        return or_or_functional_ambiguous::create(best->type_get().dncast<ss_function>()->returns_get(), viables);
        }

        return or_or_functional_concrete::create(best->type_get().dncast<ss_function>()->returns_get(), exprs, best);
}

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

bxor

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

bor

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

band

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

shl

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

shr

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

mod

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

div

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

mul

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

sub

)

lestes::lang::cplus::sem::BIND_EQUAL_SS_PI

(

add

)

ptr< func_decl_set > lestes::lang::cplus::sem::collect_candidates	(	ptr< ss_operator>	func_name,
		ptr< ss_decl_seq >	ctxt
	)

Definition at line 270 of file or.cc.

References llog.

Referenced by overload_resolution().

{
        ptr< li_func_by_name > lookup = li_func_by_name::create();
        ptr< li_func_by_name_in_single_scope > lookup_builtin = li_func_by_name_in_single_scope::create();
        ptr< func_decl_set > res_lu, res_builtin;
        func_decl_set::iterator it;

        /* lookup the name in the current scope */
        llog(or_log) << "Looking it up in the current scope\n";

        res_lu = lookup->process(func_name, ctxt);

        if (res_lu->empty()) {
                llog(or_log) << "Found nothing\n";
        }
        /* lookup the name in the builtin op scope */
        llog(or_log) << "Looking it up in the builtin op scope\n";
        res_builtin = lookup_builtin->process(func_name, or_builtin_operator_declaration_creator::instance()->builtin_op_decl_seq_get());

        /* unite the result of the lookup and the result of lookup in builtin decl seq */
        if (!res_builtin->empty()) {
                llog(or_log) << "Found something, pushing into return list\n";
                
                it = res_builtin->begin();
                for(; it != res_builtin->end(); it++){
                        res_lu->insert(*it);
                }
        }
        
        return res_lu; 
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::conflicting_types

(

::lestes::msg::message_stencil0< bool >::

create("conflict types for declaration",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::conversion_not_found

(

::lestes::msg::message_stencil0< bool >::

create("Type conversion does not exist.",::lestes::msg::message::FLG_ERROR)

)

ptr< ss_expression > lestes::lang::cplus::sem::convert_ptr_to_cv

(

ptr< or_or_functional >

source

)

This functions converts the expression, which has type of pointer to cv1 P, to pointer to cv2 P, c2 being more cv-qualified than c1. See 4.4/1

We rely on source being expression of ss_pointer type

Definition of relation "to be more qualified": none < const none < volatile none < const volatile const < const volatile volatile < const volatile

Returns:

list of conversion expressions

Definition at line 535 of file or_ics.cc.

References lestes::lang::cplus::sem::or_ics_visitor_cv::create(), OR_CV_CONST, OR_CV_CONST_VOLATILE, OR_CV_NONE, and OR_CV_VOLATILE.

{
        /* this is to store the result passed to caller */
        typedef ::lestes::std::list< srp< ss_expression > > funclist;
        ptr< funclist > seq = funclist::create();

        ptr< ss_type > p = source->type_get();
        ptr< or_ics_visitor_cv > v = or_ics_visitor_cv::create();
        /* this gets the qualification of the type pointed to by the pointer */
        or_cv_enum q = p.dncast<ss_pointer>()->what_get()->accept_or_ics_base_cv(v);

        /* TODO this is unfinished */   
        switch (q){
                case OR_CV_NONE:;       
                case OR_CV_CONST:;
                case OR_CV_VOLATILE:;
                case OR_CV_CONST_VOLATILE:;
                default:;
        }
                
        /* FIXME */
        return NULL;
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::declaration_without_type

(

::lestes::msg::message_stencil0< bool >::

create("declaration with no type",::lestes::msg::message::FLG_ERROR)

)

lestes::lang::cplus::sem::declare_logger

(

gnl

)

lestes::lang::cplus::sem::declare_logger

(

spl

)

lestes::lang::cplus::sem::declare_logger

(

fll

)

lestes::lang::cplus::sem::declare_logger

(

dtl

)

lestes::lang::cplus::sem::declare_logger

(

sem_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_param_declaration_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_param_declaration_empty_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_param_declaration_type_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_statements_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_declarator_type_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_simple_declaration_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_class_declaration_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_class_base_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_class_type_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_class_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_parser_action_logger

)

lestes::lang::cplus::sem::declare_logger

(

sa_logger

)

lestes::lang::cplus::sem::declare_logger

(

or_logger

)

lestes::lang::cplus::sem::declare_logger

(

or_ics_logger

)

lestes::lang::cplus::sem::declare_logger

(

or_ics_log

)

lestes::lang::cplus::sem::declare_logger

(

or_log

)

lestes::lang::cplus::sem::declare_logger

(

lookup_log

)

lestes::lang::cplus::sem::declare_logger

(

lu_logger

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::declared_here

(

::lestes::msg::message_stencil0< bool >::

create("declared here",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::different_return_types

(

::lestes::msg::message_stencil0< bool >::

create("the return types are different",::lestes::msg::message::FLG_ERROR)

)

void lestes::lang::cplus::sem::dumb

(

ptr< object >

x

)

Dumps objects hierarchy starting from dumpable x.

Definition at line 128 of file ss_ss2pi_base.cc.

References lestes::std::dumper::dump(), and plog.

                          {
plog(gnl)<<"..dumbing..\n";
        ::std::ofstream f("dumb.xml");
	::lestes::std::dumper::dump(f,x);
        f.close();
}

void lestes::lang::cplus::sem::dump

(

ptr< object >

x

)

Dumps objects hierarchy starting from dumpable x.

Definition at line 118 of file ss_ss2pi_base.cc.

References lestes::std::dumper::dump(), and plog.

Referenced by lestes::backend_v2::debug::b_dump(), lestes::lang::cplus::syn::do_it(), main(), and man().

                          {
plog(gnl)<<"..dumping..\n";
        ::std::ofstream f("dump.xml");
	::lestes::std::dumper::dump(f,x);
        f.close();
}

template<typename X>

ptr<X> lestes::lang::cplus::sem::dung

(

ptr< X >

x

)

[inline]

Dumps objects hierarchy starting from dumpable x. Usage a=func(b,dung(c),d);

Definition at line 140 of file ss_ss2pi_base.cc.

References lestes::std::dumper::dump(), and plog.

                       {
plog(gnl)<<"..dumbing..\n";
        ::std::ofstream f("dumb.xml");
	::lestes::std::dumper::dump(f,x);
        f.close();
        return x;
}

bool lestes::lang::cplus::sem::exists_ics_conversion	(	ptr< ss_function_declaration >	candidate,
		ptr< exprlist >	exprs
	)

This function tests if there exists implicit conversion sequence from expressions, representing arguments in function call, to parameters of the candidate function.

Bug:

This functions doesn't deal with elipsis functions yet, as thery are not handled by sem so far

Returns:

true if the conversion exists, false otherwise

Definition at line 79 of file or.cc.

References or_find_ics().

Referenced by filter_ics_existence().

{
        ptr< decl_list > params = candidate->parameters_get()->contents_get();
        decl_list::iterator it = params->begin();
        ::lestes::std::list< srp< or_or_functional > >::iterator it_expr = exprs->begin();

        for(; it_expr != exprs->end() && it != params->end(); ++it, ++it_expr) {
                if(!or_find_ics(*it_expr, (*it)->type_get()))
                        return false;
        }

        /* TODO
        for(; it_exprs != exprs->end(); ++it_expr) {
                if(!find_ics_ellipsis(*it_expr))
                        return false;
        }
        */
        return true;
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::field_redefinition

(

::lestes::msg::message_stencil0< bool >::

create("field redefined",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::field_storage_specifier

(

::lestes::msg::message_stencil0< bool >::

create("storage specifier for field",::lestes::msg::message::FLG_ERROR)

)

ptr< func_decl_set > lestes::lang::cplus::sem::filter_ics_existence	(	ptr< func_decl_set >	candidates,
		ptr< exprlist >	exprs
	)

This function filters out those candidates from candidates list, for which the implicit conversion sequence from expressions coming from call, to function parameters, doesn't exist

Returns:

filtered list of candidates

Definition at line 106 of file or.cc.

References exists_ics_conversion().

Referenced by select_viable().

{
        ptr< func_decl_set > new_cands = func_decl_set::create();

        func_decl_set::iterator it = candidates->begin(), it_end = candidates->end();

        for (it = candidates->begin(); it != it_end; ++it) {
                if (exists_ics_conversion(*it, exprs)) 
                        new_cands->insert(*it);
                
        }
        return new_cands;
}

ptr< func_decl_set > lestes::lang::cplus::sem::filter_num_args	(	ptr< func_decl_set >	candidates,
		decl_list::size_type	num_args
	)

This function filters out those candidates from candidates list, which do not have proper count of arguments.

Bug:

This functions doesn't deal with elipsis functions yet, as thery are not handled by sem so far

Returns:

filtered list of candidates

Definition at line 129 of file or.cc.

Referenced by select_viable().

{
        ptr< func_decl_set > filtered = func_decl_set::create();

        func_decl_set::iterator it = candidates->begin();
        
        for(; it != candidates->end(); ++it) {
                if((*it)->parameters_get()->contents_get()->size() == num_args) {
                        filtered->insert(*it);
                } else if ((*it)->parameters_get()->contents_get()->size() > num_args) {
                        /* FIXME for ps - has_default() ?? 
                        if((it->parameters_get()->begin()+num_args)->has_default())
                                filtered->insert(*it);
                        */
                }
                /* FIXME - don't know how to get ellipsis yet 
                else if(it->ellipsis_get()) {
                        filtered->insert(*it);
                }
                */
        }
        return filtered;
}

ptr< ::lestes::std::list< srp< or_ics_functional > > > lestes::lang::cplus::sem::filter_type	(	ptr< ::lestes::std::list< srp< or_ics_functional > > >	lst,
		ptr< ss_type >	tgt
	)

This function filters out those conversions not converting to the type of the target

Returns:

the filtered list

Definition at line 224 of file or_ics.cc.

References llog.

Referenced by or_find_ics().

{
        ::lestes::std::list< srp< or_ics_functional > >::iterator it, it_del;
        ptr< or_ics_visitor_cv > v = or_ics_visitor_cv::create();
        ptr< ::lestes::std::list< srp< or_ics_functional > > > ret = ::lestes::std::list< srp< or_ics_functional > >::create();
        
        /* this cycle erases all functionals from list, not having target_type of tgt
         *
         * this takes care of (pseudo)references automatically
         */
        llog(or_ics_log) << "Filtering ...\n";
        for(it = lst->begin(); it != lst->end();it++){
                /* are the types not references && are the same? */
                if ( (*it)->target_type_get()->equals(tgt) ) {
                        ret->push_back(*it);
                        llog(or_ics_log) << "Found identical type\n";
                }
        }
        return ret;
}

ptr< or_ics_functional > lestes::lang::cplus::sem::get_best_conversion	(	ptr< ::lestes::std::list< srp< or_ics_functional > > >	lst,
		ptr< or_or_functional >	e
	)

Definition at line 245 of file or_ics.cc.

References is_better_conv_seq().

{
        ::lestes::std::list< srp< or_ics_functional > >::iterator it = lst->begin();
        ptr< or_ics_functional > best = *it;

        for(; it != lst->end(); it++) {
                if (is_better_conv_seq(*it, e, best, e)) 
                        best = *it;
        }

        return best;
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::incompatible_types_conversion

(

::lestes::msg::message_stencil0< bool >::

create("Conversion between incompatible types requested.",::lestes::msg::message::FLG_ERROR)

)

Issued when conversion between incompatible types was requested.

lestes::lang::cplus::sem::initialize_logger	(	gnl	,
		"ss2pi"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	spl	,
		"SP"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	fll	,
		"flow"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	dtl	,
		"destr_tab"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sem_logger	,
		"sem"	,
		cplus_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_statements_logger	,
		"sa_statements"	,
		sa_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_param_declaration_logger	,
		"sa_param_declaration"	,
		sa_simple_declaration_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_param_declaration_empty_logger	,
		"sa_param_declaration_empty"	,
		sa_simple_declaration_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_param_declaration_type_logger	,
		"sa_param_declaration_type"	,
		sa_simple_declaration_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_declarator_type_logger	,
		"sa_declarator_type"	,
		sa_simple_declaration_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_simple_declaration_logger	,
		"sa_simple_declaration"	,
		sa_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_class_declaration_logger	,
		"sa_class_declaration"	,
		sa_class_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_class_base_logger	,
		"sa_class_base"	,
		sa_class_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_class_type_logger	,
		"sa_class_type"	,
		sa_class_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_class_logger	,
		"sa_class"	,
		sa_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_parser_action_logger	,
		"sa_parser_action"	,
		sa_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	sa_logger	,
		"sa"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	or_logger	,
		"or"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	or_ics_logger	,
		"or_ics"	,
		sem_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	or_ics_log	,
		"or_ics_finder"	,
		or_ics_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	or_log	,
		"overload"	,
		or_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	lookup_log	,
		"lookup"	,
		lu_logger
	)

lestes::lang::cplus::sem::initialize_logger	(	lu_logger	,
		"lu"	,
		sem_logger
	)

ptr< ::lestes::msg::message_stencil1< ucn_string > > lestes::lang::cplus::sem::integer_literal_cannot_be_represented

(

::lestes::msg::message_stencil1< ucn_string >::

create("integer literal %0 cannot be represented by any of the allowed types",::lestes::msg::message::FLG_ERROR,::lestes::msg::formatter< ucn_string >::instance())

)

[2.13.1/3] A program is ill-formed if one of its translation units contains an integer literal that cannot be represented by any of the allowed types.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_char_specifier

(

::lestes::msg::message_stencil0< bool >::

create("short or long invalid for char",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_double_specifier

(

::lestes::msg::message_stencil0< bool >::

create("signed, unsigned or short invalid for double",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_specifier_function

(

::lestes::msg::message_stencil0< bool >::

create("invalid specifier in function declaration",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_specifier_object

(

::lestes::msg::message_stencil0< bool >::

create("invalid specifier in object declaration",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_specifier_typedef

(

::lestes::msg::message_stencil0< bool >::

create("invalid specifier in typedef",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_storage_specifier

(

::lestes::msg::message_stencil0< bool >::

create("invalid storage specifier in declaration",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_type_specifier

(

::lestes::msg::message_stencil0< bool >::

create("signed, unsigned, short or long invalid for the type",::lestes::msg::message::FLG_ERROR)

)

bool lestes::lang::cplus::sem::is_better_conv_seq	(	ptr< or_ics_functional >	r1,
		ptr< or_or_functional >	e1,
		ptr< or_ics_functional >	r2,
		ptr< or_or_functional >	e2
	)

This function gets two conversions c1 and c2, represented by their "left" and "rights" SCS and uc (l1,u1,r1 and l2,u2,r2 respectively).

the passed expression is the source expression of the conversion

Returns:

true if conversion c1 is better than c2, else returns false

Definition at line 76 of file or_ics.cc.

References DEREF_PTR, DEREF_PTR_NOVIS, IS_CLASS, IS_MEMBER_PTR, IS_PTR, IS_PTR_BOOL_CONV, IS_VOID, and MEMBER_PTR_BASE.

Referenced by get_best_conversion(), is_better_function(), and is_not_worse_conv_seq().

{
        typedef ::lestes::std::list< srp< ss_type > > typelist;
        ptr< typelist > conv_list = typelist::create();
        ptr< typelist > list1, list2;
        typelist::iterator it1, it2;
        ptr< or_ics_functional_visitor > v_t = or_ics_functional_visitor::create(conv_list);

         /* if u1 != u2 return false;
          * rationale: 13.3.3.2/3

          if (!(u1->equals(u2)))
                return false;

          */    

        if (r1->rank_get() < r2->rank_get()) {
                return true;
        }
        /* 
         * now linearize the functionals into list of target types, for easy comparsion. This is done
         * using visitor on or_ics_functional. 
         * 
         * in this list, lval->rval conversions are already excluded
         */      
        list1 = r1->accept_or_ics_functional_base(v_t);
        list2 = r2->accept_or_ics_functional_base(v_t);
        
        /* now check if r1 is proper subsequence of r2 */
        it1 = list1->begin();
        it2 = list2->end();

        while (it1 != list1->end() && it2 != list2->end() && (*it1)->equals(*it2)) {
                it1++;
                it2++;
        }
        
        if (it1 == list1->end() && it2 != list2->end()) {
                return true;
        }
        
        return false;
        
        /* The following code is not reached now. Will be used when user types work */
        /* TODO qualification and reference binding conversions tests */

        /* a conversion of (member) ptr to bool is worse than conversion which is not such 
         * conversion 
         */
        /* source and destination types */
        ptr< ss_type > s1 = e1->type_get();
        ptr< ss_type > s2 = e2->type_get();
        ptr< ss_type > t1 = (*(list1->end()));
        ptr< ss_type > t2 = (*(list2->end()));
        
        ptr< or_ics_visitor_cv > v = or_ics_visitor_cv::create();
        or_cv_enum ts1 = t1->accept_or_ics_base_cv(v);
        or_cv_enum ts2 = t1->accept_or_ics_base_cv(v);
        or_cv_enum tt1 = t1->accept_or_ics_base_cv(v);
        or_cv_enum tt2 = t2->accept_or_ics_base_cv(v);
        if (IS_PTR_BOOL_CONV(ts2,tt2) && !IS_PTR_BOOL_CONV(ts1,tt1))
                return true;

        /* if *ts1 derived from *tt1, then ts1 ->tt1 is better than ts1* -> void*  when ts1 == ts2 */
        if (IS_PTR(ts1) && IS_PTR(tt1) && 
                IS_CLASS(DEREF_PTR(s1)) && IS_CLASS(DEREF_PTR(t1)) && DEREF_PTR_NOVIS(t1).dncast<ss_class>()->is_ancestor(DEREF_PTR_NOVIS(s1).dncast<ss_class>()) &&
                s1->equals(s2) && IS_PTR(tt2) && IS_VOID(DEREF_PTR(t2)))
                return true;
        
        /* if *ts2 derived from *ts1, then ts1 -> void* is better than ts2 -> void* */
        if (IS_PTR(ts1) && IS_PTR(ts2) && IS_PTR(tt1) && IS_PTR(tt2) &&
                IS_CLASS(DEREF_PTR(s1)) && IS_CLASS(DEREF_PTR(s2)) && IS_VOID(DEREF_PTR(t1)) && IS_VOID(DEREF_PTR(t2)) && 
                DEREF_PTR_NOVIS(s1).dncast<ss_class>()->is_ancestor(DEREF_PTR_NOVIS(s2).dncast<ss_class>()))
                return true;
        
        /* if *ts1 derived from *tt1 and *tt1 derived from *tt2 and ts1 == ts2 then tt1->ts1 better than tt2->ts2 */

        if (IS_PTR(ts1) && IS_PTR(tt1) && IS_PTR(tt2) &&
                IS_CLASS(DEREF_PTR(s1)) && IS_CLASS(DEREF_PTR(t1)) && IS_CLASS(DEREF_PTR(t2)) &&
                DEREF_PTR_NOVIS(t2).dncast<ss_class>()->is_ancestor(DEREF_PTR_NOVIS(t1).dncast<ss_class>()) 
                && DEREF_PTR_NOVIS(t1).dncast<ss_class>()->is_ancestor(DEREF_PTR_NOVIS(s1).dncast<ss_class>()) &&
                s1->equals(s2))
                return true;

        /* TODO binding C -> &B better than C->&A */

        /* if *tt1 derived from *ts1 and *tt2 derived from *tt1 and ts1 == ts2 then
         * ts1::* -> tt1::* is better than ts2::* -> tt2::x */ 

        if (IS_MEMBER_PTR(ts1) && IS_MEMBER_PTR(tt1) && IS_MEMBER_PTR(tt2) && 
                MEMBER_PTR_BASE(s1)->is_ancestor(MEMBER_PTR_BASE(t1)) &&
                MEMBER_PTR_BASE(t1)->is_ancestor(MEMBER_PTR_BASE(t2)) &&
                s1->equals(s2))
                return true;
        
        /* ts1 derived from tt1 and tt1 derived from tt2, then ts1->tt1 is better than ts2->tt2 (if ts1==ts2) */
        if (IS_CLASS(ts1) && IS_CLASS(tt1) && IS_CLASS(tt2) &&
                s1->equals(s2) && 
                t1.dncast<ss_class>()->is_ancestor(s1.dncast<ss_class>()) && t2.dncast<ss_class>()->is_ancestor(t1.dncast<ss_class>()))
                return true;
                
        /* if (*tt1 == *tt2) and *ts1 derived from *tt1 and *ts2 derived from *ts1 then ts1->tt1 is better than ts2->tt2 */
        if (IS_PTR(tt1) && IS_PTR(ts1) && IS_PTR(ts2) &&
                IS_CLASS(DEREF_PTR(t1)) && IS_CLASS(DEREF_PTR(s1)) && IS_CLASS(DEREF_PTR(s2)) &&
                DEREF_PTR_NOVIS(t1).dncast<ss_class>()->is_ancestor(DEREF_PTR_NOVIS(s2).dncast<ss_class>()) &&
                DEREF_PTR_NOVIS(s1).dncast<ss_class>()->is_ancestor(DEREF_PTR_NOVIS(s2).dncast<ss_class>()) &&
                t1->equals(t2))
                return true;
        /* TODO binding B->A& is better than binding C->A& */

        /* if *ts1 is derived from *ts2 and *tt1 is derived from *ts1 and tt1 == tt2, then ts1::*->tt1::* is better than 
         * ts2::*->tt2::*
         */
        
        if (IS_MEMBER_PTR(ts2) && IS_MEMBER_PTR(ts1) && IS_MEMBER_PTR(tt1) &&
                MEMBER_PTR_BASE(s2)->is_ancestor(MEMBER_PTR_BASE(s1)) &&
                MEMBER_PTR_BASE(s1)->is_ancestor(MEMBER_PTR_BASE(t1)) &&
                t1->equals(t2))
                return true;

        /* this happens only when initialization of user-defined conversion happens (13.3.3). this is the only case when
         * source types are diferrent 
         */

        if (IS_CLASS(tt1) && IS_CLASS(ts1) && IS_CLASS(ts2) &&
                t1.dncast<ss_class>()->is_ancestor(s1.dncast<ss_class>()) &&
                s1.dncast<ss_class>()->is_ancestor(s2.dncast<ss_class>())
                && t1->equals(t2))
                return true;

        return false;   
}

bool lestes::lang::cplus::sem::is_better_function	(	ptr< ss_function_declaration >	f,
		ptr< ss_function_declaration >	g,
		ptr< exprlist >	exprs
	)

This function tests if function f is better (in terms of overload resolution) than function g, when considering parameters in expression list exprlist.

Bug:

tests for templates not done, as templates are not yet supported. tests for user conversions are not done, as user conversions are not yet supported.

Returns:

true if f is better conversion than g, otherwise return false

Definition at line 180 of file or.cc.

References is_better_conv_seq(), is_not_worse_conv_seq(), and or_find_ics().

Referenced by best_selection().

{
        //decl_list::size_type num_args = exprs->size();

        ptr< decl_list > params_f = f->parameters_get()->contents_get();
        decl_list::iterator it_f_param = params_f->begin();

        ptr< decl_list > params_g = g->parameters_get()->contents_get();
        decl_list::iterator it_g_param = params_g->begin();

        exprlist::iterator it_exprs = exprs->begin();
        
        
        for(; it_f_param != params_f->end() && it_g_param != params_g->end() && it_exprs != exprs->end(); 
                        ++it_f_param, ++it_g_param, ++it_exprs) {
                ptr< or_ics_functional > f_func, g_func;

                f_func = or_find_ics((*it_exprs), (*it_f_param)->type_get());
                g_func = or_find_ics((*it_exprs), (*it_g_param)->type_get());

                if(!is_not_worse_conv_seq(f_func, (*it_exprs), g_func, (*it_exprs))) {
                        return false;
                }
        }
        for(it_f_param = params_f->begin(), it_g_param = params_g->begin(), it_exprs = exprs->begin(); 
                        it_f_param != params_f->end() && it_g_param != params_g->end() && it_exprs != exprs->end(); 
                        ++it_f_param, ++it_g_param, ++it_exprs) {
                ptr< or_ics_functional > f_func, g_func;

                f_func = or_find_ics((*it_exprs), (*it_f_param)->type_get());
                g_func = or_find_ics((*it_exprs), (*it_g_param)->type_get());
                
                if(is_better_conv_seq(f_func, (*it_exprs), g_func, (*it_exprs))){
                        return true;
                }
        }
        /* TODO 
         * - f is not template && G is a template specialization instance 
         *   && g are templates && f is a better template specialization than g (see 14.5.5.2) 
         * - context is inicialization by user conversion  && SCS from return_type(f) -> dest_type is better conv seq 
         *   than SCS from return_type(g) -> dest_type
         */

        return false;
}

bool lestes::lang::cplus::sem::is_not_worse_conv_seq	(	ptr< or_ics_functional >	r1,
		ptr< or_or_functional >	e1,
		ptr< or_ics_functional >	r2,
		ptr< or_or_functional >	e2
	)

Definition at line 210 of file or_ics.cc.

References is_better_conv_seq().

Referenced by is_better_function().

{
        return (!(is_better_conv_seq(/*l2, u2, */r2, e2, /* l1, u1,*/ r1, e1)));
}

int lestes::lang::cplus::sem::log_indent	(	ptr< ::lestes::msg::logger >	flow,
		int	ind
	)

Definition at line 100 of file ss_ss2pi_base.cc.

References log_flow_indent.

                                                   {    //indentation for control_flow logs
        for (int i=0; i<ind; i++){
                flow << log_flow_indent;
        }
        return ind;
}

int lestes::lang::cplus::sem::man

(

)

Definition at line 64 of file example1.cc.

References dump(), NOINIT, ss2pi_start(), and summary_seq_points().

Referenced by main().

         {

//ptr<ss_compound_stmt> cmps1;// = ss_compound_stmt::create();

ptr<ss_translation_unit> tu = ss_translation_unit::create( ss_decl_seq::root_instance() );

#define NOINIT ss_decl_stmt::IK_DEFAULT_INITIALIZATION

typedef  ::lestes::std::list< srp< ss_declaration > >  listdecl;
typedef  ::lestes::std::list< srp< ss_type > >  listtype;
typedef  ::lestes::std::list< srp< ss_statement > >  liststmt;
typedef  ::lestes::std::list< srp< ss_label > >  listlbl;
typedef  ::lestes::std::list< srp< ss_expression > >  listexpr;
typedef  ::lestes::std::list< srp< ss_se > >  listse;
typedef  ::lestes::std::list< srp< ss_sp > >  listsp;


ptr<ss_sp> sp13= ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp12= ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp11= ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp10= ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp9 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,1);
ptr<ss_sp> sp8 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,1);
ptr<ss_sp> sp7 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp6 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp5 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp4 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp3 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp2 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);
ptr<ss_sp> sp1 = ss_sp::create(NULL,NULL,NULL,listse::create(),listse::create(),NULL,0);


ptr<ss_decl_seq> ds1 = ss_decl_seq::root_instance();
/* commented out by Rudo
ptr<ss_decl_seq> ds1 = ss_decl_seq::create(
                NULL,   //location
                listdecl::create(),     //decl_seq
                NULL,   //parent
                NULL,   //compound
                NULL,   //using dir
                NULL    //declaration
        );
*/

ptr<ss_compound_stmt> cs1 = ss_compound_stmt::root_instance();
/* commented out by Rudo
ptr<ss_compound_stmt> cs1 = ss_compound_stmt::create(
                NULL,   //location
                listlbl::create(),      //labels
                NULL,   //parent
                NULL,   //psp
                NULL,   //nsp
                listsp::create(),       //sps
                NULL,   //decl
                liststmt::create()      //statements
                        );
*/
                        
ptr<ss_function_declaration> fd1 = ss_function_declaration::create(
        NULL,   //loc
        ss_declaration_time::create(0), //visible
        ss_declaration_time::create(0), //declt time
        NULL,   //name
        NULL,   //contain scope
        NULL,   //type
        NULL,   //linkage
        NULL,   //params
        NULL    //body
        //false,        //pure virtual
        //false,        //virtuality
        //false         //ellipsis
        );

ptr<ss_ordinary_name> on1 = ss_ordinary_name::create(NULL,"main");

ptr<ss_type> sint = ss_type_sint::instance();

ptr<ss_function> tfun1 = ss_function::create(sint,listtype::create(),false);

ptr<ss_decl_seq> ds3 = ss_decl_seq::create(NULL,listdecl::create(),ds1,NULL,NULL,NULL);

ptr<ss_decl_seq> ds2 = ss_decl_seq::create(NULL,listdecl::create(),ds3,NULL,NULL,NULL);

ptr<ss_compound_stmt> cs3 = ss_compound_stmt::create(NULL,listlbl::create(),cs1,NULL,NULL,listsp::create(),ds3,liststmt::create(),NULL);

ptr<ss_compound_stmt> cs2 = ss_compound_stmt::create(NULL,listlbl::create(),cs3,sp1,sp7,listsp::create(),ds2,liststmt::create(),sp6);

ptr<ss_decl_stmt> dst1 = ss_decl_stmt::create(NULL,listlbl::create(),cs2,sp2,sp3,listsp::create(),NULL,listexpr::create(),NOINIT);

ptr<ss_object_declaration> od1 = ss_object_declaration::create(NULL,ss_declaration_time::create(0),ss_declaration_time::create(0),NULL,NULL,sint,NULL,ss_declaration_time::infinity(),NULL);

ptr<ss_ordinary_name> on2 = ss_ordinary_name::create(NULL,"i");

ptr<ss_expr_stmt> est1 = ss_expr_stmt::create(NULL,listlbl::create(),NULL,sp4,sp5,listsp::create(),NULL);

ptr<ss_assign> as1 = ss_assign::create(NULL,sint,sp4,sp5,NULL,NULL);

ptr<ss_se> ase1 = ss_se::create(NULL,NULL,sp4,sp5);

ptr<ss_var_ref> var1 = ss_var_ref::create(NULL,sint,sp4,sp5,NULL);

ptr<ss_literal_info> linfo1 = ss_integral_literal_info::create(sint,"1");

ptr<ss_literal> lit1 = ss_literal::create(NULL,sint,sp4,sp5,NULL); 

ptr<ss_decl_stmt> dst2 = ss_decl_stmt::create(NULL,listlbl::create(),cs1,NULL,NULL,listsp::create(),NULL,listexpr::create(),NOINIT);

ptr< ss_se > fse2 = ss_se::create(NULL,NULL,sp8,sp9);

ptr< ss_funcall > fc1 = ss_funcall::create(NULL,sint,sp8,sp9,listexpr::create(),NULL);

ptr<ss_expr_stmt> est2 = ss_expr_stmt::create(NULL,listlbl::create(),cs2,sp6,sp7,listsp::create(),NULL);





ptr<ss_decl_stmt> dst3 = ss_decl_stmt::create(NULL,listlbl::create(),cs3,NULL,NULL,listsp::create(),NULL,listexpr::create(),NOINIT);

ptr< ss_parameter_declaration > dpar1 = ss_parameter_declaration::create(NULL,ss_declaration_time::create(0),ss_declaration_time::create(0),NULL,NULL,sint,NULL,ss_access_specifier::ACCESS_PUBLIC,ss_storage_class::ST_NONE,ss_declaration_time::infinity(),NULL,0);

ptr< ss_ordinary_name > on3 = ss_ordinary_name::create(NULL,"j");

ptr< ss_get > get1 = ss_get::create(NULL,sint,sp8,sp9,NULL);

ptr< ss_var_ref > var2 = ss_var_ref::create(NULL,sint,sp6,sp8,NULL);

ptr< ss_fake_declaration > fake1 = ss_fake_declaration::create(NULL,ss_declaration_time::create(0),ss_declaration_time::create(0),NULL,NULL,sint,NULL,ss_access_specifier::ACCESS_PUBLIC,ss_storage_class::ST_NONE,NULL);

ptr< ss_compound_stmt_declaration > csd1 = ss_compound_stmt_declaration::create(NULL,ss_declaration_time::create(0),ss_declaration_time::create(0),NULL,NULL,NULL,NULL,cs2);


ptr< ss_get > get2 = ss_get::create(NULL,sint,sp10,sp11,NULL);

ptr< ss_var_ref > var3 = ss_var_ref::create(NULL,sint,sp10,sp11,NULL);

ptr< ss_return > ret1 = ss_return::create(NULL,NULL,cs2,sp10,sp11,listsp::create(),NULL);

ptr< ss_get > get3 = ss_get::create(NULL,sint,sp10,sp11,NULL);

ptr< ss_var_ref > var4 = ss_var_ref::create(NULL,sint,sp10,sp11,NULL);

ptr< ss_add > add1 = ss_add::create(NULL,sint,sp10,sp11,NULL,NULL);

ptr< ss_linkage > link1 = ss_linkage::create("C",ss_linkage::LINKAGE_EXTERNAL);

//**************************************************************************************************************************

//Rudo: tu->global_scope_set(ds1);

tfun1->params_get()->push_back(sint);

ds1->contents_get()->push_back(fd1);
//Rudo: ds1->compound_stmt_set(cs1);

//Rudo: cs1->decl_seq_set(ds1);
cs1->statements_get()->push_back(dst2);

//Rudo: dst2->parent_set(cs1);
dst2->decl_set(fd1);

fd1->name_set(on1);
fd1->type_set(tfun1);
fd1->body_set(cs2);
fd1->contained_in_set(ds1);
fd1->parameters_set(ds3);
fd1->linkage_set(link1);

//Rudo: cs2->parent_set(cs1);
//Rudo: cs2->decl_seq_set(ds2);
cs2->statements_get()->push_back(dst1);
cs2->statements_get()->push_back(est1);
cs2->statements_get()->push_back(est2);
cs2->statements_get()->push_back(ret1);


//Rudo: ds2->parent_set(ds1);
ds2->compound_stmt_set(cs2);
ds2->contents_get()->push_back(fake1);
ds2->contents_get()->push_back(od1);
ds2->declared_by_set(csd1);

//Rudo: dst1->parent_set(cs2);
dst1->decl_set(od1);

od1->contained_in_set(ds2);
od1->name_set(on2);

est1->expression_set(as1);
est1->sequence_points_get()->push_back(sp4);
est1->sequence_points_get()->push_back(sp5);

as1->left_set(var1);
as1->right_set(lit1);
//as1->side_effect_set(ase1);

ase1->from_set(as1);

var1->var_decl_set(od1);

lit1->value_set(linfo1);

est2->expression_set(fc1);
est2->sequence_points_get()->push_back(sp6);
est2->sequence_points_get()->push_back(sp7);
est2->sequence_points_get()->push_back(sp8);
est2->sequence_points_get()->push_back(sp9);

fc1->function_set(fd1);
fc1->args_get()->push_back(get1);

fse2->from_set(fc1);



ds3->compound_stmt_set(cs3);
ds3->contents_get()->push_back(dpar1);
ds3->declared_by_set(fd1);

cs3->statements_get()->push_back(dst3);

dst3->decl_set(dpar1);

dpar1->name_set(on3);
dpar1->contained_in_set(ds3);

get1->expr_set(var2);

var2->var_decl_set(fake1);

fake1->real_decl_set(dpar1);
fake1->name_set(on3);
fake1->contained_in_set(ds2);


get2->expr_set(var3);

var3->var_decl_set(fake1);

ret1->result_set(add1);
ret1->sequence_points_get()->push_back(sp10);
ret1->sequence_points_get()->push_back(sp11);

get3->expr_set(var4);

var4->var_decl_set(fake1);

add1->left_set(get2);
add1->right_set(get3);


                  sp1->nsp_set(sp2);
sp2->psp_set(sp1);sp2->nsp_set(sp3);
sp3->psp_set(sp2);sp3->nsp_set(sp4);
sp4->psp_set(sp3);sp4->nsp_set(sp5);sp4->nse_get()->push_back(ase1);
sp5->psp_set(sp4);sp5->nsp_set(sp6);sp5->pse_get()->push_back(ase1);
sp6->psp_set(sp5);sp6->nsp_set(sp7);
sp7->psp_set(sp6);sp7->nsp_set(sp10);
sp8->psp_set(sp6);sp8->nsp_set(sp9);sp8->nse_get()->push_back(fse2);
sp9->psp_set(sp8);sp9->nsp_set(sp7);sp9->pse_get()->push_back(fse2);
sp10->psp_set(sp7);sp10->nsp_set(sp11);
sp11->psp_set(sp10);sp11->nsp_set(sp12);
sp12->psp_set(sp11);sp12->nsp_set(sp13);
sp13->psp_set(sp12);



                        //FIXME chybi vyplnene filedy ss.statement.sequence-points

::std::ofstream f("example1.xml");
dumper::dump( f, tu );
f.close();

ss2pi_start(tu);
summary_seq_points(sp1);
lestes::backend::backend::create(::std::cout)->main();

return 1;
}//man

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::methods_not_implemented

(

::lestes::msg::message_stencil0< bool >::

create("method declarations are not implemented",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil1< ptr< as_id > > > lestes::lang::cplus::sem::name_already_declared

(

::lestes::msg::message_stencil1< ptr< as_id > >::

create("name already declared when trying to define namespace '%0'",::lestes::msg::message::FLG_ERROR,::lestes::msg::formatter< ptr< as_id > >::instance())

)

[7.3.1/2]

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::no_viable_found

(

::lestes::msg::message_stencil0< bool >::

create("Found no viable function to call",::lestes::msg::message::FLG_ERROR)

)

Issued when the overload resolution process doesn't find any viable function.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::non_lval_assign

(

::lestes::msg::message_stencil0< bool >::

create("Non-lvalue used in assign.",::lestes::msg::message::FLG_ERROR)

)

Issued when the left argument of assign was not lvalue.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::non_lval_crement

(

::lestes::msg::message_stencil0< bool >::

create("Non-lvalue used in increment/decrement.",::lestes::msg::message::FLG_ERROR)

)

Issued when the argument of (postfix/prefix) increment/decrement was not lvalue.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::non_lvalue_in_unary_amp

(

::lestes::msg::message_stencil0< bool >::

create("Non-lvalue used in unary &",::lestes::msg::message::FLG_ERROR)

)

Issued when rvalue is used as argument to unary amp, which accepts only lvalues.

ptr< or_ics_functional > lestes::lang::cplus::sem::or_find_ics	(	ptr< or_or_functional >	source,
		ptr< ss_type >	target
	)

This is the main function called by outside world - used to find implicit conversion sequence between source and target. It fires up visitor, depending on the source type, which then constructs the conversion sequence. TODO: if the source expression is funcall && to vraci rval (neni referencni) potom identita je get (rank IDENTITY)

Returns:

expression representing the implicit conversion sequence

Definition at line 266 of file or_ics.cc.

References filter_type(), llog, OR_CV_PSEUDOREFERENCE, and RANK_EXACT.

Referenced by lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_bin_op_nosideeff(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_bin_op_nosideeff_arith(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_bin_op_nosideeff_newsp(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_crement(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_equal_sideeff(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_un_op_nosideeff(), exists_ics_conversion(), and is_better_function().

{
        typedef ::lestes::std::list< srp< or_ics_functional > > funclist;

        llog(or_ics_log) << "Entering or_find_ics()\n";

        ptr< funclist > scs_tgts_seq = funclist::create();
        ptr< funclist > scs_srcs_seq = funclist::create();
        ptr< funclist > filtered_list;
        
        ptr< or_ics_visitor_tgts > v_t = or_ics_visitor_tgts::create(source, 1, scs_tgts_seq);
        ptr< or_ics_functional > best_conv;
        
        ptr< funclist > scs_imaginable_tgts, scs_imaginable_srcs;
        
        /* this finds all SCS-imaginable types for source type. It can remember the phase 
         * so calling it three times causes multiple phases to be called.
         */

        llog(or_ics_log) << "Executing first phase\n";
        scs_imaginable_tgts = source->type_get()->accept_or_ics_base(v_t);

        /* the pseudoreference performs the recursion itself, so we must not to run it here again */
        ptr< or_ics_visitor_cv > v = or_ics_visitor_cv::create(); 
        if(source->type_get()->accept_or_ics_base_cv(v) != OR_CV_PSEUDOREFERENCE) {
                /* for non-pseudoreferences, the identity is handled here */
                ptr< ss_type > type1 = source->type_get();
                ptr< or_ics_functional_for_std_conversion > conversion1 = or_ics_functional_for_std_conversion::create(RANK_EXACT, type1);
                scs_tgts_seq->push_back(conversion1);
                
                llog(or_ics_log) << "Source is not pseudoreference, executing second and third phases\n";
                scs_imaginable_tgts = source->type_get()->accept_or_ics_base(v_t);
                scs_imaginable_tgts = source->type_get()->accept_or_ics_base(v_t);
        }
                
        llog(or_ics_log) << "Found " << scs_imaginable_tgts->size() << " imaginable target types\n";
        
        /* for each element of the target, 
         * - if the imaginable tgt is builtin type, lookup is performed and user-defined conversions (by constructor)
         * possible and create list of pairs {l1, u1}, where l1\elem scs_imaginable_tgts and
         * u1 \elem user_defined_conversions from type l1 
         *
         * - if the imaginable tgt is class (and therefore the source was also class and the conversion
         * was just derived-to-base standard conversion), it is now neccessary to search for user-defined
         * conversion functions, generate appropriate conversion by this conversion function, and continue
         * with generating 'left' part of the ICS
         * 
         * this is TODO
         */
        
        /* filter out those not having the type of target */

        filtered_list = filter_type(scs_imaginable_tgts, target);
        
        llog(or_ics_log) << "After filtering " << filtered_list->size() << " left\n";
        
        /* now get the best conversion from those remaining in the list.
         * this will be more useful as soon as user-def conversions come
         * on scene. 
         *
         * Just for now, not having user types and user conversions 
         * so far, return the first from filtered_list (if we are
         * in builtin type situation, there should be just one anyway).
         * 
         * this is TODO FIXME as long as we are going to handle user types and conversions
         */
//      best_conv = get_best_conversion(filtered_list, source);
//      return best_conv;       
        
        if (filtered_list->size() > 0) 
                return filtered_list->front();
        else
                return NULL;
}

ptr< or_or_functional > lestes::lang::cplus::sem::overload_resolution	(	ptr< exprlist >	exprs,
		ptr< func_decl_set >	candidates
	)

This is the main function performing overload resolution algorithm. It differs from the previous one in the sense of how it is collecting candidates - this one receives candidates from "upstream" and then just (will one day) performs Koenig lookup, but the set of candidates is given and not obtained using lookup.

This is used in the case of sa_deconstruct_spse::visit_as_expression_function_call, for distinguisging the function prefix. See the apropriate comment in there

Bug:

Koenig lookup not ready yet

Returns:

functional representing the best selected overloaded function

Definition at line 360 of file or.cc.

References best_selection(), and select_viable().

{
        ptr< func_decl_set > viable_candidates = select_viable(candidates, exprs);

        return best_selection(viable_candidates, exprs);
}

ptr< or_or_functional > lestes::lang::cplus::sem::overload_resolution	(	ptr< exprlist >	exprs,
		ptr< ss_operator>	func_name
	)

This is the main function performing overload resolution algorithm. It first collects candidates (performs lookup for function name), selects viable functions from these candidates, and then returns best of the viable functions found

Bug:

Koenig lookup not ready yet

Returns:

functional representing the best selected overloaded function

Definition at line 313 of file or.cc.

References best_selection(), collect_candidates(), llog, and select_viable().

Referenced by lestes::lang::cplus::sem::sa_deconstruct_spse::construct_bin_op(), lestes::lang::cplus::sem::sa_deconstruct_spse::construct_unary_op_create(), and lestes::lang::cplus::sem::sa_deconstruct_spse::construct_unary_op_nocreate().

{
        /* search func_name in current context & associated namespaces (exprs) */
        /* Rudo will search according to decl_seq and decl_name and returns 
         * collection ss_declarations (will have to be dncasted to ss_function_delcaration
         */

        ptr< ss_decl_seq > ctxt = sa_context_manager::instance()->current()->ss_get()->scope_get();

        llog(or_log) << "Before collect candidates\n";

        ptr< func_decl_set > candidates = collect_candidates(func_name, ctxt);

        llog(or_log) << "Done, selected " << candidates->size() <<  " candidates\n";

        ptr< func_decl_set > viable_candidates = select_viable(candidates, exprs);

        llog(or_log) << "After viable candidates selection, selected " << viable_candidates->size() << " viable\n";
        
        /* if no viable functions were found, look if it is not the case of 'there exists builtin
         * declaration for every type', which is ',' and some others. See [13.6] and [13.3] for more
         * details.
         *
         * In such case, add the declaration of given ss_operator with current parameters to the decl_seq. 
         * This is immediate TODO, just after a few tests.
         */
        if (viable_candidates->size() == 0) {
                return NULL;
        }
        return best_selection(viable_candidates, exprs);
}

ptr< pi_mem > lestes::lang::cplus::sem::pi_operand2pi_mem

(

ptr< pi_operand >

x

)

Converts returned result from expression visitor for requested type. TODO: reformulate dncast via visitors on pi_operand structures

Definition at line 208 of file ss_ss2pi_base.cc.

Referenced by lestes::lang::cplus::sem::ss_expr2pi::returns_mem().

                                                   {
        
        ptr<pi_mem>p = x.dncast<pi_mem>();
        return p;
}

ptr< pi_mem_ptr_deref > lestes::lang::cplus::sem::pi_operand2pi_mem_pointer

(

ptr< pi_operand >

x

)

Converts returned result from expression visitor for requested type. TODO: reformulate dncast via visitors on pi_operand structures

Definition at line 218 of file ss_ss2pi_base.cc.

Referenced by lestes::lang::cplus::sem::ss_expr2pi::returns_mem_pointer().

                                                                     {
        
        ptr<pi_mem_ptr_deref>p = x.dncast<pi_mem_ptr_deref>();
        return p;
}

ptr< pi_preg > lestes::lang::cplus::sem::pi_operand2pi_preg

(

ptr< pi_operand >

x

)

Converts returned result from expression visitor for requested type. TODO: reformulate dncast via visitors on pi_operand structures

Definition at line 228 of file ss_ss2pi_base.cc.

Referenced by lestes::lang::cplus::sem::ss_expr2pi::returns_preg().

                                                     {

        ptr<pi_preg>p = x.dncast<pi_preg>();
        return p;
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::previous_declaration

(

::lestes::msg::message_stencil0< bool >::

create("previously declared here",::lestes::msg::message::FLG_ERROR)

)

void lestes::lang::cplus::sem::process_friend_function_declaration	(	ptr< sa_context >	ctx,
		ptr< sa_declaration_specifiers >	specifiers,
		ptr< as_declarator >	declarator
	)

Definition at line 467 of file sa_simple_declaration.cc.

References lassert.

{
        lassert(ctx && specifiers && declarator);
        lassert(false);
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::redeclaration_different

(

::lestes::msg::message_stencil0< bool >::

create("redeclaration as different kind of symbol",::lestes::msg::message::FLG_ERROR)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::redefinition

(

::lestes::msg::message_stencil0< bool >::

create("redefinition of object",::lestes::msg::message::FLG_ERROR)

)

void lestes::lang::cplus::sem::run

(

void

)

Definition at line 50 of file sa_class_creation.test.cc.

References lestes::std::dumper::dump(), and loc.

{
        /* these are conceivably comming from the context */
        ptr < source_location > loc = source_location::create(file_info::create("",NULL),1,1);
        ptr < ss_compound_stmt > parent_stmt = ss_compound_stmt::root_instance();
        ptr < ss_decl_seq > parent_scope = ss_decl_seq::root_instance();
        ss_access_specifier::type access_specifier = ss_access_specifier::ACCESS_PUBLIC;
        

        /* these could be comming from the handled thing */
        /* their form is not fixed. they might come in different flavor */
        ptr < ss_decl_name > name = ss_ordinary_name::create(loc, "name_of_the_class");
        ptr < ::lestes::std::list < srp < ss_base_specifier > > > base_class_list = ::lestes::std::list < srp < ss_base_specifier > >::create();

        /* these are the ``true'' local variables */

        ptr < pair < srp < ss_decl_seq >, srp < ss_compound_stmt > > > p = sa_decl_seq_compound_pair_creator::instance()->process(loc, parent_scope, parent_stmt);

        ptr < ss_decl_seq > decl_seq = p->first;
        ptr < ss_compound_stmt > stmt = p->second;


        ptr < ss_class > a_class = ss_class::create(
                        decl_seq, /* members */
                        ss_decl_seq::root_instance()->declared_by_get(), /* declaration */
                        // FIXME more complicated approach needed
                        // to handle the POD requirements wrt/ to base classes
                        true, /* POD */
                        ss_declaration_time::infinity(), /* completition time */
                        base_class_list /* bases */
                        /* descendants */
                        );



        ptr < ss_structure_declaration > class_decl = ss_structure_declaration::create(
                        loc, // location
                        ss_declaration_time::create(loc->order_get()), // visible
                        ss_declaration_time::create(loc->order_get()), // decl time
                        name, //name
                        parent_scope, // contained in
                        a_class, // type
                        ss_linkage::create("C++", ss_linkage::LINKAGE_EXTERNAL), // linkage
                        // FIXME: lookup needed here:
                        access_specifier, // access specifier
                        ss_storage_class::ST_NONE, // storage class
                        ::lestes::std::set< srp< ss_struct_base > >::create(), // friends
                        decl_seq
                        );

        ptr < ss_injected_class_declaration > class_decl_alias = ss_injected_class_declaration::create(
                        loc, // location
                        ss_declaration_time::create(loc->order_get()), // visible
                        ss_declaration_time::create(loc->order_get()), // decl time
                        name, //name
                        parent_scope, // contained in
                        a_class, // type
                        ss_linkage::create("C++", ss_linkage::LINKAGE_EXTERNAL), // linkage
                        ss_access_specifier::ACCESS_PUBLIC, // access specifier
                        ss_storage_class::ST_NONE, // storage class
                        class_decl // real class
                        );

        /* fill 'em with THE RIGHT values */
        a_class->decl_set(class_decl);
        decl_seq->declared_by_set(class_decl);
        decl_seq->contents_get()->push_back(class_decl_alias);
        parent_scope->contents_get()->push_back(class_decl);

        ::std::ofstream f("sa_class_creation.test.xml");
	::lestes::std::dumper::dump(f, a_class);
        f.close();
        //lassert2(false, "AAAAAAAAAAAAAAAAAAAAAAA");
        //lassert2(false, "BBBBBBBBBBBBBBBBBBBBBBB");
}

int lestes::lang::cplus::sem::run_test

(

)

Definition at line 38 of file ss_decl_name_matcher.test.cc.

References lassert.

Referenced by main().

{
        ptr<source_location> l = source_location::create(file_info::create("",NULL),1,1);
        ptr<source_location> ll = source_location::create(file_info::create("",NULL),2,3);

        ptr<ss_decl_name> nvoid1 = ss_conversion_name::create( l, ss_void::instance() );
        ptr<ss_decl_name> nvoid2 = ss_conversion_name::create( ll, ss_void::instance() );
        ptr<ss_decl_name> nsint = ss_conversion_name::create( ll, ss_type_sint::instance() );

        ptr<ss_decl_name> dummy = ss_dummy_name::create( ll );

        ptr<ss_decl_name> ord1 = ss_ordinary_name::create( l, "name" );
        ptr<ss_decl_name> ord2 = ss_ordinary_name::create( ll, "name" );
        ptr<ss_decl_name> ordx = ss_ordinary_name::create( ll, "x" );

        ptr<ss_decl_name> nopbe1 = ss_operator_sbe::create( l );
        ptr<ss_decl_name> nopbe2 = ss_operator_sbe::create( ll );
        ptr<ss_decl_name> nopbg = ss_operator_sbg::create( ll );

        lassert( nvoid1->matches(nvoid2) );
        lassert( nvoid2->matches(nvoid1) );
        lassert( !nvoid1->matches(nsint) );

        lassert( !dummy->matches(dummy) );

        lassert( ord1->matches(ord2) );
        lassert( ord2->matches(ord1) );
        lassert( ordx->matches(ordx) );
        lassert( !ord1->matches(ordx) );

        lassert( nopbe1->matches(nopbe2) );
        lassert( nopbe2->matches(nopbe1) );
        lassert( !nopbe2->matches(nopbg) );

        lassert( !dummy->matches(nopbg) );
        lassert( !ord1->matches(nsint) );
        lassert( !nopbe1->matches(nvoid1) );

        return 0;
}

void lestes::lang::cplus::sem::sa_decl_spec_test

(

void

)

Tests sa_decl_spec class.

Performs testing of sa_decl_spec class.

Definition at line 63 of file sa_decl_spec.test.cc.

References lassert, lassert_no_specifiers, and loc.

Referenced by main().

{
        ptr<file_info> fi = file_info::create("abc",NULL);
        ptr<source_location> loc = source_location::create(fi,1,1);
        typedef sa_decl_spec::as_decl_spec_list_type ds_list_type;
        
        ptr<ds_list_type> dsl = ds_list_type::create();
        ptr<sa_decl_spec_context> ctx =
                sa_decl_spec_context::create(declaration_context::CTX_NAMESPACE);
        ptr<sa_decl_spec> sads = sa_decl_spec::create(ctx);
                
        dsl->push_back(as_int_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_sint::instance());
        lassert_no_specifiers(sads);
        dsl->clear();

        dsl->push_back(as_unsigned_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_uint::instance());
        lassert_no_specifiers(sads);
        dsl->clear();

        dsl->push_back(as_short_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_sshort::instance());
        lassert_no_specifiers(sads);
        dsl->clear();

        dsl->push_back(as_int_simple_type_specifier::create(loc));
        dsl->push_back(as_long_simple_type_specifier::create(loc));
        dsl->push_back(as_unsigned_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_ulong::instance());
        lassert_no_specifiers(sads);
        dsl->clear();
        
        dsl->push_back(as_char_simple_type_specifier::create(loc));
        dsl->push_back(as_unsigned_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_uchar::instance());
        lassert_no_specifiers(sads);
        dsl->clear();
        
        dsl->push_back(as_char_simple_type_specifier::create(loc));
        dsl->push_back(as_signed_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_schar::instance());
        lassert_no_specifiers(sads);
        dsl->clear();
        
        dsl->push_back(as_char_simple_type_specifier::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_type_pchar::instance());
        lassert_no_specifiers(sads);
        dsl->clear();

        dsl->push_back(as_int_simple_type_specifier::create(loc));
        dsl->push_back(as_cv_qualifier_const::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() == ss_const::instance(ss_type_sint::instance()));
        lassert_no_specifiers(sads);
        dsl->clear();

        lassert(ss_const::instance(ss_volatile::instance(ss_type_sint::instance())) ==
                ss_const::instance(ss_volatile::instance(ss_type_sint::instance())));
                
        lassert(ss_const::instance(ss_volatile::instance(ss_type_sint::instance())) ==
                ss_volatile::instance(ss_const::instance(ss_type_sint::instance())));
                
        dsl->push_back(as_int_simple_type_specifier::create(loc));
        dsl->push_back(as_cv_qualifier_const::create(loc));
        dsl->push_back(as_cv_qualifier_volatile::create(loc));
        sads->process(dsl);
        lassert(sads->type_get() ==
                ss_const::instance(ss_volatile::instance(ss_type_sint::instance())));
        lassert_no_specifiers(sads);
        dsl->clear();

}

void lestes::lang::cplus::sem::sa_declarator_test

(

void

)

Tests sa_declarator class.

Performs testing of sa_declarator class.

Definition at line 58 of file sa_declarator.test.cc.

References loc.

Referenced by main().

{
        ptr<file_info> fi = file_info::create("abc",NULL);
        ptr<source_location> loc = source_location::create(fi,1,1);

#if 0
        ptr<ss_sp> psp = ss_sp::create(
                loc,
                NULL, // a__ss_sp__psp,
                NULL, //  a__ss_sp__nsp,
                ::lestes::std::list< srp< ss_se > >::create(),  //  a__ss_sp__pse,
                ::lestes::std::list< srp< ss_se > >::create(),  //  a__ss_sp__nse,
                NULL, // ptr< ::lestes::backend::intercode::pi_sp >   a__ss_sp__pi_spe,
                0    //ulint    a__ss_sp__level
                );
                
        ptr<ss_sp> nsp = ss_sp::create(
                loc,
                NULL, // a__ss_sp__psp,
                NULL, //  a__ss_sp__nsp,
                ::lestes::std::list< srp< ss_se > >::create(),  //  a__ss_sp__pse,
                ::lestes::std::list< srp< ss_se > >::create(),  //  a__ss_sp__nse,
                NULL, // ptr< ::lestes::backend::intercode::pi_sp >   a__ss_sp__pi_spe,
                0    //ulint    a__ss_sp__level
                );
                
        ptr<ss_compound_stmt> containing_compound =
                ss_compound_stmt::create(
                        loc, // ptr< ::lestes::std::object >      a__ss_base_with_location__location,
                        ::lestes::std::list< srp< ss_label > >::create(), //   a__ss_statement__labels,
                        NULL, // a__ss_statement__parent,
                        psp, // a__ss_statement__psp,
                        nsp, // a__ss_statement__nsp,
                        ::lestes::std::list< srp< ss_sp > >::create(), // a__ss_statement__sequence_points,
                        NULL,     // ptr< ss_decl_seq >,  a__ss_compound_stmt__decl,
                        ::lestes::std::list< srp< ss_statement > >::create() // statements
                        );
        
        ptr<ss_decl_seq> containing_scope = ss_decl_seq::create(
                        loc,
                        ::lestes::std::list< srp< ss_declaration > >::create(), // a__ss_decl_seq__declarations
                        NULL, //ptr< ss_decl_seq > a__ss_decl_seq__parent
                        containing_compound, //ptr< ss_compound_stmt > a__ss_decl_seq__compound_stmt
                        ::lestes::std::list< srp< ss_using_directive > >::create(), // using directives
                        NULL //   ptr< ss_declaration >       a__ss_decl_seq__declared_by         
                        );
#endif

        ptr<ss_compound_stmt> containing_compound = ss_compound_stmt::root_instance();
        ptr<ss_decl_seq> containing_scope = ss_decl_seq::root_instance();
        
        typedef sa_declarator_context::as_decl_spec_list_type ds_list_type;
        
        ptr<ds_list_type> dsl = ds_list_type::create();
        ptr<sa_decl_spec_context> sadsc =
                sa_decl_spec_context::create(declaration_context::CTX_NAMESPACE);
        ptr<sa_decl_spec> sads = sa_decl_spec::create(sadsc);
        dsl->push_back(as_int_simple_type_specifier::create(loc));
        sads->process(dsl);

        typedef ::lestes::std::list< srp<as_cv_qualifier> > as_cv_qualifier_list;
        ptr<as_cv_qualifier_list> ascvql = as_cv_qualifier_list::create();
        ascvql->push_back(as_cv_qualifier_const::create(loc));
        
        ptr<as_ptr_op_star> aspos = as_ptr_op_star::create(loc,ascvql);
        
        typedef ::lestes::std::list< srp<as_declarator_op> > as_declarator_op_list;
        ptr<as_declarator_op_list> asdol = as_declarator_op_list::create();
        asdol->push_back(aspos);
        
        ptr<as_name> asn = as_name::create(
                        loc,
                        as_name::create(loc, NULL,as_global_namespace_fake_id::create(loc),false),
                        as_global_namespace_fake_id::create(loc),
                        true);
        
        ptr<as_declarator> asd = as_declarator::create(
                        loc,
                        asn,
                        asdol
                        );

        ptr<sa_declarator_context> sadc =
                sa_declarator_context::create(
                                declaration_context::CTX_NAMESPACE,
                                containing_scope,
                                sads);
        ptr<sa_declarator> sad = sa_declarator::create(sadc);
        sad->process(asd);

}

ptr< func_decl_set > lestes::lang::cplus::sem::select_viable	(	ptr< func_decl_set >	candidates,
		ptr< exprlist >	exprs
	)

This function returns the viable functions for overload resolution - those functions are those having correct number of arguments && those for which's parameters implicit conversion sequence from expressions to function parameters exists.

Returns:

set of viable functions

Definition at line 160 of file or.cc.

References filter_ics_existence(), filter_num_args(), and llog.

Referenced by overload_resolution().

{
        llog(or_log) << "Filtering according to num of arguments\n";

        ptr< func_decl_set > enough_arg_funcs = filter_num_args(candidates, exprs->size());

        llog(or_log) << "Selected " << enough_arg_funcs->size() << " enough-arg funcs\n";

        return filter_ics_existence(enough_arg_funcs, exprs);
}

void lestes::lang::cplus::sem::ss2pi_start

(

ptr< ss_translation_unit >

x

)

Main entry point for ss2pi transformation.

Definition at line 190 of file ss_ss2pi_base.cc.

References entry, and outry.

Referenced by lestes::lang::cplus::syn::do_it(), and man().

                                              {entry("start");

        //      dumb(x);        //To mantain constant numbers for structures in dumps
              
        ptr< variable_map_type > namespace_variable_map = variable_map_type::create();  //namespace-scope map
        
        ptr< ss_stmt2pi > stmt_visitor =                        //new visitor - new destructor list has to be created
                ss_stmt2pi::create( NULL, NULL, namespace_variable_map );
        
        x->global_scope_get()->compound_stmt_get()->accept_ss_statement_visitor(stmt_visitor);
        
outry("start");
}

ptr<::lestes::backend_v2::intercode::pi_sp > lestes::lang::cplus::sem::ss_sp2pi_sp

(

ptr< ss_sp >

sp

)

Definition at line 308 of file ss_ss2pi_base.cc.

References lestes::msg::eolog, and plog.

Referenced by lestes::lang::cplus::sem::ss_destructor_tables_stack::back_roll_from_current_compound_stmt(), summary_seq_points(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_address_of(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_assign(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_bind_reference(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_conversion(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_funcall(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_get(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_literal(), lestes::lang::cplus::sem::ss_expr2pi::visit_ss_var_ref(), and lestes::lang::cplus::sem::ss_expr2pi::visit_ss_vol_get().

                                          {
        
        if (sp->pi_spe_get()) return sp->pi_spe_get();                          //already constructed
        
        ptr< pi_sp > empty = NULL;
        
        ptr<pi_sp> tmp = pi_sp::create (NULL,NULL,sp->level_get());     //Dont mix ordering of commands below !
        
        sp->pi_spe_set(tmp);
        
        if (sp->psp_get()) tmp->psp_set(ss_sp2pi_sp(sp->psp_get()));            //recursion
        if (sp->nsp_get()) tmp->nsp_set(ss_sp2pi_sp(sp->nsp_get()));
        
        plog(spl) << "  SP: ss " <<sp->uid_get() <<" -> pi " << tmp->uid_get() << "\n" << eolog;
        
        ptr<backend_data_builder> initial_structure_builder = backend_data_builder::instance();
        initial_structure_builder->add_sp(tmp);         //backend shall know about constructed sequnce point

        return tmp;
}

void lestes::lang::cplus::sem::ss_type2info_test

(

void

)

Tests ss_type2info class.

Performs testing of ss_type2info class.

Definition at line 51 of file ss_type2info.test.cc.

References lassert.

Referenced by main().

{
        ptr<ss_type2info> ssti = ss_type2info::create();
        ptr<ss_type> sint = ss_type_sint::instance();
        ptr<ss_type> st;
        
        st = sint;
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::UNKNOWN);
        
        st = ss_const::instance(sint);
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::SS_CONST);

        st = ss_volatile::instance(sint);
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::SS_VOLATILE);

        st = ss_const::instance(ss_volatile::instance(sint));
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::SS_CONST_VOLATILE);

        st = ss_pointer::instance(sint);
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::SS_POINTER);

        st = ss_member_pointer::instance(sint,sint);
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::SS_MEMBER_POINTER);

        st = ss_reference::instance(sint);
        st->accept_ss_type_visitor(ssti);
        lassert(ssti->info_get() == ss_type2info::SS_REFERENCE);
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::static_and_extern

(

::lestes::msg::message_stencil0< bool >::

create("declaration is both static and extern",::lestes::msg::message::FLG_ERROR)

)

void lestes::lang::cplus::sem::summary_seq_points

(

ptr< ss_sp >

x

)

Print out top_level sequence points. For debuging purposes.

Definition at line 152 of file ss_ss2pi_base.cc.

References lestes::msg::eolog, plog, and ss_sp2pi_sp().

Referenced by man().

                                       {
 {
        while (x->psp_get()) x=x->psp_get();
        ptr< ss_sp > tmp, tmp2;
        
        for (tmp=x; tmp->nsp_get(); tmp=tmp->nsp_get()){
                plog(spl)<<tmp->uid_get()<<"->";
        }
        plog(spl)<<tmp->uid_get()<<"\n";
        
        for (tmp2=tmp; tmp2->psp_get(); tmp2=tmp2->psp_get()){
                plog(spl)<<tmp2->uid_get()<<"->";
        }
        plog(spl)<<tmp2->uid_get()<<"\n";
 }
 {
        ptr< pi_pi >X = ss_sp2pi_sp(x);
        ptr< pi_pi > tmp, tmp2;
        
        for (tmp=X; tmp->nsp_get(); tmp=tmp->nsp_get()){
                plog(spl)<<tmp->uid_get()<<"->";
        }
        plog(spl)<<tmp->uid_get()<<"\n";
        
        for (tmp2=tmp; tmp2->psp_get(); tmp2=tmp2->psp_get()){
                plog(spl)<<tmp2->uid_get()<<"->";
        }
        plog(spl)<<tmp2->uid_get()<<"\n"<<eolog;
 }
}

ptr< ::lestes::std::list< srp<as_declaration_specifier> > > lestes::lang::cplus::sem::ts2ds

(

ptr< ::lestes::std::list< srp< as_type_specifier > > >

tsl

)

This is helper function for the sizeof type for converting list of type specifiers to declaration specifiers

Definition at line 648 of file sa_deconstruct_spse.cc.

References lestes::lang::cplus::sem::sa_deconstruct_spse::create().

{
        ptr< list< srp<as_declaration_specifier> > > dsl = ::lestes::std::list< srp<as_declaration_specifier> >::create();
        ::std::copy(tsl->begin(),tsl->end(),::std::back_inserter(*dsl));
        return dsl;
}

static ptr<declaration_set_type> lestes::lang::cplus::sem::unify	(	const ptr< declaration_set_type > &	s1,
		const ptr< declaration_set_type > &	s2
	)			[static]

Computes union of two given sets of declarations.

Definition at line 111 of file lu_lu.cc.

Referenced by lestes::lang::cplus::sem::lu_lookup::deep_scan().

{
        ptr<declaration_set_type> result = declaration_set_type::create();
        ::std::set_union( s1->begin(), s1->end(), s2->begin(), s2->end(),
                        ::std::inserter( *result, result->end() ) );
        return result;
}

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::union_shall_not_have_bases

(

::lestes::msg::message_stencil0< bool >::

create("base classes cannot be specified in a union declaration",::lestes::msg::message::FLG_ERROR)

)

Unions shall not have bases. This message reports a violation of this rule.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::unnamed_not_yet

(

::lestes::msg::message_stencil0< bool >::

create("unnamed namespaces are not implemented yet",::lestes::msg::message::FLG_WARNING)

)

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::unrecognized_identifier

(

::lestes::msg::message_stencil0< bool >::

create("Unrecognized identifier.",::lestes::msg::message::FLG_ERROR)

)

Issued when there are was no declaration found for identifier.

---

Variable Documentation

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::ambiguous_function_prefix

The function prefix is ambiguous.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::ambiguous_result

Overload resolution was ambiguous.

Referenced by lestes::lang::cplus::sem::or_or_functional_ambiguous::operator()().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::assign_incompatible_types

Assignment for incompatible types was requested.

Referenced by lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_equal_sideeff().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::conflicting_types

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::conversion_not_found

or_find_ics returned NULL - the conversion sequence could not be found.

ptr< declaration_broadcaster > lestes::lang::cplus::sem::declaration_finished

Definition at line 37 of file declaration_broadcasting.cc.

Referenced by lestes::lang::cplus::sem::sa_statements::instance().

ptr< declaration_broadcaster > lestes::lang::cplus::sem::declaration_finished = declaration_broadcaster::create()

Definition at line 37 of file declaration_broadcasting.cc.

Referenced by lestes::lang::cplus::sem::sa_statements::instance().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::declaration_without_type

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::declared_here

Referenced by lestes::lang::cplus::sem::sa_namespace_definition::process_named().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::different_return_types

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::field_redefinition

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::field_storage_specifier

bool lestes::lang::cplus::sem::hack_used = false [static]

Definition at line 42 of file ss_statement.cc.

Referenced by lestes::lang::cplus::sem::ss_statement::parent_set_once_hack().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::incompatible_types_conversion

Conversion between incompatible types was requested.

Referenced by lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_bin_op_nosideeff(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_bin_op_nosideeff_arith(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_bin_op_nosideeff_newsp(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_crement(), lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_equal_sideeff(), and lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_un_op_nosideeff().

ptr< ::lestes::msg::message_stencil1< ucn_string > > lestes::lang::cplus::sem::integer_literal_cannot_be_represented

Integer literal cannot be represented by any type error.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_char_specifier

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_double_specifier

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_specifier_function

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_specifier_object

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_specifier_typedef

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_storage_specifier

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::invalid_type_specifier

int lestes::lang::cplus::sem::log_count = 0

Definition at line 99 of file ss_ss2pi_base.cc.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::methods_not_implemented

ptr< ::lestes::msg::message_stencil1< ptr< as_id > > > lestes::lang::cplus::sem::name_already_declared

Referenced by lestes::lang::cplus::sem::sa_namespace_definition::process_named().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::no_viable_found

No viable function found.

Referenced by lestes::lang::cplus::sem::sa_deconstruct_spse::construct_bin_op(), lestes::lang::cplus::sem::sa_deconstruct_spse::construct_unary_op_create(), lestes::lang::cplus::sem::sa_deconstruct_spse::construct_unary_op_nocreate(), and lestes::lang::cplus::sem::or_or_functional_noviable::operator()().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::non_lval_assign

Non-lvalue was used in assign.

Referenced by lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_equal_sideeff().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::non_lval_crement

Non-lvalue was used increment/decrement.

Referenced by lestes::lang::cplus::sem::or_builtin_operator_expression_creator::construct_op_crement().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::non_lvalue_in_unary_amp

rvalue used in unary amp.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::previous_declaration

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::redeclaration_different

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::redefinition

ptr<ss_decl_seq> lestes::lang::cplus::sem::seq_param [static]

Definition at line 61 of file lu_lu.cc.

Referenced by lestes::lang::cplus::sem::lu_lookup::deep_scan().

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::static_and_extern

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::union_shall_not_have_bases

Union shall not have bases.

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::unnamed_not_yet

ptr< ::lestes::msg::message_stencil0< bool > > lestes::lang::cplus::sem::unrecognized_identifier

Identifier was not found.

---