A | |
| abs [Axiom] | |
| absorbent [Relation] | |
| absorbing [Relation] | |
| add [Main.StrSet] | |
| add [Subs] |
Add a new binding: replace the previous one if any
|
| add [Tbl] | |
| add_cps [Cp] |
Critical pairs of a set of rules
|
| add_dir_to_search_path [File] | |
| add_eq [Prec] | |
| add_gt [Prec] | |
| add_info_arg_to_type_declaration [Genr_sharing] | |
| add_local_module [Main] | |
| add_lt [Prec] |
Add a new constraint.
|
| add_non_trivial [Equation] | |
| add_non_trivial_pair [Equation] | |
| add_rules [Otype] | |
| add_type_decls [Check] |
Enters a list of type definitions in the table.
|
| add_underscores [Genr_pattern] | |
| adhoc_completion [Complete] |
Some relations on a generator imply relations on other
generators, that the user cannot or does not need to
provide.
|
| align [Misc] | align n a rounds n upwards to a multiple of a
(a power of 2).
|
| annotations [Clflags] | |
| app [Term_utils] | |
| app0 [Term_utils] | |
| app1 [Term_utils] | |
| app2 [Term_utils] | |
| append [Genr_base] | |
| applicative_functors [Clflags] | |
| apply [Subs] |
Apply a substitution to a term
|
| apply [Code] | |
| apply1 [Code] | |
| apply2 [Code] | |
| apply3 [Code] |
Apply an ident to its argument(s).
|
| architecture [Config] |
Name of processor type for the native-code compiler
|
| argspec [Main] | |
| argument_of_type_list [Otype] |
Returns the type argument of the Caml compiler list type
functional type constructor.
|
| arity_of_cdef [Otype] | |
| arity_of_generator [Check] | |
| arity_of_info [Check] | |
| arrow_type [Otype] | |
| asm [Config] |
The assembler (and flags) to use for assembling
ocamlopt-generated code.
|
| ass [Axiom] | |
| associative [Relation] | |
| ast_impl_magic_number [Config] |
Magic number for file holding an implementation syntax tree
|
| ast_intf_magic_number [Config] |
Magic number for file holding an interface syntax tree
|
B | |
| backup [Terminfo] | |
| bool_of_opt [Useful] | |
| bool_type [Otype] | |
| bytecomp_c_compiler [Config] |
The C compiler to use for compiling C files
with the bytecode compiler
|
| bytecomp_c_libraries [Config] |
The C libraries to link with custom runtimes
|
C | |
| c_compiler [Clflags] | |
| call_linker [Ccomp] | |
| cardinal [Main.StrSet] | |
| careful_close_out [File] |
An alias for
close_out that performs correctly on stdout.
|
| careful_open_out [File] |
An alias for
open_out that performs correctly on stdout.
|
| cc_profile [Config] |
The command line option to the C compiler to enable profiling.
|
| ccobjs [Clflags] | |
| ccomp_type [Config] |
The "kind" of the C compiler: one of
"cc" (for Unix-style C compilers)
"msvc" (Microsoft Visual C++)
"mrc" (Macintosh MPW)
|
| ccopts [Clflags] | |
| change_extension [File] |
Computes the name of a file when its extension is modified.
|
| change_mlm_extension [File] | |
| check [Consistbl] | check tbl name crc source
checks consistency of (name, crc) with infos previously
stored in tbl.
|
| check_add [Subs] |
Add to s the mapping (x,t) if mem s x = false or find s x = t.
|
| check_and_genr_ml [Main] | |
| check_and_genr_mli [Main] | |
| check_fatal [Warnings] | |
| check_noadd [Consistbl] |
Same as
check, but raise Not_available if no CRC was previously
associated with name.
|
| check_signature_item [Main] | |
| check_structure_item [Main] | |
| choose [Main.StrSet] | |
| choose_many [Randomutils] | |
| chop_extension_if_any [Misc] |
Like Filename.chop_extension but returns the initial file
name if it has no extension
|
| chop_extensions [Misc] |
Return the given file name without its extensions.
|
| classic [Clflags] | |
| clauses_both_as_left [Genr_base] | |
| clauses_left_or_right [Genr_base] | |
| clauses_of_side [Genr_base] | |
| clear [Consistbl] | |
| clear_symbols [Symb] |
Clear the table of known symbols
|
| clear_vars [Var] |
Remove all string-variable bindings
|
| cma_magic_number [Config] |
Magic number for archive files
|
| cmi_magic_number [Config] |
Magic number for compiled interface files
|
| cmo_magic_number [Config] |
Magic number for object bytecode files
|
| cmx_magic_number [Config] |
Magic number for compilation unit descriptions
|
| cmxa_magic_number [Config] |
Magic number for libraries of compilation unit descriptions
|
| cmxs_magic_number [Config] |
Magic number for dynamically-loadable plugins
|
| com [Axiom] | |
| combine_all [Listutils] | combine ll Returns the list of all the lists that can be built by
taking one element in each list of the list of lists ll.
|
| command [Ccomp] | |
| comment_relations_in_type_declaration [Otype] | |
| commutative [Relation] | |
| comp [Subs] |
Composition of 2 substitutions:
apply (comp s1 s2) t = apply s1 (apply s2 t)
|
| comp [Order] | |
| comp_res [Subs] |
Restricted composition: comp_res s1 s2 = restrict (domain s2) (comp s1 s2)
|
| compare [Main.StrSet] | |
| compare [Main.Str] | |
| compare [Equation] |
Equality up to renaming of variables
|
| compare [Rule] |
Comparison and equality up to lhs-variables renaming
|
| compare [Rename] | |
| compare [Prec] | |
| compare [Term] |
Comparison of terms modulo variable renaming
|
| compare [Useful.ORD_PRT] | |
| compare_core_type [Otype] |
Comparison on core types (ignore locations).
|
| compare_function [Genr_base] |
Comparison function ident from its generator
|
| compare_generator [Relation] | |
| compare_relation [Relation] |
Comparison function on relations based on precedence.
|
| compare_side [Relation] | |
| comparison_function [Genr_base] |
A constant representing the name of the comparison function corresponding
to the indicated identifier.
|
| compile_file [Ccomp] | |
| compile_only [Clflags] | |
| complete [Comp] |
Full completion.
|
| complete_n [Comp] |
Kimited completion.
|
| completion [Eqnrel] | |
| cons [Genr_base] | |
| constant_type [Otype] | |
| constr_type [Otype] | |
| construction [Genr_base] |
The generic (and most general) way to apply a construction function for a
generator.
|
| construction0 [Genr_base] | |
| construction1 [Genr_base] | |
| construction2 [Genr_base] |
The application of the construction function for a zeroary, unary or
binary generator.
|
| construction_function [Genr_base] |
Construction function ident from its generator.
|
| construction_function_ident [Genr_base] |
Construction function ident from its generator ident.
|
| construction_function_memo_table_ident [Genr_base] |
Construction function memo table ident from its generator.
|
| construction_function_name [Genr_base] |
Construction function name from its generator (string) name.
|
| copy_file [Misc] | copy_file ic oc reads the contents of file ic and copies
them to oc.
|
| copy_file_chunk [Misc] | copy_file_chunk ic oc n reads n bytes from ic and copies
them to oc.
|
| cps [Cp] | |
| create [Consistbl] | |
| create_archive [Ccomp] | |
| create_hashtable [Misc] |
Create a hashtable of the given size and fills it with the
given bindings.
|
| create_lexbuf_from_file [File] | |
| curr [Location] |
Get the location of the current token from the
lexbuf.
|
| custom_runtime [Clflags] | |
D | |
| debug [Clflags] | |
| default_executable_name [Config] |
Name of executable produced by linking if none is given with -o,
e.g.
|
| defaults_w [Warnings] | |
| defaults_warn_error [Warnings] | |
| diese_line [Genr_base] |
Get the line and file where the located element appears
|
| diff [Main.StrSet] | |
| dis [Axiom] | |
| distributive [Relation] | |
| division_by_absorbent [Code] | |
| dlcode [Clflags] | |
| dllibs [Clflags] | |
| dllpaths [Clflags] | |
| domain [Subs] |
Domain of a substitution
|
| dont_write_files [Clflags] | |
| dump_cmm [Clflags] | |
| dump_combine [Clflags] | |
| dump_instr [Clflags] | |
| dump_interf [Clflags] | |
| dump_lambda [Clflags] | |
| dump_linear [Clflags] | |
| dump_live [Clflags] | |
| dump_parsetree [Clflags] | |
| dump_prefer [Clflags] | |
| dump_rawlambda [Clflags] | |
| dump_regalloc [Clflags] | |
| dump_reload [Clflags] | |
| dump_scheduling [Clflags] | |
| dump_selection [Clflags] | |
| dump_spill [Clflags] | |
| dump_split [Clflags] | |
E | |
| echo_eof [Location] | |
| elements [Main.StrSet] | |
| empty [Main.StrSet] | |
| empty [Subs] |
Identity: substitution with no binding
|
| empty [Prec] | |
| empty [Tbl] | |
| eq [Equation] | |
| eq [Rule] | |
| eq [Rename] | |
| eq [Term] | |
| eq_function [Genr_base] |
Returns the function that generates the code to call the proper equality
function to its two code arguments.
|
| eq_generator [Relation] |
Compare generators.
|
| eq_opt [Rename] |
Equality up to variable renaming.
|
| eq_side [Relation] | |
| eq_type [Otype] |
Syntactic equality ignoring locations
|
| eqns_of_rel [Eqnrel] | |
| eqnset_of_rels [Eqnrel] | |
| eqnset_of_theory [Axiom] | |
| equal [Main.StrSet] | |
| equation [Cparser] | |
| equations [Cparser] | |
| exec_magic_number [Config] |
Magic number for bytecode executable files
|
| exists [Main.StrSet] | |
| exists [Subterm] |
Test whether there exits a subterm satisfying some predicate
|
| existsi [Subterm] | |
| expand_directory [Misc] | expand_directory alt file eventually expands a + at the
beginning of file into alt (an alternate root directory)
|
| expand_libname [Ccomp] | |
| ext_asm [Config] |
Extension for assembler files, e.g.
|
| ext_dll [Config] |
Extension for dynamically-loaded libraries, e.g.
|
| ext_lib [Config] |
Extension for library files, e.g.
|
| ext_obj [Config] |
Extension for object files, e.g.
|
| extend_away [Rename] |
Extend a renaming
|
| extract [Consistbl] |
Return all bindings (
name, crc) contained in the given
table.
|
F | |
| failure_division_by_absorbent [Code] | |
| failwith_division_by_absorbent [Code] | |
| fast [Clflags] | |
| fatal_error [Misc] | |
| filter [Main.StrSet] | |
| filter [Consistbl] | filter pred tbl removes from tbl table all (name, CRC) pairs
such that pred name is false.
|
| find [Subs] |
Raise Not_found if var is not bound
|
| find [Subterm] |
Find a subterm satisfying some predicate.
|
| find [Myset.S] |
Provide an element satisfying p.
|
| find [Tbl] | |
| find_generator_ident_info [Check] | |
| find_generator_info [Check] |
Various access/test functions that may raise Unknown_generator.
|
| find_generator_name_info [Check] | |
| find_in_path [Misc] |
Search a file in a list of directories.
|
| find_in_path_uncap [Misc] |
Same, but search also for uncapitalized name, i.e.
|
| find_opt [Subterm] |
Find Some subterm satisfying some predicate or None
|
| find_opt [Myset.S] |
Provide Some element satisfying p or None
|
| find_opti [Subterm] | |
| find_relation [Relation] | |
| find_type_ident_declaration [Check] | |
| find_type_name_declaration [Check] | |
| findi [Subterm] | |
| flat_map [Listutils] | flat_map f l maps the function f on the list l, and flatten the
list of results.
|
| flatten [Longident] | |
| fold [Main.StrSet] | |
| fold [Subterm] |
Fold among subterms
|
| fold [Tbl] | |
| foldi [Subterm] |
Functions taking into account the position
|
| for_all [Main.StrSet] | |
| for_all2 [Misc] |
Same as
List.for_all but for a binary predicate.
|
| for_package [Clflags] | |
| for_position [Linenum] | Linenum.for_position file loc returns a triple describing
the location loc in the file named file.
|
| fprintf [Comp] | |
| fprintf [Equation] |
Print an equation into a formatter
|
| fprintf [Rule] |
Print an equation
|
| fprintf [Subs] |
Print a substitution into a formatter.
|
| fprintf [Term] | |
| fprintf [Myset.S] |
Print a set into a buffer
|
| fprintf [Useful.ORD_PRT] | |
| fprintf_list [Mylist] |
Print a list
|
| fresh_var [Var] |
Return a fresh variable not bound to a string by var_of_string.
|
| from_to [Listutils] | from_to b e succ Creates a list starting from element b until
element e is reached, applying function succ in turn to get the next
element of the list.
|
G | |
| ge [Order] | |
| generator [Genr_base] |
Apply the generator term constructor for the generator: in case of sharing,
we properly call the sharing version of the generator.
|
| generator0 [Genr_base] | |
| generator1 [Genr_base] | |
| generator2 [Genr_base] |
Apply the generator term constructor for the generator: special cases for
zeroary, unary, and binary generators.
|
| generator_of_cdef [Otype] | |
| genr [Main] | |
| genr_args [Code] | genr_args root n returns the list of patterns root1; ...; rootn.
|
| genr_chars [Tgenr_base] |
Same as above for characters.
|
| genr_comparisons [Genr_base] |
Generation of a triple of comparison functions for a given commutative
operator.
|
| genr_core_values [Genr_values] |
Generates a list of up to n values of the specified core type,
whose tree has a maximum depth (number of nested constructors)
|
| genr_eq [Genr_base] |
Generate an equality predicate primitive for the type name given:
for type
t, we generate the primitive eq_t, bound to "%equal" if the
values of the type are not maximally shared, or bound to "%eq"
otherwise.
|
| genr_file [Main] | |
| genr_file_ml [Main] | |
| genr_file_mli [Main] | |
| genr_floats [Tgenr_base] |
Same as above for floats.
|
| genr_function [Genr_nullary] | |
| genr_function [Genr_unary] | genr_function g generates a unary function that
normalizes terms that are built with g as their head constructor.
|
| genr_function [Genr_binary] | genr_function g generates a binary function (here binary
means that the function has a pair as unique argument) that normalizes
terms that are built with g as their head constructor.
|
| genr_function [Genr_listary] |
From a listary generator definition, generate a list of definitions
that implements its construction function.
|
| genr_function [Genr_nary] |
We treat the case of n-ary generators.
|
| genr_functions [Genr] |
The global generation procedure: it generates the whole set of construction
function definitions from a given type definition.
|
| genr_int32s [Tgenr_base] |
Same as above for
int32.
|
| genr_int64s [Tgenr_base] |
Same as above for
int64.
|
| genr_ints [Tgenr_base] |
Creates the
max_length specified number of distinct integer expressions.
|
| genr_memo_functions [Genr_memo] |
Memoize construction functions of a given constructor
cdef
among all generated functions for this very constructor.
|
| genr_mli [Genr_mli] | |
| genr_nativeints [Tgenr_base] |
Same as above for
nativeint.
|
| genr_numbered_args [Code] | genr_numbered_args root n returns 1, root1; ...; n, rootn.
|
| genr_private_type_declarations [Genr_mli] | |
| genr_projection [Genr_base] |
Generate a projection primitive for the (abbreviation) type name given.
|
| genr_public_type_declarations [Genr_mli] | |
| genr_rule [Genr_expression] |
Generation of a pattern maching clause for a user's defined rewrite rule
Rule (p, e), meaning that pattern p should be rewritten
as expression e.
|
| genr_rule_pattern [Genr_base] |
Pattern construction for generators and functions.
|
| genr_strings [Tgenr_base] |
Same as above for strings.
|
| genr_substs [Genr_substitutions] |
Generates a list of n substitutions, i.e.
|
| genr_test [Main] | |
| genr_test_file [Main] | |
| genr_test_preamble [Genr_testing] |
Generate hte AST preamble for the test file of a module.
|
| genr_type_test [Genr_testing] |
The global test generation function: it generates the whole
set of test expressions for a module name and a type definition.
|
| genr_underscores [Code] | genr_underscores n returns a list of n _ patterns.
|
| genr_units [Tgenr_base] |
Creates at most the specified number of distinct unit expressions, i.e.,
zero or one.
|
| genr_values [Genr_values] |
Generates a list of up to n values of the specified type declaration
|
| genr_values_and_equalities [Genr_equalities] |
Given
a number
n of equalities to generate,
a function generating values of a given type, and
a constructor definition,
genr_values_and_equalities generates the code to test the validity of
the equalities that must hold, according to the relations specified for the
constructor.
|
| get_arity_of_generator [Check] | |
| get_comments [Genr_base] |
Do we output normalization traces ?
|
| get_debug [Debug] | |
| get_dline_trace [Genr_base] |
Do we add diese line directives to
.ml files ?
|
| get_genr_implementation [Main] | |
| get_genr_interface [Main] | |
| get_genr_test [Main] | |
| get_input_file_name [Main] | |
| get_kb [Eqnrel] | |
| get_kb_limit [Eqnrel] | |
| get_line_count [Pr_code] | |
| get_memo_table_size [Genr_memo] | |
| get_memoize_target [Genr_memo] |
Do we generate maximum sharing ?
|
| get_num_tests [Main] | |
| get_output_module_implementation_name [Main] | |
| get_output_module_interface_name [Main] | |
| get_output_module_name [Main] | |
| get_pos_info [Location] | |
| get_relation_list [Relation] |
Access function on lists of relations.
|
| get_search_path [File] | |
| get_seed [Main] | |
| get_sharable_target [Genr_base] |
Do we generate maximum sharing ?
|
| get_structure_items_of_type_declaration [Otype] | |
| get_testing_file_name [Main] | |
| get_user_rel_order [Genr_base] |
Do we use the user order for code generation ?
|
| get_val_depth [Main] | |
| get_verbose [Configuration] | |
| gprofile [Clflags] | |
H | |
| has_absorbent [Relation] | |
| has_absorbing [Relation] | |
| has_associative [Relation] | |
| has_commutative [Relation] | |
| has_commutativity [Equation] | |
| has_idempotent [Relation] | |
| has_idempotent_and_nilpotent [Relation] | |
| has_neutral [Relation] | |
| has_nilpotent [Relation] | |
| has_relations [Otype] | |
| has_relations_cdef [Otype] | |
| has_relations_cdefs [Otype] | |
| help_warnings [Warnings] | |
| highlight_locations [Location] | |
I | |
| iapp [Term_utils] | |
| iapp0 [Term_utils] | |
| iapp1 [Term_utils] | |
| iapp2 [Term_utils] | |
| idem [Axiom] | |
| idempotent [Relation] | |
| imap_of_direction [Genr_base] |
Returns the qualified identificateur of the mapping function of the
predefined
List module that is suitable for the
distributivity_direction argument.
|
| implementation [Printast] | |
| implementation [Parse] | |
| implementation [Parser] | |
| in_comment [Lexer] | |
| in_file [Location] |
Return an empty ghost range located in a given file.
|
| include_dirs [Clflags] | |
| incr_line_count [Pr_code] | |
| infix_apply [Code] |
Apply an infix ident to its arguments.
|
| infix_name [Code] |
Apply a given infix name to its arguments.
|
| init [Location] |
Set the file name and line number of the
lexbuf to be the start
of the named file.
|
| init_file [Clflags] | |
| injection_type [Otype] | |
| inline_threshold [Clflags] | |
| input_lexbuf [Location] | |
| input_name [Location] | |
| insert_gt [Match] |
Insertion ordering: t > u if t contains an instance of u
|
| int_of_ord [Order] | |
| inter [Main.StrSet] | |
| interface [Printast] | |
| interface [Parse] | |
| interface [Parser] | |
| interface_suffix [Config] |
Suffix for interface file names
|
| ints [Randomutils] | |
| inv [Axiom] | |
| invdis [Axiom] | |
| inverse [Subs] |
Inverse a substitution mapping variables to variables.
|
| inverse [Relation] | |
| invneu [Axiom] | |
| invol [Axiom] | |
| is_absorbing [Relation] | |
| is_active [Warnings] | |
| is_associative [Relation] | |
| is_commutative [Relation] | |
| is_commutativity [Equation] |
Test if an equation is the commutativity equation
|
| is_construction_function [Genr_base] | |
| is_distributive [Relation] | |
| is_empty [Main.StrSet] | |
| is_empty [Subs] |
Test if a substitution is the identity
|
| is_error [Warnings] | |
| is_generator_ident [Check] |
Access to generators.
|
| is_idempotent [Relation] | |
| is_infix [Pr_ocaml] | |
| is_infix_longident [Pr_ocaml] | |
| is_inverse [Relation] | |
| is_involutive [Relation] | |
| is_known_and_listary [Tgenr_base] | |
| is_known_and_listary_name [Tgenr_base] |
Same as above, indicating the generator name instead of the generator
|
| is_linear [Term] | |
| is_listary_generator [Check] |
Various access/test functions.
|
| is_listary_info [Check] | |
| is_local_generator [Check] | |
| is_local_info [Check] | |
| is_local_module [Main] | |
| is_neutral [Relation] | |
| is_neutral_generator [Relation] | |
| is_nilpotent [Relation] | |
| is_norm [Norm] | |
| is_not_rewrite [Relation] | |
| is_private_generator [Check] | |
| is_private_info [Check] | |
| is_private_type_declaration [Otype] | |
| is_private_variant_type_declaration [Otype] | |
| is_red [Norm] |
Test reducibility
|
| is_rewrite [Relation] | |
| is_truly_unary_generator [Check] | |
| is_type_ident [Check] |
Access to types.
|
| is_type_list [Otype] | |
| is_variant_type_declaration [Otype] | |
| iter [Main.StrSet] | |
| iter [Tbl] | |
| ith_group [Listutils] |
Separates the list in consecutive groups of the specified size,
then returns the i_th of such groups starting from 0.
|
K | |
| keep_asm_file [Clflags] | |
| keep_startup_file [Clflags] | |
L | |
| labs [Axiom] | |
| last [Longident] | |
| lazy_opt [Genr_base] | |
| lazy_tag [Config] |
Normally the same as Obj.lazy_tag.
|
| ldis [Axiom] | |
| le [Order] | |
| let0 [Code] | |
| let1 [Code] | |
| lex [Order] |
Lexicographic extension of an ordering
|
| linearize [Term] |
Linearize a term
|
| link_everything [Clflags] | |
| linv [Axiom] | |
| linvdis [Axiom] | |
| list_remove [Misc] | list_remove x l returns a copy of l with the first
element equal to x removed.
|
| list_type [Otype] | |
| list_vars [Term] | |
| list_vars_of_terms [Term] | |
| lneu [Axiom] | |
| load_path [Config] |
Directories in the search path for .cmi and .cmo files
|
| log2 [Misc] | log2 n returns s such that n = 1 lsl s
if n is a power of 2
|
| lower_case [Genr_expression] |
Replaces constructor calls by construction function calls in an
expression.
|
M | |
| main [Main] | |
| make_Constant [Code] |
Generate a constant expression from the given
string.
|
| make_Var [Code] |
Generate a variable expression from the name of the given ident.
|
| make_archive [Clflags] | |
| make_package [Clflags] | |
| make_public_type_declaration [Otype] | |
| make_runtime [Clflags] | |
| map [Subs] |
Map a function on bindings
|
| map [Myset.S] |
map on sets
|
| map [Tbl] | |
| map_end [Misc] | map_end f l t is map f l @ t, Just more efficient.
|
| map_filter [Myset.S] |
Set of elements y such that f x = Some y for some x in xs.
|
| map_from_to [Listutils] | map_from_to f b e succ Maps a function f to a list of elements
starting from element b until element e is reached, applying
function succ in turn to get the next element of the list.
|
| map_left_right [Misc] |
Like
List.map, with guaranteed left-to-right evaluation order
|
| map_of_direction [Genr_base] |
Returns the
map like function from the predefined List module that is
suitable for the distributivity_direction argument.
|
| matches [Match] | |
| matches_opt [Match] | |
| matching_subs [Match] |
Return matching substitution or raise Failure
|
| max_elt [Main.StrSet] | |
| max_tag [Config] |
Biggest tag that can be stored in the header of a regular block.
|
| max_young_wosize [Config] |
Maximal size of arrays that are directly allocated in the
minor heap
|
| may [Misc] | |
| may_map [Misc] | |
| mem [Main.StrSet] | |
| mem [Subs] |
Test if there is a binding
|
| mem [Tbl] | |
| mgu [Unif] |
Computes the MGU of two terms.
|
| min_elt [Main.StrSet] | |
| mk [Equation] | |
| mk [Rule] | |
| mk_apply [Otype] | |
| mk_char [Tgenr_base] |
Creates a value representing a character.
|
| mk_construction [Tgenr_base] |
Creates an expression in
Code.exp representing a generator with the
specified name and arguments.
|
| mk_equality [Tgenr_base] |
Creates an expression representing the application of the equality operator
|
| mk_exp [Otype] | |
| mk_float [Tgenr_base] |
Creates a value representing a float.
|
| mk_generator [Tgenr_base] |
Creates a generator with the given name and location
|
| mk_ident [Otype] | |
| mk_int [Tgenr_base] |
Creates a value representing an integer.
|
| mk_int32 [Tgenr_base] |
Creates a value representing an int32.
|
| mk_int64 [Tgenr_base] |
Creates a value representing an int 64.
|
| mk_list [Tgenr_base] |
Creates a value representing a list with the specified expressions.
|
| mk_nativeint [Tgenr_base] |
Creates a value representing an native integer.
|
| mk_non_listary_construction [Tgenr_base] |
Creates an expression in Code.exp representing a generator with the
specified name and arguments.
|
| mk_pat [Otype] | |
| mk_rel [Otype] | |
| mk_sharing_function_ident [Genr_base] |
Name of the sharing generation functions for a given generator name.
|
| mk_string [Tgenr_base] |
Creates a value representing a string.
|
| mk_tuple [Tgenr_base] |
Creates a value representing a tuple with the specified expressions.
|
| mk_type [Otype] | |
| mk_when [Otype] | |
| mkdll [Config] |
The linker command line to build dynamic libraries.
|
| mkexe [Config] |
The linker command line to build executables.
|
| mkmaindll [Config] |
The linker command line to build main programs as dlls.
|
| moca_full_version [Configuration] | |
| moca_minor_version_number [Configuration] | |
| moca_version_number [Configuration] | |
| model [Config] |
Name of processor submodel for the native-code compiler
|
| module_of_mli_file [File] | |
N | |
| name_of_generator [Otype] | |
| name_of_longident [Otype] | |
| native_c_compiler [Config] |
The C compiler to use for compiling C files
with the native-code compiler
|
| native_c_libraries [Config] |
The C libraries to link with native-code programs
|
| native_code [Clflags] | |
| native_pack_linker [Config] |
The linker to use for packaging (ocamlopt -pack) and for partial links
(ocamlopt -output-obj).
|
| neu [Axiom] | |
| neutral [Relation] |
Returns the first neutral element (Left, Right, or Both)
for the generator.
|
| neutral_both [Relation] |
Returns the neutral element (simultaneously Left and Right, or Both)
for the generator.
|
| neutral_element_of_generator [Check] |
Gives the neutral element of
g or else raise No_neutral_element
|
| neutral_left [Relation] |
Returns a left neutral element for the generator if any.
|
| neutral_right [Relation] |
Returns a right neutral element for the generator if any.
|
| next_token [Clexer] | |
| nil [Genr_base] |
These functions generate code values.
|
| nil [Axiom] | |
| nilpotent [Relation] | |
| no_auto_link [Clflags] | |
| no_overflow_add [Misc] | no_overflow_add n1 n2 returns true if the computation of
n1 + n2 does not overflow.
|
| no_overflow_lsl [Misc] | no_overflow_add n returns true if the computation of
n lsl 1 does not overflow.
|
| no_overflow_sub [Misc] | no_overflow_add n1 n2 returns true if the computation of
n1 - n2 does not overflow.
|
| no_std_include [Clflags] | |
| noassert [Clflags] | |
| none [Location] |
An arbitrary value of type
t; describes an empty ghost range.
|
| nopervasives [Clflags] | |
| noprompt [Clflags] | |
| norm [Norm_ml] | |
| norm [Norm] | |
| norm [Otype] | |
| not_yet_implemented [Debug] |
Raises failure with "not yet implemented" and the string argument.
|
O | |
| objfiles [Clflags] | |
| occurs [Term] | |
| of_list [Myset.S] |
Build a set from a list of elements
|
| of_list_map [Myset.S] | |
| opp [Order] | |
| opposite [Otype] | |
| opt [Genr_base] |
Functions to generate clauses on demand.
|
| optimize_for_speed [Clflags] | |
| opts [Genr_base] | |
| order_relations [Genr_base] | |
| order_rels [Genr_base] | |
| output [Debug] | |
| output_c_object [Clflags] | |
| output_name [Clflags] | |
| output_sep [Debug] | |
P | |
| pair [Code] | |
| parse [Longident] | |
| parse_ml_file [File] | |
| parse_mli_file [File] | |
| parse_options [Warnings] | |
| partition [Main.StrSet] | |
| partition [Equation] |
Partition a set of equations into those whose lhs is greater,
smaller or something else
|
| partition [Order] |
Partition a list of pairs into those whose lhs is greater, equal, etc.
|
| pattern [Genr_base] | |
| pattern0 [Genr_base] | |
| pattern1 [Genr_base] | |
| pattern2 [Genr_base] |
Similar to generator application for the pattern case.
|
| pattern_info [Genr_base] |
Similar to generator application for the pattern case.
|
| pervasives_comparisons [Genr_base] |
Triple representing OCaml's Pervasives.compare functions
|
| poly_type [Otype] | |
| position [Mylist] |
Position of an element
|
| pr_clause [Pr_code] |
Prints a clause in a matching construct.
|
| pr_constant [Pr_ocaml] | |
| pr_core_type [Pr_ocaml] | |
| pr_expression [Pr_code] |
Prints an expression in the indicated formatter.
|
| pr_expression [Pr_ocaml] | |
| pr_ident_in_infix_position [Pr_ocaml] | |
| pr_ident_in_prefix_position [Pr_ocaml] | |
| pr_ident_name_in_prefix_position [Pr_ocaml] | |
| pr_params [Pr_ocaml] | |
| pr_pattern [Pr_ocaml] | |
| pr_relation [Pr_ocaml] | |
| pr_sep_vals [Pr_ocaml] | |
| pr_sep_vals_fmt [Pr_ocaml] | |
| pr_structure [Pr_code] |
Prints a code structure in the indicated formatter.
|
| pr_structure_item_desc [Pr_ocaml] | |
| pr_structure_sep [Pr_ocaml] | |
| pr_suffix_vals_fmt [Pr_ocaml] | |
| pr_symbol [Symb] | |
| pr_term [Term] |
Pretty print.
|
| pr_type [Pr_ocaml] | |
| pr_type_definitions [Pr_ocaml] | |
| pr_value_description [Pr_ocaml] | |
| pr_var [Var] | |
| pr_verbatim_structure_item [Pr_ocaml] | |
| pr_verbatim_structure_items [Pr_ocaml] | |
| prec_of_list [Prec] | f1; ..; fn gives f1 < ..
|
| precedence [Relation] | |
| prefix_construction_function [Genr_base] |
Name of the generation functions for a given prefix name
and a given generator:
prefix_generator_function p g is the ident "prefix_name",
where "prefix" is the contents of p,
and "name" is the uncapitalized version of g.
|
| prefix_construction_function2 [Genr_base] |
Name of the generation functions for a given prefix name
and the combination of two generators:
prefix_generator_function2 p g1 g2 is the ident "prefix_name1_name2",
where "prefix" is the contents of p,
and "name1", "name2" are the uncapitalized versions of g1, g2.
|
| prefix_ident [Genr_base] |
Adds a prefix to an identifier.
|
| prefix_longident [Code] |
To add a prefix string to a qualified (long) identifier.
|
| preprocessor [Clflags] | |
| prerr_warning [Location] | |
| principal [Clflags] | |
| print [Debug] | |
| print [Location] | |
| print [Warnings] | |
| print [Tbl] | |
| print_config [Config] | |
| print_error [Location] | |
| print_error_cur_file [Location] | |
| print_memo_hash_table_module [Genr_memo] |
Output module declarations and helpers for memoized functions
|
| print_moca_full_version [Main] | |
| print_moca_short_version [Main] | |
| print_moca_version [Main] | |
| print_sharing [Genr_sharing] | |
| print_sharing_ml_preamble [Genr_sharing] | |
| print_sharing_mli_preamble [Genr_sharing] | |
| print_type_private_structure_items [Genr_sharing] |
Prints the structure items defined in the private type definition.
|
| print_types [Clflags] | |
| print_usage [Main] | |
| print_warning [Location] | |
| projection_type [Otype] | |
Q | |
| qualified_name_of_generator [Otype] | |
| qualified_name_of_longident [Otype] | |
| quote_files [Ccomp] | |
| quote_optfile [Ccomp] | |
R | |
| rabs [Axiom] | |
| raise_error [Check] | |
| raise_error [Code] | |
| ranlib [Config] |
Command to randomize a library, or "" if not needed
|
| raw_string_of_var [Var] |
Convert n>=0 into xn and n<0 into yn
|
| rdis [Axiom] | |
| recursive_types [Clflags] | |
| red_opt [Norm] | |
| relations_of_cdef [Otype] | |
| remove [Main.StrSet] | |
| remove [Tbl] | |
| remove_commutativity [Equation] | |
| remove_file [Misc] |
Delete the given file if it exists.
|
| remove_rules [Otype] | |
| remove_rules_in_type_declaration [Otype] | |
| remove_topconstr [Genr_pattern] | |
| remove_trivial [Equation] | |
| rename [Rename] |
Apply a renaming to a term
|
| rename [Term] | |
| renaming_away [Rename] |
Renaming away from a term
|
| renaming_aways [Rename] | |
| repeat [Listutils] | repeat n x Creates a list with n element x.
|
| replace [Subterm] | replace t p u replaces the subterm of t at position p by u
|
| replace [Mylist] |
Replace the i-th element of a list
|
| replace_map [Mylist] |
Replace the i-th element x by f(x)
|
| replicate_list [Misc] | replicate_list elem n is the list with n elements
all identical to elem.
|
| report_error [Check] | |
| report_error [Lexer] | |
| report_error [Syntaxerr] | |
| reset [Location] | |
| reset_line_count [Pr_code] | |
| restrict [Subs] |
Restriction of a susbtitution to some domain
|
| resume [Terminfo] | |
| rev_split_words [Misc] | rev_split_words s splits s in blank-separated words, and return
the list of words in reverse order.
|
| rewrite [Relation] | |
| rhs_loc [Location] | |
| rinv [Axiom] | |
| rinvdis [Axiom] | |
| rneu [Axiom] | |
| rpo [Order] |
Recursive Path Ordering
|
| rpo_fail [Order] | |
| rule [Cparser] | |
| rules [Cparser] | |
| run_command [Ccomp] | |
S | |
| samelist [Misc] |
Like
List.for_all2 but returns false if the two
lists have different length.
|
| search_ml_file_for_module [File] | |
| search_mli_file_for_module [File] | |
| search_substring [Misc] | search_substring pat str start returns the position of the first
occurrence of string pat in string str.
|
| sep [Debug] | |
| sequence [Code] | |
| set [Consistbl] | set tbl name crc source forcefully associates name with
crc in tbl, even if name already had a different CRC
associated with name in tbl.
|
| set_comments [Genr_base] | |
| set_debug [Debug] | |
| set_dline_trace [Genr_base] | |
| set_genr_implementation [Main] | |
| set_genr_interface [Main] | |
| set_genr_test [Main] | |
| set_implementation_from_file_name [Main] | |
| set_input_file_name [Main] | |
| set_kb [Eqnrel] | |
| set_kb_limit [Eqnrel] | |
| set_memo_table_size [Genr_memo] | |
| set_memoize_target [Genr_memo] | |
| set_num_tests [Main] | |
| set_output_file_name [Main] | |
| set_output_filename [Pr_code] | |
| set_output_module_implementation_name [Main] | |
| set_output_module_interface_name [Main] | |
| set_output_module_name [Main] | |
| set_seed [Main] | |
| set_sharable_target [Genr_base] |
Maximum sharing handling.
|
| set_testing_file_name [Main] | |
| set_user_rel_order [Genr_base] | |
| set_val_depth [Main] | |
| set_verbose [Configuration] | |
| setup [Terminfo] | |
| shared [Clflags] | |
| singleton [Main.StrSet] | |
| singleton [Genr_base] | |
| skip_sharp_bang [Lexer] | |
| sort_relations [Relation] | |
| sort_rels [Relation] | |
| source [Consistbl] | source tbl name returns the file name associated with name
if the latter has an associated CRC in tbl.
|
| split [Main.StrSet] | |
| split [Mylist] |
Given a list
l and a number i such that 0 <= i < List.length l,
returns the triple l1, x, l2
such that x = List.nth l i and l = List.rev l1 @ x :: l2
|
| split_last [Misc] |
Return the last element and the other elements of the given list.
|
| stack_threshold [Config] |
Size in words of safe area at bottom of VM stack,
see byterun/config.h
|
| standard_library [Config] |
The directory containing the standard libraries
|
| standard_runtime [Config] |
The full path to the standard bytecode interpreter ocamlrun
|
| standout [Terminfo] | |
| std_include_dir [Clflags] | |
| std_include_flag [Clflags] | |
| step [Comp] |
Completion step
|
| strict_sequence [Clflags] | |
| string_of_constant [Pr_ocaml] | |
| string_of_symbol [Symb] |
Return the string represented by some symbol
|
| string_of_var [Var] |
Inverse of var_of_string.
|
| subs [Subs] |
One-variable substitution
|
| subset [Main.StrSet] | |
| subst [Otype] |
Given an association mapping variable names to core types,
applies it to the given core type list as a substitution
|
| subterm_pos [Subterm] |
Subterm at position p
|
| symbol_gloc [Location] | |
| symbol_of_string [Symb] |
Check if a string is represented by a known symbol,
associate it with a new symbol otherwise
|
| symbol_rloc [Location] | |
| symbols [Term] | |
| symbols_of_rule [Rule] |
Symbols of a set of rules
|
| symbols_of_rules [Rule] | |
| symbols_of_terms [Term] | |
| system [Config] |
Name of operating system for the native-code compiler
|
| systhread_supported [Config] |
Whether the system thread library is implemented
|
T | |
| t [Code] | |
| take [Listutils] | take n l Takes the first n elements of list l,
or the whole list l, if l has less than nn elements.
|
| term [Cparser] | |
| testing_equations_of_rels [Genr_listary_equations] | |
| token [Lexer] | |
| top_phrase [Printast] | |
| top_term [Cparser] | |
| topletrec [Code] |
To define a toplevel let rec definition in a module implementation.
|
| toplevel_phrase [Parse] | |
| toplevel_phrase [Parser] | |
| trace [Debug] | |
| trace_clause [Genr_base] |
Returns the code outputing the diese_line directives
#
int string
|
| transpose [Listutils] | transpose ll Transposes a list of lists.
|
| try_finally [Misc] | |
| tuple_type [Otype] | |
| type_of_eq [Otype] | |
| typed_vars_eqn [Typed_vars] | |
U | |
| u [Code] | |
| udis [Axiom] | |
| uidem [Axiom] | |
| umsg [Main] | |
| underscore [Code] | |
| underscored_clause [Code] | |
| underscored_ocaml_pattern [Code] | |
| underscored_pattern [Code] | |
| unif [Unif] |
Return mgu or raise Failure
|
| unil [Axiom] | |
| union [Main.StrSet] | |
| union_map [Myset.S] |
Union of the sets obtained by mapping f on some list
|
| unique [Listutils] | unique p l Removes duplicates from a list, provided a binary predicate
p.
|
| untrace [Debug] | |
| usage [Main] | |
| use_file [Parse] | |
| use_file [Parser] | |
| use_prims [Clflags] | |
| use_runtime [Clflags] | |
| use_threads [Clflags] | |
| use_vmthreads [Clflags] | |
V | |
| var_of_string [Var] |
Return a fresh variable if called with a string for the first time.
|
| var_type [Otype] | |
| vars [Term_utils] | |
| vars [Term] | |
| vars_of_terms [Term] | |
| verbose [Clflags] | |
| verbose_print [Configuration] | |
| verbose_printf [Configuration] | |
| version [Config] |
The current version number of the system
|
W | |
| w [Term_utils] | |
X | |
| x [Term_utils] | |
| x [Code] | |
| xs [Code] |
When binding a list of arguments.
|
Y | |
| y [Term_utils] | |
| y [Code] | |
Z | |
| z [Term_utils] | |
| z [Code] |