Index of values


_check_fi_db_select [SlicingSelect]

A
add_call_fun [Api.Request]
add_call_fun [Slicing.Api.Request]
May be used to change every call to any to_call source or specialisation in order to call the source function to_call in caller.
add_call_min_fun [Api.Request]
add_call_min_fun [Slicing.Api.Request]
May be used to change each call to to_call in caller such that, at least, it will be visible at the end, ie.
add_call_slice [Api.Request]
add_call_slice [Slicing.Api.Request]
May be used to change every call to any to_call source or specialisation in order to call to_call in caller.
add_crit_ff_change_call [SlicingSelect]
add_fct_ff_filter [SlicingProject]
add_fct_src_filter [SlicingProject]
Add an action to the action list to filter the function fct_id with the given criterion.
add_ff_selection [SlicingSelect]
add_fi_selection [SlicingSelect]
add a persistent selection to the function.
add_filter [SlicingProject]
add_marks_to_fi [Fct_slice]
add the marks to the persistent marks to be used when new slices will be created.
add_persistent_cmdline [Api.Request]
add_persistent_cmdline [SlicingCmds]
Registered as a slicing request function: Add selections that will be applied to all the slices of the function (already existing or created later) Note: the function begins by applying the remaining internal requests., the requests added for the last kernel function are not applied.
add_persistent_cmdline [Slicing.Api.Request]
Add persistent selection from the command line.
add_persistent_selection [Api.Request]
add_persistent_selection [SlicingCmds]
Registered as a slicing request function: Add selections that will be applied to all the slices of the function (already existing or created later) Note: the function begins by applying the remaining internal requests., the requests added for the last kernel function are not applied.
add_persistent_selection [Slicing.Api.Request]
Add a persistent selection request to all slices (already existing or created later) of a function to the project requests.
add_selection [Api.Request]
add_selection [SlicingCmds]
Registered as a slicing request function: Add selections to all concerned slices, as slicing requests and apply them, kernel function by kernel function.
add_selection [Slicing.Api.Request]
Add a selection request to all (existing) slices of a function to the project requests.
add_selection_internal [Api.Request]
add_selection_internal [Slicing.Api.Request]
May be used to add a selection request to the project requests.
add_slice_selection_internal [Api.Request]
add_slice_selection_internal [Slicing.Api.Request]
May be used to add a selection request for a function slice to the project requests.
add_to_selects [SlicingSelect.Selections]
add_to_selects_internal [Api.Select]
add_to_selects_internal [Slicing.Api.Select]
add_top_mark_to_fi [Fct_slice]
apply_add_marks [Fct_slice]
main function to build or modify a slice.
apply_all [Api.Request]
apply_all [SlicingCmds]
apply_all [Slicing.Api.Request]
Apply all slicing requests.
apply_all_actions [SlicingCmds]
apply_all_actions [SlicingProject]
apply_all_internal [Api.Request]
apply_all_internal [Slicing.Api.Request]
May be used to apply all slicing requests.
apply_change_call [Fct_slice]
check if f_to_call is ok for this call, and if so, change the function call and propagate missing marks in the inputs if needed.
apply_choose_call [Fct_slice]
Choose the function (slice or source) to call according to the slicing level of the called function.
apply_examine_calls [Fct_slice]
apply_missing_inputs [Fct_slice]
ff calls a slice g that needs more inputs than those computed by ff.
apply_missing_outputs [Fct_slice]
ff calls a slice g that doesn't compute enough outputs for the call.
apply_next_action [SlicingCmds]
apply_next_action [SlicingProject]
apply_next_internal [Api.Request]
apply_next_internal [Slicing.Api.Request]
May be used to apply the first slicing request of the project list and remove it from the list.

B
basic_add_select [SlicingSelect]
bottom_mark [SlicingMarks]
bottom_msg [SlicingSelect]
build_addr_dpds_selection [SlicingActions]
Only the control dependencies of the nodes will be marked
build_ctrl_dpds_selection [SlicingActions]
Only the control dependencies of the nodes will be marked
build_data_dpds_selection [SlicingActions]
Only the control dependencies of the nodes will be marked
build_dot_project [PrintSlice]
build_node_and_dpds_selection [SlicingActions]
Build a description to tell how the selected PDG nodes and their dependencies will have to be marked (see SlicingTypes.Internals.node_or_dpds).
build_simple_node_selection [SlicingActions]
Build a description to tell that the associated nodes have to be marked with the given mark, and than the same one will be propagated through their dependencies.

C
call_ff_in_caller [SlicingSelect]
change the call to call the given slice.
call_fsrc_in_caller [SlicingSelect]
call_min_f_in_caller [SlicingSelect]
change_fi_slicing_level [SlicingMacros]
change_slicing_level [Api.Project]
change_slicing_level [SlicingMacros]
change_slicing_level [Slicing.Api.Project]
Change the slicing level of this function (see the -slicing-level option documentation to know the meaning of the number).
check_call [SlicingSelect]
check_db_select [SlicingSelect]
check_ff_db_select [SlicingSelect]
check_kf_db_select [SlicingSelect]
check_outputs_before_change_call [Fct_slice]
When the user wants to make a change_call to a function that doesn't compute enough outputs, he can call check_outputs_before_change_call in order to build the action the add those outputs.
clear [SlicingParameters]
clear_ff [Fct_slice]
ff has to be removed.
combine_marks [SlicingMarks]
combine_marks add a new information to the old value.
compare [Api.Mark]
compare [Slicing.Api.Mark]
A total ordering function similar to the generic structural comparison function compare.
compare_mark [SlicingInternals]
compare_marks [SlicingMarks]
compare_pdg_mark [SlicingInternals]
copy [Datatype.S]
Deep copy: no possible sharing between x and copy x.
copy_slice [Api.Request]
copy_slice [Api]
copy_slice [Fct_slice]
copy_slice [Slicing.Api.Request]
May be used to copy the input slice.
create [Api.Slice]
create [Slicing.Api.Slice]
Used to get an empty slice (nothing selected) related to a function.
create_slice [SlicingProject]
Add a new slice for the function.

D
default_slice_names [Api.Project]
default_slice_names [SlicingTransform]
default_slice_names [Slicing.Api.Project]
Default function used for the optional ?f_slice_names argument of extract function.
dummy_fct_info [SlicingInternals]
dummy_fct_slice [SlicingInternals]
dummy_fct_user_crit [SlicingInternals]
dummy_ff_marks [SlicingInternals]
dummy_marks_index [SlicingInternals]
dummy_pdg_mark [SlicingInternals]
For the journalization of these internals types
dummy_project [SlicingInternals]
The whole project.
dyn_set [Api.Select]
dyn_set [Slicing.Api.Select]
For dynamic type checking and journalization.
dyn_sl_fct_slice [SlicingTypes]
dyn_sl_mark [SlicingTypes]
dyn_t [Api.Slice]
dyn_t [Api.Select]
dyn_t [Api.Mark]
dyn_t [Slicing.Api.Slice]
For dynamic type checking and journalization.
dyn_t [Slicing.Api.Select]
For dynamic type checking and journalization.
dyn_t [Slicing.Api.Mark]
For dynamic type checking and journalization.

E
empty_db_select [SlicingSelect]
empty_selects [Api.Select]
empty_selects [Slicing.Api.Select]
Empty selection.
empty_sig [SlicingMarks]
equal_ff [SlicingMacros]
equal_fi [SlicingMacros]
exists [Parameter_sig.Set]
Is there some element satisfying the given predicate?
extract [Api.Project]
extract [SlicingTransform]
Apply the actions still waiting in the project and transform the program (CIL AST) using slicing results Can optionally specify how to name the sliced functions using f_slice_names.
extract [Slicing.Api.Project]
Build a new Db.Project.t from all Slice.t of a project.

