mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-15 01:13:30 +00:00
b261c5fcb2
Until now, the only integer type we generated dense switches
(including lookup switches) for was int itself; we did not do so
for any sized and/or unsigned integer types.
compiler/switch_util.m:
Simplify the representation of whether a switch is on an integer type.
The new version makes it impossible to make the mistake that caused
bug582 in the first place: not having a single representation for
for the switch being on *any* kind of integer type.
This fix requires solving a problem we never had to solve before:
representing information such as the min and max case values
in a way that works for every integer type, signed or unsigned,
sized or not. The solution that this diff adopts is to use int32s
to represent those limits, which implies that whatever the type
of the integer value being switched on, we will generate a dense
or a lookup switch for it only if all case values fit into an int32.
Since case values over two billion are vanishingly rare, this should be
an acceptable restriction.
Use uints instead of ints to represent counts of things.
Delete an unneeded pair of arguments.
compiler/lookup_switch_util.m:
Conform to the changes in switch_util.m. Use some of the new types
there to make arguments in arguments lists less confusable.
Provide some new utility operations.
Add XXXs where the basic operations we need seem not to exist.
compiler/dense_switch.m:
compiler/lookup_switch.m:
Use the new types in switch_util.m that can represent switches
on any integer type.
compiler/ml_lookup_switch.m:
compiler/ml_simplify_switch.m:
compiler/ml_string_switch.m:
compiler/ml_switch_gen.m:
compiler/switch_gen.m:
Conform to the changes above, and thereby gain the ability
to generate switches on integer types other than int itself.
library/int64.m:
Add a (commmented-out) declaration of an operation that could
help resolve one of the issues in new code in the modules above.
Similar operations would be needed in the modules of other
sized integer types as well.
library/library.m:
Fix a typo.
tests/hard_coded/bug582.{m,exp}:
Add a test case for this issue. Note that while we test whether
we get the expected output, there is no simple automatic way
to detect whether it was generated using a lookup table.
tests/hard_coded/Mmakefile:
Enable the new test case.
804 lines
33 KiB
Mathematica
804 lines
33 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ts=4 sw=4 et ft=mercury
|
|
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 1993-2007, 2009-2014 The University of Melbourne.
|
|
% Copyright (C) 2013-2023, 2025-2026 The Mercury team.
|
|
% This file is distributed under the terms specified in COPYING.LIB.
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% This module imports all the modules in the Mercury standard library.
|
|
%
|
|
% Its main use is telling build systems what modules are part of
|
|
% the Mercury standard library. This implicitly specifies what files
|
|
% (such as interface files, optimization files, header files, object files,
|
|
% and so on) need to be installed as part of installing the library.
|
|
%
|
|
% It also provides functions that return version and architecture
|
|
% information for the Mercury installation.
|
|
%
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Many modules in the Mercury standard library are standalone, but
|
|
% many others are part of clusters (i.e. groups) of related modules.
|
|
% Typically, the modules in each such cluster
|
|
%
|
|
% - either implement the exact same abstract data type,
|
|
% - or they implement slight variations on an abstract data type.
|
|
%
|
|
% In both cases, the different modules have different strengths and
|
|
% weaknesses, with different ones being suitable for different workloads.
|
|
% (If one was better than all the others for all workloads, then
|
|
% there would be no need for any of the others.)
|
|
%
|
|
% The main clusters are
|
|
%
|
|
% - sets
|
|
% - lists
|
|
% - queues
|
|
% - arrays
|
|
% - maps
|
|
%
|
|
% The following sections describe each cluster in detail.
|
|
%
|
|
%---------------------%
|
|
%
|
|
% The *set* cluster.
|
|
%
|
|
% This consists of modules that implement the set abstract data type.
|
|
% The modules in this cluster fall into two subclusters.
|
|
%
|
|
% The first subcluster consists of modules whose sets can store values
|
|
% of any type. These modules are
|
|
%
|
|
% - set_unordlist, which represents sets as unsorted lists
|
|
% with possible duplicates.
|
|
%
|
|
% This has the fastest insertion operation, but is suitable
|
|
% only for very small sets.
|
|
%
|
|
% - set_ordlist, which represents sets as sorted lists without duplicates.
|
|
%
|
|
% This has a slower insertion operation than set_unordlist, but faster
|
|
% membership test operations. It is suitable only for small sets.
|
|
%
|
|
% - set_bbbtree, which represents sets as bounded-balance binary trees
|
|
% - set_tree234, which represents sets as 234-trees
|
|
%
|
|
% These modules use balanced trees to achieve logarithmic complexity
|
|
% for both insertion and membership test operations (and for some other
|
|
% operations, such as deletion). This makes them suitable for
|
|
% significantly larger sets than set_unordlist or set_ordlist, with
|
|
% the tradeoff being that their higher complexity results in higher
|
|
% constant factors.
|
|
%
|
|
% - set_ctree234, which represents sets as 234-trees with counts
|
|
%
|
|
% This module differs from set_tree234 only in that it explicitly records
|
|
% the count of items in the tree. This makes the "count items" operation
|
|
% constant time, at the cost of extra work on every insertion and deletion
|
|
% to update the count.
|
|
%
|
|
% - set, which is effectively a short name for one of the modules above.
|
|
% For a long time now, it has been a shorthand for set_ordlist, which is
|
|
% a good general choice for small sets. It has the separate, generic name
|
|
% to allow this to be changed in the future.
|
|
%
|
|
% The second subcluster consists of modules whose sets can store only
|
|
% integers, or values that can be transformed into integers. These modules are
|
|
%
|
|
% - sparse_bitset, which represents sets as a list of words, with
|
|
% each word being a bitmap that is constrained to represent the integers
|
|
% in the range [N * wordsize, (N * wordsize) + wordsize-1]. The list
|
|
% contains only bitmaps in which at least one bit is set.
|
|
%
|
|
% This representation can be thought of as a version of set_ordlist with
|
|
% smaller constant factors whenever a bitmap has two or more bits set.
|
|
%
|
|
% The point of the alignment constraint is to simplify and speed up
|
|
% union, intersection and difference operations.
|
|
%
|
|
% - fat_sparse_bitset is a variant of sparse_bitset. Whereas sparse_bitset
|
|
% uses two two-word cells on the heap to represent a bitmap (one cell
|
|
% for the list constructor, and one for the <N,bitmap> pair), this module
|
|
% uses just one three-word heap cell containing N, the bitmap, and the
|
|
% rest of the list.
|
|
%
|
|
% fat_sparse_bitset avoids a pointer indirection on each access,
|
|
% but it gets its heap cells from a different list in the memory allocator
|
|
% than sparse_bitset. This is the list of four-word cells, since the Boehm
|
|
% collector, and most others, round up requests to the next multiple of two.
|
|
%
|
|
% Whether fat_sparse_bitset is better than sparse_bitset itself depends
|
|
% on the machine architecture and on the workload.
|
|
%
|
|
% - fatter_sparse_bitset is a variant of fat_sparse_bitset. It is intended
|
|
% to make use of the otherwise-fallow fourth word in a four-word allocation,
|
|
% by storing two adjacent bitmaps between the value of N and the
|
|
% next pointer.
|
|
%
|
|
% fatter_sparse_bitset can be faster than fat_sparse_bitset if the
|
|
% probability of some set members falling into each extra bitmap
|
|
% is high enough. If it is too low, then its higher constant factors
|
|
% will make it slower than fat_sparse_bitset.
|
|
%
|
|
% - tree_bitset is another variant of sparse_bitset. While sparse_bitset
|
|
% represents a set using a list of bitmaps of unlimited length, in which
|
|
% getting to a bitmap representing a large integer requires following
|
|
% a lot of pointers, tree_bitset represents them using a tree whose leaves
|
|
% consist of relatively short lists (up to 32 bitmaps), and whose interior
|
|
% nodes each contain lists of up to 32 nodes at the next lower level.
|
|
%
|
|
% This structure can speed up operations by significantly reducing the
|
|
% number of list element traversals, but it also has higher constant
|
|
% factors.
|
|
%
|
|
% - ranges represents sets using a simple list of ranges, where every integer
|
|
% in a range is in the set.
|
|
%
|
|
% This representation is suitable only for sets in which most ranges contain
|
|
% more than one integer. (If most contain only one integer, then either
|
|
% set_ordlist or sparse_bitset would probably be faster.)
|
|
%
|
|
% - diet represents sets using discrete interval encoding trees.
|
|
% This data structure is also based on ranges (which it calls intervals),
|
|
% but the superstructure it builds on top of them is not a list (as with
|
|
% the ranges module) but a balanced tree (specifically, an AVL tree).
|
|
%
|
|
% This representation is also suitable only for sets in which most ranges
|
|
% contain more than one integer, but it has better worst-case complexity
|
|
% (logarithmic rather than linear) for membership test operations.
|
|
%
|
|
%---------------------%
|
|
%
|
|
% The *list* cluster.
|
|
%
|
|
% This consists of modules that implement ordered sequences.
|
|
%
|
|
% - list is the standard implementation of ordered sequences.
|
|
%
|
|
% - one_or_more is a variant of the list module that is specifically
|
|
% intended to represent *nonempty* ordered sequences, with empty
|
|
% sequences being ruled out by the type system.
|
|
%
|
|
% - cord represents lists using a data structure that can append two cords
|
|
% in constant time. (In both the list and one_or_more modules, appending
|
|
% two lists takes time that is proportional to the length of the
|
|
% first list.) The cord representation uses a tree whose shape
|
|
% corresponds to the append operations that created it.
|
|
%
|
|
% If you need to build up a long list piece by piece, represent the pieces
|
|
% using cords, and then convert the final cord to a list.
|
|
%
|
|
% - ra_list also uses trees (actually, a list of perfectly balanced
|
|
% binary trees) to represent ordered sequences, but its objective is
|
|
% to speed up random access to selected list elements (the "ra" part of
|
|
% the name stands for "random access"), instead of append operations.
|
|
%
|
|
% - assoc_list implements one popular use of lists, which is lists of
|
|
% key/value pairs.
|
|
%
|
|
% - kv_list is a variant of assoc_list that is intended to have
|
|
% better memory behavior. Whereas assoc_list stores each key/value pair
|
|
% two two-word cells on the heap (one cell for the list constructor,
|
|
% and one for the <key,value> pair), this module uses just one three-word
|
|
% heap cell containing the key, the value, and the pointer to the rest
|
|
% of the list. This can yield better performance on some architectures
|
|
% and for some workloads, at the price of not being able to apply standard
|
|
% list operations to kv_lists (other than the ones supplied by the kv_list
|
|
% module itself).
|
|
%
|
|
%---------------------%
|
|
%
|
|
% The *queue* cluster.
|
|
%
|
|
% This consists of modules that implement ordered sequences which have
|
|
% separate operations to *put* items into the sequence, and to *get* items
|
|
% out of the sequence.
|
|
%
|
|
% - queue is the standard implementation of this abstract data type.
|
|
% The sequences it supports have two distinct ends: the tail where
|
|
% new items are put onto the queue, and the front where items get
|
|
% taken off the queue.
|
|
%
|
|
% - pqueue implements a variant of this abstract data type, the priority
|
|
% queue, which stores key/value pairs, and whose get operation removes from
|
|
% the queue not the pair at the front, but the pair whose key is the
|
|
% smallest. In this abstract data type, the list is ordered not from
|
|
% oldest to newest insertion time, but from low keys to high keys.
|
|
%
|
|
% - psqueue, which is short for "priority search queue", implements a variant
|
|
% of priority queue which allows operations that return the value associated
|
|
% with a key in the queue (if the key exists in the queue).
|
|
%
|
|
%---------------------%
|
|
%
|
|
% The *array* cluster.
|
|
%
|
|
% This consists of modules that implement arrays, which, conceptually,
|
|
% are maps from integers (in the range of 0 to some N) to values.
|
|
%
|
|
% - array defines the standard one-dimensional array data structure.
|
|
% It supports constant time lookup and update, but guarantees
|
|
% correct operation only if the user never performs any operation
|
|
% whatsoever on any array that has had any updates applied to.
|
|
% This is because its updates are destructive updates. Since the
|
|
% Mercury mode system is not expressive enough to prevent access
|
|
% to outdated versions of arrays, that task falls to programmers.
|
|
%
|
|
% - array2d defines two-dimensional arrays, but in every other respect,
|
|
% its behavior matches that of the array module.
|
|
%
|
|
% - version_array is a version of the array module that allows both
|
|
% efficient access to the latest version of the array, and less efficient
|
|
% but still safe access to earlier versions of the array. In general,
|
|
% the more outdated an array is, the less efficient access to its elements
|
|
% will be. This is because a version array effectively consists of
|
|
% the latest version of the array, and a list of "diffs" that allow
|
|
% the reconstruction of earlier and earlier versions.
|
|
%
|
|
% - version_array2d is effectively a two-dimensional array version
|
|
% of the version_array module.
|
|
%
|
|
% - bt_array solves the same problem as version_array (safe access
|
|
% to non-current versions of the array), but using a different
|
|
% data structure: random access lists, as in the ra_list module.
|
|
% This has different performance characteristics: it has faster access
|
|
% to old versions, at the cost of logarithmic and not constant time access
|
|
% to the current version.
|
|
%
|
|
%---------------------%
|
|
%
|
|
% The *map* cluster.
|
|
%
|
|
% This consists of modules that store key/value pairs, and support
|
|
% the lookup of the value (if any) associated with a given key.
|
|
%
|
|
% - map is the standard implementation of maps. For a long time now,
|
|
% it has been a shorthand for the tree234 implementation of maps.
|
|
% It has the separate, generic name to allow this to be changed
|
|
% in the future.
|
|
%
|
|
% - tree234 is the implementation of maps using 2-3-4 trees, which are
|
|
% a kind of balanced tree.
|
|
%
|
|
% - rbtree is the implementation of maps using red-black trees, which are
|
|
% a different kind of balanced tree.
|
|
%
|
|
% - multi_map implements one popular kind of map: maps that allow each key
|
|
% to be mapped to a *list* of values. If a key is mapped to the empty list
|
|
% of values, then operations in this module will delete the key, but since
|
|
% the definition of multi_map is visible from outside its module, it is
|
|
% possible for users of the module to create map entries that map a key
|
|
% to the empty list of values.
|
|
%
|
|
% - one_or_more_map is a version of multi_maps which does enforce
|
|
% the invariant that if a key exists in the map, then the list of values
|
|
% corresponding to it will be nonempty.
|
|
%
|
|
% - bimap implements a bidirectional map, which in mathematics is called
|
|
% a bijection. This requires that each key maps to a unique value,
|
|
% and for each value is mapped from a unique key. Bimaps allow
|
|
% not just a lookup of a value given the key, but also the key given value.
|
|
%
|
|
% - injection implements an injection, which is closely related to, but
|
|
% nevertheless different from, a bijection. Like a bijection, an injection
|
|
% requires that each key map to a unique value, but unlike a bijection,
|
|
% it allows a value to be mapped from more than one key.
|
|
%
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- module library.
|
|
:- interface.
|
|
|
|
% version(VersionString, FullarchString)
|
|
%
|
|
:- pred version(string::out, string::out) is det.
|
|
|
|
% Return the Mercury version string.
|
|
%
|
|
:- func mercury_version = string.
|
|
|
|
% Return the architecture string.
|
|
%
|
|
:- func architecture = string.
|
|
|
|
% Return the package version string.
|
|
%
|
|
:- func package_version = string.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
% Everything below here is not intended to be part of the public interface,
|
|
% and will not be included in the Mercury library reference manual.
|
|
|
|
:- interface.
|
|
|
|
% Is a module or submodule intended to be documented in the library
|
|
% reference manual, or not?
|
|
%
|
|
:- type doc_or_undoc
|
|
---> doc
|
|
; undoc.
|
|
|
|
% Succeeds if-and-only-if the string is the (unqualified) name
|
|
% of one of the modules in the Mercury standard library.
|
|
%
|
|
:- pred mercury_std_library_module(string::in) is semidet.
|
|
|
|
% Maps the name of each module in the Mercury standard library
|
|
% to an indication of whether we want to document it or not.
|
|
%
|
|
% Can also be used to get the names and doc status of *all* the
|
|
% modules in the Mercury standard library.
|
|
%
|
|
:- pred stdlib_module_doc_undoc(string, doc_or_undoc).
|
|
:- mode stdlib_module_doc_undoc(in, out) is semidet.
|
|
:- mode stdlib_module_doc_undoc(out, out) is multi.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
% NOTE: If you add a new module to the library, you also need to do the
|
|
% following.
|
|
%
|
|
% - Unless the new module is a private submodule of an existing library module,
|
|
% import the new module in one of the two lists below: the list of modules
|
|
% intended for application programmers, or the list of modules intended
|
|
% only for Mercury system implementors.
|
|
%
|
|
% - Add the module name to the definition of mercury_std_library_module below.
|
|
% This is regardless of whether
|
|
%
|
|
% - the module is for implementors or not, and
|
|
% - whether it is a private submodule or not.
|
|
%
|
|
% The mercury_std_library_module predicate should list all the modules
|
|
% in a Mercury source file in the library directory.
|
|
%
|
|
% - Add the file name either to MODULES_DOC (if it is intended for application
|
|
% programmers, and should therefore be included in the automatically
|
|
% generated user-facing documentation), or to MODULES_UNDOC (if it is
|
|
% intended only for Mercury system implementors, in which case it should
|
|
% not be included in that documentation).
|
|
%
|
|
% Please keep all these lists in alphabetical order.
|
|
% NOTE_TO_IMPLEMENTORS But do it manually. The standard Unix sort program
|
|
% NOTE_TO_IMPLEMENTORS screws up the ordering of e.g. int8 vs int16.
|
|
|
|
% The modules intended for application programmers.
|
|
:- import_module array.
|
|
:- import_module array2d.
|
|
:- import_module assoc_list.
|
|
:- import_module backjump.
|
|
:- import_module bag.
|
|
:- import_module benchmarking.
|
|
:- import_module bimap.
|
|
:- import_module bit_buffer.
|
|
:- import_module bit_buffer.read.
|
|
:- import_module bit_buffer.write.
|
|
:- import_module bitmap.
|
|
:- import_module bool.
|
|
:- import_module bt_array.
|
|
:- import_module builtin.
|
|
:- import_module calendar.
|
|
:- import_module char.
|
|
:- import_module construct.
|
|
:- import_module cord.
|
|
:- import_module counter.
|
|
:- import_module deconstruct.
|
|
:- import_module diet.
|
|
:- import_module digraph.
|
|
:- import_module dir.
|
|
:- import_module edit_distance.
|
|
:- import_module edit_seq.
|
|
:- import_module enum.
|
|
:- import_module eqvclass.
|
|
:- import_module exception.
|
|
:- import_module fat_sparse_bitset.
|
|
:- import_module fatter_sparse_bitset.
|
|
:- import_module float.
|
|
:- import_module gc.
|
|
:- import_module getopt.
|
|
:- import_module getopt_io.
|
|
:- import_module hash_table.
|
|
:- import_module injection.
|
|
:- import_module int.
|
|
:- import_module int8.
|
|
:- import_module int16.
|
|
:- import_module int32.
|
|
:- import_module int64.
|
|
:- import_module integer.
|
|
:- import_module io.
|
|
:- import_module io.call_system.
|
|
:- import_module io.environment.
|
|
:- import_module io.error_util.
|
|
:- import_module io.file.
|
|
:- import_module io.primitives_read.
|
|
:- import_module io.primitives_write.
|
|
:- import_module io.stream_db.
|
|
:- import_module io.stream_ops.
|
|
:- import_module kv_list.
|
|
:- import_module lazy.
|
|
:- import_module list.
|
|
:- import_module map.
|
|
:- import_module math.
|
|
:- import_module maybe.
|
|
:- import_module mercury_term_lexer.
|
|
:- import_module mercury_term_parser.
|
|
:- import_module multi_map.
|
|
:- import_module one_or_more.
|
|
:- import_module one_or_more_map.
|
|
:- import_module ops.
|
|
:- import_module pair.
|
|
:- import_module parsing_utils.
|
|
:- import_module pprint.
|
|
:- import_module pqueue.
|
|
:- import_module pretty_printer.
|
|
:- import_module prolog.
|
|
:- import_module psqueue.
|
|
:- import_module queue.
|
|
:- import_module ra_list.
|
|
:- import_module random.
|
|
:- import_module random.sfc16.
|
|
:- import_module random.sfc32.
|
|
:- import_module random.sfc64.
|
|
:- import_module random.system_rng.
|
|
:- import_module ranges.
|
|
:- import_module rational.
|
|
:- import_module rbtree.
|
|
:- import_module require.
|
|
:- import_module robdd.
|
|
:- import_module rtree.
|
|
:- import_module set.
|
|
:- import_module set_bbbtree.
|
|
:- import_module set_ctree234.
|
|
:- import_module set_ordlist.
|
|
:- import_module set_tree234.
|
|
:- import_module set_unordlist.
|
|
:- import_module solutions.
|
|
:- import_module sparse_bitset.
|
|
:- import_module stack.
|
|
:- import_module std_util.
|
|
:- import_module store.
|
|
:- import_module stream.
|
|
:- import_module stream.string_writer.
|
|
:- import_module string.
|
|
:- import_module string.builder.
|
|
:- import_module string.format.
|
|
:- import_module string.parse_util.
|
|
:- import_module table_statistics.
|
|
:- import_module term.
|
|
:- import_module term_context.
|
|
:- import_module term_conversion.
|
|
:- import_module term_int.
|
|
:- import_module term_io.
|
|
:- import_module term_subst.
|
|
:- import_module term_to_xml.
|
|
:- import_module term_unify.
|
|
:- import_module term_vars.
|
|
:- import_module thread.
|
|
:- import_module time.
|
|
:- import_module tree234.
|
|
:- import_module tree_bitset.
|
|
:- import_module type_desc.
|
|
:- import_module uint.
|
|
:- import_module uint8.
|
|
:- import_module uint16.
|
|
:- import_module uint32.
|
|
:- import_module uint64.
|
|
:- import_module unit.
|
|
:- import_module univ.
|
|
:- import_module varset.
|
|
:- import_module version_array.
|
|
:- import_module version_array2d.
|
|
:- import_module version_bitmap.
|
|
:- import_module version_hash_table.
|
|
:- import_module version_store.
|
|
|
|
% The modules intended for Mercury system implementors.
|
|
% NOTE: changes to this list may need to be reflected
|
|
% in mdbcomp/builtin_modules.m.
|
|
:- import_module mutvar.
|
|
:- import_module par_builtin.
|
|
:- import_module private_builtin.
|
|
:- import_module profiling_builtin.
|
|
:- import_module region_builtin.
|
|
:- import_module rtti_implementation.
|
|
:- import_module stm_builtin.
|
|
:- import_module table_builtin.
|
|
:- import_module term_size_prof_builtin.
|
|
:- import_module test_bitset.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
version(Version, Fullarch) :-
|
|
Version = mercury_version,
|
|
Fullarch = architecture.
|
|
|
|
%---------------------%
|
|
|
|
% mercury_version, architecture and package_version must be implemented using
|
|
% pragma foreign_proc, so we can get at the MR_VERSION, MR_FULLARCH and
|
|
% MR_PACKAGE configuration parameters (and their C# and Java equivalents).
|
|
% We cannot just generate library.m from library.m.in at configuration time,
|
|
% because that would cause bootstrapping problems: we might not have a working
|
|
% Mercury compiler to compile library.m with.
|
|
|
|
:- pragma no_inline(func(mercury_version/0)).
|
|
|
|
:- pragma foreign_proc("C",
|
|
mercury_version = (Version::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe, will_not_modify_trail],
|
|
"
|
|
MR_ConstString version_string = MR_VERSION;
|
|
// We need to cast away const here, because Mercury declares Version to
|
|
// have type MR_String, not MR_ConstString.
|
|
Version = (MR_String) (MR_Word) version_string;
|
|
").
|
|
|
|
:- pragma foreign_proc("C#",
|
|
mercury_version = (Version::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe],
|
|
"
|
|
Version = runtime.Constants.MR_VERSION;
|
|
").
|
|
|
|
:- pragma foreign_proc("Java",
|
|
mercury_version = (Version::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe],
|
|
"
|
|
Version = jmercury.runtime.Constants.MR_VERSION;
|
|
").
|
|
|
|
%---------------------%
|
|
|
|
:- pragma no_inline(func(architecture/0)).
|
|
|
|
:- pragma foreign_proc("C",
|
|
architecture = (Fullarch::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe, will_not_modify_trail],
|
|
"
|
|
MR_ConstString fullarch_string = MR_FULLARCH;
|
|
// We need to cast away const here, because Mercury declares Fullarch to
|
|
// have type MR_String, not MR_ConstString.
|
|
Fullarch = (MR_String) (MR_Word) fullarch_string;
|
|
").
|
|
|
|
:- pragma foreign_proc("C#",
|
|
architecture = (Fullarch::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe],
|
|
"
|
|
Fullarch = runtime.Constants.MR_FULLARCH;
|
|
").
|
|
|
|
:- pragma foreign_proc("Java",
|
|
architecture = (Fullarch::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe],
|
|
"
|
|
Fullarch = jmercury.runtime.Constants.MR_FULLARCH;
|
|
").
|
|
|
|
%---------------------%
|
|
|
|
:- pragma no_inline(func(package_version/0)).
|
|
|
|
:- pragma foreign_proc("C",
|
|
package_version = (Package::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe, will_not_modify_trail],
|
|
"
|
|
MR_ConstString package_string = MR_PKGVERSION;
|
|
// We need to cast away const here, because Mercury declares Package to
|
|
// have type MR_String, not MR_ConstString.
|
|
Package = (MR_String) (MR_Word) package_string;
|
|
").
|
|
|
|
:- pragma foreign_proc("C#",
|
|
package_version = (Package::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe],
|
|
"
|
|
Package = runtime.Constants.MR_PKGVERSION;
|
|
").
|
|
|
|
:- pragma foreign_proc("Java",
|
|
package_version = (Package::out),
|
|
[will_not_call_mercury, promise_pure, thread_safe],
|
|
"
|
|
Package = jmercury.runtime.Constants.MR_PKGVERSION;
|
|
").
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
mercury_std_library_module(ModuleName) :-
|
|
stdlib_module_doc_undoc(ModuleName, _).
|
|
|
|
% NOTE If you ever add any module name here that contains more than two dots,
|
|
% i.e. it represents the submodule of a submodule of a submodule, then
|
|
% you will need to update the code of the "trusted" predicate in
|
|
% browse/declarative_oracle.m to handle such names.
|
|
stdlib_module_doc_undoc("array", doc).
|
|
stdlib_module_doc_undoc("array2d", doc).
|
|
stdlib_module_doc_undoc("assoc_list", doc).
|
|
stdlib_module_doc_undoc("backjump", undoc).
|
|
stdlib_module_doc_undoc("bag", doc).
|
|
stdlib_module_doc_undoc("benchmarking", doc).
|
|
stdlib_module_doc_undoc("bimap", doc).
|
|
stdlib_module_doc_undoc("bitmap", doc).
|
|
stdlib_module_doc_undoc("bit_buffer", doc).
|
|
stdlib_module_doc_undoc("bit_buffer.read", doc).
|
|
stdlib_module_doc_undoc("bit_buffer.write", doc).
|
|
stdlib_module_doc_undoc("bool", doc).
|
|
stdlib_module_doc_undoc("bt_array", doc).
|
|
stdlib_module_doc_undoc("builtin", doc).
|
|
stdlib_module_doc_undoc("calendar", doc).
|
|
stdlib_module_doc_undoc("char", doc).
|
|
stdlib_module_doc_undoc("construct", doc).
|
|
stdlib_module_doc_undoc("cord", doc).
|
|
stdlib_module_doc_undoc("counter", doc).
|
|
stdlib_module_doc_undoc("deconstruct", doc).
|
|
stdlib_module_doc_undoc("diet", doc).
|
|
stdlib_module_doc_undoc("digraph", doc).
|
|
stdlib_module_doc_undoc("dir", doc).
|
|
stdlib_module_doc_undoc("edit_distance", doc).
|
|
stdlib_module_doc_undoc("edit_seq", doc).
|
|
stdlib_module_doc_undoc("enum", doc).
|
|
stdlib_module_doc_undoc("eqvclass", doc).
|
|
stdlib_module_doc_undoc("exception", doc).
|
|
stdlib_module_doc_undoc("fat_sparse_bitset", doc).
|
|
stdlib_module_doc_undoc("fatter_sparse_bitset", doc).
|
|
stdlib_module_doc_undoc("float", doc).
|
|
stdlib_module_doc_undoc("gc", doc).
|
|
stdlib_module_doc_undoc("getopt", doc).
|
|
stdlib_module_doc_undoc("getopt_io", doc).
|
|
stdlib_module_doc_undoc("hash_table", doc).
|
|
stdlib_module_doc_undoc("injection", doc).
|
|
stdlib_module_doc_undoc("int", doc).
|
|
stdlib_module_doc_undoc("int8", doc).
|
|
stdlib_module_doc_undoc("int16", doc).
|
|
stdlib_module_doc_undoc("int32", doc).
|
|
stdlib_module_doc_undoc("int64", doc).
|
|
stdlib_module_doc_undoc("integer", doc).
|
|
stdlib_module_doc_undoc("io", doc).
|
|
stdlib_module_doc_undoc("io.call_system", doc).
|
|
stdlib_module_doc_undoc("io.environment", doc).
|
|
stdlib_module_doc_undoc("io.error_util", undoc).
|
|
stdlib_module_doc_undoc("io.file", doc).
|
|
stdlib_module_doc_undoc("io.primitives_read", undoc).
|
|
stdlib_module_doc_undoc("io.primitives_write", undoc).
|
|
stdlib_module_doc_undoc("io.stream_db", undoc).
|
|
stdlib_module_doc_undoc("io.stream_ops", undoc).
|
|
stdlib_module_doc_undoc("io.text_read", undoc).
|
|
stdlib_module_doc_undoc("kv_list", doc).
|
|
stdlib_module_doc_undoc("lazy", doc).
|
|
stdlib_module_doc_undoc("library", doc).
|
|
stdlib_module_doc_undoc("list", doc).
|
|
stdlib_module_doc_undoc("map", doc).
|
|
stdlib_module_doc_undoc("math", doc).
|
|
stdlib_module_doc_undoc("maybe", doc).
|
|
stdlib_module_doc_undoc("mercury_term_lexer", doc).
|
|
stdlib_module_doc_undoc("mercury_term_parser", doc).
|
|
stdlib_module_doc_undoc("multi_map", doc).
|
|
stdlib_module_doc_undoc("one_or_more", doc).
|
|
stdlib_module_doc_undoc("one_or_more_map", doc).
|
|
stdlib_module_doc_undoc("mutvar", undoc).
|
|
stdlib_module_doc_undoc("ops", doc).
|
|
stdlib_module_doc_undoc("pair", doc).
|
|
stdlib_module_doc_undoc("par_builtin", undoc).
|
|
stdlib_module_doc_undoc("parsing_utils", doc).
|
|
stdlib_module_doc_undoc("pprint", doc).
|
|
stdlib_module_doc_undoc("pqueue", doc).
|
|
stdlib_module_doc_undoc("pretty_printer", doc).
|
|
stdlib_module_doc_undoc("private_builtin", undoc).
|
|
stdlib_module_doc_undoc("profiling_builtin", undoc).
|
|
stdlib_module_doc_undoc("prolog", doc).
|
|
stdlib_module_doc_undoc("psqueue", doc).
|
|
stdlib_module_doc_undoc("queue", doc).
|
|
stdlib_module_doc_undoc("ra_list", doc).
|
|
stdlib_module_doc_undoc("random", doc).
|
|
stdlib_module_doc_undoc("random.sfc16", doc).
|
|
stdlib_module_doc_undoc("random.sfc32", doc).
|
|
stdlib_module_doc_undoc("random.sfc64", doc).
|
|
stdlib_module_doc_undoc("random.system_rng", doc).
|
|
stdlib_module_doc_undoc("ranges", doc).
|
|
stdlib_module_doc_undoc("rational", doc).
|
|
stdlib_module_doc_undoc("rbtree", doc).
|
|
stdlib_module_doc_undoc("region_builtin", undoc).
|
|
stdlib_module_doc_undoc("require", doc).
|
|
stdlib_module_doc_undoc("robdd", undoc).
|
|
stdlib_module_doc_undoc("rtree", doc).
|
|
stdlib_module_doc_undoc("rtti_implementation", undoc).
|
|
stdlib_module_doc_undoc("set", doc).
|
|
stdlib_module_doc_undoc("set_bbbtree", doc).
|
|
stdlib_module_doc_undoc("set_ctree234", doc).
|
|
stdlib_module_doc_undoc("set_ordlist", doc).
|
|
stdlib_module_doc_undoc("set_tree234", doc).
|
|
stdlib_module_doc_undoc("set_unordlist", doc).
|
|
stdlib_module_doc_undoc("solutions", doc).
|
|
stdlib_module_doc_undoc("sparse_bitset", doc).
|
|
stdlib_module_doc_undoc("stack", doc).
|
|
stdlib_module_doc_undoc("std_util", doc).
|
|
stdlib_module_doc_undoc("stm_builtin", undoc).
|
|
stdlib_module_doc_undoc("store", doc).
|
|
stdlib_module_doc_undoc("stream", doc).
|
|
stdlib_module_doc_undoc("stream.string_writer", doc).
|
|
stdlib_module_doc_undoc("string", doc).
|
|
stdlib_module_doc_undoc("string.builder", doc).
|
|
stdlib_module_doc_undoc("string.format", undoc).
|
|
stdlib_module_doc_undoc("string.parse_runtime", undoc).
|
|
stdlib_module_doc_undoc("string.parse_util", undoc).
|
|
stdlib_module_doc_undoc("string.to_string", undoc).
|
|
stdlib_module_doc_undoc("table_builtin", undoc).
|
|
stdlib_module_doc_undoc("table_statistics", doc).
|
|
stdlib_module_doc_undoc("term", doc).
|
|
stdlib_module_doc_undoc("term_context", doc).
|
|
stdlib_module_doc_undoc("term_conversion", doc).
|
|
stdlib_module_doc_undoc("term_int", doc).
|
|
stdlib_module_doc_undoc("term_subst", doc).
|
|
stdlib_module_doc_undoc("term_unify", doc).
|
|
stdlib_module_doc_undoc("term_vars", doc).
|
|
stdlib_module_doc_undoc("term_io", doc).
|
|
stdlib_module_doc_undoc("term_size_prof_builtin", undoc).
|
|
stdlib_module_doc_undoc("term_to_xml", doc).
|
|
stdlib_module_doc_undoc("test_bitset", undoc).
|
|
stdlib_module_doc_undoc("time", doc).
|
|
stdlib_module_doc_undoc("thread", doc).
|
|
stdlib_module_doc_undoc("thread.barrier", doc).
|
|
stdlib_module_doc_undoc("thread.channel", doc).
|
|
stdlib_module_doc_undoc("thread.closeable_channel", doc).
|
|
stdlib_module_doc_undoc("thread.future", doc).
|
|
stdlib_module_doc_undoc("thread.mvar", doc).
|
|
stdlib_module_doc_undoc("thread.semaphore", doc).
|
|
stdlib_module_doc_undoc("tree234", doc).
|
|
stdlib_module_doc_undoc("tree_bitset", doc).
|
|
stdlib_module_doc_undoc("type_desc", doc).
|
|
stdlib_module_doc_undoc("uint", doc).
|
|
stdlib_module_doc_undoc("uint8", doc).
|
|
stdlib_module_doc_undoc("uint16", doc).
|
|
stdlib_module_doc_undoc("uint32", doc).
|
|
stdlib_module_doc_undoc("uint64", doc).
|
|
stdlib_module_doc_undoc("unit", doc).
|
|
stdlib_module_doc_undoc("univ", doc).
|
|
stdlib_module_doc_undoc("varset", doc).
|
|
stdlib_module_doc_undoc("version_array", doc).
|
|
stdlib_module_doc_undoc("version_array2d", doc).
|
|
stdlib_module_doc_undoc("version_bitmap", doc).
|
|
stdlib_module_doc_undoc("version_hash_table", doc).
|
|
stdlib_module_doc_undoc("version_store", doc).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% Overall library initializer called before any user code,
|
|
% including module local initializers.
|
|
%
|
|
:- pred std_library_init(io::di, io::uo) is det.
|
|
|
|
:- pragma foreign_export("C", std_library_init(di, uo),
|
|
"ML_std_library_init").
|
|
:- pragma foreign_export("C#", std_library_init(di, uo),
|
|
"ML_std_library_init").
|
|
:- pragma foreign_export("Java", std_library_init(di, uo),
|
|
"ML_std_library_init").
|
|
|
|
std_library_init(!IO) :-
|
|
promise_pure (
|
|
impure builtin.init_runtime_hooks,
|
|
io.init_state(!IO)
|
|
).
|
|
|
|
% Overall library finalizer.
|
|
%
|
|
:- pred std_library_finalize(io::di, io::uo) is det.
|
|
|
|
:- pragma foreign_export("C", std_library_finalize(di, uo),
|
|
"ML_std_library_finalize").
|
|
|
|
std_library_finalize(!IO) :-
|
|
io.finalize_state(!IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
:- end_module library.
|
|
%---------------------------------------------------------------------------%
|