| C=:=/1 | |
| C=:=/2 | |
| C__cp_frame | |
| C__dummy_lock_t | |
| C_PL_blob_t | |
| C_PL_extension | |
| Cabolish/1 | abolish(+ PredSpec) |
| Cabolish/2 | abolish(+ P,+ N) |
| Cabolish_module/1 | abolish_module( + Mod) |
| Cabolish_table/1 | YapTab extends the Yap Prolog engine to support sequential tabling |
| Cabort/0 | |
| Cabsolute_file_name/2 | absolute_file_name(+Name:atom,+Path:atom) |
| Cabsolute_file_name/3 | absolute_file_name( -File:atom, +Path:atom, +Options:list) |
| Caccess_file/2 | access_file(+F , +G) |
| Cacyclic_term/1 | |
| Cadd_edges/3 | add_edges(+ Graph, + Edges, - NewGraph) |
| Cadd_import_module/3 | add_import_module( + Module, + ImportModule , +_Pos_) |
| Cadd_to_array_element/4 | add_to_array_element(+ Name, + Index, + Number, ? NewValue) |
| Cadd_to_heap/4 | add_to_heap(OldHeap, Key, Datum, NewHeap) |
| Cadd_to_path/1 | add_to_path(+Directory:atom) |
| Cadd_to_path/2 | add_to_path(+Directory:atom, +Position:atom) |
| Cadd_vertices/3 | add_vertices(+ Graph, + Vertices, - NewGraph) |
| Calarm/3 | alarm(+ Seconds,+ Callable,+ OldAlarm) |
| CAliasDescS | |
| Call/3 | all( T,+ G,- L) |
| Calways_prompt_user/0 | always_prompt_user |
| Canswer_trie_hash | |
| Canswer_trie_node | |
| Cappend/1 | append(+ S) |
| Cappend/2 | append(? Lists,? Combined) |
| Cappend/3 | append(? List1,? List2,? List3) |
| Carg/3 | arg(+ N,+ T, A) |
| Carg0/3 | arg0( +_Index_, +_Term_ , -_Arg_ ) |
| Carg_info | |
| Cargs/3 | args( +_Index_, +_ListOfTerms_ , -_ListOfArgs_ ) |
| Cargs0/3 | args0( +_Index_, +_ListOfTerms_ , -_ListOfArgs_ ) |
| Carray/2 | array( +Name, +Size ) |
| Carray_access_struct | |
| Carray_element/3 | array_element(+ Name, + Index, ? Element) |
| Carray_entry | |
| Cassert/1 | assert(+ C) |
| Cassert/2 | assert(+ C,- R) |
| Cassert_static/1 | assert_static(: C) |
| Casserta/1 | asserta(+ C) |
| Casserta/2 | asserta(+ C,- R) |
| Casserta_static/1 | asserta_static(: C) |
| Cassertz/1 | assertz(+ C) |
| Cassertz/2 | assertz(+ C,- R) |
| Cassertz_static/1 | assertz_static(: C) |
| Cassoc_to_list/2 | assoc_to_list(+ Assoc,? List) |
| Cat_end_of_line/1 | at_end_of_line( +Stream ) |
| Cat_end_of_stream/0 | at_end_of_stream |
| Cat_end_of_stream/1 | at_end_of_stream(+ S) |
| Catom/1 | atom( T) |
| Catom_blob | |
| Catom_chars/2 | atom_chars(? A,? L) |
| Catom_codes/2 | atom_codes(?Atom, ?Codes) |
| Catom_concat/2 | atom_concat(+ As, ? A) |
| Catom_hash_entry | |
| Catom_length/2 | atom_length(+ A,? I) |
| Catom_number/2 | atom_number(? Atom,? Number) |
| Catom_string/1 | atom_string(?Atom.?String) |
| Catom_to_chars/2 | atom_to_chars(+ Atom, - Result) |
| Catom_to_chars/3 | atom_to_chars(+ Atom, - Result0, - Result) |
| Catom_to_string/1 | atom_to_string(?Atom.?String) |
| CAtomEntryStruct | |
| Catomic/1 | atomic(T) |
| Catomic_length/2 | atomic_length(+ A,? I) |
| Catomic_list_concat/2 | atomic_list_concat(+ As,? A) |
| Catomic_list_concat/3 | atomic_list_concat(? As,+ Separator,? A) |
| Catomic_to_string/1 | atomic_to_string(?Atomic.?String) |
| CAtomSwiEntry | |
| Catt_rec | Routine to locate attributed variables |
| Cattr_unify_hook/2 | attr_unify_hook(+ AttValue,+ VarValue) |
| Cattribute_goals/3 | attribute_goals(+ Var,- Gs,+ GsRest) |
| Cattvar/1 | attvar( -Var) |
| Cattvar_struct | Attributed variales are controlled by the attvar_record |
| Cavl_insert/4 | avl_insert(+ Key,? Value,+ T0,- TF) |
| Cavl_lookup/3 | avl_lookup(+ Key,- Value,+ T) |
| Cavl_new/1 | avl_new(+ T) |
| Cb_getval/2 | b_getval(+ Name, - Value) |
| Cb_hash_insert_new/4 | b_hash_insert_new(+_Hash_, +_Key_, Val, +_NewHash_ ) |
| Cb_hash_lookup/3 | b_hash_lookup( +_Key_, ?_Val_, +_Hash_ ) |
| Cb_hash_new/1 | b_hash_new( -NewHash ) |
| Cb_hash_new/2 | b_hash_new( -_NewHash_, +_Size_ ) |
| Cb_hash_new/4 | b_hash_new( -_NewHash_, +_Size_, :Hash, :Cmp ) |
| Cb_hash_size/2 | b_hash_size( +_Hash_, -_Size_ ) |
| Cb_hash_to_list/2 | b_hash_to_list(+_Hash_, -_KeyValList_ ) |
| Cb_hash_update/3 | b_hash_update( +_Key_, +_Hash_, +NewVal ) |
| Cb_hash_update/4 | b_hash_update( +_Key_, -_OldVal_, +_Hash_, +NewVal ) |
| Cb_key_to_list/2 | b_key_to_list(+_Hash_, -_KeyList_ ) |
| Cbagof/3 | bagof( T,+ G,- L) |
| Cbb_delete/2 | bb_delete(+ Key,? Term) |
| Cbb_get/2 | bb_get(+ Key,? Term) |
| Cbb_put/2 | bb_put(+ Key,? Term) |
| Cbb_update/3 | bb_update( +_Key_, ?_Term_, ?_New_) |
| Cbetween/3 | between(+ Low:int, + High:int, ? Value:int) |
| CBlackBoardEntry | |
| Cblank/2 | blank(+ Line,+ RestOfLine) |
| Cblock/1 | block(C) |
| Cbranch_descriptor | |
| Cbucket | |
| Cbuf_struct_t | |
| Cbuffer_ds | |
| Cbventry | |
| Cc_error_info | |
| Ccall/1 | call( 0:P ) |
| Ccall/4 | call(+ Closure,...,? Ai,...) |
| Ccall_cleanup/2 | call_cleanup(: Goal, : CleanUpGoal) |
| Ccall_count/3 | call_count(? CallsMax, ? RetriesMax, ? CallsAndRetriesMax) |
| Ccall_count_data/3 | call_count_data(- Calls, - Retries, - CallsAndRetries) |
| Ccall_in_module/1 | call_in_module( +M:G ) |
| Ccall_residue/2 | call_residue(: G, L) |
| Ccall_residue_vars/2 | call_residue_vars(: G, L) |
| Ccall_shared_object_function/2 | call_shared_object_function(+ Handle, + Function) |
| Ccall_with_args/4 | call_with_args(+ Name,...,? Ai,...) |
| Ccallable/1 | callable( ?_Goal_ ) |
| Ccatch/3 | catch( : Goal,+ Exception,+ Action) |
| Ccd/1 | cd(+ D) |
| Ccell_size_t | |
| Ccell_space | A cell_space is a short code region, where we want bindings to proceed locally |
| CCEXPENTRY | |
| Cchar_code/2 | char_code(? A,? I) |
| Cchar_type/2 | char_type(?_Char_ , ?Type) |
| Cchecklist/2 | checklist( 1:Pred, + List) |
| Cchecknodes/2 | checknodes(+ Pred, + Term) |
| Cchoicept | |
| Cclause/1 | clause( +Term ) |
| Cclause/2 | clause(+ H, B) |
| Cclause/3 | clause(+ H, B,- R) |
| Cclause_info_struct | |
| Cclause_obj | |
| Cclause_ptr | |
| CClauseList | |
| Cclose/1 | close(+ S) |
| Cclose/2 | close(+ S,+ O) |
| Cclose_shared_object/1 | |
| Cclose_static_array/1 | close_static_array(+ Name) |
| Ccmp_op_info_struct | |
| Ccollate_st_chain_pri | |
| Ccollate_st_char_pri | |
| Ccommons_directory/1 | commons_directory(? Directory:atom) |
| Ccompile/1 | compile(+ F ) |
| Ccompile_predicates/1 | compile_predicates(: ListOfNameArity) |
| Ccompiler_struct_struct | |
| Ccomplement/2 | complement(+ Graph, - NewGraph) |
| Ccompose/3 | compose(+ LeftGraph, + RightGraph, - NewGraph) |
| Ccompound/1 | compound( T) |
| Cconsult/1 | consult(+ F) |
| CCONSULT_OBJ | |
| Cconsumer_choicept | |
| Cconvlist/3 | convlist(: Pred, + ListIn, ? ListOut) |
| Cconvlist/4 | convlist(: Pred, ? ListIn, ?ExtraList, ? ListOut) |
| Ccopy_frame | |
| Ccopy_line/2 | copy_line(+ StreamInput,+ StreamOutput) |
| Ccopy_term/2 | copy_term(? TI,- TF) |
| Ccopy_term/3 | copy_term(? TI,- TF,- Goals) |
| Ccopy_term_nat/2 | copy_term_nat(? TI,- TF) |
| Ccp_frame | |
| Ccreate_array/2 | create_array(?Name, + Size) |
| Ccreate_mutable/2 | create_mutable(+ D,- M) |
| Ccreate_prolog_flag/3 | create_prolog_flag( +Flag, +Value, +Options) |
| Ccset | |
| Ccurrent_atom/1 | current_atom( A) |
| Ccurrent_char_conversion/2 | current_char_conversion(? IN,? OUT) |
| Ccurrent_choice_point/1 | current_choice_point( -CP ) |
| Ccurrent_error/1 | current_error(- S) |
| Ccurrent_host/1 | current_host(? HOSTNAME) |
| Ccurrent_input/1 | current_input(+ S) |
| Ccurrent_key/2 | current_key(? A,? K) |
| Ccurrent_line_number/1 | current_line_number(- LineNumber) |
| Ccurrent_line_number/2 | current_line_number(+ Stream,- LineNumber) |
| Ccurrent_module/1 | current_module( ? Mod:atom) |
| Ccurrent_module/2 | current_module( ? Mod:atom, ? F : file ) |
| Ccurrent_mutex/3 | current_mutex(? MutexId, ? ThreadId, ? Count) |
| Ccurrent_op/3 | current_op( P, T, F) |
| Ccurrent_output/1 | current_output(+ S) |
| Ccurrent_predicate/1 | current_predicate( F ) |
| Ccurrent_predicate/2 | current_predicate( A, P) |
| Ccurrent_prolog_flag/2 | current_prolog_flag(? Flag,- Value) |
| Ccurrent_prolog_flag/3 | current_prolog_flag(? Flag,- Value, +_New_) |
| Ccurrent_stack/1 | current_stack( +Depth ) |
| Ccurrent_stream/3 | current_stream( F, M, S) |
| Ccurrent_thread/2 | current_thread(+ Id, - Status) |
| Ccut_c_str | |
| Ccwk_segment | A segment represents a single component of a path |
| Ccwk_segment_joined | A joined path represents multiple path strings which are concatenated, but not (necessarily) stored in contiguous memory |
| Ccyclic_term/1 | cyclic_term( + T ) |
| Cdatime/6 | datime(datime(- Year, - Month, - DayOfTheMonth, - Hour, - Minute, - Second) |
| Cdb_dynamic/1 | db_dynamic(+ Threshold) |
| Cdb_entry | |
| Cdb_globs | |
| Cdb_reference/1 | db_reference( T) |
| Cdb_static/1 | db_static(+ Threshold) |
| CDB_STRUCT | |
| CDB_TERM | |
| Cdb_trie_opt_level | |
| Cdbterm_list | |
| CDdChildren | The two children of a non-terminal node |
| CDdNode | Decision diagram node |
| Cdel_assoc/4 | del_assoc(+ Key, + Assoc, ? Val, ? NewAssoc) |
| Cdel_attr/2 | del_attr(+ Var,+ Module) |
| Cdel_attrs/1 | del_attrs(+ Var) |
| Cdel_edges/3 | del_edges(+ Graph, + Edges, - NewGraph) |
| Cdel_max_assoc/4 | del_max_assoc(+ Assoc, ? Key, ? Val, ? NewAssoc) |
| Cdel_min_assoc/4 | del_min_assoc(+ Assoc, ? Key, ? Val, ? NewAssoc) |
| Cdel_vertices/3 | del_vertices(+ Graph, + Vertices, - NewGraph) |
| Cdelete/3 | delete(+ List, ? Element, ? Residue) |
| Cdelete_file/2 | delete_file(+ File,+ Opts) |
| Cdelete_import_module/2 | delete_import_module( + ExportModule, + ImportModule ) |
| Cdependency_frame | |
| Cdgraph_add_edge/4 | dgraph_add_edge(+ Graph, + N1, + N2, - NewGraph) |
| Cdgraph_add_edges/3 | dgraph_add_edges(+ Graph, + Edges, - NewGraph) |
| Cdgraph_add_vertex/3 | dgraph_add_vertex(+ Graph, + Vertex, - NewGraph) |
| Cdgraph_add_vertices/3 | dgraph_add_vertices(+ Graph, + Vertices, - NewGraph) |
| Cdgraph_complement/2 | dgraph_complement(+ Graph, - NewGraph) |
| Cdgraph_del_edge/4 | dgraph_del_edge(+ Graph, + N1, + N2, - NewGraph) |
| Cdgraph_del_edges/3 | dgraph_del_edges(+ Graph, + Edges, - NewGraph) |
| Cdgraph_del_vertex/3 | dgraph_del_vertex(+ Graph, + Vertex, - NewGraph) |
| Cdgraph_del_vertices/3 | dgraph_del_vertices(+ Graph, + Vertices, - NewGraph) |
| Cdgraph_edge/3 | dgraph_edge(+ N1, + N2, + Graph) |
| Cdgraph_edges/2 | dgraph_edges(+ Graph, - Edges) |
| Cdgraph_isomorphic/4 | dgraph_isomorphic(+ Vs, + NewVs, + G0, - GF) |
| Cdgraph_leaves/2 | dgraph_leaves(+ Graph, ? Vertices) |
| Cdgraph_max_path/5 | dgraph_max_path(+ V1, + V1, + Graph, - Path, ? Costt) |
| Cdgraph_min_path/5 | dgraph_min_path(+ V1, + V1, + Graph, - Path, ? Costt) |
| Cdgraph_min_paths/3 | dgraph_min_paths(+ V1, + Graph, - Paths) |
| Cdgraph_neighbors/3 | dgraph_neighbors(+ Vertex, + Graph, - Vertices) |
| Cdgraph_neighbours/3 | dgraph_neighbours(+ Vertex, + Graph, - Vertices) |
| Cdgraph_new/1 | dgraph_new(+ Graph) |
| Cdgraph_path/3 | dgraph_path(+ Vertex, + Graph, ? Path) |
| Cdgraph_path/4 | dgraph_path(+ Vertex, + Vertex1, + Graph, ? Path) |
| Cdgraph_reachable/3 | dgraph_reachable(+ Vertex, + Graph, ? Edges) |
| Cdgraph_symmetric_closure/2 | dgraph_symmetric_closure(+ Graph, - Closure) |
| Cdgraph_to_ugraph/2 | dgraph_to_ugraph(+ Graph, - UGraph) |
| Cdgraph_top_sort/2 | dgraph_top_sort(+ Graph, - Vertices) |
| Cdgraph_top_sort/3 | dgraph_top_sort(+ Graph, - Vertices, ? Vertices0) |
| Cdgraph_transitive_closure/2 | dgraph_transitive_closure(+ Graph, - Closure) |
| Cdgraph_transpose/2 | dgraph_transpose(+ Graph, - Transpose) |
| Cdgraph_vertices/2 | dgraph_vertices(+ Graph, - Vertices) |
| Cdif/2 | dif( X, Y) |
| Cdirectory_files/2 | directory_files(+ Dir,+ List) |
| Cdirectory_map/2 | directory_map(+ Dir, 1:P) |
| Cdiscontiguous/1 | discontiguous(+ G) |
| Cdisplay/1 | display(+ T) |
| Cdisplay/2 | display(+ S, T) |
| Cdomain_error/3 | domain_error(+Type, +Value, +Term) |
| Cdowncase_text_to_atom/2 | downcase_text_to_atom(+Text, -Atom) |
| Cdowncase_text_to_chars/2 | downcase_text_to_chars(+Text, -Chars) |
| Cdowncase_text_to_codes/2 | downcase_text_to_codes(+Text, -Codes) |
| Cdowncase_text_to_string/2 | downcase_text_to_string(+Text, -String) |
| Cduplicate_term/2 | duplicate_term(? TI,- TF) |
| Cdynamic/1 | dynamic( + P ) |
| Cdynamic_clause | |
| Cdynamic_predicate/2 | dynamic_predicate(+ P,+ Semantics) |
| Cedges/2 | edges(+ Graph, - Edges) |
| Celif/1 | elif(+ Goal) |
| Cempty_assoc/1 | empty_assoc(+ Assoc) |
| Cempty_heap/1 | empty_heap(? Heap) |
| Cempty_queue/1 | empty_queue(+ Queue) |
| Cenc_map | |
| Censure_loaded/1 | ensure_loaded(+ F) |
| Censure_prompting/0 | ensure_prompting |
| Cenv_tmp | |
| Cenviron/2 | environ(? EnvVar,+ EnvValue) |
| Cerase/1 | erase(+ R) |
| Ceraseall/1 | eraseall(+ K) |
| Cerased/1 | erased(+ R) |
| Cexception/3 | exception(+ Exception, + Context, - Action) |
| Cexclude/3 | exclude( 2:Goal, + List1, ? List2) |
| Cexec/3 | exec(+ Command, StandardStreams, -PID) |
| Cexistence_error/2 | existence_error(+Type, +Term) |
| Cexists/1 | exists(+ F) |
| Cexo_udi_access_t | |
| Cexpand_exprs/2 | expand_exprs(- O,+ N) |
| Cexpand_term/2 | expand_term( T,- X) |
| CExpEntry | |
| Cexport_atom_hash_entry_struct | |
| Cexport_dbref_hash_entry_struct | |
| Cexport_functor_hash_entry_struct | |
| Cexport_pred_entry_hash_entry_struct | |
| Cext_op | |
| CExtraAtomEntryStruct | |
| Cfail/0 | fail |
| Cfalse/0 | false |
| CFEnv | |
| Cfields/2 | fields(+ Line,- Split) |
| Cfields/3 | fields(+ Line,+ Separators,- Split) |
| Cfile_exists/1 | file_exists(+ _File__) |
| Cfile_filter/3 | file_filter(+ FileIn, + FileOut, + Goal) |
| Cfile_filter_with_initialization/5 | file_filter_with_initialization(+ FileIn, + FileOut, + Goal, + FormatCommand, + Arguments) |
| Cfile_filter_with_start_end/5 | file_filter_with_start_end(+ FileIn, + FileOut, + Goal, + StartGoal, + EndGoal) |
| Cfile_name_extension/3 | file_name_extension( ? BaseFile, ?Extension, ?FullNameO) |
| Cfile_property/2 | file_property(+ File,? Property) |
| Cfile_search_path/2 | file_search_path(+Name:atom, -Directory:atom) |
| Cfile_select/2 | file_select(+ FileIn, + Goal) |
| Cfilter/3 | filter(+ StreamInp, + StreamOut, + Goal) |
| Cfindall/3 | findall( T,+ G,- L) |
| Cfindall/4 | findall( ?Key, +Goal, +InitialSolutions, -Solutions ) |
| Cflag_info | prolog_flag/2 support, notice flag is initialized as text |
| CFlagEntry | |
| Cflags_type_definition/3 | flags_type_definition(TypeName, TypeHandler, TypeValidator) |
| CflagTerm | Flag is represented as a Prolog term |
| Cflatten/2 | flatten(+ List, ? FlattenedList) |
| Cfloat/1 | float( T) |
| Cflush_output/0 | flush_output |
| Cflush_output/1 | flush_output(+Stream) |
| Cfoldl/5 | foldl(: Pred, + List1, + List2, ? AccIn, ? AccOut) |
| Cfoldl/6 | foldl(:Goal, +List, +V0, -V, +W0, -WN) |
| Cfoldl2/6 | foldl2(: Pred, + List, ? X0, ? X, ? Y0, ? Y) |
| Cfoldl2/7 | V |
| Cfoldl2/8 | foldl2(: Pred, + List, ? List1, ? List2, ? X0, ? X, ? Y0, ? Y) |
| Cfoldl3/9 | foldl3(: Pred, + List1, ? List2, ? X0, ? X, ? Y0, ? Y, ? Z0, ? Z) |
| Cfoldl4/11 | foldl4(: Pred, + List1, ? List2, ? X0, ? X, ? Y0, ? Y, ? Z0, ? Z, ? W0, ? W) |
| Cforall/2 | forall(: Cond,: Action) |
| Cforeign_context | |
| Cforeign_directory/1 | foreign_directory(? Directory:atom) |
| CForeignLoadItem | |
| Cformat/1 | format(+ T) |
| Cformat/2 | format(+ T, :L) |
| Cformat_status | |
| Cformat_to_chars/3 | format_to_chars(+ Form, + Args, - Result) |
| Cformat_to_chars/4 | format_to_chars(+ Form, + Args, - Result, - Result0) |
| CFREEB | |
| Cfreeze/2 | freeze(? X,: G) |
| Cfrozen/2 | frozen( X, G) |
| CFuncSwiEntry | |
| Cfunctor/3 | functor( T, F, N) |
| CFunctorEntryStruct | |
| Cgap_t | |
| Cgc_entry_info | |
| Cgc_ma_hash_entry_struct | |
| Cgc_mark_continuation | |
| Cgen_assoc/3 | gen_assoc( ?Key, +Assoc, ?Valu_) |
| Cgenarg/3 | genarg( ?Index, +Term , -Arg ) |
| Cgenarg0/3 | genarg0( +_Index_, +_Term_ , -_Arg_ ) |
| Cgenerator_choicept | |
| Cget/1 | get(- C) |
| Cget/2 | get(S, - C) |
| Cget_assoc/3 | get_assoc(+ Key,+ Assoc,? Value) |
| Cget_assoc/5 | get_assoc(+ Key,+ Assoc,? Value,+ NAssoc,? NValue) |
| Cget_attr/3 | get_attr( + Var,+ Module,- Value) |
| Cget_attrs/2 | get_attrs(+ Var,- Attributes) |
| Cget_byte/1 | get_byte(- C) |
| Cget_byte/2 | get_byte(+ S,- C) |
| Cget_char/1 | get_char(- C) |
| Cget_char/2 | get_char(+ S,- C) |
| Cget_code/1 | get_code(- C) |
| Cget_code/2 | get_code(+ S,- C) |
| Cget_label/3 | get_label(+ Index, + Tree, ? Label) |
| Cget_mutable/2 | get_mutable(? D,+ M) |
| Cget_next_assoc/4 | get_next_assoc(+ Key,+ Assoc,? Next,? Value) |
| Cget_prev_assoc/4 | get_prev_assoc(+ Key,+ Assoc,? Next,? Value) |
| Cget_time/1 | get_time(-T) |
| Cget_value/2 | get_value(+ A,- V) |
| Cgetcwd/1 | getcwd(- D) |
| Cgetrand/1 | getrand(- Key) |
| Cglobal_data | |
| Cglobal_entry | |
| Cglobal_optyap_data | |
| Cglobal_page_entry | |
| Cglobal_pages | |
| Cglobal_trie_hash | |
| Cglobal_trie_node | |
| Cglue/3 | glue(+ Words,+ Separator,- Line) |
| Cgoal_expansion/3 | goal_expansion( :G,+ M,- NG) |
| Cgoalexpansion/3 | goalexpansion(+ G,+ M,- NG) |
| Cground/1 | ground( T) |
| CGroupDef | |
| Cgrow_heap/1 | grow_heap(+ Size) |
| Cgrow_stack/1 | grow_stack(+ Size) |
| Chalt/1 | halt(+ I) |
| Chalt_hook | |
| Chashtable_s | |
| Chead_queue/2 | head_queue(+ Queue, ? Head) |
| Cheap_size/2 | heap_size(+ Heap, - Size) |
| Cheap_to_list/2 | heap_to_list(+ Heap, - List) |
| Chidden_atom/1 | hidden_atom( +Atom ) |
| Chide_atom/1 | hide_atom(+ Atom) |
| Chide_predicate/1 | hide_predicate(+ Pred) |
| Chold_entry | |
| Chost_id/1 | host_id(- Id) |
| Chost_name/1 | host_name(- Name) |
| Chostname_address/2 | hostname_address(? HOSTNAME,? IP_ADDRESS) |
| Cidb_queue | |
| Cidentical_member/2 | identical_member(?Element, ?Set) |
| Cif/1 | if( : Goal) |
| Cif/3 | if(? G,? H,? I) |
| Cignore/1 | ignore(: Goal) |
| Cimport_atom_hash_entry_struct | |
| Cimport_dbref_hash_entry_struct | |
| Cimport_functor_hash_entry_struct | |
| Cimport_module/2 | import_module( +ImportingModule, +ExportingModule ) |
| Cimport_opcode_hash_entry_struct | |
| Cimport_pred_entry_hash_entry_struct | |
| Cinclude/1 | include(+ F) |
| Cinclude/3 | include( 2:Pred, + ListIn, ? ListOut) |
| Cincore/1 | incore( 0:P ) |
| Cindex_t | |
| Cinit_const_eval | |
| Cinit_un_eval | |
| Cinitialization/1 | initialization(+ G) |
| Cinitialization/2 | initialization(+ Goal,+ When) |
| Cinstance/2 | instance(+ R,- T) |
| Cinstantiation_error/1 | instantiation_error(+Term) |
| Cinteger/1 | integer( T) |
| Cinteger/3 | integer(? Int,+ Line,+ RestOfLine) |
| Cintermediates | |
| Cintersection/3 | intersection(+ Set1, + Set2, + Set3) |
| Cis/2 | is( X:number, + Y:ground) |
| Cis_assoc/1 | is_assoc(+ Assoc) |
| Cis_b_hash/1 | is_b_hash( +Hash ) |
| Cis_callable/1 | is_callable( ?_Goal_ ) |
| Cis_list/1 | is_list( ?_List_ ) |
| Cis_mutable/1 | is_mutable(? D) |
| Cis_nonvar/1 | is_nonvar(T) |
| Cis_not/2 | is_not(+Type, @Term) |
| Cis_tabled/1 | is_tabled(+ P) |
| Cisinf/1 | isinf(? X:float) |
| Cisnan/1 | isnan(? X:float) |
| Cistack_entry | |
| Citrie_data | |
| Citrie_entry | |
| Cjmp_buff_struct | |
| Cjoin_queue/3 | join_queue(+ Element, + OldQueue, - NewQueue) |
| Cjump_queue/3 | jump_queue(+ Element, + OldQueue, - NewQueue) |
| Ckey_statistics/3 | key_statistics(+ K,- Entries,- TotalSize) |
| Ckey_statistics/4 | key_statistics(+ K,- Entries,- Size,- IndexSize) |
| Ckeysort/2 | keysort(+ L, S) |
| Clast/2 | last(+ List,? Last) |
| Cleash/1 | leash(+ M) |
| Clength/2 | length(? L,? S) |
| Clength_queue/2 | length_queue(+ Queue, - Length) |
| Clibrary_directory/1 | library_directory(?Directory:atom) |
| Clist_concat/2 | list_concat(+ Lists,? List) |
| Clist_directory/2 | list_directory(+ Dir, -ListOfFiles) |
| Clist_join_queue/3 | list_join_queue(+ List, + OldQueue, - NewQueue) |
| Clist_jump_queue/3 | list_jump_queue(+ List, + OldQueue, + NewQueue) |
| Clist_to_assoc/2 | list_to_assoc(+ List,? Assoc) |
| Clist_to_heap/2 | list_to_heap(+ List, - Heap) |
| Clist_to_ord_set/2 | list_to_ord_set(+List, ?Set) |
| Clist_to_queue/2 | list_to_queue(+ List, - Queue) |
| Clist_to_tree/2 | list_to_tree(+ List, - Tree) |
| Clisting/1 | listing(+ P) |
| Clisting/2 | listing(Stream, + P) |
| Clive_term | |
| Cload_absolute_foreign_files/3 | load_absolute_foreign_files( Files, Libs, InitRoutine) |
| Cload_db/1 | load_db(+ Files) |
| Cload_files/2 | load_files(+_Files_, +_Options_) |
| Cload_foreign_files/3 | load_foreign_files( Files, Libs, InitRoutine) |
| Cload_mega_clause/1 | load_mega_clause( +Stream ) |
| Cloader_choicept | |
| Clocal_optyap_data | |
| Clocal_page_entry | |
| Clog_goal/2 | log_goal( +Tag , :Goal ) |
| Clog_section/1 | log_section( +String ) |
| Clog_title/1 | log_title( +String ) |
| Clog_unit/2 | log_unit( +String, + Level ) |
| Clogic_upd_clause | |
| Clogic_upd_index | |
| Clogsum/3 | logsum(+ Log1:float, + Log2:float, - Out:float ) |
| CLogUpdDBEntry | |
| Cm | A matrix |
| Cmake_diagram/2 | make_diagram(+Inputfilename, +Ouputfilename) |
| Cmake_diagram/5 | make_diagram(+Inputfilename, +Ouputfilename, +Predicate, +Depth, +Extension) |
| Cmake_directory/1 | make_directory(+ Dir) |
| Cmake_queue/1 | make_queue(+ Queue) |
| Cmap_assoc/2 | map_assoc(+ Pred,+ Assoc) |
| Cmap_assoc/3 | map_assoc(+ Pred,+ Assoc,? New) |
| Cmap_tree/3 | map_tree(+ Pred, + OldTree, - NewTree) |
| Cmaplist/3 | maplist( 2:Pred, + List1,+ List2) |
| Cmaplist/4 | maplist(3:Pred,+ List1,+ List2,+ List4) |
| Cmaplist/5 | maplist(: Pred, ? L1, ? L2, ? L3, ? L4) |
| Cmaplist/6 | maplist(: Pred, ? L1, ? L2, ? L3, ? L4, ? L5) |
| Cmapnodes/3 | mapnodes(+ Pred, + TermIn, ? TermOut) |
| Cmatch | |
| Cmatlab_cells/2 | matlab_cells(+ Size, ? Array) |
| Cmatlab_cells/3 | matlab_cells(+ SizeX, + SizeY, ? Array) |
| Cmatlab_eval_string/1 | matlab_eval_string(+ Command) |
| Cmatlab_eval_string/2 | matlab_eval_string(+ Command, - Answer) |
| Cmatlab_get_variable/2 | matlab_get_variable(+ MatVar, - List) |
| Cmatlab_initialized_cells/4 | matlab_initialized_cells(+ SizeX, + SizeY, + List, ? Array) |
| Cmatlab_item/3 | matlab_item(+ MatVar, + X, ? Val) |
| Cmatlab_item/4 | matlab_item(+ MatVar, + X, + Y, ? Val) |
| Cmatlab_item1/3 | matlab_item1(+ MatVar, + X, ? Val) |
| Cmatlab_item1/4 | matlab_item1(+ MatVar, + X, + Y, ? Val) |
| Cmatlab_matrix/4 | matlab_matrix(+ SizeX, + SizeY, + List, ? Array) |
| Cmatlab_sequence/3 | matlab_sequence(+ Min, + Max, ? Array) |
| Cmatlab_set/4 | matlab_set(+ MatVar, + X, + Y, + Value) |
| Cmatlab_vector/3 | matlab_vector(+ Size, + List, ? Array) |
| Cmatlab_zeros/2 | matlab_zeros(+ Size, ? Array) |
| Cmatlab_zeros/3 | matlab_zeros(+ SizeX, + SizeY, ? Array) |
| Cmatlab_zeros/4 | matlab_zeros(+ SizeX, + SizeY, + SizeZ, ? Array) |
| Cmatrix_agg_cols/3 | matrix_agg_cols(+ Matrix,+Operator,+ Aggregate) |
| Cmatrix_agg_lines/3 | matrix_agg_lines(+ Matrix,+Operator,+ Aggregate) |
| Cmatrix_arg_to_offset/3 | matrix_arg_to_offset(+ Matrix,+ Position,- Offset) |
| Cmatrix_column/3 | matrix_column(+ Matrix,+ Column,- NewMatrix) |
| Cmatrix_dec/2 | matrix_dec(+ Matrix,+ Position) |
| Cmatrix_dec/3 | matrix_dec(+ Matrix,+ Position,- Element) |
| Cmatrix_get/3 | matrix_get(+ Matrix,+ Position,- Elem) |
| Cmatrix_new/3 | matrix_new(+ Type,+ Dims,- Matrix) |
| Cmatrix_new/4 | matrix_new(+ Type,+ Dims,+ List,- Matrix) |
| Cmatrix_new_set/4 | matrix_new_set(? Dims,+ OldMatrix,+ Value,- NewMatrix) |
| Cmatrix_offset_to_arg/3 | matrix_offset_to_arg(+ Matrix,- Offset,+ Position) |
| Cmatrix_op/4 | matrix_op(+ Matrix1,+ Matrix2,+ Op,- Result) |
| Cmatrix_op_to_all/4 | matrix_op_to_all(+ Matrix1,+ Op,+ Operand,- Result) |
| Cmatrix_op_to_cols/4 | matrix_op_to_cols(+ Matrix1,+ Cols,+ Op,- Result) |
| Cmatrix_op_to_lines/4 | matrix_op_to_lines(+ Matrix1,+ Lines,+ Op,- Result) |
| Cmatrix_select/4 | matrix_select(+ Matrix,+ Dimension,+ Index,- New) |
| Cmatrix_shuffle/3 | matrix_shuffle(+ Matrix,+ NewOrder,- Shuffle) |
| Cmatrix_size/2 | matrix_size(+ Matrix,- NElems) |
| Cmatrix_sum/2 | matrix_sum(+ Matrix,+ Sum) |
| Cmatrix_to_list/2 | matrix_to_list(+ Matrix,- Elems) |
| Cmatrix_transpose/2 | matrix_transpose(+ Matrix,- Transpose) |
| Cmatrix_type/2 | matrix_type(+ Matrix,- Type) |
| Cmax/1 | max(+ Expression) |
| Cmax/2 | max( X, Vs) |
| Cmax_assoc/3 | max_assoc(+ Assoc,- Key,? Value) |
| Cmax_list/2 | max_list(? Numbers, ? Max) |
| Cmblock | |
| Cmd5_state_s | |
| Cmem_blk | |
| Cmem_desc | |
| Cmember/2 | Member(?Element, ?Set) is true when Set is a list, and Element occurs in it |
| Cmemberchk/2 | memberchk(+ Element, + Set) |
| Cmessage_hook/3 | message_hook(+ Term, + Kind, + Lines) |
| Cmessage_queue_create/1 | message_queue_create(? Queue) |
| Cmessage_queue_destroy/1 | message_queue_destroy(+ Queue) |
| Cmessage_to_string/2 | message_to_string(+ Term, - String) |
| Cmeta_predicate/3 | meta_predicate(G1 , Gj , Gn) |
| Cmin/1 | min(+ Expression) |
| Cmin/2 | min( X, Vs) |
| Cmin_assoc/3 | min_assoc(+ Assoc,- Key,? Value) |
| Cmin_list/2 | min_list(? Numbers, ? Min) |
| Cmin_of_heap/3 | min_of_heap(Heap, Key, Datum) |
| Cmktemp/2 | mktemp( Spec,- File) |
| Cmktime/2 | mktime(+_Datime_, - Seconds) |
| Cmmapped_array/4 | mmapped_array(+ Name, + Size, + Type, + File) |
| Cmod_entry | Module property: low-level data used to manage modes |
| Cmodule/1 | module(+M) |
| Cmodule/2 | module(+ M:atom,+ L:list ) |
| Cmodule_property/2 | module_property( +Module, ? Property ) |
| Cmodule_transparent/1 | module_transparent( + Preds ) |
| CMP_INT | |
| CMP_RAT | |
| Cmpi_bcast2/2 | mpi_bcast2(+ Root, ? Data) |
| Cmpi_comm_rank/1 | mpi_comm_rank(- Rank) |
| Cmpi_comm_size/1 | mpi_comm_size(- Size) |
| Cmpi_irecv/3 | mpi_irecv(? Source,? Tag,- Handle) |
| Cmpi_isend/4 | mpi_isend(+ Data,+ Dest,+ Tag,- Handle) |
| Cmpi_msg_size/2 | mpi_msg_size( Msg, - MsgSize) |
| Cmpi_recv/3 | mpi_recv(? Source,? Tag,- Data) |
| Cmpi_send/3 | mpi_send(+ Data,+ Dest,+ Tag) |
| Cmpi_test/2 | mpi_test(? Handle,- Status) |
| Cmpi_test_recv/3 | mpi_test_recv(? Handle,- Status,- Data) |
| Cmpi_version/2 | mpi_version(- Major,- Minor) |
| Cmpi_wait/2 | mpi_wait(? Handle,- Status) |
| Cmpi_wait_recv/3 | mpi_wait_recv(? Handle,- Status,- Data) |
| Cmultifile/1 | multifile( P ) |
| Cmust_be_bound/1 | must_be_bound( ?_T_ ) |
| Cmust_be_callable/1 | must_be_callable( ?_Goal_ ) |
| Cmust_be_ground/1 | must_be_ground( ?_T_ ) |
| Cmust_be_predicate_indicator/4 | must_be_predicate_indicator( Term, Module, Name, Arity ) |
| Cmutex_create/1 | mutex_create(? MutexId) |
| Cmutex_entry | |
| Cname/2 | name( A, L) |
| Cnatural/3 | natural(? Nat,+ Line,+ RestOfLine) |
| Cnb_beam/2 | nb_beam(+ DefaultSize,- Beam) |
| Cnb_beam_add/3 | nb_beam_add(+ Beam, + Key, + Value) |
| Cnb_beam_close/1 | nb_beam_close(+ Beam) |
| Cnb_beam_del/3 | nb_beam_del(+ Beam, - Key, - Value) |
| Cnb_beam_empty/1 | nb_beam_empty(+ Beam) |
| Cnb_beam_peek/3 | nb_beam_peek(+ Beam, - Key, - Value) |
| Cnb_beam_size/2 | nb_beam_size(+ Beam, - Size) |
| Cnb_current/2 | nb_current(? Name, ? Value) |
| Cnb_delete/1 | nb_delete(+ Name) |
| Cnb_getval/2 | nb_getval(+ Name, - Value) |
| Cnb_heap/2 | nb_heap(+ DefaultSize,- Heap) |
| Cnb_heap_add/3 | nb_heap_add(+ Heap, + Key, + Value) |
| Cnb_heap_close/1 | nb_heap_close(+ Heap) |
| Cnb_heap_del/3 | nb_heap_del(+ Heap, - Key, - Value) |
| Cnb_heap_empty/1 | nb_heap_empty(+ Heap) |
| Cnb_heap_peek/3 | nb_heap_peek(+ Heap, - Key, - Value) |
| Cnb_heap_size/2 | nb_heap_size(+ Heap, - Size) |
| Cnb_linkarg/3 | nb_linkarg(+ Arg, + Term, + Value) |
| Cnb_linkval/2 | nb_linkval(+ Name, + Value) |
| Cnb_queue/1 | nb_queue(- Queue) |
| Cnb_queue_close/3 | nb_queue_close(+ Queue, - Head, ? Tail) |
| Cnb_queue_dequeue/2 | nb_queue_dequeue(+ Queue, - Element) |
| Cnb_queue_empty/1 | nb_queue_empty(+ Queue) |
| Cnb_queue_enqueue/2 | nb_queue_enqueue(+ Queue, + Element) |
| Cnb_queue_peek/2 | nb_queue_peek(+ Queue, - Element) |
| Cnb_queue_size/2 | nb_queue_size(+ Queue, - Size) |
| Cnb_set_shared_arg/3 | nb_set_shared_arg(+ Arg, + Term, + Value) |
| Cnb_set_shared_val/2 | nb_set_shared_val(+ Name, + Value) |
| Cnb_setarg/3 | nb_setarg(+{Arg], + Term, + Value) |
| Cnb_setval/2 | nb_setval(+ Name,+ Value) |
| Cneighbors/3 | neighbors(+ Vertex, + Graph, - Vertices) |
| Cneighbours/3 | neighbours(+ Vertex, + Graph, - Vertices) |
| Cnew_variables_in_term/3 | new_variables_in_term(+_CurrentVariables_, ? Term, -_Variables_) |
| Cnl/0 | nl |
| Cnl/1 | nl(+ S) |
| Cno_source/0 | no_source |
| Cno_style_check/1 | no_style_check(+ X) |
| Cnonvar/1 | nonvar( T) |
| Cnospy/1 | nospy( + P ) |
| Cnth/3 | nth(? N, ? List, ? Elem) |
| Cnth/4 | nth(? N, ? List, ? Elem, ? Rest) |
| Cnth0/3 | nth0(? N, ? List, ? Elem) |
| Cnth0/4 | nth0(? N, ? List, ? Elem, ? Rest) |
| Cnth1/3 | nth1(+ Index,? List,? Elem) |
| Cnth1/4 | nth1(? N, ? List, ? Elem, ? Rest) |
| Cnth_clause/3 | nth_clause(+ H, I,- R) |
| Cnth_instance/3 | nth_instance(? Key,? Index,? R) |
| Cnth_instance/4 | nth_instance(? Key,? Index, T,? R) |
| Cnumber/1 | number( T) |
| Cnumber_atom/2 | number_atom(? I,? A) |
| Cnumber_chars/2 | number_chars(? I,? L) |
| Cnumber_codes/2 | number_codes(? I,? L) |
| Cnumber_string/2 | number_string(? I,? L) |
| Cnumber_to_chars/2 | number_to_chars(+ Number, - Result) |
| Cnumber_to_chars/3 | number_to_chars(+ Number, - Result0, - Result) |
| Cnumbervars/3 | numbervars( t,+ _N1,- Nn) |
| Cnumlist/3 | numlist(+ Low, + High, + List) |
| Coldl/5 | oldl(: Pred, + List1, + List2, ? AccIn, ? AccOut) |
| Con_cleanup/1 | on_cleanup(+ CleanUpGoal) |
| Con_signal/3 | on_signal(+ Signal,? OldAction,+ Callable) |
| Conce/1 | once( 0:G) |
| Cop/3 | op(+ P,+ T,+ A) |
| Copen/3 | open(+ F,+ M,- S) |
| Copen/4 | open(+ F,+ M,- S,+ Opts) |
| Copen_chars_stream/2 | open_chars_stream(+ Chars, - Stream) |
| Copen_pipe_streams/2 | open_pipe_streams(Read, Write) |
| Copen_query_struct | |
| Copen_shared_object/2 | open_shared_object(+ File, - Handle) |
| Copen_shared_object/3 | open_shared_object(+ File, - Handle, + Options) |
| Coperator_entry | |
| COPSTRUCT | |
| Cor_frame | |
| Cord_add_element/3 | ord_add_element(+ Set1, + Element, ? Set2) |
| Cord_del_element/3 | ord_del_element(+ Set1, + Element, ? Set2) |
| Cord_disjoint/2 | ord_disjoint(+ Set1, + Set2) |
| Cord_insert/3 | ord_insert(+ Set1, + Element, ? Set2) |
| Cord_intersect/2 | ord_intersect(+ Set1, + Set2) |
| Cord_intersection/3 | ord_intersection(+ Set1, + Set2, ? Intersection) |
| Cord_intersection/4 | ord_intersection(+ Set1, + Set2, ? Intersection, ? Diff) |
| Cord_list_to_assoc/2 | ord_list_to_assoc(+ List,? Assoc) |
| Cord_member/2 | ord_member(+ Element, + Set) |
| Cord_seteq/2 | ord_seteq(+ Set1, + Set2) |
| Cord_setproduct/3 | ord_setproduct(+ Set1, + Set2, - Set) |
| Cord_subset/2 | ord_subset(+ Set1, + Set2) |
| Cord_subtract/3 | ord_subtract(+ Set1, + Set2, ? Difference) |
| Cord_symdiff/3 | ord_symdiff(+ Set1, + Set2, ? Difference) |
| Cord_union/2 | ord_union(+ Sets, ? Union) |
| Cord_union/3 | ord_union(+ Set1, + Set2, ? Union) |
| Cord_union/4 | ord_union(+ Set1, + Set2, ? Union, ? Diff) |
| Cotherwise/0 | otherwise |
| Cout/2 | out(+Format, +Args) |
| Cparse | |
| Cpartition/4 | partition(1:Pred, + List1, ? Included, ? Excluded) |
| Cpartition/5 | partition(2:Pred, + List1, ? Lesser, ? Equal, ? Greater) |
| Cpath/1 | path(-Directories:list) |
| Cpath_arg/3 | path_arg( +_Path_ , +_Term_, -_Arg_ ) |
| Cpath_stack_entry | |
| Cpeek/1 | peek( - C) |
| Cpeek/2 | peek(+ S, - C) |
| Cpeek_byte/1 | peek_byte( - C) |
| Cpeek_byte/2 | peek_byte(+Stream, - C) |
| Cpeek_char/1 | peek_char( - C) |
| Cpeek_char/2 | peek_char(+_S_, - C) |
| Cpeek_code/1 | peek_code( - C) |
| Cpeek_code/2 | peek_code(+ S, - C) |
| Cpermission_error/3 | permission_error(+Action, +Type, +Term) |
| Cpermutation/2 | permutation(+ List,? Perm) |
| Cphrase/2 | phrase(+ P, L) |
| Cphrase/3 | phrase(+ P, L, R) |
| Cpid/1 | pid(- Id) |
| CPL_thread_attr_t | |
| Cplus/3 | plus(? Int1:int, ? Int2:int, ? Int3:int) |
| Cpopen/3 | popen( +Command, +TYPE, -Stream) |
| Cportray_clause/1 | portray_clause(+ C) |
| Cportray_clause/2 | portray_clause(+ S,+ C) |
| Cpred_entry | |
| Cpredicate_erased_statistics/4 | predicate_erased_statistics( P, NCls, Sz, IndexSz) |
| Cpredicate_property/2 | predicate_property( P, Prop) |
| Cpredicate_statistics/4 | predicate_statistics( P, NCls, Sz, IndexSz) |
| Cpredsort/3 | Predsort(:Compare, +List, -Sorted) is det |
| Cprimitive/1 | primitive( ?_T_) |
| Cprint/2 | print(+ S, T) |
| Cprint_message/2 | print_message(+ Severity, +Term) |
| Cprint_message_lines/3 | print_message_lines(+ Stream, + Prefix__, + _Lines) |
| Cprocess/2 | process(+ StreamInp, + Goal) |
| Cprofile_data | |
| Cprofile_data/3 | profile_data( ?Na/Ar, ?Parameter, -Data_) |
| Cprolog_file_name/2 | prolog_file_name( +File, -PrologFileaName) |
| Cprolog_file_type/2 | prolog_file_type(?Suffix:atom, ?Handler:atom) |
| Cprolog_flag/3 | prolog_flag(? Flag,- OldValue,+ NewValue) |
| Cprolog_flag_property/2 | prolog_flag_property(+ Flag,+ Prooperties) |
| Cprolog_initialization/1 | prolog_initialization( G) |
| Cprolog_load_context/2 | prolog_load_context(? Key, ? Value) |
| Cprolog_to_os_filename/2 | prolog_to_os_filename(+ PrologPath,- OsPath) |
| Cprompt/2 | prompt(- A,+ B) |
| Cprompt1/1 | prompt1(+ _A__) |
| CPropEntryStruct | |
| CPSEUDO | |
| Cpublic/1 | public( P ) |
| Cput_assoc/4 | put_assoc(+ Key,+ Assoc,+ Val,+ New) |
| Cput_attr/3 | put_attr(+ Var,+ Module,+ Value) |
| Cput_attrs/2 | put_attrs(+ Var,+ Attributes) |
| Cput_byte/1 | put_byte(+ N) |
| Cput_byte/2 | put_byte(+ S,+ N) |
| Cput_char/1 | put_char(+ N) |
| Cput_char/2 | put_char(+ S,+ A) |
| Cput_code/1 | put_code(+ N) |
| Cput_code/2 | put_code(+ S,+ N) |
| Cput_label/4 | put_label(+ Index, + OldTree, + Label, - NewTree) |
| Cputenv/2 | putenv(+ E,+ S) |
| Cqload_file/1 | qload_file(+ F) |
| Cqload_module/1 | qload_module(+ M) |
| Cqq_struct_t | |
| Cqsave_file/2 | '$cvt_qsave_flag'(autoload(_B), G, autoload(_B)) |
| Cqsave_module/1 | qsave_module(+ Module x) |
| Cqsave_module/2 | qsave_module(+ Module, +_State_) |
| Cqsave_program/2 | qsave_program(+ F, Opts) |
| Cquery_goal_answer_frame | |
| Cquery_goal_solution_frame | |
| Cqueue_entry | |
| Cqueue_to_list/2 | queue_to_list(+ Queue, - List) |
| Craakau/3 | raakau(Vertices, InitialValue, Tree) |
| Crandom/1 | random(- Number) |
| Crandom/3 | random(+ LOW, + HIGH, - NUMBER) |
| Crandseq/3 | randseq(+ LENGTH, + MAX, - Numbers) |
| Crandset/3 | randset(+ LENGTH, + MAX, - Numbers) |
| Crannum/1 | @groupdef prandom Van Gelder Random Number Generator% % The following code produces the same random numbers as my previous ranpkg.pl, but is more accurately documented and slightly more efficient |
| Cranstart/1 | ranstart(+ Seed) |
| Cranunif/2 | ranunif(+ Range,- I) |
| Crational/1 | |
| Crational_term_to_tree/4 | |
| Crational_tree_to_forest/4 | rational_tree_to_forest(? TI,- TF, -Extras, ?More) |
| Crb_apply/4 | rb_apply(+T, +Key, :G, -TN) |
| Crb_clone/3 | rb_clone(+ T,+ NT,+ Nodes) |
| Crb_del_max/4 | rb_del_max( +T, -Key, -Val, -TN) |
| Crb_del_min/4 | rb_del_min(+T, -Key, -Val, -TN) |
| Crb_delete/3 | rb_delete(+T, +Key, -TN) |
| Crb_delete/4 | rb_delete(+T, +Key, -Val, -TN) |
| Crb_empty/1 | rb_empty(?T) |
| Crb_fold/4 | rb_fold(+ T,+ G,+ Acc0, - AccF) |
| Crb_insert/4 | rb_insert(+ T0,+ Key,? Value,+ TF) |
| Crb_key_fold/4 | rb_key_fold(+ T,+ G,+ Acc0, - AccF) |
| Crb_keys/2 | rb_keys(+ T,+ Keys) |
| Crb_lookup/3 | rb_lookup(+Key, -Value, +T) |
| Crb_lookupall/3 | rb_lookupall(+ Key,- Value,+ T) |
| Crb_map/3 | rb_map(+ T,+ G,- TN) |
| Crb_max/3 | rb_max( +T, -Key, -Value) |
| Crb_min/3 | rb_min(+T, -Key, -Value) |
| Crb_new/1 | rb_new(-T) |
| Crb_next/4 | rb_next(+T, +Key, -Next,-Value) |
| Crb_partial_map/4 | rb_partial_map(+ T,+ Keys,+ G,- TN) |
| Crb_previous/4 | rb_previous(+T, +Key, -Previous, -Value) |
| CRB_red_blk_node | |
| Crb_rewrite/3 | rb_rewrite(+T, +Key, +NewVal) |
| Crb_rewrite/4 | rb_rewrite(+T, +Key, ?OldVal, +NewVal) |
| Crb_size/2 | rb_size(+ T,- Size) |
| Crb_update/4 | rb_update(+T, +Key, +NewVal, -TN) |
| Crb_update/5 | rb_update(+T, +Key, ?OldVal, +NewVal, -TN) |
| Crb_visit/2 | rb_visit(+ T,- Pairs) |
| Cre_guts | |
| Creachable/3 | reachable(+ Node, + Graph, - Vertices) |
| Cread/1 | read(- T) |
| Cread/2 | read(+ Stream, -Term ) |
| Cread_clause/3 | read_clause( +Stream, -Clause, ?Opts) |
| Cread_data_t | |
| Cread_from_chars/2 | read_from_chars( + Chars, - Term) |
| Cread_line_to_codes/2 | read_line_to_codes( +_Stream_, -_String_) |
| Cread_link/3 | read_link(+ SymbolicLink, -Link, -NewPath) |
| Cread_stream_to_codes/3 | read_stream_to_codes( +_Stream_, -Codes, ?_Tail_) |
| Cread_stream_to_terms/3 | read_stream_to_terms( +_Stream_, -Terms, ?_Tail_) |
| Cread_term_from_atom/3 | read_term_from_atom( +Atom , -T , +Options ) |
| Cread_term_from_atomic/3 | read_term_from_atomic( +Atomic , - T , +Options ) |
| Cread_term_from_string/3 | read_term_from_string( +String , - T , + Options ) |
| Creconsult/1 | reconsult(+ F ) |
| Crecord_list | |
| Crecorda/3 | |
| Crecorda_at/3 | recorda_at(+ R0, T,- R) |
| Crecordaifnot/3 | recordaifnot(+ K, T,- R) |
| Crecorded/3 | |
| Crecordz/3 | recordz(+ K, T,- R) |
| Crecordz_at/3 | recordz_at(+ R0, T,- R) |
| Crecordzifnot/3 | recordzifnot(+ K, T,- R) |
| Creexport/1 | reexport(+F) |
| Creexport/2 | reexport(+F, +Decls ) |
| Cregex_t | |
| Cregexp/3 | regexp(+ RegExp,+ String,+ Opts) |
| Cregexp/4 | regexp(+ RegExp,+ String,+ Opts,? SubMatchVars) |
| Cregmatch_t | |
| Cregstore_t | |
| Cremove_duplicates/2 | remove_duplicates(+ List, ? Pruned) |
| Cremove_from_path/1 | remove_from_path(+Directory:atom) |
| Crename/2 | rename(+F , +G) |
| Crename_file/2 | rename_file(+ OldFile,+ NewFile) |
| Crenv | |
| Crepresentation_error/1 | representation_error(+Reason) |
| Creset_static_array/1 | reset_static_array(+ Name) |
| Crestore/1 | restore(+ F) |
| Cretract/1 | retract(+ C) |
| Cretract/2 | retract(+ C,- R) |
| Cretractall/1 | retractall(+ G) |
| Creverse/2 | reverse(+ List, ? Reversed) |
| Crl_copy/2 | rl_copy(+Range-List Id,-New Range-List Id) |
| Crl_free/1 | rl_free(+Range-List Id) |
| Crl_freeze/1 | rl_freeze(+Range-List Id) |
| Crl_in/2 | rl_in(+Range-List Id,?Number) |
| Crl_new/1 | rl_new( ? AllTrees ) |
| Crl_new/2 | rl_new(+Maximum Interval value, -Range-List Id) |
| CRL_Node | |
| Crl_print/1 | rl_print(+Range-List Id) |
| Crl_set_all/2 | rl_set_all( + Tree, Els) |
| Crl_set_all_in/1 | rl_set_all_in(+Range-List Id) |
| Crl_set_in/2 | rl_set_in(+Range-List Id,+Number) |
| Crl_set_out/2 | rl_set_out(+Range-List Id,+Number) |
| Crl_size/2 | rl_size(+Range-List Id,-Size in bytes) |
| Crl_struct | |
| Crwlock_t | |
| Cs_buffer | |
| Cs_node | |
| Cs_yap_error_descriptor | All we need to know about an error/throw |
| Csame_length/2 | same_length(? List1, ? List2) |
| Csave_program/1 | YAP can save and read images of its current state to files, known as saved states |
| Csave_program/2 | save_program(+ F, : G) |
| Cscan_integer/3 | scan_integer(? Int,+ Line,+ RestOfLine) |
| Cscan_natural/3 | scan_natural(? Nat,+ Line,+ RestOfLine) |
| Cscan_to_list/2 | scan_to_list( +Stream, -Tokens ) |
| Cscanner_extra_alloc | |
| Cscanner_extra_params | |
| Cscratch_block_struct | |
| Cscratch_buf_struct_t | Thread view of the scratch buffer |
| Cscratch_user_buf_struct_t | User view of the scratch buffer |
| Csearch_for/2 | search_for(+ Char,+ Line) |
| Csee/1 | see(+ S) |
| Cseeing/1 | seeing(- S) |
| Cselect/3 | select(? Element, ? List, ? Residue) |
| Cselectchk/3 | selectchk(? Element, ? List, ? Residue) |
| Cselectlist/3 | selectlist(1:Pred, + ListIn, ? ListOut) |
| Cselectlist/4 | selectlist( 2:Pred, + ListIn, + ListInAux, ? ListOut) |
| Cselectlist/5 | selectlist( 2:Pred, + ListIn, + ListInAux, ? ListOut, ? ListOutAux) |
| Cseq_val_t | |
| Cserve_queue/3 | serve_queue(+ OldQueue, + Head, - NewQueue) |
| Cset_alarm/3 | set_alarm(+Seconds, +Execute, -ID) |
| Cset_base_module/1 | set_base_module( +Expor tingModule ) |
| Cset_error/1 | set_error(+ S) |
| Cset_input/1 | set_input(+ S) |
| Cset_output/1 | set_output(+ S) |
| Cset_prolog_flag/2 | set_prolog_flag(+ Flag,+ Value) |
| Cset_value/2 | set_value(+ A,+ C) |
| Csetarg/3 | setarg(+ I,+ S,? T) |
| Csetenv/2 | setenv(+ Name,+ Value) |
| Csetof/3 | setof( X,+ P,- B) |
| Csetrand/1 | setrand(+ Key) |
| Csetup_call_cleanup/3 | setup_call_cleanup(: Setup,: Goal, : CleanUpGoal) |
| Csh/0 | sh |
| Cshell/1 | shell(+ Command) |
| Cshell/2 | shell(+ Command,- Status) |
| Cshow_table/1 | show_table(+ P) |
| Cshowprofres/1 | showprofres( N) |
| Csi_callback_h | |
| Csimple/1 | simple( T) |
| Csingleton_vs_numbervars/3 | singleton_vs_numbervars( t,+ _N1,- Nn) |
| Cskip/1 | skip(+ N) |
| Cskip/2 | skip(+ S,- C) |
| Cskip_whitespace/2 | skip_whitespace(+ Line,+ RestOfLine) |
| Csocket/2 | socket(+ DOMAIN,- SOCKET) |
| Csocket/4 | socket(+ DOMAIN,+ TYPE,+ PROTOCOL,- SOCKET) |
| Csocket_accept/2 | socket_accept(+ SOCKET, - STREAM) |
| Csocket_accept/3 | socket_accept(+ SOCKET, - CLIENT, - STREAM) |
| Csocket_bind/2 | socket_bind(+ SOCKET, ? PORT) |
| Csocket_buffering/4 | socket_buffering(+ SOCKET, - MODE, - OLD, + NEW) |
| Csocket_close/1 | socket_close(+ SOCKET) |
| Csocket_connect/3 | socket_connect(+ SOCKET, + PORT, - STREAM) |
| Csocket_listen/2 | socket_listen(+ SOCKET, + LENGTH) |
| Csocket_select/5 | socket_select(+ SOCKETS, - NEWSTREAMS, + TIMEOUT, + STREAMS, - READSTREAMS) |
| Csort/2 | sort(+ L,- S) |
| Csource/0 | source |
| Csource_location/3 | Start input for a meta-clause |
| Csource_mode/2 | source_mode(- O,+ N) |
| Csource_module/1 | source_module(-Mod) |
| Cspinlock_t | |
| Csplay_del/3 | splay_del(+ Item,+ Tree,- NewTree) |
| Csplay_init/1 | splay_init(- NewTree) |
| Csplay_insert/4 | splay_insert(+ Key,? Val,+ Tree,- NewTree) |
| Csplay_join/3 | splay_join(+ LeftTree,+ RighTree,- NewTree) |
| Csplay_split/5 | splay_split(+ Key,? Val,+ Tree,- LeftTree,- RightTree) |
| Csplit/2 | split(+ Line,- Split) |
| Csplit/3 | split(+ Line,+ Separators,- Split) |
| Csplit_quoted/5 | split_quoted(+ Line,+ Separators, GroupQuotes, SingleQuotes, - Split) |
| Csplit_unquoted/3 | split_unquoted(+ Line,+ Separators,- Split) |
| Cspy/1 | spy( + P ) |
| Cssz_t | |
| Cstack_dump/1 | stack_dump(+N) |
| Cstash_predicate/1 | stash_predicate(+ Pred) |
| Cstatarray_elements | |
| Cstatic_array/3 | static_array(+ Name, + Size, + Type) |
| Cstatic_array_entry | |
| Cstatic_array_location/2 | static_array_location(+ Name, - Ptr) |
| Cstatic_array_properties/3 | static_array_properties(+Name,+Size,+Type) |
| Cstatic_array_to_term/2 | static_array_to_term(? Name, ? Term) |
| Cstatic_clause | |
| Cstatic_index | |
| Cstatic_mega_clause | |
| Cstatistics/2 | statistics(? Param,- Info) |
| Cstream_desc | |
| Cstream_position/2 | stream_position(+ Stream,- StreamPosition) |
| Cstream_position/3 | stream_position(+ Stream,- StreamPosition, +_NewPosition_) |
| Cstream_position_data/3 | stream_position_data(+ Field,+ StreamPosition,- Info) |
| Cstream_property/2 | stream_property( Stream, Prop ) |
| Cstring_to_atom/2 | string_to_atom(?String, ?Atom) |
| Cstring_to_atomic/2 | string_to_atomic(?S, ?Atomic) |
| CStringListItem | |
| Cstruct_dbentry | |
| Cstruct_param | |
| Cstruct_param2 | |
| CStructClauseDef | |
| Csub_atom/5 | sub_atom(+ A,? Bef, ? Size, ? After, ? At_out) |
| Csub_string/5 | sub_string(+ S,? Bef, ? Size, ? After, ? S_out) |
| Csubgoal_entry | |
| Csubgoal_frame | |
| Csubgoal_trie_hash | |
| Csubgoal_trie_node | |
| Csubsumes/2 | subsumes(? Term1, ? Term2) |
| Csubsumes_chk/2 | subsumes_chk(? Term1, ? Term2) |
| Csubsumes_term/2 | subsumes_term(? Subsumer, ? Subsumed) |
| Csucc/2 | succ(? Int1:int, ? Int2:int) |
| Csuffix/2 | suffix(? Suffix, ? List) |
| Csum_list/2 | sum_list(? Numbers, ? Total) |
| Csum_list/3 | sum_list(? Numbers, + SoFar, ? Total) |
| Csumlist/2 | sumlist(? Numbers, ? Total) |
| Csumlist/4 | sumlist(: Pred, + List, ? AccIn, ? AccOut) |
| Csumnodes/4 | sumnodes(+ Pred, + Term, ? AccIn, ? AccOut) |
| Csus_record_struct | |
| Csus_tag_struct | |
| CSWI_IO | |
| Cswi_reverse_hash | |
| Csystem/1 | system(+ S) |
| Csystem/2 | system(+ Command,- Res) |
| Csystem_error/2 | system_error( +Error, +Cause) |
| Csystem_module/1 | system_module( + Mod) |
| Csystem_predicate/1 | system_predicate( ?_P_ ) |
| Csystem_predicate/2 | system_predicate( ?A, ?P ) |
| CT | If you like being short, use T instead of YapTerm |
| Ctab/1 | tab(+ N) |
| Ctab/2 | tab(+ S,+ N) |
| Ctable/1 | table( + P ) |
| Ctable_entry | |
| Ctable_statistics/1 | table_statistics(+ P) |
| Ctabling_mode/2 | tabling_mode(+ P,? Mode) |
| Ctell/1 | tell(+ S) |
| Ctelling/1 | telling(- S) |
| Cterm_array | |
| Cterm_attvars/2 | term_attvars(+ Term,- AttVars) |
| Cterm_expansion/2 | term_expansion( T,- X) |
| Cterm_factorized/3 | |
| Cterm_hash/2 | term_hash(+ Term, ? Hash) |
| Cterm_hash/4 | term_hash(+ Term, + Depth, + Range, ? Hash) |
| Cterm_subsumer/3 | term_subsumer(? T1, ? T2, ? Subsumer) |
| Cterm_variables/2 | term_variables(? Term, - Variables) |
| Cterm_variables/3 | term_variables(? Term, - Variables, +_ExternalVars_) |
| Cterm_variables_difference/3 | term_variables_difference(? Term1, - Term2, +_Vars_) |
| Cterm_variables_union/3 | term_variables_union(? Term1, - Term2, +_Vars_) |
| Ctext_cvt | |
| CTextBuffer_manager | |
| Cthread_at_exit/1 | thread_at_exit(: Term) |
| Cthread_create/1 | thread_create(: Goal) |
| Cthread_create/2 | thread_create(: Goal, - Id) |
| Cthread_create/3 | thread_create(: Goal, - Id, + Options) |
| Cthread_exit/1 | thread_exit(+ Term) |
| Cthread_get_message/1 | thread_get_message(? Term) |
| Cthread_get_message/2 | thread_get_message(+ Queue, ? Term) |
| Cthread_join/2 | thread_join(+ Id, - Status) |
| Cthread_local/1 | thread_local( +Functor/Arity) |
| Cthread_peek_message/1 | thread_peek_message(? Term) |
| Cthread_peek_message/2 | thread_peek_message(+ Queue, ? Term) |
| Cthread_property/2 | thread_property(? Id, ? Property) |
| Cthread_self/1 | thread_self(- Id) |
| Cthread_send_message/1 | thread_send_message(+ Term) |
| Cthread_send_message/2 | thread_send_message(+ QueueOrThreadId, + Term) |
| Cthread_sleep/1 | thread_sleep(+ Time) |
| Cthread_statistics/3 | thread_statistics(+ Id, + Key, - Value) |
| Cthrow/1 | throw(+ Ball) |
| Ctime/1 | Time(:Goal) % % Time the execution of Goal |
| CTIMED_MAVAR | |
| Ctmp_file/2 | tmp_file(+_Base_, - File) |
| Ctmpnam/1 | tmpnam(- File) |
| CTOKEN | |
| Ctop_sort/2 | top_sort(+ Graph, - Sort) |
| Ctop_sort/3 | top_sort(+ Graph, - Sort0, - Sort) |
| Ctrace_goal/4 | trace_goal( +G, +M, +GoalNumber, +CP) |
| Ctransitive_closure/2 | transitive_closure(+ Graph, + Closure) |
| Ctranslate_message/3 | translate_message(+Term, +Lines, -Lines0) |
| Ctranslation_entry | |
| Ctranspose/2 | transpose(+ Graph, - NewGraph) |
| Ctree_size/2 | tree_size(+ Tree, - Size) |
| Ctree_to_list/2 | tree_to_list(+ Tree, - List) |
| Ctrie_check_entry/3 | trie_check_entry(+ Trie,+ Term,- Ref) |
| Ctrie_close/1 | trie_close(+ Id) |
| Ctrie_close_all/0 | trie_close_all |
| Ctrie_data | |
| Ctrie_engine | |
| Ctrie_entry | |
| Ctrie_get_entry/2 | trie_get_entry(+ Ref,- Term) |
| Ctrie_hash | |
| Ctrie_load/2 | trie_load(- Trie,+ FileName) |
| Ctrie_max_stats/4 | trie_max_stats(- Memory,- Tries,- Entries,- Nodes) |
| Ctrie_mode/1 | trie_mode(? Mode) |
| Ctrie_node | |
| Ctrie_print/1 | trie_print(+ Trie) |
| Ctrie_put_entry/4 | trie_put_entry(+Mode,+ Trie,+ Term,- Ref) |
| Ctrie_remove_entry/1 | trie_remove_entry(+ Ref) |
| Ctrie_remove_subtree/1 | trie_remove_subtree(+ Ref) |
| Ctrie_save/2 | trie_save(+ Trie,+ FileName) |
| Ctrie_stats/4 | trie_stats(- Memory,- Tries,- Entries,- Nodes) |
| Ctrie_usage/4 | trie_usage(+ Trie,- Entries,- Nodes,- VirtualNodes) |
| Ctrue/0 | true |
| Cttyget/1 | ttyget(- C) |
| Cttyget0/1 | ttyget0(- C) |
| Cttyput/1 | ttyput(+ N) |
| Cttyskip/1 | ttyskip(- C) |
| Ctype_error/2 | type_error(+Type, +Term) |
| CTypeSwitch | |
| Cudi_control_block | |
| Cudi_info | |
| Cudi_p_args | |
| Cugraph_to_dgraph/2 | ugraph_to_dgraph( +_UGraph_, -_Graph_) |
| Cundgraph_add_edges/3 | undgraph_add_edges(+ Graph, + Edges, - NewGraph) |
| Cundgraph_add_vertices/3 | undgraph_add_vertices(+ Graph, + Vertices, - NewGraph) |
| Cundgraph_complement/2 | undgraph_complement(+ Graph, - NewGraph) |
| Cundgraph_del_edges/3 | undgraph_del_edges(+ Graph, + Edges, - NewGraph) |
| Cundgraph_del_vertices/3 | undgraph_del_vertices(+ Graph, + Vertices, - NewGraph) |
| Cundgraph_edges/2 | undgraph_edges(+ Graph, - Edges) |
| Cundgraph_neighbours/3 | undgraph_neighbours(+ Vertex, + Graph, - Vertices) |
| Cundgraph_new/1 | undgraph_new(+ Graph) |
| Cundgraph_vertices/2 | undgraph_vertices(+ Graph, - Vertices) |
| Cunhide_atom/1 | unhide_atom(+ Atom) |
| Cunif_record | |
| Cunifiable/3 | unifiable(? Term1, ? Term2, - Bindings) |
| Cunify_with_occurs_check/2 | |
| Cunion_direct | |
| Cunion_slots | |
| Cunix/1 | unix(+ S) |
| Cunknown/2 | No need for code at this point |
| Cunknown_predicate_handler/3 | unknown_predicate_handler(+ Call, + M, - N) |
| Cunnumbervars/1 | unnumbervars(+ Term) |
| CUnsafeEntry | |
| Cunset_alarm/1 | unset_alarm(+ID) |
| Cupcase_text_to_atom/2 | upcase_text_to_atom(+Text, -Atom) |
| Cupcase_text_to_chars/2 | upcase_text_to_chars(+Text, -Chars) |
| Cupcase_text_to_codes/2 | upcase_text_to_codes(+Text, -Codes) |
| Cupcase_text_to_string/2 | upcase_text_to_string(+Text, -String) |
| Cupdate_array/3 | update_array(+ Name, + Index, ? Value) |
| Cupdate_mutable/2 | update_mutable(+ D,+ M) |
| Cuse_module/1 | use_module( +Files ) |
| Cuse_module/2 | use_module(+Files, +Imports) |
| Cuse_module/3 | use_module(? M,? F,+ L) |
| CUT_array | |
| CUT_hash_bucket | |
| CUT_hash_handle | |
| CUT_hash_table | |
| CUT_icd | |
| Cv_record | |
| CValEntry | |
| Cvar/1 | var( T) |
| Cvar/2 | ?_X_ == ?_Y_ |
| Cvariables_in_term/3 | variables_in_term( +_t, +_SetOfVariables_, +_ExtendedSetOfVariables_ ) |
| Cvariables_within_term/3 | variables_within_term(+ Variables,? Term, - OutputVariables) |
| Cvariant/2 | variant(? Term1, ? Term2) |
| Cvarious_codes | |
| Cvarnumbers/2 | varnumbers(+ Term, Term) |
| CVARSTRUCT | |
| Cvcell | |
| CVENTRY | |
| Cversion/1 | version(- Message) |
| Cvertices/2 | vertices(+ Graph, - Vertices) |
| Cvertices_edges_to_ugraph/3 | vertices_edges_to_ugraph(+ Vertices, + Edges, - Graph) |
| Cvfs | |
| Cvfs_stat | |
| Cvirtual_alarm/3 | virtual_alarm(+Interval, 0:Goal, -Left) |
| Cvisited | |
| Cvisitel | |
| Cvlist_struct_t | |
| Cwait/1 | wait(G) |
| Cwhen/2 | when(+ C,: G) |
| Cwith_output_to/2 | with_output_to(+ Ouput,: Goal) |
| Cwith_output_to_chars/2 | with_output_to_chars(? Goal, - Chars) |
| Cwith_output_to_chars/3 | with_output_to_chars(? Goal, ? Chars0, - Chars) |
| Cwith_output_to_chars/4 | With_output_to_chars(:Goal, -Stream, -Codes, ?Tail) is det |
| Cworker_local | |
| Cworking_directory/2 | working_directory( ?_CurDir_,? NextDir) |
| Cwrite/2 | write(+ S, T) |
| Cwrite_canonical/1 | write_canonical(+ T) |
| Cwrite_canonical/2 | write_canonical(+ S,+ T) |
| Cwrite_globs | |
| Cwrite_term/2 | write_term(+ T, + Opts) |
| Cwrite_term/3 | write_term(+ S, + T, + Opts) |
| Cwrite_to_chars/2 | write_to_chars(+ Term, - Result) |
| Cwrite_to_chars/3 | write_to_chars(+ Term, - Result0, - Result) |
| Cwriteq/2 | writeq(+ S, ? T) |
| Cx_el | |
| Cyami | |
| Cyap_back_data_type | |
| CYAP_blob_prop_entry | |
| Cyap_boot_params | |
| CYAP_delaymodule_t | |
| CYAP_dogoalinfo | |
| Cyap_error_prolog_source | Prolog goal that caused a bug |
| Cyap_flag/2 | yap_flag( ?Param, ?Value) |
| CYap_InitCPreds | |
| Cyap_io_position | |
| CYAP_opaque_handler_struct | Opaque variables can interact with the system |
| CYAP_thread_attr_struct | |
| CYAPApplTerm | Compound Term |
| CYAPAtom | Atom A YAP data-base is a collection of atoms, where each atom has a name and a set of Properties |
| CYAPAtomTerm | Atom Term Term Representation of an Atom |
| CYAPCallback | This class implements a callback Prolog-side |
| Cyapchlookahead | |
| CYAPConjunctiveTerm | |
| CYAPEngine | YAP Engine: takes care of the execution environment where we can go executing goals |
| CYAPEngineArgs | Setup all arguments to a new engine |
| CYAPError | Take information on a Prolog error: |
| CYAPErrorTerm | Prolog container for error descriptors |
| CYAPFLIP | PrologPredicate |
| CYAPFloatTerm | Floating Point Term |
| CYAPFunctor | YAPFunctor represents Prolog functors Name/Arity |
| CYAPIntegerTerm | Integer Term |
| CYAPListTerm | |
| CYAPModule | YAPModule A YAPModule describes a bare module, which in YAP is just a name |
| CYAPModuleProp | YAPModuleProp A YAPModuleProp controls access to a module property |
| CYAPNumberTerm | Number Term |
| CYAPPairTerm | List Constructor Term |
| CYAPPredicate | Predicates |
| CYAPPrologPredicate | PrologPredicate |
| CYAPProp | Prop A YAP Propery is ameta-class for everything one can in a atom |
| CYAPQuery | Queries and engines |
| CyapSourceLocation | |
| CYAPStringTerm | String Term |
| CYAPTerm | Generic Prolog Term |
| CYAPVarTerm | Variable Term |
| CYstack_t | |
1.9.3