F
f_name [SlicingMacros]
ff_name [SlicingMacros]
get the name of the function corresponding to that slice.
ff_slicing_level [SlicingMacros]
ff_src_name [SlicingMacros]
ff_svar [SlicingMacros]
fi_has_persistent_selection [SlicingMacros]
fi_name [SlicingMacros]
fi_slices [SlicingMacros]
fi_svar [SlicingMacros]
filter_already_in [Fct_slice]
a function that doesn't modify anything but test if the nodes_marks are already in the slice or not.
fold_fi [SlicingMacros]
fold_selects_internal [Api.Select]
fold_selects_internal [SlicingSelect.Selections]
fold_selects_internal [Slicing.Api.Select]
from_num_id [Api.Slice]
from_num_id [Slicing.Api.Slice]

G
get [SlicingState]
Get the state of the slicing project.
get_all [Api.Slice]
get_all [Slicing.Api.Slice]
Get all slices related to a function.
get_all_input_marks [SlicingMarks]
get_called_funcs [Api.Slice]
get_called_funcs [Slicing.Api.Slice]
To get the source functions called by the statement of a slice.
get_called_slice [Api.Slice]
get_called_slice [Fct_slice]
Inform about the called slice or else calls to source functions.
get_called_slice [Slicing.Api.Slice]
To get the slice directly called by the statement of a slice.
get_callers [Api.Slice]
get_callers [Slicing.Api.Slice]
Get the slices having direct calls to a slice.
get_default_level_option [SlicingMacros]
get_ff_id [SlicingMacros]
getting num id
get_ff_kf [SlicingMacros]
get_ff_pdg [SlicingMacros]
get_fi_call [SlicingMacros]
get the fct_info of the called function, if we know it
get_fi_kf [SlicingMacros]
get_fi_pdg [SlicingMacros]
get_from_src_func [Api.Mark]
get_from_src_func [Slicing.Api.Mark]
The mark m related to all statements of a source function kf.
get_function [Api.Slice]
get_function [Api.Select]
get_function [Slicing.Api.Slice]
To get the function related to a slice
get_function [Slicing.Api.Select]
May be used to get the function related to an internal selection.
get_function_name [Parameter_sig.String]
returns the given argument only if it is a valid function name (see Parameter_customize.get_c_ified_functions for more information), and abort otherwise.
get_in_ctrl_mark [SlicingMarks]
get_input_loc_under_mark [Fct_slice]
get_input_loc_under_mark [SlicingMarks]
get_input_mark [SlicingMarks]
get_kf_fi [SlicingMacros]
Get the fct_info if it exists or build a new fct_info.
get_label_mark [Fct_slice]
get_local_var_mark [Fct_slice]
get_mark_from_formal [Api.Slice]
get_mark_from_formal [Slicing.Api.Slice]
Get the mark from the formal of a function.
get_mark_from_label [Api.Slice]
get_mark_from_label [Slicing.Api.Slice]
Get the mark value of a label.
get_mark_from_local_var [Api.Slice]
get_mark_from_local_var [Slicing.Api.Slice]
Get the mark value of local variable.
get_mark_from_src_fun [Fct_slice]
The mark m related to all statements of a source function kf.
get_mark_from_stmt [Api.Slice]
get_mark_from_stmt [Slicing.Api.Slice]
Get the mark value of a statement.
get_marked_out_zone [SlicingMarks]
get_matching_input_marks [SlicingMarks]
get_node_key_mark [Fct_slice]
get_node_mark [Fct_slice]
get_num_id [Api.Slice]
get_num_id [Slicing.Api.Slice]
get_param_mark [Fct_slice]
get_pdg_kf [SlicingMacros]
get_plain_string [Parameter_sig.String]
always return the argument, even if the argument is not a function name.
get_possible_values [Parameter_sig.String]
What are the acceptable values for this parameter.
get_range [Parameter_sig.Int]
What is the possible range of values for this parameter.
get_select_kf [SlicingCmds]
get_select_kf [SlicingSelect]
get_slice_callers [SlicingProject]
get_slices [SlicingProject]
get_stmt_mark [Fct_slice]
get_top_input_mark [Fct_slice]
get_user_mark_from_inputs [Api.Slice]
get_user_mark_from_inputs [Slicing.Api.Slice]
Get a mark that is the merged user inputs marks of the slice

