Sindbad~EG File Manager
/* proto.h made
Tuesday, May 08, 02:40:38 PM 2001 (CDT)
*/
/* main.c */
void print_banner(int argc,
char **argv);
/* av.c */
int **tp_alloc(int n);
struct term *get_term(void);
void free_term(struct term *p);
struct rel *get_rel(void);
void free_rel(struct rel *p);
struct sym_ent *get_sym_ent(void);
void free_sym_ent(struct sym_ent *p);
struct term_ptr *get_term_ptr(void);
void free_term_ptr(struct term_ptr *p);
struct formula_ptr_2 *get_formula_ptr_2(void);
void free_formula_ptr_2(struct formula_ptr_2 *p);
struct fpa_tree *get_fpa_tree(void);
void free_fpa_tree(struct fpa_tree *p);
struct fpa_head *get_fpa_head(void);
void free_fpa_head(struct fpa_head *p);
struct context *get_context(void);
void free_context(struct context *p);
struct trail *get_trail(void);
void free_trail(struct trail *p);
struct imd_tree *get_imd_tree(void);
void free_imd_tree(struct imd_tree *p);
struct imd_pos *get_imd_pos(void);
void free_imd_pos(struct imd_pos *p);
struct is_tree *get_is_tree(void);
void free_is_tree(struct is_tree *p);
struct is_pos *get_is_pos(void);
void free_is_pos(struct is_pos *p);
struct fsub_pos *get_fsub_pos(void);
void free_fsub_pos(struct fsub_pos *p);
struct literal *get_literal(void);
void free_literal(struct literal *p);
struct clause *get_clause(void);
void free_clause(struct clause *p);
struct list *get_list(void);
void free_list(struct list *p);
struct clash_nd *get_clash_nd(void);
void free_clash_nd(struct clash_nd *p);
struct clause_ptr *get_clause_ptr(void);
void free_clause_ptr(struct clause_ptr *p);
struct ci_ptr *get_ci_ptr(void);
void free_ci_ptr(struct ci_ptr *p);
struct int_ptr *get_int_ptr(void);
void free_int_ptr(struct int_ptr *p);
struct ans_lit_node *get_ans_lit_node(void);
void free_ans_lit_node(struct ans_lit_node *p);
struct formula_box *get_formula_box(void);
void free_formula_box(struct formula_box *p);
struct formula *get_formula(void);
void free_formula(struct formula *p);
struct formula_ptr *get_formula_ptr(void);
void free_formula_ptr(struct formula_ptr *p);
struct cl_attribute *get_cl_attribute(void);
void free_cl_attribute(struct cl_attribute *p);
struct link_node *get_link_node(void);
void free_link_node(struct link_node *p);
void free_imd_pos_list(struct imd_pos *p);
void free_is_pos_list(struct is_pos *p);
void print_mem(FILE *fp);
void print_mem_brief(FILE *fp);
int total_mem(void);
int total_mem_calls(void);
void print_linked_ur_mem_stats(void);
/* io.c */
int str_double(char *s,
double *dp);
void double_str(double d,
char *s);
int str_int(char *s,
int *np);
void int_str(int i,
char *s);
int str_long(char *s,
long int *np);
int bits_ulong(char *s,
long unsigned int *np);
void long_str(long int i,
char *s);
void ulong_bits(long unsigned int i,
char *s);
void cat_str(char *s1,
char *s2,
char *s3);
int str_ident(char *s,
char *t);
void reverse(char *s);
struct sym_ent *insert_sym(char *s,
int arity);
int str_to_sn(char *str,
int arity);
void print_syms(FILE *fp);
void p_syms(void);
char *sn_to_str(int sym_num);
int sn_to_arity(int sym_num);
struct sym_ent *sn_to_node(int sym_num);
int sn_to_ec(int sym_num);
struct sym_ent *sym_tab_member(char *str,
int arity);
int in_sym_tab(char *s);
void free_sym_tab(void);
int is_symbol(struct term *t,
char *str,
int arity);
void mark_as_skolem(int sym_num);
int is_skolem(int sym_num);
int initial_str(char *s,
char *t);
int set_vars(struct term *t);
int set_vars_term(struct term *t,
char **varnames);
int var_name(char *s);
struct term_ptr *read_list(FILE *fp,
int *ep,
int integrate);
void print_list(FILE *fp,
struct term_ptr *p);
void bird_print(FILE *fp,
struct term *t);
void write_term(FILE *fp,
struct term *t,
int n,
int *prev);
void display_term(FILE *fp,
struct term *t);
void print_term(FILE *fp,
struct term *t);
void p_term(struct term *t);
void d_term(struct term *t);
void print_term_nl(FILE *fp,
struct term *t);
int print_term_length(struct term *t);
void pretty_print_term(FILE *fp,
struct term *t,
int indents);
void print_variable(FILE *fp,
struct term *t);
void built_in_symbols(void);
int declare_op(int prec,
int type,
char *str);
void init_special_ops(void);
int process_op_command(struct term *t);
void skip_white(char *buf,
int *p);
int name_sym(char *s);
void print_error(FILE *fp,
char *buf,
int pos);
struct term *str_to_term(char *buf,
int *p,
int in_list);
int read_buf(FILE *fp,
char *buf);
struct term *term_fixup(struct term *t);
struct term *term_fixup_2(struct term *t);
struct term *read_term(FILE *fp,
int *rcp);
void merge_sort(void **a,
void **w,
int start,
int end,
int (*comp_proc)(void *v1, void *v2));
int compare_for_auto_lex_order(void *d1,
void *d2);
void auto_lex_order(void);
/* share.c */
struct term *integrate_term(struct term *t);
void disintegrate_term(struct term *t);
void set_up_pointers(struct term *t);
void zap_term(struct term *t);
void print_term_tab(FILE *fp);
void p_term_tab(void);
void test_terms(FILE *fp);
struct term_ptr *all_instances(struct term *atom);
struct term_ptr *all_instances_fpa(struct term *atom);
void bd_kludge_insert(struct term *t);
void bd_kludge_delete(struct term *t);
/* fpa.c */
struct fpa_index *alloc_fpa_index(void);
void fpa_insert(struct term *t,
int level,
struct fpa_index *index);
void fpa_delete(struct term *t,
int level,
struct fpa_index *index);
struct fpa_tree *build_tree(struct term *t,
int u_type,
int bound,
struct fpa_index *index);
struct term *next_term(struct fpa_tree *n,
int max);
struct fpa_tree *build_for_all(struct fpa_index *index);
void zap_prop_tree(struct fpa_tree *n);
void print_fpa_tab(FILE *fp,
struct fpa_index *index);
void p_fpa_tab(struct fpa_index *index);
void print_prop_tree(FILE *fp,
struct fpa_tree *n,
int level);
void p_prop_tree(struct fpa_tree *n);
void print_path(FILE *fp,
int *path);
void p_path(int *path);
int new_sym_num(void);
/* clocks.c */
void clock_init(void);
long clock_val(int c);
void clock_reset(int c);
char *get_time(void);
long system_time(void);
long run_time(void);
long wall_seconds(void);
/* unify.c */
int occur_check(int vn,
struct context *vc,
struct term *t,
struct context *c);
int unify(struct term *t1,
struct context *c1,
struct term *t2,
struct context *c2,
struct trail **trp);
int unify_no_occur_check(struct term *t1,
struct context *c1,
struct term *t2,
struct context *c2,
struct trail **trp);
int otter_match(struct term *t1,
struct context *c1,
struct term *t2,
struct trail **trp);
struct term *apply(struct term *t,
struct context *c);
int term_ident(struct term *t1,
struct term *t2);
void clear_subst_2(struct trail *t1,
struct trail *t2);
void clear_subst_1(struct trail *t1);
void print_subst(FILE *fp,
struct context *c);
void p_subst(struct context *c);
void print_trail(FILE *fp,
struct trail *t);
/* demod.c */
struct term *convenient_demod(struct term *t);
void zap_term_special(struct term *t);
struct term *apply_demod(struct term *t,
struct context *c,
int *pf);
void demod_cl(struct clause *c);
void back_demod(struct clause *d,
struct clause *c,
int input,
struct list *lst);
int lit_t_f_reduce(struct clause *c);
int check_input_demod(struct clause *c);
int dynamic_demodulator(struct clause *c);
struct clause *new_demod(struct clause *c,
int demod_flag);
/* weight.c */
struct term_ptr *read_wt_list(FILE *fp,
int *ep);
int noncomplexifying(struct context *c);
int overbeek_match(struct term *t);
int weight(struct term *t,
struct is_tree *wt_index);
int wt_match(struct term *t,
struct term *template,
int *wtp,
struct is_tree *wt_index);
void set_wt_list(struct term_ptr *wt_list,
struct is_tree *wt_index,
int *ep);
void weight_index_delete(struct is_tree *wt_index);
int lex_order(struct term *t1,
struct term *t2);
int lex_order_vars(struct term *t1,
struct term *t2);
int lex_check(struct term *t1,
struct term *t2);
int var_subset(struct term *t1,
struct term *t2);
void order_equalities(struct clause *c);
int term_ident_x_vars(struct term *t1,
struct term *t2);
/* imd.c */
void imd_insert(struct clause *demod,
struct imd_tree *imd);
void imd_delete(struct clause *demod,
struct imd_tree *root_imd);
struct term *contract_imd(struct term *t_in,
int *demods,
struct context *subst,
int *demod_id_p);
void print_imd_tree(FILE *fp,
struct imd_tree *imd,
int level);
void p_imd_tree(struct imd_tree *imd);
/* is.c */
void is_insert(struct term *t,
struct is_tree *root_is);
void is_delete(struct term *t,
struct is_tree *root_is);
struct term_ptr *is_retrieve(struct term *t,
struct context *subst,
struct is_tree *is,
struct is_pos **is_pos);
struct term *fs_retrieve(struct term *t,
struct context *subst,
struct is_tree *is,
struct fsub_pos **fs_pos);
void canc_fs_pos(struct fsub_pos *pos,
struct context *subst);
void print_is_tree(FILE *fp,
struct is_tree *is);
void p_is_tree(struct is_tree *is);
/* clause.c */
void reset_clause_counter(void);
int next_cl_num(void);
void assign_cl_id(struct clause *c);
void hot_cl_integrate(struct clause *c);
void cl_integrate(struct clause *c);
void cl_del_int(struct clause *c);
void cl_del_non(struct clause *c);
void cl_int_chk(struct clause *c);
struct term *clause_to_term(struct clause *c);
struct clause *term_to_clause(struct term *t);
struct clause *read_sequent_clause(FILE *fp,
int *rcp);
struct clause *read_clause(FILE *fp,
int *rcp);
struct list *read_cl_list(FILE *fp,
int *ep);
int set_vars_cl(struct clause *cl);
void print_sequent_clause(FILE *fp,
struct clause *c);
void print_clause(FILE *fp,
struct clause *cl);
void p_clause(struct clause *cl);
void print_cl_list(FILE *fp,
struct list *lst);
void cl_merge(struct clause *c);
int tautology(struct clause *c);
int prf_weight(struct clause *c);
int proof_length(struct clause *c);
int subsume(struct clause *c,
struct clause *d);
int map_rest(struct clause *c,
struct clause *d,
struct context *s,
struct trail **trp);
int anc_subsume(struct clause *c,
struct clause *d);
struct clause *for_sub_prop(struct clause *d);
struct clause *forward_subsume(struct clause *d);
struct clause_ptr *back_subsume(struct clause *c);
struct clause_ptr *unit_conflict(struct clause *c);
int propositional_clause(struct clause *c);
int xx_resolvable(struct clause *c);
int pos_clause(struct clause *c);
int answer_lit(struct literal *lit);
int pos_eq_lit(struct literal *lit);
int neg_eq_lit(struct literal *lit);
int eq_lit(struct literal *lit);
int neg_clause(struct clause *c);
int num_literals(struct clause *c);
int num_answers(struct clause *c);
int num_literals_including_answers(struct clause *c);
int literal_number(struct literal *lit);
int unit_clause(struct clause *c);
int horn_clause(struct clause *c);
int equality_clause(struct clause *c);
int symmetry_clause(struct clause *c);
struct literal *ith_literal(struct clause *c,
int n);
void append_cl(struct list *l,
struct clause *c);
void prepend_cl(struct list *l,
struct clause *c);
void insert_before_cl(struct clause *c,
struct clause *c_new);
void insert_after_cl(struct clause *c,
struct clause *c_new);
void rem_from_list(struct clause *c);
void insert_clause(struct clause *c,
struct clause_ptr **cpp);
int max_literal_weight(struct clause *c,
struct is_tree *wt_index);
int weight_cl(struct clause *c,
struct is_tree *wt_index);
void hide_clause(struct clause *c);
void del_hidden_clauses(void);
struct clause *cl_copy(struct clause *c);
int clause_ident(struct clause *c1,
struct clause *c2);
void remove_var_syms(struct term *t);
void cl_insert_tab(struct clause *c);
void cl_delete_tab(struct clause *c);
struct clause *cl_find(int id);
int lit_compare(struct literal *l1,
struct literal *l2);
int ordered_sub_clause(struct clause *c1,
struct clause *c2);
int sub_clause(struct clause *c1,
struct clause *c2);
int sort_lits(struct clause *c);
void all_cont_cl(struct term *t,
struct clause_ptr **cpp);
void zap_cl_list(struct list *lst);
int is_eq(int sym_num);
void mark_literal(struct literal *lit);
int get_ancestors(struct clause *c,
struct clause_ptr **cpp,
struct int_ptr **ipp);
int renumber_vars_term(struct term *t);
int renumber_vars(struct clause *c);
int renum_vars_term(struct term *t,
int *varnums);
void clear_var_names(struct term *t);
void cl_clear_vars(struct clause *c);
int distinct_vars(struct clause *c);
struct clause *find_first_cl(struct list *l);
struct clause *find_last_cl(struct list *l);
struct clause *find_random_cl(struct list *l);
struct clause_ptr *get_clauses_of_wt_range(struct clause *c,
int min, int max);
int clause_ptr_list_size(struct clause_ptr *p);
struct clause *nth_clause(struct clause_ptr *p, int n);
void zap_clause_ptr_list(struct clause_ptr *p);
struct clause *find_random_lightest_cl(struct list *l);
struct clause *find_mid_lightest_cl(struct list *l);
struct clause *find_lightest_cl(struct list *l);
struct clause *find_lightest_geo_child(struct list *l);
struct clause *find_interactive_cl(void);
struct clause *find_given_clause(void);
struct clause *extract_given_clause(void);
int unit_del(struct clause *c);
void back_unit_deletion(struct clause *c,
int input);
/* options.c */
void init_options(void);
void print_options(FILE *fp);
void p_options(void);
void auto_change_flag(FILE *fp,
int index,
int val);
void dependent_flags(FILE *fp,
int index);
void auto_change_parm(FILE *fp,
int index,
int val);
void dependent_parms(FILE *fp,
int index);
int change_flag(FILE *fp,
struct term *t,
int set);
int change_parm(FILE *fp,
struct term *t);
void check_options(void);
/* resolve.c */
int maximal_lit(struct literal *l1);
void hyper_res(struct clause *giv_cl);
void neg_hyper_res(struct clause *giv_cl);
void ur_res(struct clause *giv_cl);
int one_unary_answer(struct clause *c);
struct term *build_term(int sn,
struct term *arg1,
struct term *arg2,
struct term *arg3);
void combine_answers(struct clause *res,
struct term *a1,
struct context *s1,
struct term *a2,
struct context *s2);
struct clause *build_bin_res(struct term *a1,
struct context *s1,
struct term *a2,
struct context *s2);
struct clause *apply_clause(struct clause *c,
struct context *s);
void bin_res(struct clause *giv_cl);
struct clause *first_or_next_factor(struct clause *c,
struct literal **l1p,
struct literal **l2p);
void all_factors(struct clause *c,
struct list *lst);
int factor_simplify(struct clause *c);
/* index.c */
void index_lits_all(struct clause *c);
void un_index_lits_all(struct clause *c);
void index_lits_clash(struct clause *c);
void un_index_lits_clash(struct clause *c);
/* paramod.c */
void para_from(struct clause *giv_cl);
void para_into(struct clause *giv_cl);
/* formula.c */
void print_formula(FILE *fp,
struct formula *f);
void p_formula(struct formula *f);
struct term *formula_to_term(struct formula *f);
struct formula *term_to_formula(struct term *t);
struct formula *read_formula(FILE *fp,
int *rcp);
struct formula_ptr *read_formula_list(FILE *fp,
int *ep);
void print_formula_list(FILE *fp,
struct formula_ptr *p);
struct formula *copy_formula(struct formula *f);
void zap_formula(struct formula *f);
struct formula *negate_formula(struct formula *f);
struct formula *nnf(struct formula *f);
struct formula *skolemize(struct formula *f);
struct formula *anti_skolemize(struct formula *f);
void subst_free_formula(struct term *var,
struct formula *f,
struct term *sk);
void gen_sk_sym(struct term *t);
int skolem_symbol(int sn);
int contains_skolem_symbol(struct term *t);
int new_var_name(void);
int new_functor_name(int arity);
void unique_all(struct formula *f);
struct formula *zap_quant(struct formula *f);
void flatten_top(struct formula *f);
struct formula *cnf(struct formula *f);
struct formula *dnf(struct formula *f);
void rename_syms_formula(struct formula *f,
struct formula *fr);
void subst_sn_term(int old_sn,
struct term *t,
int new_sn,
int type);
void subst_sn_formula(int old_sn,
struct formula *f,
int new_sn,
int type);
int gen_subsume_prop(struct formula *c,
struct formula *d);
struct formula *subsume_conj(struct formula *c);
struct formula *subsume_disj(struct formula *c);
int formula_ident(struct formula *f,
struct formula *g);
void conflict_tautology(struct formula *f);
void ts_and_fs(struct formula *f);
struct list *clausify(struct formula *f);
struct list *clausify_formula_list(struct formula_ptr *fp);
struct formula *negation_inward(struct formula *f);
struct formula *expand_imp(struct formula *f);
struct formula *iff_to_conj(struct formula *f);
struct formula *iff_to_disj(struct formula *f);
struct formula *nnf_cnf(struct formula *f);
struct formula *nnf_dnf(struct formula *f);
struct formula *nnf_skolemize(struct formula *f);
struct formula *clausify_formed(struct formula *f);
void rms_conflict_tautology(struct formula *f);
struct formula *rms_subsume_conj(struct formula *c);
struct formula *rms_subsume_disj(struct formula *c);
int free_occurrence(struct term *v,
struct formula *f);
struct formula *rms_distribute_quants(struct formula *f_quant);
struct formula *rms_push_free(struct formula *f);
struct formula *rms_quantifiers(struct formula *f);
struct formula *rms(struct formula *f);
struct formula *renumber_unique(struct formula *f,
int *vnum_p);
int gen_subsume_rec(struct formula *c,
struct context *cs,
struct formula *d,
struct context *ds,
struct trail **tr_p);
int gen_subsume(struct formula *c,
struct formula *d);
int gen_conflict(struct formula *c,
struct formula *d);
int gen_tautology(struct formula *c,
struct formula *d);
struct formula *rms_cnf(struct formula *f);
struct formula *rms_dnf(struct formula *f);
struct formula *distribute_quantifier(struct formula *f);
/* process.c */
void post_proc_all(struct clause *lst_pos,
int input,
struct list *lst);
void infer_and_process(struct clause *giv_cl);
int proc_gen(struct clause *c,
int input);
void pre_process(struct clause *c,
int input,
struct list *lst);
/* misc.c */
void init(void);
void abend(char *str);
void read_a_file(FILE *in_fp,
FILE *out_fp);
void sos_argument(int argc,
char **argv);
void read_all_input(int argc,
char **argv);
void set_lex_vals(struct term *t);
void set_lrpo_status(struct term *t,
int val);
void set_special_unary(struct term *t);
void set_skolem(struct term *t);
void free_all_mem(void);
void output_stats(FILE *fp,
int level);
void print_stats(FILE *fp);
void print_stats_brief(FILE *fp);
void p_stats(void);
void print_times(FILE *fp);
void print_times_brief(FILE *fp);
void p_times(void);
void append_lists(struct list *l1,
struct list *l2);
struct term *copy_term(struct term *t);
int biggest_var(struct term *t);
int biggest_var_clause(struct clause *c);
int ground_clause(struct clause *c);
void zap_list(struct term_ptr *p);
int occurs_in(struct term *t1,
struct term *t2);
int occurrences(struct term *s,
struct term *t);
int sn_occur(int sn,
struct term *t);
int is_atom(struct term *t);
int ident_nested_skolems(struct clause *c);
int ground(struct term *t);
void cleanup(void);
int check_stop(void);
void report(void);
void control_memory(void);
void print_proof(FILE *fp,
struct clause *c);
struct clause *check_for_proof(struct clause *c);
int proper_list(struct term *t);
void move_clauses(int (*clause_proc)(struct clause *c),
struct list *source,
struct list *destination);
struct int_ptr *copy_int_ptr_list(struct int_ptr *p);
int int_list_length(struct int_ptr *p);
void automatic_1_settings(void);
int sos_has_pos_nonground(void);
void automatic_2_settings(void);
void log_for_x_show(FILE *fp);
int same_structure(struct term *t1,
struct term *t2);
void zap_variable_names(struct term *t);
/* lrpo.c */
int lrpo(struct term *t1,
struct term *t2);
int lrpo_greater(struct term *t1,
struct term *t2);
void order_equalities_lrpo(struct clause *c);
/* linkur.c */
void linked_ur_res(struct clause *giv_cl);
int process_linked_tags(struct clause *cp);
/* linkhyp.c */
void linked_hyper_res(struct clause *giv_cl);
/* foreign.c */
long foo(long int l,
double d,
char *s);
long user_test_long(long int l,
double d,
int b,
char *s,
struct term *t);
double user_test_double(long int l,
double d,
int b,
char *s,
struct term *t);
int user_test_bool(long int l,
double d,
int b,
char *s,
struct term *t);
char *user_test_string(long int l,
double d,
int b,
char *s,
struct term *t);
struct term *user_test_term(long int l,
double d,
int b,
char *s,
struct term *t);
void declare_user_functions(void);
int get_args_for_user_function(struct term *t,
int op_code,
long int *long_args,
double *double_args,
int *bool_args,
char **string_args,
struct term **term_args);
struct term *long_to_term(long int i);
struct term *double_to_term(double d);
struct term *bool_to_term(int i);
struct term *string_to_term(char *s);
struct term *evaluate_user_function(struct term *t,
int op_code);
/* geometry.c */
int geo_rewrite(struct clause *c);
void geometry_rule_unif(struct clause *giv_cl);
int child_of_geometry(struct clause *c);
void gl_demod(struct clause *c,
struct list *lst);
/* hot.c */
void init_hot(void);
int heat_is_on(void);
void switch_to_hot_index(void);
void switch_to_ordinary_index(void);
void hot_index_clause(struct clause *c);
void hot_dynamic(struct clause *c);
void hot_mark_clash_cl(struct clause *c,
int mark);
void hot_inference(struct clause *new_cl);
/* nonport.c */
void non_portable_init(int argc,
char **argv);
void sig_handler(int condition);
char *username(void);
char *hostname(void);
void interact(void);
FILE *init_log_for_x_show(void);
int my_process_id(void);
/* check.c */
struct gen_node *get_gen_node(void);
struct proof_object *get_proof_object(void);
struct proof_object_node *get_proof_object_node(void);
struct int_ptr *copy_ip_segment(struct int_ptr *ip,
int n);
void print_int_list(FILE *fp,
struct int_ptr *ip);
void p_int_list(struct int_ptr *ip);
int trivial_subst(struct context *c);
struct proof_object_node *connect_new_node(struct proof_object *new_proof);
void print_term_s(FILE *fp,
struct term *t);
void p_term_s(struct term *t);
void print_clause_s(FILE *fp,
struct clause *c);
void p_clause_s(struct clause *c);
void print_clause_s2(FILE *fp,
struct clause *c);
void p_clause_s2(struct clause *c);
void print_proof_object_node(FILE *fp,
struct proof_object_node *pn);
void p_proof_object_node(struct proof_object_node *pn);
void print_proof_object(FILE *fp,
struct proof_object *po);
void p_proof_object(struct proof_object *po);
struct clause *cl_copy_delete_literal(struct clause *c,
int n);
int variant(struct term *t1,
struct context *c1,
struct term *t2,
struct context *c2,
struct trail **trp,
int flip);
struct int_ptr *match_clauses(struct clause *c1,
struct clause *c2);
struct clause *cl_append(struct clause *c1,
struct clause *c2);
struct clause *identity_resolve(struct clause *c1,
int i1,
struct clause *c2,
int i2);
void renumber_vars_subst(struct clause *c,
struct term **terms);
int finish_translating(struct clause *c,
struct int_ptr *rest_of_history,
struct proof_object_node *current,
struct proof_object *new_proof);
int ipx(struct int_ptr *ip,
int n);
struct proof_object_node *find_match2(struct clause *c,
struct proof_object *obj,
struct term **vars);
int contains_answer_literal(struct clause *c);
int contains_rule(struct clause *c,
int rule);
void zap_int_ptr_list(struct int_ptr *p);
struct int_ptr *trans_2_pos(int id,
struct int_ptr *pos);
void type_2_trans(struct proof_object *po);
void build_proof_object(struct clause *c);
void init_proof_object_environment(void);
/* hints.c */
void process_hint_attributes(struct clause *c);
void print_hint_clause(FILE *fp,
struct clause *c);
void p_hint_clause(struct clause *c);
void print_hints_cl_list(FILE *fp,
struct list *lst);
void p_hints_cl_list(struct list *lst);
void adjust_weight_with_hints(struct clause *c);
int hint_keep_test(struct clause *c);
/* attrib.c */
void init_attributes(void);
int get_attribute_index(char *s);
int attribute_type(int name);
struct cl_attribute *get_attribute(struct clause *c,
int name);
void set_attribute(struct clause *c,
int name,
void *val_ptr);
void delete_attributes(struct clause *c);
struct cl_attribute *term_to_attributes(struct term *t);
void print_attributes(FILE *fp,
struct cl_attribute *a);
/* case.c */
int splitting(void);
int max_split_depth(void);
int splitable_literal(struct clause *c,
struct literal *l);
int splitable_clause(struct clause *c);
struct clause *compare_splitable_clauses(struct clause *c,
struct clause *d);
void print_case(FILE *fp);
void p_case(void);
void print_case_n(FILE *fp,
int n);
void p_case_n(int n);
void p_assumption_depths(char assumptions[]);
struct int_ptr *current_case(void);
void add_subcase(int i);
int case_depth(void);
struct clause *find_clause_to_split(void);
struct term *find_atom_to_split(void);
int prover_forks(int n,
int *ip,
char assumptions[]);
int split_clause(struct clause *giv_cl);
int split_atom(void);
void possible_split(void);
void always_split(void);
void possible_given_split(struct clause *c);
void assumps_to_parent(struct clause *e);
void exit_with_possible_model(void);
/* lisp.c */
/* ivy.c */
int special_is_symbol(struct term *t, char *str, int arity);
void trans_logic_symbols(struct term *t);
struct proof_object *parse_initial_proof_object(FILE *fp);
struct list *init_proof_object(FILE *fin,
FILE *fout);
struct proof_object *retrieve_initial_proof_object(void);
/* pickdiff.c */
struct int_ptr *cldiff(struct clause *c, struct clause *d);
void print_int_ptr(FILE *fp, struct int_ptr *p);
void p_int_ptr(struct int_ptr *p);
void zap_ci_ptr_list(struct ci_ptr *p);
struct clause *find_pickdiff_cl(struct list *sos, struct list *usable);
/* overbeek.c */
void overbeek_insert(struct term *t);
int overbeek_weight(struct term *t, int *ip);
void print_overbeek_world(void);
void check_overbeek_world(void);
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists