|
template<> |
bool | can_cast_expr< code_frontend_assignt > (const exprt &base) |
|
void | validate_expr (const code_frontend_assignt &x) |
|
const code_frontend_assignt & | to_code_frontend_assign (const codet &code) |
|
code_frontend_assignt & | to_code_frontend_assign (codet &code) |
|
template<> |
bool | can_cast_expr< code_blockt > (const exprt &base) |
|
const code_blockt & | to_code_block (const codet &code) |
|
code_blockt & | to_code_block (codet &code) |
|
template<> |
bool | can_cast_expr< code_assumet > (const exprt &base) |
|
void | validate_expr (const code_assumet &x) |
|
const code_assumet & | to_code_assume (const codet &code) |
|
code_assumet & | to_code_assume (codet &code) |
|
template<> |
bool | can_cast_expr< code_assertt > (const exprt &base) |
|
void | validate_expr (const code_assertt &x) |
|
const code_assertt & | to_code_assert (const codet &code) |
|
code_assertt & | to_code_assert (codet &code) |
|
template<> |
bool | can_cast_expr< code_skipt > (const exprt &base) |
|
template<> |
bool | can_cast_expr< code_frontend_declt > (const exprt &base) |
|
void | validate_expr (const code_frontend_declt &x) |
|
const code_frontend_declt & | to_code_frontend_decl (const codet &code) |
|
code_frontend_declt & | to_code_frontend_decl (codet &code) |
|
code_blockt | create_fatal_assertion (const exprt &condition, const source_locationt &source_location) |
| Create a fatal assertion, which checks a condition and then halts if it does not hold.
|
|
template<> |
bool | can_cast_expr< code_ifthenelset > (const exprt &base) |
|
void | validate_expr (const code_ifthenelset &x) |
|
const code_ifthenelset & | to_code_ifthenelse (const codet &code) |
|
code_ifthenelset & | to_code_ifthenelse (codet &code) |
|
template<> |
bool | can_cast_expr< code_switcht > (const exprt &base) |
|
void | validate_expr (const code_switcht &x) |
|
const code_switcht & | to_code_switch (const codet &code) |
|
code_switcht & | to_code_switch (codet &code) |
|
template<> |
bool | can_cast_expr< code_whilet > (const exprt &base) |
|
void | validate_expr (const code_whilet &x) |
|
const code_whilet & | to_code_while (const codet &code) |
|
code_whilet & | to_code_while (codet &code) |
|
template<> |
bool | can_cast_expr< code_dowhilet > (const exprt &base) |
|
void | validate_expr (const code_dowhilet &x) |
|
const code_dowhilet & | to_code_dowhile (const codet &code) |
|
code_dowhilet & | to_code_dowhile (codet &code) |
|
template<> |
bool | can_cast_expr< code_fort > (const exprt &base) |
|
void | validate_expr (const code_fort &x) |
|
const code_fort & | to_code_for (const codet &code) |
|
code_fort & | to_code_for (codet &code) |
|
template<> |
bool | can_cast_expr< code_gotot > (const exprt &base) |
|
void | validate_expr (const code_gotot &x) |
|
const code_gotot & | to_code_goto (const codet &code) |
|
code_gotot & | to_code_goto (codet &code) |
|
template<> |
bool | can_cast_expr< code_frontend_returnt > (const exprt &base) |
|
void | validate_expr (const code_frontend_returnt &x) |
|
const code_frontend_returnt & | to_code_frontend_return (const codet &code) |
|
code_frontend_returnt & | to_code_frontend_return (codet &code) |
|
template<> |
bool | can_cast_expr< code_labelt > (const exprt &base) |
|
void | validate_expr (const code_labelt &x) |
|
const code_labelt & | to_code_label (const codet &code) |
|
code_labelt & | to_code_label (codet &code) |
|
template<> |
bool | can_cast_expr< code_switch_caset > (const exprt &base) |
|
void | validate_expr (const code_switch_caset &x) |
|
const code_switch_caset & | to_code_switch_case (const codet &code) |
|
code_switch_caset & | to_code_switch_case (codet &code) |
|
template<> |
bool | can_cast_expr< code_gcc_switch_case_ranget > (const exprt &base) |
|
void | validate_expr (const code_gcc_switch_case_ranget &x) |
|
const code_gcc_switch_case_ranget & | to_code_gcc_switch_case_range (const codet &code) |
|
code_gcc_switch_case_ranget & | to_code_gcc_switch_case_range (codet &code) |
|
template<> |
bool | can_cast_expr< code_breakt > (const exprt &base) |
|
const code_breakt & | to_code_break (const codet &code) |
|
code_breakt & | to_code_break (codet &code) |
|
template<> |
bool | can_cast_expr< code_continuet > (const exprt &base) |
|
const code_continuet & | to_code_continue (const codet &code) |
|
code_continuet & | to_code_continue (codet &code) |
|
template<> |
bool | can_cast_expr< code_asmt > (const exprt &base) |
|
code_asmt & | to_code_asm (codet &code) |
|
const code_asmt & | to_code_asm (const codet &code) |
|
template<> |
bool | can_cast_expr< code_asm_gcct > (const exprt &base) |
|
void | validate_expr (const code_asm_gcct &x) |
|
code_asm_gcct & | to_code_asm_gcc (codet &code) |
|
const code_asm_gcct & | to_code_asm_gcc (const codet &code) |
|
template<> |
bool | can_cast_expr< code_expressiont > (const exprt &base) |
|
void | validate_expr (const code_expressiont &x) |
|
code_expressiont & | to_code_expression (codet &code) |
|
const code_expressiont & | to_code_expression (const codet &code) |
|
template<typename Tag > |
bool | detail::can_cast_side_effect_expr_impl (const exprt &expr, const Tag &tag) |
|
template<> |
bool | can_cast_expr< side_effect_exprt > (const exprt &base) |
|
side_effect_exprt & | to_side_effect_expr (exprt &expr) |
|
const side_effect_exprt & | to_side_effect_expr (const exprt &expr) |
|
template<> |
bool | can_cast_expr< side_effect_expr_nondett > (const exprt &base) |
|
side_effect_expr_nondett & | to_side_effect_expr_nondet (exprt &expr) |
|
const side_effect_expr_nondett & | to_side_effect_expr_nondet (const exprt &expr) |
|
template<> |
bool | can_cast_expr< side_effect_expr_assignt > (const exprt &base) |
|
side_effect_expr_assignt & | to_side_effect_expr_assign (exprt &expr) |
|
const side_effect_expr_assignt & | to_side_effect_expr_assign (const exprt &expr) |
|
template<> |
bool | can_cast_expr< side_effect_expr_statement_expressiont > (const exprt &base) |
|
side_effect_expr_statement_expressiont & | to_side_effect_expr_statement_expression (exprt &expr) |
|
const side_effect_expr_statement_expressiont & | to_side_effect_expr_statement_expression (const exprt &expr) |
|
template<> |
bool | can_cast_expr< side_effect_expr_function_callt > (const exprt &base) |
|
side_effect_expr_function_callt & | to_side_effect_expr_function_call (exprt &expr) |
|
const side_effect_expr_function_callt & | to_side_effect_expr_function_call (const exprt &expr) |
|
template<> |
bool | can_cast_expr< side_effect_expr_throwt > (const exprt &base) |
|
side_effect_expr_throwt & | to_side_effect_expr_throw (exprt &expr) |
|
const side_effect_expr_throwt & | to_side_effect_expr_throw (const exprt &expr) |
|
template<> |
bool | can_cast_expr< code_push_catcht > (const exprt &base) |
|
static code_push_catcht & | to_code_push_catch (codet &code) |
|
static const code_push_catcht & | to_code_push_catch (const codet &code) |
|
template<> |
bool | can_cast_expr< code_pop_catcht > (const exprt &base) |
|
static code_pop_catcht & | to_code_pop_catch (codet &code) |
|
static const code_pop_catcht & | to_code_pop_catch (const codet &code) |
|
template<> |
bool | can_cast_expr< code_landingpadt > (const exprt &base) |
|
static code_landingpadt & | to_code_landingpad (codet &code) |
|
static const code_landingpadt & | to_code_landingpad (const codet &code) |
|
template<> |
bool | can_cast_expr< code_try_catcht > (const exprt &base) |
|
void | validate_expr (const code_try_catcht &x) |
|
const code_try_catcht & | to_code_try_catch (const codet &code) |
|
code_try_catcht & | to_code_try_catch (codet &code) |
|
const code_function_bodyt & | to_code_function_body (const codet &code) |
|
code_function_bodyt & | to_code_function_body (codet &code) |
|