H
has_persistent_selection [Api.Project]
has_persistent_selection [SlicingMacros]
has_persistent_selection [Slicing.Api.Project]
Return true iff the source function has persistent selection

I
incr [Parameter_sig.Int]
Increment the integer.
inter_marks [SlicingMarks]
is_addr [Api.Mark]
is_addr [Slicing.Api.Mark]
The element is used to compute the address of a selected data.
is_addr_mark [SlicingMarks]
is_already_selected [SlicingSelect]
is_bottom [Api.Mark]
is_bottom [Slicing.Api.Mark]
true iff the mark is empty: it is the only case where the associated element is invisible.
is_bottom_mark [SlicingMarks]
is_call_stmt [SlicingMacros]
is_called [Api.Project]
is_called [Slicing.Api.Project]
Return true iff the source function is called (even indirectly via transitivity) from a Slice.t.
is_ctrl [Api.Mark]
is_ctrl [Slicing.Api.Mark]
The element is used to control the program point of a selected data.
is_ctrl_mark [SlicingMarks]
is_data [Api.Mark]
is_data [Slicing.Api.Mark]
The element is used to compute selected data.
is_data_mark [SlicingMarks]
is_directly_called_internal [Api.Project]
is_directly_called_internal [Slicing.Api.Project]
Return true if the source function is directly (even via pointer function) called from a Slice.t.
is_on [SlicingParameters]
is_request_empty [SlicingProject]
is_request_empty_internal [Api.Request]
is_request_empty_internal [Slicing.Api.Request]
May be used to know if internal requests are pending.
is_spare [Api.Mark]
is_spare [Slicing.Api.Mark]
Smallest visible mark.
is_spare_mark [SlicingMarks]
is_src_fun_called [Fct_slice]
Return true if the source function is called (even indirectly via transitivity) from a Slice.t.
is_src_fun_called [SlicingMacros]
is_src_fun_visible [Fct_slice]
Return true if the source function is visible (even indirectly via transitivity) from a Slice.t.
is_src_fun_visible [SlicingMacros]
is_top_mark [SlicingMarks]
is_topin_visible [SlicingMarks]
iter_selects_internal [Api.Select]
iter_selects_internal [SlicingSelect.Selections]
iter_selects_internal [Slicing.Api.Select]

M
make [Api.Mark]
make [Slicing.Api.Mark]
To construct a mark such as (is_ctrl result, is_data result, isaddr result) =
        (~ctrl, ~data, ~addr)
, (is_bottom result) = false and (is_spare result) = not (~ctrl || ~data || ~addr).
make_new_ff [Fct_slice]
build a new empty slice in the given fct_info.
make_type [Datatype.Hashtbl]
mark_to_string [SlicingMarks]
may [SlicingState]
apply the given closure if the slicing project has been initialized through Db.Slicing.reset_slice.
may_map [SlicingState]
apply the given closure if the slicing project has been initialized through Db.Slicing.reset_slice, or else return the default value.
mem [Parameter_sig.Set]
Does the given element belong to the set?
merge_db_select [SlicingSelect]
merge_inputs_m1_mark [Fct_slice]
merge_inputs_m1_mark [SlicingMarks]
merge_internal [Api.Select]
merge_internal [Slicing.Api.Select]
merge_marks [SlicingMarks]
merge_select [SlicingSelect]
merge_slices [Api.Request]
merge_slices [Api]
merge_slices [SlicingProject]
Build a new slice ff which contains the marks of ff1 and ff2 and generate everything that is needed to choose the calls in ff.
merge_slices [Fct_slice]
Build a new slice which marks are a join between ff1 marks and ff2 marks.
merge_slices [Slicing.Api.Request]
May be used to build a new slice which marks is a merge of the two given slices.
minus_marks [SlicingMarks]
missing_input_mark [SlicingMarks]
missing_output_mark [SlicingMarks]
mk_appli_select_calls [SlicingActions]
mk_crit_add_output_marks [SlicingActions]
mk_crit_change_call [SlicingActions]
mk_crit_choose_call [SlicingActions]
mk_crit_examines_calls [SlicingActions]
mk_crit_fct_top [SlicingActions]
mk_crit_fct_user_select [SlicingActions]
mk_crit_mark_calls [SlicingActions]
mk_crit_missing_inputs [SlicingActions]
mk_crit_missing_outputs [SlicingActions]
mk_crit_prop_persit_marks [SlicingActions]
mk_fct_crit [SlicingActions]
build an action to apply the criteria to the persistent selection of the function.
mk_ff_user_select [SlicingActions]
mk_gen_spare [SlicingMarks]
generated spare = the smallest visible mark
mk_select [SlicingSelect]
mk_user_mark [SlicingMarks]
mk_user_spare [SlicingMarks]

N
nearest_elt_ge [Datatype.Set]
nearest_elt_le [Datatype.Set]

O
off [Parameter_sig.Bool]
Set the boolean to false.
on [Parameter_sig.Bool]
Set the boolean to true.

P
pdg_mark_packed_descr [SlicingInternals]
pp_sl_fct_slice [SlicingTypes]
pp_sl_mark [SlicingTypes]
pp_sl_project [SlicingTypes]
pretty [Api.Request]
pretty [Api.Slice]
pretty [Api.Select]
pretty [Api.Mark]
pretty [Api.Project]
pretty [Slicing.Api.Request]
May be used for debugging...
pretty [Slicing.Api.Slice]
May be used for debugging...
pretty [Slicing.Api.Select]
May be used for debugging...
pretty [Slicing.Api.Mark]
May be used for debugging...
pretty [Slicing.Api.Project]
May be used for debugging...
pretty_mark [SlicingMarks]
pretty_sig [SlicingMarks]
pretty_slice [SlicingProject]
print_crit [SlicingActions]
print_dot [Api.Project]
print_dot [Slicing.Api.Project]
May be used to for debugging...
print_f_crit [SlicingActions]
print_fct_from_pdg [PrintSlice]
print_fct_stmts [PrintSlice]
print_fct_stmts [Slicing.PrintSlice]
print_ff_sig [Fct_slice]
print_list_crit [SlicingActions]
print_marked_ff [PrintSlice]
print_nd_and_mark_list [SlicingActions]
Printing
print_nodes [SlicingActions]
print_original_glob [PrintSlice]
print_proj_worklist [SlicingProject]
print_project_and_worklist [SlicingProject]
print_sel_marks_list [SlicingActions]
print_select [SlicingSelect]
propagate_user_marks [Api.Request]
propagate_user_marks [Slicing.Api.Request]
May be used to apply pending request then propagate user marks to callers recursively then apply pending requests

R
remove [Api.Slice]
remove [Slicing.Api.Slice]
Remove the slice from the project.
remove_ff [SlicingProject]
Delete ff_to_remove if it is not called.
remove_uncalled [Api.Slice]
remove_uncalled [Slicing.Api.Slice]
Remove the uncalled slice from the project.
remove_uncalled_slices [SlicingProject]
reset_slicing [Api.Project]
reset_slicing [SlicingState]
Function that can be used for: initializing the slicing tool before starting a slicing project;, removing all computed slices and all internal pending requests of the current slicing project.
reset_slicing [Slicing.Api.Project]
Function that can be used for: initializing the slicing tool before starting a slicing project;, removing all computed slices and all internal pending requests of the current slicing project.

S
same_ff_call [SlicingMacros]
select_decl_var [SlicingSelect]
select_decl_var_internal [Api.Select]
select_decl_var_internal [Slicing.Api.Select]
select_entry_point [SlicingSelect]
select_entry_point_internal [Api.Select]
select_entry_point_internal [Slicing.Api.Select]
select_func_annots [Api.Select]
select_func_annots [SlicingCmds]
Registered as a slicing selection function: Add a selection of the annotations related to a function.
select_func_annots [Slicing.Api.Select]
To select the annotations related to a function.
select_func_calls_into [Api.Select]
select_func_calls_into [SlicingCmds]
Registered as a slicing selection function: Add a selection of calls to a kf.
select_func_calls_into [Slicing.Api.Select]
To select every calls to the given function without the selection of its inputs/outputs.
select_func_calls_to [Api.Select]
select_func_calls_to [SlicingCmds]
Registered as a slicing selection function: Add a selection of calls to a kf.
select_func_calls_to [Slicing.Api.Select]
To select every calls to the given function, i.e.
select_func_lval [Api.Select]
select_func_lval [SlicingCmds]
Registered as a slicing selection function: Add selection of function outputs.
select_func_lval [Slicing.Api.Select]
To select lvalues (given as a string) related to a function.
select_func_lval_rw [Api.Select]
select_func_lval_rw [SlicingCmds]
Registered as a slicing selection function: Add a selection of data relative to read/write accesses.
select_func_lval_rw [Slicing.Api.Select]
To select rw accesses to lvalues (given as a string) related to a function.
select_func_return [Api.Select]
select_func_return [SlicingCmds]
Registered as a slicing selection function: Add a selection of the kf return statement.
select_func_return [Slicing.Api.Select]
To select the function result (returned value).
select_func_zone [Api.Select]
select_func_zone [SlicingCmds]
Registered as a slicing selection function: Add selection of function outputs.
select_func_zone [Slicing.Api.Select]
To select an output zone related to a function.
select_in_out_zone [SlicingSelect]
this one is similar to select_stmt_zone with the return statement when the function is defined, but it can also be used for undefined functions.
select_label [SlicingSelect]
select_label_internal [Api.Select]
select_label_internal [Slicing.Api.Select]
May be used to select a label.
select_min_call_internal [Api.Select]
select_min_call_internal [Slicing.Api.Select]
May be used to select a statement call without its inputs/outputs so that it doesn't select the statements computing the inputs of the called function as select_stmt_internal would do.
select_minimal_call [SlicingSelect]
marking a call node means that a choose_call will have to decide that to call according to the slicing-level, but anyway, the call will be visible.
select_modified_output_zone [SlicingSelect]
select_modified_output_zone_internal [Api.Select]
select_modified_output_zone_internal [Slicing.Api.Select]
May be used to select the statements that modify the given zone considered as in output.
select_pdg_nodes [Api.Select]
select_pdg_nodes [SlicingCmds]
Registered as a slicing selection function: Add a selection of the pdg nodes.
select_pdg_nodes [SlicingSelect]
select_pdg_nodes [Slicing.Api.Select]
To select nodes of the PDG if is_ctrl_mark m, propagate ctrl_mark on ctrl dependencies, if is_addr_mark m, propagate addr_mark on addr dependencies, if is_data_mark m, propagate data_mark on data dependencies, mark the node with a spare_mark and propagate so that the dependencies that were not selected yet will be marked spare.
select_pdg_nodes_internal [Api.Select]
select_pdg_nodes_internal [Slicing.Api.Select]
May be used to select PDG nodes.
select_return [SlicingSelect]
select_return_internal [Api.Select]
select_return_internal [Slicing.Api.Select]
select_stmt [Api.Select]
select_stmt [SlicingCmds]
Registered as a slicing selection function: Add a selection of the statement.
select_stmt [Slicing.Api.Select]
To select a statement.
select_stmt_annot [Api.Select]
select_stmt_annot [SlicingCmds]
Registered as a slicing selection function: Add selection of the annotations related to a statement.
select_stmt_annot [Slicing.Api.Select]
To select the annotations related to a statement.
select_stmt_annots [Api.Select]
select_stmt_annots [SlicingCmds]
Registered as a slicing selection function: Add selection of the annotations related to a statement.
select_stmt_annots [Slicing.Api.Select]
To select the annotations related to a statement.
select_stmt_computation [SlicingSelect]
select_stmt_ctrl [Api.Select]
select_stmt_ctrl [SlicingCmds]
Registered as a slicing selection function: Add a selection of the statement reachability.
select_stmt_ctrl [SlicingSelect]
select_stmt_ctrl [Slicing.Api.Select]
To select a statement reachability.
select_stmt_ctrl_internal [Api.Select]
select_stmt_ctrl_internal [Slicing.Api.Select]
May be used to select a statement reachability : Only propagate a ctrl_mark on the statement control dependencies.
select_stmt_internal [Api.Select]
select_stmt_internal [Slicing.Api.Select]
May be used to select a statement : if is_ctrl_mark m, propagates ctrl_mark on ctrl dependencies of the statement, if is_addr_mark m, propagates addr_mark on addr dependencies of the statement, if is_data_mark m, propagates data_mark on data dependencies of the statement, otherwise, marks the node with a spare_mark and propagate so that the dependencies that were not selected yet will be marked spare. When the statement is a call, its functional inputs/outputs are also selected (The call is still selected even it has no output). When the statement is a composed one (block, if, etc...), all the sub-statements are selected.
select_stmt_lval [Api.Select]
select_stmt_lval [SlicingCmds]
Registered as a slicing selection function: Add a selection of data relative to a statement.
select_stmt_lval [Slicing.Api.Select]
To select lvalues (given as string) related to a statement.
select_stmt_lval_rw [Api.Select]
select_stmt_lval_rw [SlicingCmds]
Registered as a slicing selection function: Add a selection of rw accesses to lvalues relative to a statement.
select_stmt_lval_rw [Slicing.Api.Select]
To select rw accesses to lvalues (given as a string) related to a statement.
select_stmt_pred [Api.Select]
select_stmt_pred [SlicingCmds]
Registered as a slicing selection function: Add selection of the annotations related to a statement.
select_stmt_pred [Slicing.Api.Select]
To select a predicate value related to a statement.
select_stmt_term [Api.Select]
select_stmt_term [SlicingCmds]
Registered as a slicing selection function: Add selection of the annotations related to a statement.
select_stmt_term [Slicing.Api.Select]
To select a predicate value related to a statement.
select_stmt_zone [Api.Select]
select_stmt_zone [SlicingCmds]
Registered as a slicing selection function: Add a selection of data relative to a statement.
select_stmt_zone [SlicingSelect]
select_stmt_zone [Slicing.Api.Select]
To select a zone value related to a statement.
select_stmt_zone_internal [Api.Select]
select_stmt_zone_internal [Slicing.Api.Select]
May be used to select a zone value at a program point.
select_zone_at_end [SlicingSelect]
select_zone_at_end_internal [Api.Select]
select_zone_at_end_internal [Slicing.Api.Select]
May be used to select a zone value at the end of a function.
select_zone_at_entry [SlicingSelect]
select_zone_at_entry_point_internal [Api.Select]
select_zone_at_entry_point_internal [Slicing.Api.Select]
May be used to select a zone value at the beginning of a function.
self [Api]
self [SlicingState]
Internal state of the slicing tool from project viewpoints.
self [Slicing.Api]
Internal state of the slicing tool from project viewpoints.
set_modes [Api]
set_modes [Slicing.Api]
Sets slicing parameters related to command line options -slicing-level, -slice-callers, -slice-undef-functions, -slicing-keep-annotations.
set_off [SlicingParameters]
set_possible_values [Parameter_sig.String]
Set what are the acceptable values for this parameter.
set_range [Parameter_sig.Int]
Set what is the possible range of values for this parameter.
some_visible_out [SlicingMarks]
something_visible [SlicingMarks]
split_slice [Api.Request]
split_slice [Api]
split_slice [SlicingProject]
split_slice [Slicing.Api.Request]
May be used to copy the input slice to have one slice for each call of the original slice and generate requests in order to call them.
stmt_nodes_to_select [SlicingSelect]
str_level_option [SlicingMacros]

T
top_db_select [SlicingSelect]
topologic_propagation [SlicingCmds]
Topologically propagate user marks to callers in whole project
translate_crit_to_select [SlicingActions]

W
wkey_cmdline [SlicingParameters]